Java—如何保证线程按顺序执行

当多个线程执行任务时，可以通过Thread.join()方法保证多线程的执行顺序，其内部是通过调用主线程的wait方法，使主线程等待；当子线程执行完成后，再唤醒主线程。
下面写一个简单的实例：创建ABCD四个线程，每个线程都需要将资源1和资源2持有1000ms才算完成任务

1、未使用join：执行顺序不确定

public class DeadLock {
    //声明资源a和b
    private static Object a=new Object();
    private static Object b=new Object();

    public static void sleep(){
        try {
            Thread.sleep(1000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }

    public static void thread(String name){
        synchronized (DeadLock.b){
            System.out.println(name+" 占有 资源1");
            sleep();
            synchronized (DeadLock.a){
                System.out.println(name+" 得到 资源2");
                sleep();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread a=new Thread(()->{
            thread("A");
        });
        
        Thread b=new Thread(()->{
            thread("线程B");
        });
       
        Thread c=new Thread(()->{
            thread("线程C");
        });
        
        Thread d=new Thread(()->{
            thread("线程D");
        });
        
        a.start();
        b.start();
        c.start();
        d.start();
    }
}

打印结果

线程A 占有 资源1
线程A 得到 资源2
线程D 占有 资源1
线程D 得到 资源2
线程C 占有 资源1
线程C 得到 资源2
线程B 占有 资源1
线程B 得到 资源2

2、使用join()：顺序执行

public class DeadLock {
    //声明资源a和b
    private static Object a=new Object();
    private static Object b=new Object();

    public static void sleep(){
        try {
            Thread.sleep(1000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }

    public static void thread(String name){
        synchronized (DeadLock.b){
            System.out.println(name+" 占有 资源1");
            sleep();
            synchronized (DeadLock.a){
                System.out.println(name+" 得到 资源2");
                sleep();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread a=new Thread(()->{
            thread("线程A");
        });
        
        Thread b=new Thread(()->{
            thread("线程B");
        });
        
        Thread c=new Thread(()->{
            thread("线程C");
        });
        
        Thread d=new Thread(()->{
            thread("线程D");
        });
        
        a.start();
        a.join();
        
        b.start();
        b.join();
        
        c.start();
        c.join();
        
        d.start();
        d.join();
    }
}

打印结果

线程A 占有 资源1
线程A 得到 资源2
线程B 占有 资源1
线程B 得到 资源2
线程C 占有 资源1
线程C 得到 资源2
线程D 占有 资源1
线程D 得到 资源2