Java 指定线程执行顺序（三种方式）其实是四种

转载：https://blog.csdn.net/eene894777/article/details/74942485

  方法一：通过共享对象锁加上可见变量来实现。

public class MyService {
 
    private volatile int orderNum = 1;
 
    public synchronized void methodA() {
        try {
            while (orderNum != 1) {
                wait();
            }
            for (int i = 0; i < 2; i++) {
                System.out.println("AAAAA");
            }
            orderNum = 2;
            notifyAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
 
    public synchronized void methodB() {
        try {
            while (orderNum != 2) {
                wait();
            }
            for (int i = 0; i < 2; i++) {
                System.out.println("BBBBB");
            }
            orderNum = 3;
            notifyAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
 
    public synchronized void methodC() {
        try {
            while (orderNum != 3) {
                wait();
            }
            for (int i = 0; i < 2; i++) {
                System.out.println("CCCCC");
            }
            orderNum = 1;
            notifyAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

 
import service.MyService;
public class ThreadAA extends Thread {
 
    private MyService dbtools;
 
    public ThreadAA(MyService dbtools) {
        super();
        this.dbtools = dbtools;
    }
 
    @Override
    public void run() {
        dbtools.methodA();
    }
 
}

import service.MyService;
public class ThreadBB extends Thread {
 
    private MyService dbtools;
 
    public ThreadBB(MyService dbtools) {
        super();
        this.dbtools = dbtools;
    }
 
    @Override
    public void run() {
        dbtools.methodB();
    }
 
}

import service.MyService;
public class ThreadCC extends Thread {
 
    private MyService dbtools;
 
    public ThreadCC(MyService dbtools) {
        this.dbtools = dbtools;
    }
 
    @Override
    public void run() {
        dbtools.methodC();
    }
 
}

import extthread.ThreadCC;
import service.MyService;
import extthread.ThreadAA;
import extthread.ThreadBB;
 
public class Run {
 
    public static void main(String[] args) {
        MyService myService = new MyService();
        for (int i = 0; i < 2; i++) {
            ThreadBB output = new ThreadBB(myService);
            output.start();
            ThreadAA input = new ThreadAA(myService);
            input.start();
            ThreadCC threadCC = new ThreadCC(myService);
            threadCC.start();
        }
    }
 
}

   方法二：通过主线程Join()

class T11 extends Thread {
    public void run() {
        System.out.println("in T1");
    }
}
 
class T22 extends Thread {
    public void run() {
        System.out.println("in T2");
    }
}
 
class T33 extends Thread {
    public void run() {
        System.out.println("in T3");
    }
}
 
public class Test2 {
    public static void main(String[] args) throws InterruptedException {
        T11 t1 = new T11();
        T22 t2 = new T22();
        T33 t3 = new T33();
        t1.start();
        t1.join();
        t2.start();
        t2.join();
        t3.start();
    }
}

方法三：通过线程执行时Join()

class T1 extends Thread {
    public void run(){
        Random random = new Random();
        try {
            Thread.sleep(random.nextInt(1000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("in T1");
    }
}
 
class T2 extends Thread{
    private Thread thread;
    public T2(Thread thread) {
        this.thread = thread;
    }
 
    public void run(){
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("in T2");
    }
}
 
class T3 extends Thread{
    private Thread thread;
    public T3(Thread thread) {
        this.thread = thread;
    }
 
    public void run(){
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("in T3");
    }
}
 
public class Test {
    public static void main(String[] args) throws InterruptedException {
        T1 t1 = new T1();
        T2 t2 = new T2(t1);
        T3 t3 = new T3(t2);
        t2.start();
        t1.start();
        t3.start();
    }
}

方法四，使用线程池newSingleThreadExecutor()

package com.zyh.controller.test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * student threads
 *
 * @author 1101399
 * @CreateDate 2018-7-30 下午2:09:01
 */
public class ThreadTestOne {

    public static void main(String[] args) throws InterruptedException {
        final ThreadTest A1 = new ThreadTest("A1");
        final ThreadTest A2 = new ThreadTest("A2");
        final ThreadTest A3 = new ThreadTest("A3");
        // A1.start(); TODO 屏蔽
        // A2.start(); TODO 屏蔽
        A1.join();
        A2.join();
        System.out.println("方法一实现多线程");
        if (!A1.isAlive()) {// A1 线程不存在的时候控制台打印一条信息
            System.out.println("A1执行完毕？！");
        }

        final Thread B1 = new Thread(new RunnableTest("B1"));
        // B1.start(); TODO 屏蔽
        final Thread B2 = new Thread(new RunnableTest("B2"));
        // B2.start(); TODO 屏蔽
        B1.join();
        B2.join();
        System.out.println("方法二实现多线程");

        /**
         * 直接实现线程的开辟 FIXME
         */
        final Thread C1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    A1.join();
                    A2.join();
                    B1.join();
                    B2.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                for (int i = 0; i < 15; i++) {
                    System.out.println("··············");
                }
            }

        });
        // C1.start(); TODO 屏蔽
        C1.join();
        System.out.println("方法三实现多线程");


        System.out.println("线程池的应用");
        // 线程池的学习&应用 TODO 依次执行
        ExecutorService executor = Executors.newSingleThreadExecutor();
        executor.submit(A1);
        executor.submit(A2);
        executor.submit(A3);
        executor.execute(B1);// 这种样子的线程类就是不执行
        executor.execute(A1);
        executor.submit(B1);// 这三种线程的实现方式之前不能 XXX start()启动线程
        executor.submit(B2);// 这三种线程的实现方式之前不能 XXX start()启动线程
        executor.submit(C1);// 这三种线程的实现方式之前不能 XXX start()启动线程

        executor.shutdown();// 停止传入任务

        // executor.shutdownNow();// 停止线程池-对线程池说STOP
        // 会导致线程池中第一个线程的sleep出现sleep interrupted异常
        // 该函数的核心是：它向该线程发起interrupt()请求，而sleep()方法遇到有interrupt()请求时，会抛出InterruptedException()，并继续往下执行
        // 运行到这条语句直接停止线程池-检测线程停止后执行的join()函数毫无意义，不能生效
    }

    /**
     * 继承Thread来实现多线程编程 FIXME
     */
    public static class ThreadTest extends Thread {
        public String nameOne;
        public StringBuffer nameTwo;
        public StringBuilder nameThree;
        private long time;

        // 构造函数
        public ThreadTest(String name) {
            this.nameOne = name;
        }

        // 构造函数
        public ThreadTest(String name, long time) {
            this.nameOne = name;
            this.time = time;
        }

        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                System.out.println(this.nameOne + " Thread运行第 " + i + " 次!");
                try {
                    if (this.time != 0) {
                        sleep(this.time + i);
                        System.out.println(this.nameOne + "-time-" + (time + i));
                    } else {
                        // sleep((int) Math.random() * 1000);
                        sleep(50);
                        System.out
                                .println(this.nameOne + "-random-" + (int) (Math.random() * 1000));
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 实现接口Runnable来实现多线程编程 FIXME
     */
    public static class RunnableTest implements Runnable {

        public String nameOne;
        public StringBuffer nameTwo;
        public StringBuilder nameThree;
        private long time;

        public RunnableTest(String name) {
            this.nameOne = name;
        }

        public RunnableTest(String name, long time) {
            this.nameOne = name;
            this.time = time;
        }

        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                System.out.println(this.nameOne + " Runnable运行第 " + i + " 次!");
                try {
                    if (this.time != 0) {
                        Thread.sleep(this.time + i);
                        System.out.println(this.nameOne + "-time-" + (time + i));
                    } else {
                        Thread.sleep((int) Math.random() * 1000);
                        System.out
                                .println(this.nameOne + "-random-" + (int) (Math.random() * 1000));
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }

}

newSingleThreadExecutor()单线程化线程池

      final Thread B1 = new Thread(new RunnableTest("B1"));
        B1.start();// TODO 屏蔽
        final Thread B2 = new Thread(new RunnableTest("B2"));
        B2.start();// TODO 屏蔽

final Thread C1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    A1.join();
                    A2.join();
                    B1.join();
                    B2.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                for (int i = 0; i < 2; i++) {
                    System.out.println("··············");
                }
            }

        });
        C1.start();// TODO 屏蔽


        executor.submit(B1);// 这三种线程的实现方式之前不能 XXX start()启动线程
        executor.submit(B2);// 这三种线程的实现方式之前不能 XXX start()启动线程
        executor.submit(C1);// 这三种线程的实现方式之前不能 XXX start()启动线程