SLEEP

sleep 意思是睡眠，当前线程暂停一段时间让给别的线程去运行。sleep是怎么复活的？由你的睡眠时间而定，等睡眠到规定的时间自动复活，CPU 没有线程的概念，会不断的从内存中获取指令去执行，睡眠的意思就是当前线程让出cpu 由其他线程去执行。

  1.  static void testSleep() {
  2.         new Thread(()->{
  3.             for(int i=0; i<100; i++) {
  4.                 System.out.println("A" + i);
  5.                 try {
  6.                     Thread.sleep(500);
  7.                     //TimeUnit.Milliseconds.sleep(500)
  8.                 } catch (InterruptedException e) {
  9.                     e.printStackTrace();
  10.                 }
  11.             }
  12.         }).start();
  13.     }
  15.     public static void main(String[] args) throws InterruptedException {
  16.          sleep();
  17. //        yield();
  18.    //      join();
  19.     }

YIELD

yield 让出当前cpu进入线程的等待队列，下一次能不能进入线程看自己能不能抢到，当yield让出cpu后后续更大可能是将等待队列里面的线程拿过来进行执行。暂时没有应用场景。

  2.     static void yield(){
  3.         new Thread(()->{
  4.             for (int i = 0; i < 100; i++) {
  5.                 try {
  6.                     if (i % 10 == 0) {
  7.                         Thread.yield();
  8.                     }
  9.                     System.out.println("i am thread a");
  10.                     TimeUnit.SECONDS.sleep(1);
  11.                 } catch (InterruptedException e) {
  12.                     e.printStackTrace();
  13.                 }
  14.             }
  15.         }).start();
  17.         new Thread(()->{
  18.             for (int i = 0; i < 100; i++) {
  19.                 try {
  20.                     if (i % 10 == 0) {
  21.                         Thread.yield();
  22.                     }
  23.                     System.out.println("i am thread b");
  24.                     TimeUnit.SECONDS.sleep(1);
  25.                 } catch (InterruptedException e) {
  26.                     e.printStackTrace();
  27.                 }
  28.             }
  29.         }).start();
  30.     }
  32.     public static void main(String[] args) throws InterruptedException {
  33. //        sleep();
  34.          yield();
  35.          //join();
  36.     }

JOIN

在当前线程加入你调用join的线程，此处是t1 线程加入到t2线程里面去了，当t2线程执行到 join的时候，就会去执行t1线程，只有t1 线程执行完成之后才会接着执行t2线程。

  1.    static void join() throws InterruptedException {
  2.         Thread t1 = new Thread(() -> {
  3.             for (int i = 0; i < 100; i++) {
  4.                 try {
  5.                     System.out.println("i am thread a");
  6.                     TimeUnit.SECONDS.sleep(1000);
  7.                 } catch (InterruptedException e) {
  8.                     e.printStackTrace();
  9.                 }
  10.             }
  11.         });
  13.         Thread t2 = new Thread(() -> {
  14.             for (int i = 0; i < 100; i++) {
  15.                 try {
  16.                      System.out.println("i am thread b");
  17.                       t1.join();
  18.                       System.out.println("i am thread b");
  19.                     TimeUnit.SECONDS.sleep(1);
  20.                 } catch (InterruptedException e) {
  21.                     e.printStackTrace();
  22.                 }
  23.             }
  24.         });
  25.         t1.start();
  26.         TimeUnit.SECONDS.sleep(10);
  27.         t2.start();
  28.     }
  30.     public static void main(String[] args) throws InterruptedException {
  31. //        sleep();
  32. //        yield();
  33.          join();
  34.     }