Handler、Thread和Runnable简单分析

 1 /**
 2  * Represents a command that can be executed. Often used to run code in a
 3  * different {@link Thread}.
 4  */
 5 public interface Runnable {
 6 
 7     /**
 8      * Starts executing the active part of the class‘ code. This method is
 9      * called when a thread is started that has been created with a class which
10      * implements {@code Runnable}.
11      */
12     public void run();
13 }

 1     /**
 2      * Constructs a new {@code Thread} with a {@code Runnable} object and a
 3      * newly generated name. The new {@code Thread} will belong to the same
 4      * {@code ThreadGroup} as the {@code Thread} calling this constructor.
 5      *
 6      * @param runnable
 7      *            a {@code Runnable} whose method <code>run</code> will be
 8      *            executed by the new {@code Thread}
 9      *
10      * @see java.lang.ThreadGroup
11      * @see java.lang.Runnable
12      */
13     public Thread(Runnable runnable) {
14         create(null, runnable, null, 0);
15     }

/**
     * Initializes a new, existing Thread object with a runnable object,
     * the given name and belonging to the ThreadGroup passed as parameter.
     * This is the method that the several public constructors delegate their
     * work to.
     *
     * @param group ThreadGroup to which the new Thread will belong
     * @param runnable a java.lang.Runnable whose method <code>run</code> will
     *        be executed by the new Thread
     * @param threadName Name for the Thread being created
     * @param stackSize Platform dependent stack size
     * @throws IllegalThreadStateException if <code>group.destroy()</code> has
     *         already been done
     * @see java.lang.ThreadGroup
     * @see java.lang.Runnable
     */
    private void create(ThreadGroup group, Runnable runnable, String threadName, long stackSize) {
        Thread currentThread = Thread.currentThread();
        if (group == null) {
            //前面我们说过了，用Runnable新建的线程和原线程属于同一线程容器
            group = currentThread.getThreadGroup();      
        }
        if (group.isDestroyed()) {
            throw new IllegalThreadStateException("Group already destroyed");
        }

        this.group = group;
        //此处用synchronized来保证新建的线程id+1并且使唯一的
        synchronized (Thread.class) {
            id = ++Thread.count;
        }
        //threadName 
        if (threadName == null) {
            this.name = "Thread-" + id;
        } else {
            this.name = threadName;
        }
        //相当于目标任务
        this.target = runnable;
        //线程开辟栈的大小，为0就是默认值8M
        this.stackSize = stackSize;
        //新线程的优先级和父线程是一样的
        this.priority = currentThread.getPriority();

        this.contextClassLoader = currentThread.contextClassLoader;

        // Transfer over InheritableThreadLocals.
        if (currentThread.inheritableValues != null) {
            inheritableValues = new ThreadLocal.Values(currentThread.inheritableValues);
        }
     
        // add ourselves to our ThreadGroup of choice
        this.group.addThread(this);
    }

 1     /**
 2      * Calls the <code>run()</code> method of the Runnable object the receiver
 3      * holds. If no Runnable is set, does nothing.
 4      *
 5      * @see Thread#start
 6      */
 7     public void run() {
 8         if (target != null) {
 9             target.run();
10         }
11     }

 1     /**
 2      * Starts the new Thread of execution. The <code>run()</code> method of
 3      * the receiver will be called by the receiver Thread itself (and not the
 4      * Thread calling <code>start()</code>).
 5      *
 6      * @throws IllegalThreadStateException - if this thread has already started.
 7      * @see Thread#run
 8      */
 9     public synchronized void start() {
10         checkNotStarted();
11 
12         hasBeenStarted = true;
13 
14         nativeCreate(this, stackSize, daemon);
15     }
16 
17     private native static void nativeCreate(Thread t, long stackSize, boolean daemon);

 1     volatile ThreadGroup group;
 2     volatile boolean daemon;
 3     volatile String name;
 4     volatile int priority;
 5     volatile long stackSize;
 6     Runnable target;
 7     private static int count = 0;
 8 
 9     /**
10      * Holds the thread‘s ID. We simply count upwards, so
11      * each Thread has a unique ID.
12      */
13     private long id;
14 
15     /**
16      * Normal thread local values.
17      */
18     ThreadLocal.Values localValues;
19 
20     /**
21      * Inheritable thread local values.
22      */
23     ThreadLocal.Values inheritableValues;

 1 static JNINativeMethod gMethods[] = {
 2   NATIVE_METHOD(Thread, currentThread, "!()Ljava/lang/Thread;"),
 3   NATIVE_METHOD(Thread, interrupted, "!()Z"),
 4   NATIVE_METHOD(Thread, isInterrupted, "!()Z"),
 5   NATIVE_METHOD(Thread, nativeCreate, "(Ljava/lang/Thread;JZ)V"),
 6   NATIVE_METHOD(Thread, nativeGetStatus, "(Z)I"),
 7   NATIVE_METHOD(Thread, nativeHoldsLock, "(Ljava/lang/Object;)Z"),
 8   NATIVE_METHOD(Thread, nativeInterrupt, "!()V"),
 9   NATIVE_METHOD(Thread, nativeSetName, "(Ljava/lang/String;)V"),
10   NATIVE_METHOD(Thread, nativeSetPriority, "(I)V"),
11   NATIVE_METHOD(Thread, sleep, "!(Ljava/lang/Object;JI)V"),
12   NATIVE_METHOD(Thread, yield, "()V"),
13 };

 1 void Thread::CreateNativeThread(JNIEnv* env, jobject java_peer, size_t stack_size, bool is_daemon) {
 2   CHECK(java_peer != nullptr);//即为java层的thread实例，包裹着run方法的具体实现
 3   Thread* self = static_cast<JNIEnvExt*>(env)->self;
 4   Runtime* runtime = Runtime::Current();
 5 
 6   // Atomically start the birth of the thread ensuring the runtime isn‘t shutting down.
 7   bool thread_start_during_shutdown = false;//这段代码用来检测thread是否在runtime宕机时start的
 8   {
 9     MutexLock mu(self, *Locks::runtime_shutdown_lock_);
10     if (runtime->IsShuttingDownLocked()) {
11       thread_start_during_shutdown = true;
12     } else {
13       runtime->StartThreadBirth();
14     }
15   }
16   if (thread_start_during_shutdown) {//若runtime宕机了就抛出异常
17     ScopedLocalRef<jclass> error_class(env, env->FindClass("java/lang/InternalError"));
18     env->ThrowNew(error_class.get(), "Thread starting during runtime shutdown");
19     return;
20   }
21 
22   Thread* child_thread = new Thread(is_daemon);//新建子线程
23   // Use global JNI ref to hold peer live while child thread starts.
24   child_thread->tlsPtr_.jpeer = env->NewGlobalRef(java_peer);//把java层的run方法实体传递给子线程
25   stack_size = FixStackSize(stack_size);
26 
27   // Thread.start is synchronized, so we know that nativePeer is 0, and know that we‘re not racing to
28   // assign it.
29   env->SetLongField(java_peer, WellKnownClasses::java_lang_Thread_nativePeer,
30                     reinterpret_cast<jlong>(child_thread));
31 
32   pthread_t new_pthread;
33   pthread_attr_t attr;
34   CHECK_PTHREAD_CALL(pthread_attr_init, (&attr), "new thread");
35   CHECK_PTHREAD_CALL(pthread_attr_setdetachstate, (&attr, PTHREAD_CREATE_DETACHED), "PTHREAD_CREATE_DETACHED");
36   CHECK_PTHREAD_CALL(pthread_attr_setstacksize, (&attr, stack_size), stack_size);
37   //创建新线程的方法，返回一个标志
38   int pthread_create_result = pthread_create(&new_pthread, &attr, Thread::CreateCallback, child_thread);
39   CHECK_PTHREAD_CALL(pthread_attr_destroy, (&attr), "new thread");
40 
41   //线程创建如果失败则清除子线程信息，释放空间
42   if (pthread_create_result != 0) {
43     // pthread_create(3) failed, so clean up.
44     {
45       MutexLock mu(self, *Locks::runtime_shutdown_lock_);
46       runtime->EndThreadBirth();
47     }
48     // Manually delete the global reference since Thread::Init will not have been run.
49     env->DeleteGlobalRef(child_thread->tlsPtr_.jpeer);
50     child_thread->tlsPtr_.jpeer = nullptr;
51     delete child_thread;
52     child_thread = nullptr;
53     // TODO: remove from thread group?
54     env->SetLongField(java_peer, WellKnownClasses::java_lang_Thread_nativePeer, 0);
55     {
56       std::string msg(StringPrintf("pthread_create (%s stack) failed: %s",
57                                    PrettySize(stack_size).c_str(), strerror(pthread_create_result)));
58       ScopedObjectAccess soa(env);
59       soa.Self()->ThrowOutOfMemoryError(msg.c_str());
60     }
61   }
62 }

 1 /**
 2  * A Handler allows you to send and process {@link Message} and Runnable
 3  * objects associated with a thread‘s {@link MessageQueue}.  Each Handler
 4  * instance is associated with a single thread and that thread‘s message
 5  * queue.  When you create a new Handler, it is bound to the thread /
 6  * message queue of the thread that is creating it -- from that point on,
 7  * it will deliver messages and runnables to that message queue and execute
 8  * them as they come out of the message queue.
 9  * 
10 **/

 1 public final boolean sendMessage(Message msg)
 2     {
 3         return sendMessageDelayed(msg, 0);
 4     }
 5 public final boolean sendMessageDelayed(Message msg, long delayMillis)
 6     {
 7         if (delayMillis < 0) {
 8             delayMillis = 0;
 9         }
10         return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
11     }
12 public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
13         MessageQueue queue = mQueue;
14         if (queue == null) {
15             RuntimeException e = new RuntimeException(
16                     this + " sendMessageAtTime() called with no mQueue");
17             Log.w("Looper", e.getMessage(), e);
18             return false;
19         }
20         return enqueueMessage(queue, msg, uptimeMillis);
21     }
22 public final boolean sendMessageAtFrontOfQueue(Message msg) {
23         MessageQueue queue = mQueue;
24         if (queue == null) {
25             RuntimeException e = new RuntimeException(
26                 this + " sendMessageAtTime() called with no mQueue");
27             Log.w("Looper", e.getMessage(), e);
28             return false;
29         }
30         return enqueueMessage(queue, msg, 0);
31     }

1     private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
2         msg.target = this;
3         if (mAsynchronous) {
4             msg.setAsynchronous(true);
5         }
6         return queue.enqueueMessage(msg, uptimeMillis);
7     }

 1     boolean enqueueMessage(Message msg, long when) {
 2         if (msg.target == null) {
 3             throw new IllegalArgumentException("Message must have a target.");
 4         }
 5         if (msg.isInUse()) {
 6             throw new IllegalStateException(msg + " This message is already in use.");
 7         }
 8 
 9         synchronized (this) {
10             if (mQuitting) {
11                 IllegalStateException e = new IllegalStateException(
12                         msg.target + " sending message to a Handler on a dead thread");
13                 Log.w("MessageQueue", e.getMessage(), e);
14                 msg.recycle();
15                 return false;
16             }
17 
18             msg.markInUse();
19             msg.when = when;
20             Message p = mMessages;
21             boolean needWake;
22             if (p == null || when == 0 || when < p.when) {
23                 // New head, wake up the event queue if blocked.
24                 msg.next = p;
25                 mMessages = msg;
26                 needWake = mBlocked;
27             } else {
28                 // Inserted within the middle of the queue.  Usually we don‘t have to wake
29                 // up the event queue unless there is a barrier at the head of the queue
30                 // and the message is the earliest asynchronous message in the queue.
31                 needWake = mBlocked && p.target == null && msg.isAsynchronous();
32                 Message prev;
33                 //经典的队列add操作
34                 for (;;) {
35                     prev = p;
36                     p = p.next;
37                     if (p == null || when < p.when) {
38                         break;
39                     }
40                     if (needWake && p.isAsynchronous()) {
41                         needWake = false;
42                     }
43                 }
44                 msg.next = p; // invariant: p == prev.next
45                 prev.next = msg;
46             }
47 
48             // We can assume mPtr != 0 because mQuitting is false.
49             if (needWake) {
50                 nativeWake(mPtr);
51             }
52         }
53         return true;
54     }

 1     /**
 2      * Run the message queue in this thread. Be sure to call
 3      * {@link #quit()} to end the loop.
 4      */
 5     public static void loop() {
 6         final Looper me = myLooper();
 7         if (me == null) {
 8             throw new RuntimeException("No Looper; Looper.prepare() wasn‘t called on this thread.");
 9         }
10         final MessageQueue queue = me.mQueue;
11 
12         // Make sure the identity of this thread is that of the local process,
13         // and keep track of what that identity token actually is.
14         Binder.clearCallingIdentity();
15         final long ident = Binder.clearCallingIdentity();
16 
17         for (;;) {
18             Message msg = queue.next(); // might block
19             if (msg == null) {
20                 // No message indicates that the message queue is quitting.
21                 return;
22             }
23 
24             // This must be in a local variable, in case a UI event sets the logger
25             Printer logging = me.mLogging;
26             if (logging != null) {
27                 logging.println(">>>>> Dispatching to " + msg.target + " " +
28                         msg.callback + ": " + msg.what);
29             }
30 
31             msg.target.dispatchMessage(msg);
32 
33             if (logging != null) {
34                 logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
35             }
36 
37             // Make sure that during the course of dispatching the
38             // identity of the thread wasn‘t corrupted.
39             final long newIdent = Binder.clearCallingIdentity();
40             if (ident != newIdent) {
41                 Log.wtf(TAG, "Thread identity changed from 0x"
42                         + Long.toHexString(ident) + " to 0x"
43                         + Long.toHexString(newIdent) + " while dispatching to "
44                         + msg.target.getClass().getName() + " "
45                         + msg.callback + " what=" + msg.what);
46             }
47 
48             msg.recycleUnchecked();
49         }
50     }

 1    /**
 2      * Handle system messages here.
 3      */
 4     public void dispatchMessage(Message msg) {
 5         if (msg.callback != null) {
 6             handleCallback(msg);
 7         } else {
 8             if (mCallback != null) {
 9                 if (mCallback.handleMessage(msg)) {
10                     return;
11                 }
12             }
13             handleMessage(msg);
14         }
15     }