Java 基础 —— 多线程（读书笔记）「一」

多线程对于 Android 开发者来说是基础。而且这类知识在计算机里也是很重要的一环，所以很有必要整理一番。

• 文章来源：itsCoder 的 WeeklyBolg 项目
• itsCoder主页：http://itscoder.com/
• 作者：谢三弟
• 审阅者：Jaeger

目录

• 目录
• 多线程的实现
  • Thread 源码
  • 线程的几个重要的函数
  • Wait() 的实践
  • Join() 的实践
  • Yield() 的实践
• 总结与参考

多线程的实现

来上代码：

// 最常见的两种方法启动新的线程
public static void startThread() {
    // 覆盖 run 方法
    new Thread() {
        @Override
        public void run() {
            // 耗时操作
        }
    }.start();

    // 传入 Runnable 对象
    new Thread(new Runnable() {
        public void run() {
            // 耗时操作
        }
    }).start();
}

其实第一个就是在 Thread 里覆写了 run() 函数，第二个是给 Thread 传了一个 Runnable 对象，在 Runnable 对象 run() 方法里进行耗时操作。
以前没有怎么考虑过他们两者的关系，今天我们来具体看看到底是什么鬼？

Thread 源码

进入 Thread 源码我们看看：

public class Thread implements Runnable {
    /* What will be run. */
    private Runnable target;

    /* The group of this thread */
    private ThreadGroup group;


    public Thread() {
        init(null, null, "Thread-" + nextThreadNum(), 0);
    }
    public Thread(Runnable target) {
    init(null, target, "Thread-" + nextThreadNum(), 0);
    }
}

源码很长，我进行了一点分割。一点一点的来解析看看。
我们首先知道 Thread 也是一个 Runnable ，它实现了 Runnable 接口，并且在 Thread 类中有一个 Runnable 类型的 target 对象。

构造方法里我们都会调用 init() 方法，接下来看看在该方法里做了如何的初始化配置。

    private void init(ThreadGroup g, Runnable target, String name,
                  long stackSize) {
    init(g, target, name, stackSize, null);
    }

    private void init(ThreadGroup g, Runnable target, String name,
                  long stackSize, AccessControlContext acc) {

    Thread parent = currentThread();
    SecurityManager security = System.getSecurityManager();
    // group 参数如果为 null ，则获得当前线程的 group（线程组）
    if (g == null) {
            g = parent.getThreadGroup();
    }
    // 代码省略

    this.group = g;
    this.daemon = parent.isDaemon();
    this.priority = parent.getPriority();
    // 设置 target（ Runnable 类型 ）
    this.target = target;

    }


    public synchronized void start() {

    // 将当前线程加入线程组
    group.add(this);

    boolean started = false;
    try {
        // 启动 native 方法启动新的线程
        start0();
        started = true;
    } finally {
        // 代码省略
    }

   private native void start0();



   @Override
   public void run() {
       if (target != null) {
        target.run();
       }
    }

从上我们可以明白，最终被线程执行的任务是 Runnable ，Thread 只是对 Runnable 的一个包装，并且通过一些状态对 Thread 进行管理和调度。
当启动一个线程时，如果 Thread 的 target 不为空，则会在子线程中执行这个 target 的 run() 函数，否则虚拟机就会执行该线程自身的 run() 函数。

线程的几个重要的函数

• wait()
  当一个线程执行到 wait() 方法时，它就进入到一个和该对象相关的等待池中，同时失去（释放）了对象的机锁，使得其他线程可以访问。用户可以使用 notify 、notifyAll 或者指定睡眠时间来唤醒当前等待池中的线程。
  注意：wait() notify() notifyAll() 必须放在 synchronized block 中，否则会抛出异常。
• sleep()
  该函数是 Thread 的静态函数，作用是使调用线程进入睡眠状态。因为 sleep() 是 Thread 类的静态方法，因此他不能改变对象的机锁。所以，当在一个 synchronized 块中调用 sleep() 方法时，线程虽然休眠了，但是对象的机锁并没有被释放，其他线程无法访问这个对象。
• join()
  等待目标线程执行完成之后继续执行。
• yield()
  线程礼让。目前线程由运行状态转换为就绪状态，也就是让出执行权限，让其他线程得以优先执行，但其他线程能否优先执行未知。

在源码中，查看 Thread 里的 State ，对几种状态解释的很清楚。

NEW 状态是指线程刚创建，尚未启动

RUNNABLE 状态是线程正在正常运行中，当然可能会有某种耗时计算 / IO 等待的操作 / CPU 时间片切换等, 这个状态下发生的等待一般是其他系统资源, 而不是锁, Sleep 等

BLOCKED 这个状态下，是在多个线程有同步操作的场景, 比如正在等待另一个线程的 synchronized 块的执行释放，或者可重入的 synchronized 块里别人调用 wait() 方法，也就是这时线程在等待进入临界区

WAITING 这个状态下是指线程拥有了某个锁之后，调用了他的 wait 方法，等待其他线程 / 锁拥有者调用 notify / notifyAll 一遍该线程可以继续下一步操作，这里要区分 BLOCKED 和 WATING ，一个是在临界点外面等待进入， 一个是在临界点里面 wait 等待别人 notify ， 线程调用了 join 方法 进入另外的线程的时候, 也会进入 WAITING 状态，等待被他 join 的线程执行结束

TIMED_WAITING 这个状态就是有限的 (时间限制) 的 WAITING， 一般出现在调用 wait(long), join(long) 等情况下，另外，一个线程 sleep 后, 也会进入 TIMED_WAITING 状态

TERMINATED 这个状态下表示 该线程的 run 方法已经执行完毕了, 基本上就等于死亡了 (当时如果线程被持久持有, 可能不会被回收)

Wait() 的实践

我们来看一段，wait() 的用途和效果。

    static void waitAndNotifyAll() {

        System.out.println("主线程运行");

        Thread thread = new WaitThread();
        thread.start();
        long startTime = System.currentTimeMillis();
        try {
            synchronized (sLockOject) {
                System.out.println("主线程等待");
                sLockOject.wait();
            }
        } catch (Exception e) {
        }

        long timeMs = System.currentTimeMillis() - startTime;
        System.out.println("主线程继续 —-> 等待耗时：" + timeMs + " ms");

    }

    static class WaitThread extends Thread {

        @Override
        public void run() {
            try {
                synchronized (sLockOject) {
                    System.out.println("进入子线程");
                    Thread.sleep(3000);
                    System.out.println("唤醒主线程");
                    sLockOject.notifyAll();
                }
            } catch (Exception e) {
            }
        }

    }

在 waitAndNotifyAll() 函数里，会启动一个 WaitThread 线程，在该线程中将会调用 sleep 函数睡眠 3 秒。线程启动之后在主线程调用 sLockOject 的 wait() 函数，使主线程进入等待状态，此时将不会继续执行。等 WaitThread 在 run() 函数沉睡了 3 秒后会调用 sLockOject 的 notifyAll() 函数，此时就会重新唤醒正在等待中的主线程，因此会继续往下执行。

结果如下：

主线程运行
主线程等待
进入子线程
唤醒主线程
主线程继续 —-> 等待耗时：3005 ms

wait()、notify() 机制通常用于等待机制的实现，当条件未满足时调用 wait 进入等待状态，一旦条件满足，调用 notify 或 notifyAll 唤醒等待的线程继续执行。

对于这里细节可能会有一些疑问。</br>

在子线程启动的时候，run() 函数里面已经持有了该对象锁。</br>

但是真实环境下，其实是主线程先持有对象锁，然后调用 wait() 进入等待区并且释放锁等待唤醒。

这个问题涉及到 JNI 代码，目前我只能从理论上来解释这个问题。
我们都知道一个线程 start() 并不是马上启动，而是需要 CPU 分配资源的，根据目前运行来看，分配资源的时间大于 Java 虚拟机运行指令的时间，所以主线程比子线程先拿到锁。
我们还可以知道一点，控制台打印出的时间是 3005 ms ，在代码里我们只等待了 3s 多出来的 5ms （这个数字会浮动）我们可以推断是，子线程获取 CPU 的时间加上唤醒主线程的时间。

上述只是自己的一个猜测，能力还有欠缺，准备深入学习。

不过推荐大家看看这篇文章 Synchnornized 在 JVM 下的实现 - 简书。

Join() 的实践

join() 的注释上面写着：

Waits for this thread to die.

意思是，阻塞当前调用 join() 函数所在的线程，直到接收线程执行完毕之后再继续。
我们来看看实践代码：

public class JoinThread {

    public static void main(String[] args) {
        joinDemo();
    }

    public static void joinDemo() {
        Worker worker1 = new Worker("work-1");
        Worker worker2 = new Worker("work-2");
        worker1.start();
        System.out.println("启动线程 1 ");

        try {
            // 调用 worker1 的 join 函数，主线，程会阻塞直到 woker1 执行完成
            worker1.join();
            System.out.println("启动线程 2");
            // 再启动线程 2 ，并且调用线程 2 的 join 函数，主线程会阻塞直到 woker2 执行完成
            worker2.start();
            worker2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("主线程继续执行");
    }

    static class Worker extends Thread {
        public Worker(String name) {
            super(name);
        }

        @Override
        public void run() {

            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {

                e.printStackTrace();
            }

            System.out.println("work in " + getName());

        }
    }
}

运行之后我们得到：

启动线程 1
work in work-1
启动线程 2
work in work-2
主线程继续执行

在 joinDemo() 方法里我们创建两个子线程，然后启动了 work1 线程，下一步调用了 woker1 的 join() 函数。此时，主线程会进入阻塞状态，直到 work1 执行完毕之后才开始继续执行。因为 Worker 的 run() 方法里会休眠 2 秒，因此线程每次调用了 join() 方法实际上都会阻塞 2 秒，直到 run() 方法执行完毕再继续。
所以，上述代码逻辑其实就是：

启动线程1 —-> 等待线程 1 执行完毕 —-> 启动线程2 —-> 等待线程 2 执行完毕 —-> 继续执行主线程代码

Yield() 的实践

yield() 是 Thread 的静态方法，注释上说：

A hint to the scheduler that the current thread is willing to yield its current use of a processor. The scheduler is free to ignore this hint.

大致意思是说：当前线程让出执行时间给其他的线程。
我们都知道，线程的执行是有时间片的，每个线程轮流占用 CPU 固定时间，执行周期到了之后让出执行权给其他线程。
yield() 就是主动让出执行权给其他线程。

来看看我们实践的代码：

public class YieldThreadTest {

    public static void main(String[] args) {
        YieldTread t1 = new YieldTread("thread-1");
        YieldTread t2 = new YieldTread("thread-2");
        t1.start();
        t2.start();
    }

    public static class YieldTread extends Thread {

        public YieldTread(String name) {
            super(name);
        }

        public synchronized void run() {
            for (int i = 0; i < 5; i++) {
                System.out.printf("%s 优先级为 [%d] -------> %d\n", this.getName(), this.getPriority(), i);
                // 当 i 为 2 时，调用当前线程的 yield 函数
                if (i == 2) {
                    Thread.yield();

                }
            }
        }

    }

}

在 main() 方法里创建了两个 YieldTread 线程，控制台输出结果如下：

thread-1 优先级为 [5] -------> 0
thread-1 优先级为 [5] -------> 1
thread-1 优先级为 [5] -------> 2

thread-2 优先级为 [5] -------> 0
thread-2 优先级为 [5] -------> 1
thread-2 优先级为 [5] -------> 2

thread-1 优先级为 [5] -------> 3
thread-1 优先级为 [5] -------> 4
thread-2 优先级为 [5] -------> 3
thread-2 优先级为 [5] -------> 4

通常情况下 t1 首先执行，让 t1 的 run() 函数执行到了 i 等于 2 时让出当前线程的执行时间。所以我们看到前三行都是 t1 在执行，让出执行时间后 t2 开始执行。后面逻辑简单思考下就得知了，这里也不做过多诠释。

因此，调用 yield() 就是让出当前线程的执行权，这样一来让其他线程得到优先执行。

总结与参考

本章内容属于线程的基础，本系列会更新到线程池相关。
这章内容也及其重要，因为它是后面的基础。
正确理解才能让我们对各种线程问题有方向和思路。

参考读物：

• Android 开发进阶 --- 从小工到专家
• 我是一个线程