前言：
在看了这些多线程的知识之后，突发奇想到怎么让多线程有序执行呢？
第一种：用Thread.join（）方法来确定该线程执行完毕
第二种：用线程池的队列来执行任务
第三种：用公共锁Object，配合wait/notifyAll方法，睡眠自己，唤醒另一个线程~

join方法：
join方法是阻塞的，会一定等到取消或者超时为止，这样就可以按顺序来。
@Slf4j
public class JoinExample {

    public static void main(String[] args) throws InterruptedException{

        log.info("{} is start", Thread.currentThread().getName());

        Thread t0 = new Thread(() -> {
            try{
                log.info( "{} is Start,sleep 6 second", Thread.currentThread().getName());
                Thread.sleep(6000);
                log.info("{} is Completed", Thread.currentThread().getName());
            }catch (InterruptedException e){
                log.error("exception", e);
            }
        });
        t0.start();
        t0.join();

        Thread t1 = new Thread(() -> {
            try{
                log.info( "{} is Start,sleep 2 second", Thread.currentThread().getName());
                Thread.sleep(2000);
                log.info( "{} is Completed", Thread.currentThread().getName());
            }catch (InterruptedException e){
                log.error("exception", e);
            }
        });
        t1.start();
        t1.join();

        log.info("{} is Completed", Thread.currentThread().getName() );
    }
}


再来一个，
@Slf4j
public class JoinExample1 {

    public static void main(String[] args) {
        final Thread t1 = new Thread(() -> {
            log.info("{} is first", Thread.currentThread().getName());
        },"线程1");

        final Thread t2 = new Thread(() -> {
            try {
                t1.join();
                log.info("{} is second", Thread.currentThread().getName());
            }catch (InterruptedException e){
                log.info("exception", e);
            }
        },"线程2");

        final Thread t3 = new Thread(() -> {
            try {
                t2.join();
                log.info("{} is third", Thread.currentThread().getName());
            }catch (InterruptedException e){
                log.info("exception", e);
            }
        },"线程3");
        
        t2.start();
        t3.start();
        t1.start();
//顺序sart是没有关系的
    }
}

线程池newSingleThreadExecutor：
@Slf4j
public class JoinExample2 {

    public static void main(String[] args) {

        final Thread t1 = new Thread(() -> {
            log.info("{}, the first 运行了！", Thread.currentThread().getName());
        },"线程1");


        final Thread t2 = new Thread(() -> {
            log.info("{}, the second 运行了！", Thread.currentThread().getName());
        }, "线程2");

        final Thread t3 = new Thread(() -> {
            log.info("{}, the third 运行了！", Thread.currentThread().getName());
        }, "线程3");

        ExecutorService exec = Executors.newSingleThreadExecutor();
        exec.submit(t1);
        exec.submit(t2);
        exec.submit(t3);
        exec.shutdown();
    }
}
由于线程池中只有一个，所以默认就它一个能运行的线程~~

和wait()有点类似，join()方法可以让多个线程之间排队等待，按照一定的顺序执行。join方法是阻塞的，会一直等到取消或超时为止。假如现在有三个线程，main,t0,t1，要在main线程启动之后相继执行t0，t1,那么可以在main线程之后，启动t0,t0加入执行队列，即t0.join(),之后再启动t1,t1.join()。


public class JoinDemo {

      public static void main(String args[]) throws InterruptedException{

            System.out.println(Thread.currentThread().getName() + " is Started");

            Thread t0 = new Thread(){
                public void run(){
                    try {
                        System.out.println(Thread.currentThread().getName() + " is Started,sleep 2 second");
                        Thread.sleep(2000);
                        System.out.println(Thread.currentThread().getName() + " is Completed");
                    } catch (InterruptedException ex) {
                    }
                }
            };

            t0.start();
            t0.join();


            Thread t1 = new Thread(){
                public void run(){
                    try {
                        System.out.println(Thread.currentThread().getName() + " is Started,sleep 6 second");
                        Thread.sleep(6000);
                        System.out.println(Thread.currentThread().getName() + " is Completed");
                    } catch (InterruptedException ex) {
                    }
                }
            };

            t1.start();
            t1.join();

            System.out.println(Thread.currentThread().getName() + " is Completed");
        }

}

执行结果：



main is Started
Thread-0 is Started,sleep 2 second
Thread-0 is Completed
Thread-1 is Started,sleep 6 second
Thread-1 is Completed
main is Completed

可以使用互斥锁完成多个任务，有序的进程工作，这就是线程的同步
from threading import Thread, Lock
import time
mutex1= Lock()  #
创建一个互斥锁
mutex2= Lock()  #
创建一个互斥锁
mutex3= Lock()  #
创建一个互斥锁
 
 
def fun1():
    while 1:
        mutex1.acquire()  #
阻塞
        print("线程1
执行")
        mutex2.release()   #
释放锁2，让线程2继续执行
        time.sleep(0.1)
 
 
def fun2():
    while 1:
        mutex2.acquire()  #
阻塞
        print("线程2
执行")
        mutex3.release()   #
释放锁3，让线程3继续执行
        time.sleep(0.1)
 
 
def fun3():
    while 1:
        mutex3.acquire()  #
阻塞
        print("线程3
执行")
        mutex1.release()   #
释放锁1，让线程1继续执行
        time.sleep(0.1)
 
t1 =Thread(target=fun1)  #
创建一个线程对象
t2 =Thread(target=fun2)  #
创建一个线程对象
t3 =Thread(target=fun3)  #
创建一个线程对象
 
mutex2.acquire()  #
将锁2设置为上锁，线程2不能运行
mutex3.acquire()  #
将锁2设置为上锁，线程2不能运行
 
t1.start()  #
开启线程的执行
t2.start()
t3.start()
 
t1.join()  #
回收线程资源
t2.join()
t3.join()

1、使用Thread.join()方法

thread.Join把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B

public class ThreadTest1 {
    public static void main(String[] args) {
        Thread t1 = new Thread(new Work(null));
        Thread t2 = new Thread(new Work(t1));
        Thread t3 = new Thread(new Work(t2));
        t1.setName("第一个");
        t2.setName("第二个");
        t3.setName("第三个");
        t1.start();
        t2.start();
        t3.start();
    }
    static class Work implements Runnable {
        private Thread thread;
        public Work(Thread thread) {
            this.thread = thread;
        }
        @Override
        public void run() {
            if (thread != null) {
                try {
                    thread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                execute();
            } else {
                execute();
            }
        }
        private void execute() {
            System.out.println("线程" + Thread.currentThread().getName() + "执行");
        }
    }
}

执行结果：
线程第一个执行
线程第二个执行
线程第三个执行

Process finished with exit code 0

2、使用线程池使用一个固定大小的线程池
public class ThreadTest2 {
    private static ExecutorService es = Executors.newFixedThreadPool(1);
    public static void main(String[] args) {
        Work t1 = new Work("t1");
        Work t2 = new Work("t2");
        Work t3 = new Work("t3");
        es.submit(t1);
        es.submit(t2);
        es.submit(t3);
    }
    static class Work implements Runnable {
        private String key;
        public Work(String key) {
            this.key = key;
        }
        @Override
        public void run() {
            execute();
        }
        private void execute() {
            try {
                TimeUnit.MILLISECONDS.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程：" + Thread.currentThread().getName() + "执行" + key);
        }
    }
}


执行结果：
线程：pool-1-thread-1执行t1
线程：pool-1-thread-1执行t2
线程：pool-1-thread-1执行t3

Process finished with exit code 0

注意：
线程池shutdown方法和shutdownNow有区别，shutdown要等所有线程执行完后再关闭，shutdownNow将线程池内正在执行的线程强制停掉。