前言#

这几天忙一点私事，今天回来赶紧把面试总结接着写下去，这次来看看Thread的join（）方法和sleep（）和wait（）方法的区别。

正文#

<h2> 线程同步</h2>

上一篇提到了线程同步的问题，主要是通过锁的形式来进行线程间的唤醒和等待，线程之间的协作都是很密切的，有些时候我们需要线程之间顺序执行要怎么做呢？？？

方法有很多，除了之前讲过的以外，我所了解的还有两种方法：

<h3>一、Thread的join()方法</h3>

join（）可以让线程顺序执行，他内部也是锁的实现机制，看一下demo代码：

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        startFirstThread();
        startSecondThread();
        Log.e("lzp", "over");
    }

    private void startFirstThread(){
        Thread thread = new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 100; i++){
                    Log.e("lzp", "first:"+ i);
                    if (i == 50){
                        try {
                            sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        };
        thread.start();
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void startSecondThread(){
        Thread thread =  new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 100; i++){
                    Log.e("lzp", "second:"+ i);
                }
            }
        };
        thread.start();
    }
}

代码比较简单，就是同时开启了两条线程，如果没有没有join方法的话，肯定这两条线程是同时执行的，log的结果也是乱的。

这里写图片描述

然后在看一下第一条线程使用了join（）之后的结果，为了突出显示显示join的作用，我还在oncreate也输入了一句over。

这里写图片描述

从log上来看，当第一条线程使用了join之后，主线程和第二条线程都暂停了，等待第一条线程执行完毕，在接着往下执行，说明调用了join之后，系统把所有的资源都给了第一条线程，就算是sleep（），也必要等待他执行完毕。

下面是第二条线程也join的结果：

这里写图片描述 这里写图片描述

所以join的作用就相当于阻塞掉除了当前线程以外的所有的线程（包括主线程），等待自己执行结束，并且遵守先来后到的排队原则，先join的先执行，后join后执行，必须注意的是，最后的线程不能使用join，否则线程就全部在等待中，可以把最后一条不使用join的线程，当做此次排队的结束。例如大家可以把demo中的oncreate中的最后的Log去掉，并且把第二条线程也join，看一下运行结果。

所以根据Thread的join（）方法的特性，可以实现线程的同步。

<h3>二、单线程池</h3>

SingleThreadExecutor：是单线程池，他保证在自己线程池中提交的线程，按照提交的顺序，顺序执行且同时只有一条线程在跑。

也就是他只能运行一条线程，运行完了再跑下一条，例如我们平时线程操作数据库，防止多线程并发，就会经常使用SingleThreadExecutor。

那我们来修改一下代码：

public class MainActivity extends AppCompatActivity {

    /**
     * 单线程池
     * */
    private Executor executor = Executors.newSingleThreadExecutor();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        startFirstThread();
        startSecondThread();
        Log.e("lzp", "over");

    }

    private void startFirstThread(){
        executor.execute(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++){
                    Log.e("lzp", "first:"+ i);
                    if (i == 50){
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        });
    }

    private void startSecondThread(){
        executor.execute(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++){
                    Log.e("lzp", "second:"+ i);
                }
            }
        });
    }
}

demo中顺序提交了两条线程，并且第一条线程还sleep了一秒，看一下运行结果：

这里写图片描述

线程1和线程2确实是顺序执行的，就算是sleep也不行，但是同时也发现线程池不能把主线程的执行顺序也包括进来，而这一点join可以做到。

ok，那线程同步就到此结束了，当然还有一些另类的方法，例如通过handler来发送消息或者是其他的方法，这里不做介绍了，需求是死的，但是套路是活的，有更好的方法，可以留言，大家一起交流。

<h2>sleep() 、wait（）的区别</h2>

这个问题当时是把我弄蒙圈了，因为我第一反应不知道为啥他俩要比较，因为觉得他俩好像没多大的关系，后来在面试官的提示下我才明白他的意思，在这里做个总结：

1、sleep（）属于Thread，wait（）属于 Thread。

2、sleep（）仅仅是睡眠，不涉及到锁的释放问题，睡眠时间结束自动恢复到运行状态。
wait（）绑定了某个对象的锁，等待该对象的notify（），notifyAll（）来唤醒自己，等待的时间是未知的，甚至出现死锁。

那sleep（）和wait（）会释放cpu吗？

这个问题在网上是五花八门，刚才我们已经使用了sleep（），就可以得到以下结论：

非线程池中
1、sleep（）中会释放cpu，让cpu去执行其他的线程，睡眠时间结束，在重新占用cpu运行。（第一个demo的代码，线程1在睡眠中，直接把cpu交给了线程2）

2、如果调用了join方法（），相当于没有释放cpu，因为其他线程无法得到执行。（join方法的demo，顺序执行，sleep无影响）。

线程池中
跟非线程池中一样，会把资源让给同时运行的线程，但是仍然会占用线程池的位置，例如demo中的单线程池，尽管sleep，但是位置仍然占用，所以下一个线程不会得到执行。

总结：无论怎用sleep都会释放cpu，但是在线程池中会占用位置。

那么再来看看wait，wait跟sleep没有太大差别，cpu肯定是要释放出去的，那么他会占用线程池中的位置吗？

修改一下代码：

private void startFirstThread(){
        executor.execute(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++){
                    Log.e("lzp", "first:"+ i);
                    if (i == 50){
                        try {
                            synchronized (this){
                                wait();
                            }
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        });
    }

我在第一个线程中，直接wait，看一下log：

这里写图片描述

log在50的时候停止了，第二条线程没有执行，说明wait也会占用线程池中的位置。

总结#

首先我们聊了聊线程同步的问题，实现线程顺序执行有很多种方法，就看大家自己的思考了，脑洞的同时也得思考合理性和实用性，好坏就不做评判了。

然后去讨论一下sleep和wait的区别，总结：他俩都是要释放cpu的，并且在线程池中会占用位置。如果你也遇到了这样的问题，就好办多了。

OK，那这一篇就结束了，有什么问题和建议欢迎留言。

demo下载地址