同步和异步

1. 需要等待结果

这时既可以使用同步处理，也可以使用异步来处理

1. join实现(同步)

  1. static int result = 0;
  2. private static void test1() throws InterruptedException {
  3.     log.debug("开始");
  4.     Thread t1 = new Thread(() -> {
  5.         log.debug("开始");
  6.         sleep(1);
  7.         log.debug("结束");
  8.         result = 10;
  9.     }, "t1");
  10.     t1.start();
  11.     t1.join();
  12.     log.debug("结果为:{}", result);
  13. }

输出

  1. 20:30:40.453 [main] c.TestJoin - 开始
  2. 20:30:40.541 [Thread-0] c.TestJoin - 开始
  3. 20:30:41.543 [Thread-0] c.TestJoin - 结束
  4. 20:30:41.551 [main] c.TestJoin - 结果为:10

评价

  • 需要外部共享变量，不符合面向对象封装的思想
  • 必须等待线程结束，不能配合线程池使用

    2. Future实现(同步)

2. 不需要等待结果

统筹

案例-烧水 泡茶

解法1：join

  1. Thread t1 = new Thread(() -> {
  2.     log.debug("洗水壶");
  3.     sleep(1);
  4.     log.debug("烧开水");
  5.     sleep(15);
  6. }, "老王");
  8. Thread t2 = new Thread(() -> {
  9.     log.debug("洗茶壶");
  10.     sleep(1);
  11.     log.debug("洗茶杯");
  12.     sleep(2);
  13.     log.debug("拿茶叶");
  14.     sleep(1);
  15.     try {
  16.         t1.join();
  17.     } catch (InterruptedException e) {
  18.         e.printStackTrace();
  19.     }
  20.     log.debug("泡茶");
  21. }, "小王");
  23. t1.start();
  24. t2.start();

输出

  1. 19:19:37.547 [小王] c.TestMakeTea - 洗茶壶
  2. 19:19:37.547 [老王] c.TestMakeTea - 洗水壶
  3. 19:19:38.552 [小王] c.TestMakeTea - 洗茶杯
  4. 19:19:38.552 [老王] c.TestMakeTea - 烧开水
  5. 19:19:40.553 [小王] c.TestMakeTea - 拿茶叶
  6. 19:19:53.553 [小王] c.TestMakeTea - 泡茶

解法1 的 缺陷

  • 上面模拟的是小王等老王的水烧开了，小王泡茶，如果反过来要实现老王等小王的茶叶拿来了，老王泡茶呢？代码最好能适应两种情况

  • 上面的两个线程其实是各执行各的，如果要模拟老王把水壶交给小王泡茶，或模拟小王把茶叶交给老王泡茶
    呢

    解法2：wait/notify（没懂）

    1. class S2 {
    2.   static String kettle = "冷水";
    3.   static String tea = null;
    4.   static final Object lock = new Object();
    5.   static boolean maked = false;
    7.   public static void makeTea() {
    8.       new Thread(() -> {
    9.           log.debug("洗水壶");
    10.           sleep(1);
    11.           log.debug("烧开水");
    12.           sleep(5);
    13.           synchronized (lock) {
    14.               kettle = "开水";
    15.               lock.notifyAll();
    16.               while (tea == null) {
    17.                   try {
    18.                       lock.wait();
    19.                   } catch (InterruptedException e) {
    20.                       e.printStackTrace();
    21.                   }
    22.               }
    23.               if (!maked) {
    24.                   log.debug("拿({})泡({})", kettle, tea);
    25.                   maked = true;
    26.               }
    27.           }
    28.       }, "老王").start();
    29.       new Thread(() -> {
    30.           log.debug("洗茶壶");
    31.           sleep(1);
    32.           log.debug("洗茶杯");
    33.           sleep(2);
    34.           log.debug("拿茶叶");
    35.           sleep(1);
    36.           synchronized (lock) {
    37.               tea = "花茶";
    38.               lock.notifyAll();
    39.               while (kettle.equals("冷水")) {
    40.                   try {
    41.                       lock.wait();
    42.                   } catch (InterruptedException e) {
    43.                       e.printStackTrace();
    44.                   }
    45.               }
    46.               if (!maked) {
    47.                   log.debug("拿({})泡({})", kettle, tea);
    48.                   maked = true;
    49.               }
    50.           }
    51.       }, "小王").start();
    52.   }
    53. }

    输出

    1. 20:04:48.179 c.S2 [小王] - 洗茶壶
    2. 20:04:48.179 c.S2 [老王] - 洗水壶
    3. 20:04:49.185 c.S2 [老王] - 烧开水
    4. 20:04:49.185 c.S2 [小王] - 洗茶杯
    5. 20:04:51.185 c.S2 [小王] - 拿茶叶
    6. 20:04:54.185 c.S2 [老王] - 拿(开水)泡(花茶)

    解法2 解决了解法1 的问题，不过老王和小王需要相互等待，不如他们只负责各自的任务，泡茶交给第三人来做

    解法3：第三者协调（没懂）

    1. class S3 {
    2.   static String kettle = "冷水";
    3.   static String tea = null;
    4.   static final Object lock = new Object();
    6.   public static void makeTea() {
    7.       new Thread(() -> {
    8.           log.debug("洗水壶");
    9.           sleep(1);
    10.           log.debug("烧开水");
    11.           sleep(5);
    12.           synchronized (lock) {
    13.               kettle = "开水";
    14.               lock.notifyAll();
    15.           }
    16.       }, "老王").start();
    18.       new Thread(() -> {
    19.           log.debug("洗茶壶");
    20.           sleep(1);
    21.           log.debug("洗茶杯");
    22.           sleep(2);
    23.           log.debug("拿茶叶");
    24.           sleep(1);
    25.           synchronized (lock) {
    26.               tea = "花茶";
    27.               lock.notifyAll();
    28.           }
    29.       }, "小王").start();
    31.       new Thread(() -> {
    32.           synchronized (lock) {
    33.               while (kettle.equals("冷水") || tea == null) {
    34.                   try {
    35.                       lock.wait();
    36.                   } catch (InterruptedException e) {
    37.                       e.printStackTrace();
    38.                   }
    39.               }
    40.               log.debug("拿({})泡({})", kettle, tea);
    41.           }
    42.       }, "王夫人").start();
    43.   }
    44. }

    输出：

    1. 20:13:18.202 c.S3 [小王] - 洗茶壶
    2. 20:13:18.202 c.S3 [老王] - 洗水壶
    3. 20:13:19.206 c.S3 [小王] - 洗茶杯
    4. 20:13:19.206 c.S3 [老王] - 烧开水
    5. 20:13:21.206 c.S3 [小王] - 拿茶叶
    6. 20:13:24.207 c.S3 [王夫人] - 拿(开水)泡(花茶)