前言
在Android開發中我們可能會有延時執行某個操作的需求，例如我們啟動應用的時候，一開始呈現的是一個引導頁面，過了兩三秒后，會自動跳轉到主界面。這就是一個延時操作。
而寫這篇文章的目的，是看到群里有人在實現延遲的時候，用如下的第四種方法，個人感覺有點不妥，為了防止更多的人有這種想法，所以自己抽空深入分析，就分析的結果，寫下此文，希望對部分人有啟示作用。
1.實現延遲的幾種方法？
答：
1.java.util.Timer類的：
public void schedule(TimerTask task, long delay) { if (delay < 0) throw new IllegalArgumentException("Negative delay."); sched(task, System.currentTimeMillis()+delay, 0); }2.android/55655.html">android/277326.html">android.os.Handler類：
public final boolean postDelayed(Runnable r, long delayMillis) { return sendMessageDelayed(getPostMessage(r), delayMillis); }3.android.app.AlarmManager類:
@SystemApi @RequiresPermission(android.Manifest.permission.UPDATE_DEVICE_STATS) public void set(@AlarmType int type, long triggerAtMillis, long windowMillis, long intervalMillis, OnAlarmListener listener, Handler targetHandler, WorkSource workSource) { setImpl(type, triggerAtMillis, windowMillis, intervalMillis, 0, null, listener, null, targetHandler, workSource, null); }4.Thread.sleep()然后在一定時間之后再執行想執行的代碼：
new Thread(new Runnable(){ Thead.sleep(4*1000); doTask();}).start()2.他們的各自的實現原理？
答：
1.Timer的實現，是通過內部開啟一個TimerThread：
private void mainLoop() { while (true) { try { TimerTask task; boolean taskFired; synchronized(queue) { // Wait for queue to become non-empty while (queue.isEmpty() && newTasksMayBeScheduled) queue.wait(); if (queue.isEmpty()) break; // Queue is empty and will forever remain; die // Queue nonempty; look at first evt and do the right thing long currentTime, executionTime; task = queue.getMin(); synchronized(task.lock) { if (task.state == TimerTask.CANCELLED) { queue.removeMin(); continue; // No action required, poll queue again } currentTime = System.currentTimeMillis(); executionTime = task.nextExecutionTime; if (taskFired = (executionTime<=currentTime)) { if (task.period == 0) { // Non-repeating, remove queue.removeMin(); task.state = TimerTask.EXECUTED; } else { // Repeating task, reschedule queue.rescheduleMin( task.period<0 ? currentTime - task.period : executionTime + task.period); } } } if (!taskFired) // Task hasn't yet fired; wait queue.wait(executionTime - currentTime); } if (taskFired) // Task fired; run it, holding no locks task.run(); } catch(InterruptedException e) { } } }是通過wait和延遲時間到達的時候，調用notify來喚起線程繼續執行，這樣來實現延遲的話，我們可以回開啟一個新的線程，貌似為了個延遲沒必要這樣吧，定時，頻繁執行的任務，再考慮這個吧。
2.Handler的postDelay是通過設置Message的when為delay的時間，我們知道當我們的應用開啟的時候，會同步開啟Looper.loop()方法循環的，不停的通過MeassgeQueue的next方法：
Message next() { ...... int nextPollTimeoutMillis = 0; for (;;) { if (nextPollTimeoutMillis != 0) { Binder.flushPendingCommands(); } nativePollOnce(ptr, nextPollTimeoutMillis); synchronized (this) { // Try to retrieve the next message. Return if found. final long now = SystemClock.uptimeMillis(); Message prevMsg = null; Message msg = mMessages; if (msg != null && msg.target == null) { // Stalled by a barrier. Find the next asynchronous message in the queue. do { prevMsg = msg; msg = msg.next; } while (msg != null && !msg.isAsynchronous()); } if (msg != null) { if (now < msg.when) { // Next message is not ready. Set a timeout to wake up when it is ready. nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE); } else { // Got a message. mBlocked = false; if (prevMsg != null) { prevMsg.next = msg.next; } else { mMessages = msg.next; } msg.next = null; if (DEBUG) Log.v(TAG, "Returning message: " + msg); msg.markInUse(); return msg; } } else { // No more messages. nextPollTimeoutMillis = -1; } ...... } } 當我們向MessageQueue插入一條延遲的Message的時候，Looper在執行loop方法，底層會調用epoll_wait(mEpollFd, eventItems, EPOLL_MAX_EVENTS, timeoutMillis);其中的timeoutMillis參數指定了在沒有事件發生的時候epoll_wait調用阻塞的毫秒數(milliseconds)。這樣我們在之前的時間內這個時候阻塞了是會釋放cpu的資源，等到延遲的時間到了時候，再監控到事件發生。在這里可能有人會有疑問，一直阻塞，那我接下來的消息應該怎么執行呢？
我們可以看到當我們插入消息的時候的方法：
boolean enqueueMessage(Message msg, long when) { if (msg.target == null) { throw new IllegalArgumentException("Message must have a target."); } if (msg.isInUse()) { throw new IllegalStateException(msg + " This message is already in use."); } synchronized (this) { if (mQuitting) { IllegalStateException e = new IllegalStateException( msg.target + " sending message to a Handler on a dead thread"); Log.w(TAG, e.getMessage(), e); msg.recycle(); return false; } msg.markInUse(); msg.when = when; Message p = mMessages; boolean needWake; if (p == null || when == 0 || when < p.when) { msg.next = p; mMessages = msg; needWake = mBlocked; } else { needWake = mBlocked && p.target == null && msg.isAsynchronous(); Message prev; for (;;) { prev = p; p = p.next; if (p == null || when < p.when) { break; } if (needWake && p.isAsynchronous()) { needWake = false; } } msg.next = p; // invariant: p == prev.next prev.next = msg; } mQuitting is false. if (needWake) { nativeWake(mPtr); } } return true; }阻塞了有兩種方式喚醒，一種是超時了，一種是被主動喚醒了，在上面我們可以看到當有消息進入的時候，我們會喚醒繼續執行，所以我們的即時消息在延遲消息之后插入是沒有關系的。然后在延遲時間到了的時候，我們也會被喚醒，執行對應的消息send，以達到延遲時間執行某個任務的目的。
優勢：這種延遲在阻塞的時候，是會釋放cpu的鎖，不會過多地占用cpu的資源。
3.AlarmManager的延遲的實現原理，是通過一個AlarmManager的set方法:
IAlarmManager mService.set(mPackageName, type, triggerAtMillis, windowMillis, intervalMillis, flags, operation, recipientWrapper, listenerTag, workSource, alarmClock);
這里是通過aidl與AlarmManagerService的所在進程進行通信，具體的實現是在AlarmManagerService類里面：
private final IBinder mService = new IAlarmManager.Stub() { @Override public void set(String callingPackage, int type, long triggerAtTime, long windowLength, long interval, int flags, PendingIntent operation, IAlarmListener directReceiver, String listenerTag, WorkSource workSource, AlarmManager.AlarmClockInfo alarmClock) { final int callingUid = Binder.getCallingUid(); if (interval != 0) { if (directReceiver != null) { throw new IllegalArgumentException("Repeating alarms cannot use AlarmReceivers"); } } if (workSource != null) { getContext().enforcePermission( android.Manifest.permission.UPDATE_DEVICE_STATS, Binder.getCallingPid(), callingUid, "AlarmManager.set"); } // No incoming callers can request either WAKE_FROM_IDLE or // ALLOW_WHILE_IDLE_UNRESTRICTED -- we will apply those later as appropriate. flags &= ~(AlarmManager.FLAG_WAKE_FROM_IDLE | AlarmManager.FLAG_ALLOW_WHILE_IDLE_UNRESTRICTED); // Only the system can use FLAG_IDLE_UNTIL -- this is used to tell the alarm // manager when to come out of idle mode, which is only for DeviceIdleController. if (callingUid != Process.SYSTEM_UID) { flags &= ~AlarmManager.FLAG_IDLE_UNTIL; } if (windowLength == AlarmManager.WINDOW_EXACT) { flags |= AlarmManager.FLAG_STANDALONE; } if (alarmClock != null) { flags |= AlarmManager.FLAG_WAKE_FROM_IDLE | AlarmManager.FLAG_STANDALONE; } else if (workSource == null && (callingUid < Process.FIRST_APPLICATION_UID || Arrays.binarySearch(mDeviceIdleUserWhitelist, UserHandle.getAppId(callingUid)) >= 0)) { flags |= AlarmManager.FLAG_ALLOW_WHILE_IDLE_UNRESTRICTED; flags &= ~AlarmManager.FLAG_ALLOW_WHILE_IDLE; } setImpl(type, triggerAtTime, windowLength, interval, operation, directReceiver, listenerTag, flags, workSource, alarmClock, callingUid, callingPackage); } }} 雖然有人覺得用AlarmManager能夠在應用關閉的情況下，定時器還能再喚起，經過自己的測試，當殺掉應用程序的進程，AlarmManager的receiver也是接收不到消息的，但是我相信在這里定時器肯定是發送了，但是作為接收方的應用程序進程被殺掉了，執行不了對應的代碼。不過有人也覺得AlarmManager更耗電，是因為我們執行定時任務的情況會頻繁喚起cpu，但是如果只是用來只是執行延遲任務的話，個人覺得和Handler.postDelayed()相比應該也不會耗電多的。
2.在上面的第四種方法，達到的延遲會一直通過Thread.sleep來達到延遲的話，會一直占用cpu的資源，這種方法不贊同使用。
3.總結
如上面我們看到的這樣，如果是單純的實現一個任務的延遲的話，我們可以用Handler.postDelayed()和AlarmManager.set()來實現，用（4）的方法Thread.sleep()的話，首先開啟一個新的線程，然后會持有cpu的資源，用（1）的方法，Timer，會開啟一個死循環的線程，這樣在資源上面都有點浪費。
好了，以上就是這篇文章的全部內容了，希望本文的內容對大家的學習或者工作具有一定的參考學習價值，如果有疑問大家可以留言交流，謝謝大家對VEVB武林網的支持。
新聞熱點
疑難解答
