多线程与并发（十）：多线程同步模式

* 同步模式之两阶段终止（Two Phase Termination）

在一个线程 t1 如何优雅结束线程 t2 ? 优雅的意思是：给线程t2 一个料理后事的机会

1. 错误思路

• 使用线程对象的stop 方法停止线程
  • stop 方法会真正杀死线程，如果这时线程锁住了共享资源，那么当他被杀死后，就再也没有机会释放锁，其他线程将永远无法获取锁
• 使用System.exit(int)方法停止线程
  • 目的仅是停止一个线程，但这种做法会让整个程序都停止

例如：要做一个系统的健康状况监控，没个两秒记录一次

两阶段终止模式.jpg

public class InterruptModeTest {

    public static void main(String[] args) {
        TwoPhaseTermination twoPhaseTermination = new TwoPhaseTermination();
        twoPhaseTermination.start();

        try {
            Thread.sleep(3500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        twoPhaseTermination.stop();
    }
}
class TwoPhaseTermination{
    private Thread monitor;

    //启动监控线程
    public void start(){
        monitor = new Thread(()->{
            while (true){
                if (Thread.currentThread().isInterrupted()){
                    System.out.println("料理后事");
                    break;
                }

                try {
                    Thread.sleep(1000); //情况一：睡眠过程中被打断
                    System.out.println("执行监控..."); //情况二
                } catch (InterruptedException e) {
                    e.printStackTrace();

                    Thread.currentThread().interrupt(); //重新设置打断标记
                }

            }
        });

        monitor.start();
    }

    //终止线程
    public void stop(){
        monitor.interrupt();
    }
}

执行结果：
执行监控...
执行监控...
执行监控...
java.lang.InterruptedException: sleep interrupted
at java.lang.Thread.sleep(Native Method)
at com.lily.base.TwoPhaseTermination.lambda0(InterruptModeTest.java:32)
at java.lang.Thread.run(Thread.java:748)
料理后事

---

细节一：sleep 时打断
细节二：执行监控记录时打断

同步模式之保护性暂停

即Guarded Suspension, 用在一个线程等待另一个线程的执行结果。

要点

• 有一个结果需要从一个线程传递到另一个线程，让他们关联同一个GuardedObject

• 如果有结果不断从一个线程到另一个线程那么可以使用消息队列（见生产者/消费者）

• JDK中,join 的实现，Future 的实现，采用的就是此模式

• 因为要等待另一方的结果，因此归类到同步模式

  
  保护性暂停.jpg

• 代码实现

保护性暂停-扩展-增加超时

join方法

看一下join 的源码

保护性暂停-扩展-解耦等待和生产-分析

图中Futures就好比居民楼一层的信箱（每个信箱有房间编号），左侧的t0,t2,t4就好比等待邮件的居民，右侧t1,t3,t5就好比邮递员。

如果需要在多个类之间使用GuardedObject 对象，作为参数传递不是很方便，因此设计一个用来解耦的中间类，这样不仅能够解耦【结果等待者】和【结果生产者】，还能够同时支持多个任务的管理。

异步模式之工作线程

1. 定义
   让有限的工作线程来轮流异步处理无限多的任务。也可以将其归类为分工模式，它的典型实现就是线程池，也体现了经典设计模式中的享元模式。

例如，海底捞的服务员（线程），轮流处理每位客人的点餐（任务），如果每位客人都配备一名专属的服务员，那么成本就太高了（对比另一种多线程设计模式：Thread-Per-Message）

注意，不同任务类型应该使用不同的线程池，这样能够避免饥饿，并能提升效率

例如，如果一个餐馆的工人既要招呼客人，又要到后厨做菜显然效率不高，分成服务员（线程池A），厨师（线程池B）更为合理，当然你能想到更细致的分工。

2.饥饿

固定大小线程池会有饥饿现象

• 两个工人是同一个线程池的两个线程
• 他们要做的事是：为客人点餐和到后厨做菜，这时两个阶段的工作。
  • 客人点餐：必须先点完餐，等菜做好，上菜，在此期间处理点餐的工人必须等待
  • 后厨做菜：没啥说的，做就是了
• 比如工人A处理了点餐任务，接下来它要等着工人B把菜做好，然后上菜，他两也配合的蛮好的
• 但现在同时来了两个客人，这个时候工人A 和 工人B 都去处理点餐了，这时没人做菜了，死锁

public class TestDeadLock {

    static final List<String> MENU = Arrays.asList("地三鲜","宫保鸡丁","辣子鸡丁","烤翅");
    static Random RANDOM = new Random();
    static String cooking(){
        return MENU.get(RANDOM.nextInt(MENU.size()));
    }

    public static void main(String[] args) throws InterruptedException{
        ExecutorService pool = Executors.newFixedThreadPool(2);

        pool.execute(()->{
            System.out.println("处理点餐...");

            Future<String> f = pool.submit(()->{
                System.out.println("做菜");
                return cooking();
            });

            try {
                System.out.println("上菜 " + f.get());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }

        });

        pool.execute(()->{
            System.out.println("处理点餐...");

            Future<String> f = pool.submit(()->{
                System.out.println("做菜");
                return cooking();
            });

            try {
                System.out.println("上菜 " + f.get());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }

        });
    }
}

执行结果：
处理点餐...
处理点餐...

---

饥饿解决
不同的任务类型使用不同的线程池

public class TestDeadLock {

   static final List<String> MENU = Arrays.asList("地三鲜","宫保鸡丁","辣子鸡丁","烤翅");
   static Random RANDOM = new Random();
   static String cooking(){
       return MENU.get(RANDOM.nextInt(MENU.size()));
   }

   public static void main(String[] args) throws InterruptedException{
       ExecutorService orderPool = Executors.newFixedThreadPool(2);
       ExecutorService cookPool = Executors.newFixedThreadPool(2);

       orderPool.execute(()->{
           System.out.println(Thread.currentThread().getName() + " 处理点餐...");

           Future<String> f = cookPool.submit(()->{
               System.out.println(Thread.currentThread().getName() + " 做菜");
               return cooking();
           });

           try {
               System.out.println(Thread.currentThread().getName() + " 上菜 " + f.get());
           } catch (InterruptedException | ExecutionException e) {
               e.printStackTrace();
           }

       });

       orderPool.execute(()->{
           System.out.println(Thread.currentThread().getName() + " 处理点餐...");

           Future<String> f = cookPool.submit(()->{
               System.out.println(Thread.currentThread().getName() + " 做菜");
               return cooking();
           });

           try {
               System.out.println(Thread.currentThread().getName() +" 上菜 " + f.get());
           } catch (InterruptedException | ExecutionException e) {
               e.printStackTrace();
           }

       });
   }
}

执行结果：
pool-1-thread-1 处理点餐...
pool-1-thread-2 处理点餐...
pool-2-thread-1 做菜
pool-1-thread-2 上菜 烤翅
pool-2-thread-2 做菜
pool-1-thread-1 上菜 辣子鸡丁

---