通过java.util.Timer和java.util.TimerTask使用计时器的标准Java方法在Android中运行良好，但是你应该知道这个方法创建了一个新线程。

您可以考虑使用非常方便的Handler类(android.os.Handler)并通过sendMessageAtTime(android.os.Message, long)或sendMessageDelayed(android.os.Message, long)向处理程序发送消息。收到消息后，您可以运行所需的任务。第二个选项是创建一个Runnable对象，并通过Handler函数postAtTime(java.lang.Runnable, long)或postDelayed(java.lang.Runnable, long)进行调度。

是的java的计时器可以使用，但随着问题要求更好的方式(移动)。这在这里解释。

为了StackOverflow：

由于Timer创建一个新线程，它可能被认为很重，

如果你需要的只是在活动运行时回调，那么Handler可以与a一起使用

可运行：

private final int interval = 1000; // 1 Second

private Handler handler = new Handler();

private Runnable runnable = new Runnable(){

public void run() {

Toast.makeText(MyActivity.this, "C'Mom no hands!", Toast.LENGTH_SHORT).show();

}

};

...

handler.postAtTime(runnable, System.currentTimeMillis()+interval);

handler.postDelayed(runnable, interval);

或消息

private final int EVENT1 = 1;

private Handler handler = new Handler() {

@Override

public void handleMessage(Message msg) {

switch (msg.what) {

case Event1:

Toast.makeText(MyActivity.this, "Event 1", Toast.LENGTH_SHORT).show();

break;

default:

Toast.makeText(MyActivity.this, "Unhandled", Toast.LENGTH_SHORT).show();

break;

}

}

};

...

Message msg = handler.obtainMessage(EVENT1);

handler.sendMessageAtTime(msg, System.currentTimeMillis()+interval);

handler.sendMessageDelayed(msg, interval);

另外，如果你想在另一个线程的UI线程中运行一段代码，可以使用这种方法。

如果你需要回电话，即使你的活动没有运行，你也可以使用AlarmManager

正如我所见，java.util.Timer最常用于实现计时器。

对于重复任务：

new Timer().scheduleAtFixedRate(task, after, interval);

对于单次运行任务：

new Timer().schedule(task, after);

任务是要执行的方法

在初始执行之后

(间隔重复执行的时间)

可能是Timerconcept

new CountDownTimer(40000, 1000) { //40000 milli seconds is total time, 1000 milli seconds is time interval

public void onTick(long millisUntilFinished) {

}

public void onFinish() {

}

}.start();

要么

方法2 ::

编程定时器

添加一个名为time的int的新变量。将其设置为0。

将以下代码添加到MainActivity.java中的onCreate函数。

//Declare the timer

Timer t = new Timer();

//Set the schedule function and rate

t.scheduleAtFixedRate(new TimerTask() {

@Override

public void run() {

//Called each time when 1000 milliseconds (1 second) (the period parameter)

}

},

//Set how long before to start calling the TimerTask (in milliseconds)

0,

//Set the amount of time between each execution (in milliseconds)

1000);

进入run方法并添加以下代码。

//We must use this function in order to change the text view text

runOnUiThread(new Runnable() {

@Override

public void run() {

TextView tv = (TextView) findViewById(R.id.main_timer_text);

tv.setText(String.valueOf(time));

time += 1;

}

});

我希望这个有用，可能需要付出更少的努力来实施，

Android CountDownTimer类

例如

new CountDownTimer(30000, 1000) {

public void onTick(long millisUntilFinished) {

mTextField.setText("seconds remaining: " + millisUntilFinished / 1000);

}

public void onFinish() {

mTextField.setText("done!");

}

}.start();

这是情境。

Android文档建议您应该使用AlarmManager注册一个Intent，如果您的应用程序可能没有运行，它将在指定的时间触发。

否则，您应该使用Handler。

注意：警报管理器是预期的

如果你想拥有你的

应用程序代码运行在特定的

时间，即使你的申请不是

目前正在运行正常时间

操作(滴答，超时等)

更简单，更有效率

使用Handler。

我们走了......我们需要两节课。我发布的代码会在每5秒(5000毫秒)之后更改移动音频配置文件...

我们的头等舱

public class ChangeProfileActivityMain extends Activity {

@Override

protected void onCreate(Bundle savedInstanceState) {

// TODO Auto-generated method stub

super.onCreate(savedInstanceState);

Timer timer = new Timer();

TimerTask updateProfile = new CustomTimerTask(ChangeProfileActivityMain.this);

timer.scheduleAtFixedRate(updateProfile, 0, 5000);

}

}

我们的第二课

public class CustomTimerTask extends TimerTask {

private AudioManager audioManager;

private Context context;

private Handler mHandler = new Handler();

// Write Custom Constructor to pass Context

public CustomTimerTask(Context con) {

this.context = con;

}

@Override

public void run() {

// TODO Auto-generated method stub

// your code starts here.

// I have used Thread and Handler as we can not show Toast without starting new thread when we are inside a thread.

// As TimePicker has run() thread running., So We must show Toast through Handler.post in a new Thread. Thats how it works in Android..

new Thread(new Runnable() {

@Override

public void run() {

audioManager = (AudioManager) context.getApplicationContext().getSystemService(Context.AUDIO_SERVICE);

mHandler.post(new Runnable() {

@Override

public void run() {

if(audioManager.getRingerMode() == AudioManager.RINGER_MODE_SILENT) {

audioManager.setRingerMode(AudioManager.RINGER_MODE_NORMAL);

Toast.makeText(context, "Ringer Mode set to Normal", Toast.LENGTH_SHORT).show();

} else {

audioManager.setRingerMode(AudioManager.RINGER_MODE_SILENT);

Toast.makeText(context, "Ringer Mode set to Silent", Toast.LENGTH_SHORT).show();

}

}

});

}

}).start();

}

}

我是一个Android新手，但这里是我根据上面的答案创建的计时器类。它适用于我的应用程序，但我欢迎任何建议。

用法示例：

...{

public Handler uiHandler = new Handler();

private Runnable runMethod = new Runnable()

{

public void run()

{

// do something

}

};

timer = new UITimer(handler, runMethod, timeoutSeconds*1000);

timer.start();

}...

public class UITimer

{

private Handler handler;

private Runnable runMethod;

private int intervalMs;

private boolean enabled = false;

private boolean oneTime = false;

public UITimer(Handler handler, Runnable runMethod, int intervalMs)

{

this.handler = handler;

this.runMethod = runMethod;

this.intervalMs = intervalMs;

}

public UITimer(Handler handler, Runnable runMethod, int intervalMs, boolean oneTime)

{

this(handler, runMethod, intervalMs);

this.oneTime = oneTime;

}

public void start()

{

if (enabled)

return;

if (intervalMs < 1)

{

Log.e("timer start", "Invalid interval:" + intervalMs);

return;

}

enabled = true;

handler.postDelayed(timer_tick, intervalMs);

}

public void stop()

{

if (!enabled)

return;

enabled = false;

handler.removeCallbacks(runMethod);

handler.removeCallbacks(timer_tick);

}

public boolean isEnabled()

{

return enabled;

}

private Runnable timer_tick = new Runnable()

{

public void run()

{

if (!enabled)

return;

handler.post(runMethod);

if (oneTime)

{

enabled = false;

return;

}

handler.postDelayed(timer_tick, intervalMs);

}

};

}

我正在使用一个处理程序和runnable来创建一个计时器。我将它包装在一个抽象类中。只是派生/实现它，你很高兴：

public static abstract class SimpleTimer {

abstract void onTimer();

private Runnable runnableCode = null;

private Handler handler = new Handler();

void startDelayed(final int intervalMS, int delayMS) {

runnableCode = new Runnable() {

@Override

public void run() {

handler.postDelayed(runnableCode, intervalMS);

onTimer();

}

};

handler.postDelayed(runnableCode, delayMS);

}

void start(final int intervalMS) {

startDelayed(intervalMS, 0);

}

void stop() {

handler.removeCallbacks(runnableCode);

}

}

请注意，在执行代码之前调用handler.postDelayed - 这将使计时器更加关闭，并将其定时为“预期”。但是，如果计时器频繁运行并且任务(onTimer())很长 - 可能会有重叠。如果要在任务完成后开始计算intervalMS，请将onTimer()呼叫移到上面一行。

我相信在android上执行此操作的方法是您需要运行后台服务。在该后台应用程序中，创建计时器。当计时器“滴答”(设置您想要等待多长时间的间隔)时，启动您要启动的活动。

http://developer.android.com/guide/topics/fundamentals.html(＆lt; - 本文解释了Android开发的活动，服务，意图和其他核心基础之间的关系)

我曾经使用(Timer，TimerTask)和Handler定期开始(耗时)任务。现在我把整个转换为RxJava。 RxJava提供了Observable.timer，它更简单，更不容易出错，无需使用。

public class BetterTimerFragment extends Fragment {

public static final String TAG = "BetterTimer";

private TextView timeView;

private Subscription timerSubscription;

@Override

public View onCreateView(LayoutInflater inflater,

@Nullable ViewGroup container,

@Nullable Bundle savedInstanceState) {

return inflater.inflate(R.layout.fragment_timer, container, false);

}

@Override

public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {

super.onViewCreated(view, savedInstanceState);

timeView = (TextView) view.findViewById(R.id.timeView);

}

@Override

public void onResume() {

super.onResume();

// Right after the app is visible to users, delay 2 seconds

// then kick off a (heavy) task every 10 seconds.

timerSubscription = Observable.timer(2, 10, TimeUnit.SECONDS)

.map(new Func1() {

@Override

public String call(Long unused) {

// TODO: Probably do time-consuming work here.

// This runs on a different thread than the main thread.

return "Time: " + System.currentTimeMillis();

}

})

.observeOn(AndroidSchedulers.mainThread())

.subscribe(new Action1() {

@Override

public void call(String timeText) {

// The result will then be propagated back to the main thread.

timeView.setText(timeText);

}

}, new Action1() {

@Override

public void call(Throwable throwable) {

Log.e(TAG, throwable.getMessage(), throwable);

}

});

}

@Override

public void onPause() {

super.onPause();

// Don't kick off tasks when the app gets invisible.

timerSubscription.unsubscribe();

}

}

对于计时操作，您应该使用Handler。

如果您需要运行后台服务，则可以使用AlarmManager。