两个线程同时开启，如果让两个线程顺序执行

  1. synchronized，然后用 wait notify
  2. locksupport 的 park，unpark
  3. cas，不停的去判断另一个线程运行完了没有
  4. 使用很多种 aqs 实现，如 countdownlatch，semaphore，reentrylock 等
  5. blockingqueue
  6. exchanger
  7. 单一线程池——控制线程顺序运行 8.future 9.pipedinputstram 和 pipedoutputstream

使用join()

join在线程里面意味着“插队”，哪个线程调用join代表哪个线程插队先执行——但是插谁的队是有讲究了，不是说你可以插到队头去做第一个吃螃蟹的人，而是插到在当前运行线程的前面，比如系统目前运行线程A，在线程A里面调用了线程B.join方法，则接下来线程B会抢先在线程A面前执行，等到线程B全部执行完后才继续执行线程A。

而在JDK的解释中,join方法被解释成等待这个线程死亡，也就是等待这个线程全部执行完后才继续执行接下来的进程。

image.png

  1.     @Test
  2.     @SneakyThrows
  3.     public void useJoin() {
  5.         Thread t1 = new Thread(() -> System.out.println(T1_WORD));
  6.         Thread t2 = new Thread(() -> {
  7.             try {
  8.                 t1.join(); //插队
  9.             } catch (InterruptedException e) {
  10.                 e.printStackTrace();
  11.             }
  12.             System.out.println(T2_WORD);
  13.         });
  14.         t1.start();
  15.         t2.start();
  16.         t2.join();
  17.     }

使用synchronized关键字和 wait&notify

  1.     private static volatile Integer STATUS = 1;
  3.     @Test
  4.     @SneakyThrows
  5.     public void useSynchronized() {
  7.         Object object = new Object();
  8.         Thread t1 = new Thread(() -> {
  9.             while (true) {
  10.                 while (STATUS == 1) {
  11.                     synchronized (object) {
  12.                         try {
  13.                             System.out.println(T1_WORD);
  14.                             STATUS = 2;
  15.                             object.wait();
  16.                         } catch (InterruptedException e) {
  17.                             e.printStackTrace();
  18.                         }
  19.                     }
  20.                 }
  21.             }
  22.         }, "T1");
  23.         Thread t2 = new Thread(() -> {
  24.             while (true) {
  25.                 while (STATUS == 2) {
  26.                     synchronized (object) {
  27.                         try {
  28.                             System.out.println(T2_WORD);
  29.                             TimeUnit.SECONDS.sleep(2);
  30.                             STATUS = 1;
  31.                             object.notify();
  32.                         } catch (InterruptedException e) {
  33.                             e.printStackTrace();
  34.                         }
  35.                     }
  36.                 }
  37.             }
  38.         }, "T2");
  39.         t2.start();
  40.         t1.start();
  41.         t2.join();
  42.     }

使用LockSupport （链接）

  1.     @Test
  2.     @SneakyThrows
  3.     public void useLockSupport() {
  5.         Thread t2 = new Thread(() -> {
  6.             LockSupport.park();
  7.             System.out.println(T2_WORD);
  8.         });
  9.         Thread t1 = new Thread(() -> {
  10.             System.out.println(T1_WORD);
  11.             try {
  12.                 TimeUnit.SECONDS.sleep(2);
  13.             } catch (InterruptedException e) {
  14.                 e.printStackTrace();
  15.             }
  16.             LockSupport.unpark(t2);
  17.         });
  18.         t1.start();
  19.         t2.start();
  20.         t2.join();
  21.     }

使用CAS

  1.     private final AtomicBoolean THREAD_A = new AtomicBoolean(false);
  2.     @Test
  3.     @SneakyThrows
  4.     public void useCas() {
  6.         Thread t1 = new Thread(() -> {
  7.             System.out.println(T1_WORD);
  8.             try {
  9.                 TimeUnit.SECONDS.sleep(2);
  10.             } catch (InterruptedException e) {
  11.                 e.printStackTrace();
  12.             }
  13.             THREAD_A.set(true);
  14.         });
  16.         Thread t2 = new Thread(() -> {
  17.             while (true) {
  18.                 if (THREAD_A.get()) {
  19.                     System.out.println(T2_WORD);
  20.                     break;
  21.                 }
  22.             }
  23.         });
  24.         t1.start();
  25.         t2.start();
  26.         t2.join();
  27.     }

使用很多种 aqs 实现，如 countdownlatch，semaphore，reentrylock 等

CountDownLatch（2021.04.02 修正）

  1.     private static final CountDownLatch COUNT_DOWN_LATCH = new CountDownLatch(1);
  3.     @Test
  4.     @SneakyThrows
  5.     public void useCountDownLatch() {
  7.         Thread t1 = new Thread(() -> {
  9.             try {
  10.                 while (true) {
  11.                     while (STATUS == 1) {
  12.                         System.out.println(T1_WORD);
  13.                         COUNT_DOWN_LATCH.countDown();
  14.                         STATUS = 2;
  15.                         COUNT_DOWN_LATCH.await();
  16.                     }
  17.                 }
  18.             } catch (InterruptedException e) {
  19.                 e.printStackTrace();
  20.             }
  21.         });
  23.         Thread t2 = new Thread(() -> {
  24.             try {
  25.                 while (true) {
  26.                     while (STATUS == 2) {
  27.                         COUNT_DOWN_LATCH.await();
  28.                         System.out.println(T2_WORD);
  29.                         TimeUnit.SECONDS.sleep(2);
  30.                         STATUS = 1;
  31.                         COUNT_DOWN_LATCH.countDown();
  32.                     }
  33.                 }
  34.             } catch (InterruptedException e) {
  35.                 e.printStackTrace();
  36.             }
  37.         });
  38.         t1.start();
  39.         t2.start();
  40.         t2.join();
  41.     }

Semaphore（2021.04.02 修正）

  1.     private static final Semaphore SEMAPHORE_A = new Semaphore(1);
  2.     private static final Semaphore SEMAPHORE_B = new Semaphore(0);
  4.     @SneakyThrows
  5.     @Test
  6.     public void useSemaphore() {
  8.         Thread t1 = new Thread(() -> {
  9.             try {
  10.                 while (true) {
  11.                     SEMAPHORE_A.acquire();
  12.                     System.out.println(T1_WORD);
  13.                     SEMAPHORE_B.release();
  14.                 }
  15.             } catch (InterruptedException e) {
  16.                 e.printStackTrace();
  17.             }
  18.         });
  20.         Thread t2 = new Thread(() -> {
  21.             try {
  22.                 while (true) {
  23.                     SEMAPHORE_B.acquire();
  24.                     System.out.println(T2_WORD);
  25.                     System.out.println("-------------------");
  26.                     TimeUnit.SECONDS.sleep(2);
  27.                     SEMAPHORE_A.release();
  28.                 }
  29.             } catch (InterruptedException e) {
  30.                 e.printStackTrace();
  31.             }
  32.         });
  34.         t1.start();
  35.         t2.start();
  36.         t2.join();
  37.     }

ReentryLock

    private static final ReentrantLock REENTRANT_LOCK = new ReentrantLock();

    @Test
    @SneakyThrows
    public void useReentryLock() {

        Thread t1 = new Thread(() -> {
            try {
                REENTRANT_LOCK.lock();
                System.out.println(T1_WORD);
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                REENTRANT_LOCK.unlock();
            }
        });

        Thread t2 = new Thread(() -> {
            try {
                REENTRANT_LOCK.lock();
                System.out.println(T2_WORD);
            } finally {
                REENTRANT_LOCK.unlock();
            }
        });
        t1.start();
        t2.start();
        t2.join();
    }

使用BlockingQueue：take（），put（）

    private static final BlockingQueue<Integer> BLOCKING_QUEUE = new ArrayBlockingQueue<>(1);

    @Test
    @SneakyThrows
    public void useBlockingQueue() {

        Thread t1 = new Thread(() -> {
            try {
                System.out.println(T1_WORD);
               TimeUnit.SECONDS.sleep(3);
                BLOCKING_QUEUE.put(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread t2 = new Thread(() -> {
            try {
                Integer take = BLOCKING_QUEUE.take();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(T2_WORD);
        });
        t1.start();
        t2.start();
        t2.join();
    }

使用Exchanger

    private static final Exchanger<Boolean> EXCHANGER = new Exchanger<>();

    @Test
    @SneakyThrows
    public void useExchanger() {

        Thread t1 = new Thread(() -> {
            System.out.println(T1_WORD);
            try {
                EXCHANGER.exchange(true);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread t2 = new Thread(() -> {
            try {
                if (EXCHANGER.exchange(false)) {
                    System.out.println(T2_WORD);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

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

    }

使用单线程池

     @Test
    @SneakyThrows
    public void useSingleThreadPool() {

        ExecutorService executor = Executors.newSingleThreadExecutor();
        Thread t1 = new Thread(() -> {
            System.out.println(T1_WORD);
            try {
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread t2 = new Thread(() -> {
            System.out.println(T2_WORD);
            COUNT_DOWN_LATCH.countDown();
        });
        executor.execute(t1);
        executor.execute(t2);
        COUNT_DOWN_LATCH.await();
        executor.shutdown();

    }

使用Future

    @Test
    @SneakyThrows
    public void useFuture() {

        Future<Void> future = CompletableFuture.runAsync(() -> {
            System.out.println(T1_WORD);
            try {
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        future.get();
        System.out.println(T2_WORD);
    }

使用PipedInputStream和PipedOutputStream

    @Test
    @SneakyThrows
    public void usePipedInputStreamAndPipedOutputStream() {

        PipedInputStream pis = new PipedInputStream();
        PipedOutputStream pos = new PipedOutputStream();
        pis.connect(pos);
        Thread t1 = new Thread(() -> {
            System.out.println(T1_WORD);
            try {
                TimeUnit.SECONDS.sleep(3);
                pos.write(T1_WORD.getBytes());
            } catch (InterruptedException | IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    pos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread t2 = new Thread(() -> {
            byte[] byteArray = new byte[20];
            try {
                int readLength = pis.read(byteArray);
                while (readLength != -1) {
                    String newData = new String(byteArray, 0, readLength);
                    System.out.println("读出数据:" + newData);
                    readLength = pis.read(byteArray);
                }
                System.out.println(T2_WORD);
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    pis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.start();
        t2.start();
        t2.join();
    }