你知道Thread线程是如何运作的吗？

// 创建Thread的公有构造函数，都调用的都是这个私有的init()方法。我们看看到底干什么了。 
/** 
     * 
     * @param 线程组 
     * @param 就是我们平时接触最多的Runnable同学 
     * @param 指定线程的名称 
     * @param 指定线程堆栈的大小 
     */ 
private void init(ThreadGroup g, Runnable target, String name, long stackSize) { 
        Thread parent = currentThread();             
//先获取当前运行中的线程。这一个Native函数，暂时不用理会它怎么做到的。黑盒思想，哈哈！ 
        if (g == null) { 
            g = parent.getThreadGroup();            
 //如果没有指定ThreadGroup，将获取父线程的TreadGroup 
        } 
 
        g.addUnstarted();                           
 //将ThreadGroup中的就绪线程计数器增加一。注意，此时线程还并没有被真正加入到ThreadGroup中。 
        this.group = g;                             
 //将Thread实例的group赋值。从这里开始线程就拥有ThreadGroup了。 
 
        this.target = target;                       
 //给Thread实例设置Runnable。以后start()的时候执行的就是它了。 
        this.priority = parent.getPriority();        
//设置线程的优先权重为父线程的权重 
        this.daemon = parent.isDaemon();            
 //根据父线程是否是守护线程来确定Thread实例是否是守护线程。 
        setName(name);                              
 //设置线程的名称   
 
        init2(parent);                             
  //纳尼？又一个初始化，参数还是父线程。不急，稍后在看。 
 
        /* Stash the specified stack size in case the VM cares */ 
        this.stackSize = stackSize;                 
 //设置线程的堆栈大小 
        tid = nextThreadID();                       
 //线程的id。这是个静态变量，调用这个方法会自增，然后作为线程的id。 
    }  
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.

private void init2(Thread parent) { 
        this.contextClassLoader = parent.getContextClassLoader();           
 //设置ClassLoader成员变量 
        this.inheritedAccessControlContext = AccessController.getContext(); 
 //设置访问权限控制环境 
        if (parent.inheritableThreadLocals != null) { 
            this.inheritableThreadLocals = ThreadLocal.createInheritedMap(  
 //创建Thread实例的ThreadLoacaleMap。需要用到父线程的ThreadLocaleMap，目的是为了将父线程中的变量副本拷贝一份到当前线程中。 
            //ThreadLocaleMap是一个Entry型的数组，Thread实例会将变量副本保存在这里面。 
                    parent.inheritableThreadLocals);         
        } 
    }  
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

Thread threadDemo = new Thread(() -> { 
 
    }); 
threadDemo.start();  
1.
2.
3.
4.

//如我们所见，这个方法是加了锁的。 
//原因是避免开发者在其它线程调用同一个Thread实例的这个方法，从而尽量避免抛出异常。 
//这个方法之所以能够执行我们传入的Runnable里的run()方法， 
//是应为JVM调用了Thread实例的run()方法。 
public synchronized void start() { 
        //检查线程状态是否为0，为0表示是一个新状态，即还没被start()过。不为0就抛出异常。 
        //就是说，我们一个Thread实例，我们只能调用一次start()方法。 
        if (threadStatus != 0) 
            throw new IllegalThreadStateException(); 
 
        //从这里开始才真正的线程加入到ThreadGroup组里。 
//再重复一次，前面只是把nUnstartedThreads这个计数器进行了增量，并没有添加线程。 
        //同时，当线程启动了之后，nUnstartedThreads计数器会-1。因为就绪状态的线程少了一条啊！ 
        group.add(this); 
 
        started = false; 
        try { 
            nativeCreate(this, stackSize, daemon);   
//又是个Native方法。这里交由JVM处理，会调用Thread实例的run()方法。 
            started = true; 
        } finally { 
            try { 
                if (!started) { 
                    group.threadStartFailed(this);   
//如果没有被启动成功，Thread将会被移除ThreadGroup， 
//同时，nUnstartedThreads计数器又增量1了。 
                } 
            } catch (Throwable ignore) { 
 
            } 
        } 
    }  
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.

//没错，就是这么简单！仅仅调用了Runnable类型的成员变量target的run()方法。 
//至此，我们需要执行的代码就执行起来了。 
//至于这个@Overrid的存在，完全是因为Thread本身也是一个Runnable！ 
//就是说，我们的Thread也可以作为一个Runnable来使用。 
@Override 
public void run() { 
        if (target != null) { 
            target.run(); 
        } 
    }  
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

public void test_1() { 
    Thread thread1 = new Thread(() -> { 
      System.out.println(Thread.currentThread().getName()); 
    }, "Thread_1"); 
 
 
    Thread thread2 = new Thread(thread1, "Thread_2"); 
    thread2.start(); 
  } 
 
 
--- 
输出： 
Thread_2  
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

//平时我们调用的Thread.sleep(long)***调用到这个方法来，后一个陌生一点的参数就是纳秒。 
//你可以在纳秒级控制线程。 
public static void sleep(long millis, int nanos) 
    throws InterruptedException { 
        //下面三个检测毫秒和纳秒的设置是否合法。 
        if (millis < 0) { 
            throw new IllegalArgumentException("millis < 0: " + millis); 
        } 
        if (nanos < 0) { 
            throw new IllegalArgumentException("nanos < 0: " + nanos); 
        } 
        if (nanos > 999999) { 
            throw new IllegalArgumentException("nanos > 999999: " + nanos); 
        } 
 
 
        if (millis == 0 && nanos == 0) { 
            if (Thread.interrupted()) {    
//当睡眠时间为0时，检测线程是否中断， 
//并清除线程的中断状态标记。这是个Native的方法。 
              throw new InterruptedException();  
 //如果线程被设置了中断状态为true了(调用Thread.interrupt())。 
//那么他将抛出异常。如果在catch住这个异常之后return线程，那么线程就停止了。   
 //需要注意，在调用了Thread.sleep()之后，再调用isInterrupted()得到的结果永远是False。 
//别忘了Thread.interrupted()在检测的同时还会清除标记位置哦！ 
            } 
            return; 
        } 
 
        long start = System.nanoTime();  
 //类似System.currentTimeMillis()。但是获取的是纳秒，可能不准。 
        long duration = (millis * NANOS_PER_MILLI) + nanos;   
 
        Object lock = currentThread().lock;  
 //获得当前线程的锁。 
 
        synchronized (lock) {    
//对当前线程的锁对象进行同步操作 
            while (true) { 
                sleep(lock, millis, nanos);  
 //这里又是一个Native的方法，并且也会抛出InterruptedException异常。 
                //据我估计，调用这个函数睡眠的时长是不确定的。 
 
                long now = System.nanoTime(); 
                long elapsed = now - start;   
//计算线程睡了多久了 
 
                if (elapsed >= duration) {    
//如果当前睡眠时长，已经满足我们的需求，就退出循环，睡眠结束。 
                    break; 
                } 
 
                duration -= elapsed;    
//减去已经睡眠的时间，重新计算需要睡眠的时长。 
                start = now; 
                millis = duration / NANOS_PER_MILLI;  
 //重新计算毫秒部分 
                nanos = (int) (duration % NANOS_PER_MILLI);  
//重新计算微秒部分 
            } 
        } 
    }  
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.

new Thread(()->{ 
 
    ... 
    Looper.prepare(); 
    Handler handler = new Handler(){ 
        @Override 
        public void handleMessage(Message msg) { 
          super.handleMessage(msg); 
        } 
      }; 
    Looper.loop(); 
 
}).start()  
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

public static void prepare() { 
        prepare(true);   
//最终其实执行的是私有方法prepare(boolean quitAllowed)中的逻辑 
    } 
 
    private static void prepare(boolean quitAllowed) { 
        if (sThreadLocal.get() != null) {   
 //先尝试获取是否已经存在一个Looper在当前线程中，如果有就抛个异常。 
        //这就是为什么我们不能在一个Thread中调用两次Looper.prepare()的原因。 
            throw new RuntimeException("Only one Looper may be created per thread"); 
        } 
        sThreadLocal.set(new Looper(quitAllowed));   
//***调用的话，就创建一个新的Looper。 
    } 
 
    //Looper的私有构造函数 
    private Looper(boolean quitAllowed) { 
        mQueue = new MessageQueue(quitAllowed);   
 //创建新的MessageQueue，稍后在来扒它。 
        mThread = Thread.currentThread();         
 //把当前的线程赋值给mThread。 
    }  
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.

public T get() { 
        Thread t = Thread.currentThread();  
  //重点啊！获取到了当前运行的线程。 
        ThreadLocalMap map = getMap(t);      
 //取出当前线程的ThreadLocalMap。这个东西是个重点，前面已经提到过。 
//忘了的同学在前面再看看。 
        if (map != null) { 
            ThreadLocalMap.Entry e = map.getEntry(this);   
            //可以看出，每条线程的ThreadLocalMap中都有一个<ThreadLocal,Looper>键值对。 
//绑定关系就是通过这个键值对建立的。 
            if (e != null) 
                return (T)e.value; 
        } 
        return setInitialValue(); 
    } 
 
public void set(T value) { 
        Thread t = Thread.currentThread();   
//同样先获取到当前的线程 
        ThreadLocalMap map = getMap(t);      
//获取线程的ThreadLocalMap 
        if (map != null) 
            map.set(this, value);           
 //储存键值对 
        else 
            createMap(t, value); 
    }  
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.

public Handler() { 
        this(null, false);  
} 
 
public Handler(Callback callback, boolean async) {      //可以看到，最终调用了这个方法。 
        if (FIND_POTENTIAL_LEAKS) { 
            final Class<? extends Handler> klass = getClass(); 
            if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) && 
                    (klass.getModifiers() & Modifier.STATIC) == 0) { 
                Log.w(TAG, "The following Handler class should be static or leaks might occur: " + 
                    klass.getCanonicalName()); 
            } 
        } 
 
        mLooper = Looper.myLooper();                    
 //重点啊！在这里Handler和当前Thread的Looper绑定了。 
//Looper.myLooper()就是从ThreadLocale中取出当前线程的Looper。 
        if (mLooper == null) { 
 //如果子线程中new Handler()之前没有调用Looper.prepare()，那么当前线程的Looper就还没创建。 
//就会抛出这个异常。 
            throw new RuntimeException( 
                "Can't create handler inside thread that has not called Looper.prepare()"); 
        } 
        mQueue = mLooper.mQueue; 
  //赋值Looper的MessageQueue给Handler。 
        mCallback = callback; 
        mAsynchronous = async; 
    }  
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.

public static void loop() { 
        final Looper me = myLooper();    
//这个方法前面已经提到过了，就是获取到当前线程中的Looper对象。 
        if (me == null) {  
            //没有Looper.prepare()是要报错的！ 
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread."); 
        } 
        final MessageQueue queue = me.mQueue;      
  //获取到Looper的MessageQueue成员变量，这是在Looper创建的时候new的。 
 
 //这是个Native方法，作用就是检测一下当前线程是否属于当前进程。并且会持续跟踪其真实的身份。 
 //在IPC机制中，这个方法用来清除IPCThreadState的pid和uid信息。并且返回一个身份，便于使用restoreCallingIdentity()来恢复。 
        Binder.clearCallingIdentity(); 
        final long ident = Binder.clearCallingIdentity(); 
 
        for (;;) {  
 //重点(敲黑板)！这里是个死循环，一直等待抽取消息、发送消息。 
            Message msg = queue.next(); 
 //  从MessageQueue中抽取一条消息。至于怎么取的，我们稍后再看。 
            if (msg == null) { 
                // No message indicates that the message queue is quitting. 
                return; 
            } 
 
            // This must be in a local variable, in case a UI event sets the logger 
            final Printer logging = me.mLogging; 
            if (logging != null) { 
                logging.println(">>>>> Dispatching to " + msg.target + " " + 
                        msg.callback + ": " + msg.what); 
            } 
 
            final long traceTag = me.mTraceTag;   //取得MessageQueue的跟踪标记 
            if (traceTag != 0) { 
                Trace.traceBegin(traceTag, msg.target.getTraceName(msg));  
 //开始跟踪本线程的MessageQueue中的当前消息，是Native的方法。 
            } 
            try { 
                msg.target.dispatchMessage(msg);   
 //尝试分派消息到和Message绑定的Handler中 
            } finally { 
                if (traceTag != 0) { 
                    Trace.traceEnd(traceTag);      
 //这个和Trace.traceBegin()配套使用。 
                } 
            } 
 
            if (logging != null) { 
                logging.println("<<<<< Finished to " + msg.target + " " + msg.callback); 
            } 
 
 
            final long newIdent = Binder.clearCallingIdentity();    
//what？又调用这个Native方法了。这里主要是为了再次验证，线程所在的进程是否发生改变。 
            if (ident != newIdent) { 
                Log.wtf(TAG, "Thread identity changed from 0x" 
                        + Long.toHexString(ident) + " to 0x" 
                        + Long.toHexString(newIdent) + " while dispatching to " 
                        + msg.target.getClass().getName() + " " 
                        + msg.callback + " what=" + msg.what); 
            } 
 
            msg.recycleUnchecked();   
 //回收释放消息。 
        } 
    }  
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.

Looper myLooper = Looper.myLoop(); 
myLooper.quit();        //普通退出方式。 
myLooper.quitSafely();  //安全的退出方式。  
1.
2.
3.

Message next() { 
 //检查loop是否已经为退出状态。mPrt是Native层的MessageQueue的地址。 
//通过这个地址可以和Native层的MessageQueue互动。 
        final long ptr = mPtr; 
        if (ptr == 0) { 
            return null; 
        } 
 
        int pendingIdleHandlerCount = -1; 
        int nextPollTimeoutMillis = 0;       
//时间标记，当且仅当***次获取消息时才为0。因为它在死循环外面啊！ 
        for (;;) { 
            if (nextPollTimeoutMillis != 0) { 
                Binder.flushPendingCommands();      
//如果不是***次获取消息，调用Native的函数，让虚拟机刷新所有的饿Binder命令， 
//确保进程在执行可能阻塞的任务之前，释放之前的对象。 
            } 
 
            //这是一个Native的方法。 
            nativePollOnce(ptr, nextPollTimeoutMillis); 
 
            synchronized (this) {       //锁住MessageQueue 
                //获取当前的系统时间，用于后面和msg.when进行比较。 
                final long now = SystemClock.uptimeMillis(); 
                Message prevMsg = null; 
                Message msg = mMessages;        
 //获得当前MessageQueue中的***条消息 
                if (msg != null && msg.target == null) { 
 
                    do { 
                        prevMsg = msg; 
                        msg = msg.next; 
                    } while (msg != null && !msg.isAsynchronous()); 
                } 
                if (msg != null) { 
                    if (now < msg.when) {  
 //这个判断的意义在于只有到了Message应该被发送的时刻才去发送，否则继续循环。 
 //计算下一条消息的时间。注意***就是Integer.MAX_VALUE。 
                        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;         
 //返回一条消息给Looper。 
                    } 
                } else { 
                    // 如果取到的Message为null，将时间标记设置为-1。 
                    nextPollTimeoutMillis = -1; 
                } 
 
                // Process the quit message now that all pending messages have been handled. 
                if (mQuitting) { 
                    dispose(); 
                    return null; 
                } 
 
                // If first time idle, then get the number of idlers to run. 
                // Idle handles only run if the queue is empty or if the first message 
                // in the queue (possibly a barrier) is due to be handled in the future. 
                if (pendingIdleHandlerCount < 0 
                        && (mMessages == null || now < mMessages.when)) { 
                    pendingIdleHandlerCount = mIdleHandlers.size(); 
                } 
                if (pendingIdleHandlerCount <= 0) { 
                    // No idle handlers to run.  Loop and wait some more. 
                    mBlocked = true; 
                    continue; 
                } 
 
                if (mPendingIdleHandlers == null) { 
                    mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)]; 
                } 
                mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers); 
            } 
 
            // Run the idle handlers. 
            // We only ever reach this code block during the first iteration. 
            for (int i = 0; i < pendingIdleHandlerCount; i++) { 
                final IdleHandler idler = mPendingIdleHandlers[i]; 
                mPendingIdleHandlers[i] = null; // release the reference to the handler 
 
                boolean keep = false; 
                try { 
                    keep = idler.queueIdle(); 
                } catch (Throwable t) { 
                    Log.wtf(TAG, "IdleHandler threw exception", t); 
                } 
 
                if (!keep) { 
                    synchronized (this) { 
                        mIdleHandlers.remove(idler); 
                    } 
                } 
            } 
 
            // Reset the idle handler count to 0 so we do not run them again. 
            pendingIdleHandlerCount = 0; 
 
            // While calling an idle handler, a new message could have been delivered 
            // so go back and look again for a pending message without waiting. 
            nextPollTimeoutMillis = 0; 
        } 
    }  
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) { 
        msg.target = this;     
  //在这里给Message的target赋值。 
        if (mAsynchronous) { 
            msg.setAsynchronous(true);      
 //如果是异步，就标记为异步 
        } 
        return queue.enqueueMessage(msg, uptimeMillis);     
 //就是这个方法把Message添加到线程的MessageQueue中的。 
    }  
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

boolean enqueueMessage(Message msg, long when) { 
        if (msg.target == null) {   
 //没Handler调用是会抛异常的啊 
            throw new IllegalArgumentException("Message must have a target."); 
        } 
        if (msg.isInUse()) {       
  //不能使用一条正在使用中的Message。 
            throw new IllegalStateException(msg + " This message is already in use."); 
        } 
 
        synchronized (this) {      
  //锁住MessageQueue再往里添加消息。 
            if (mQuitting) {         
//如果MessageQueue被标记为退出，就返回。 
                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();         
//切换Message的使用状态为未使用。 
            msg.when = when;        
 //我们设置的延迟发送的时间。 
 //经过下面的逻辑，Message将会被“储存”在MessageQueue中。 
//实际上，Message在MessageQueue中的储存方式， 
//是使用Message.next逐个向后指向的单链表结构来储存的。 
//比如：A.next = B, B.next = C... 
            Message p = mMessages;   
//尝试获取当前Message 
            boolean needWake; 
            if (p == null || when == 0 || when < p.when) { 
                // 如果为null，说明是***条。 
                msg.next = p;    
                mMessages = msg;     
//设置当前的Message为传入的Message，也就是作为***条。 
                needWake = mBlocked; 
            } else { 
 
                needWake = mBlocked && p.target == null && msg.isAsynchronous(); 
                Message prev; 
//不满足作为***条Message的条件时，通过下面的逐步变换，将它放在***面。 
//这样便把Message“储存”到MessageQueue中了。 
                for (;;) { 
                    prev = p; 
                    p = p.next; 
                    if (p == null || when < p.when) { 
                        break; 
                    } 
                    if (needWake && p.isAsynchronous()) { 
                        needWake = false; 
                    } 
                } 
                msg.next = p;  
                prev.next = msg; 
            } 
 
 
            if (needWake) { 
                nativeWake(mPtr); 
            } 
        } 
        return true; 
    }  
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.

//这个main()方法可以认为是Android应用的起点 
public static void main(String[] args) { 
                。 
                。 
                。 
        Looper.prepareMainLooper();                             
 //主要作用和我们平时调用的Looper.prepare()差不多 
 
        ActivityThread thread = new ActivityThread();            
//创建本类实例 
        thread.attach(false); 
 
        if (sMainThreadHandler == null) { 
            sMainThreadHandler = thread.getHandler();            
//重点啊！这里取得了处理主线程事物的Handler。 
        } 
 
        if (false) { 
            Looper.myLooper().setMessageLogging(new 
                    LogPrinter(Log.DEBUG, "ActivityThread")); 
        } 
 
        // End of event ActivityThreadMain. 
        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER); 
        Looper.loop();                                           
//开始循环。可以看到，主线程本质上是阻塞的！ 
                。 
                。 
                。 
        }  
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.