多线程学习-基础（ 十一）synchronized关键字修饰方法的简单案例

一、本案例设计到的知识点

　　（1）Object的notify(),notifyAll(),wait()等方法

　　（2）Thread的sleep(),interrupt()。

　　（3）如何终止线程。

　　（4）如何控制多个线程之间按顺序执行。

二、一个电梯的上下运送人员的案例

　　   引用生活中的一个情景，（先从最简单的处理方式出发，以后再出后续研究版本）：

　　　　已知：一楼是服务大厅，顶楼是一个餐厅（食堂），顶楼有一群人等待坐电梯下到一楼，一楼有部分人再等待坐电梯去顶楼。限制的条件有：只有一部电梯，每次电梯只能运载一个人。

　　　　那么如何实现这种场景呢？

　　　　（以后再放开条件研究：多部电梯，多个人，去不同楼层的实现方法，此处先从最简单的入手）　　

　　 那么继续分析：

　　　　　　把当前的场景按照面向对象的思想来抽象一下：

　　　　　　创建如下类：Personnel 工作人员类，Elevator  电梯类，DownThread  电梯下送工作线程，UpThread 电梯上送工作线程， 以及一个测试类ThreadTest

　　具体代码如下：

　　Personnel 工作人员类　　

 package com.jason.models;
 /**
  * 多线程学习：·分析
  * @function  工作人员类
  * @author 小风微凉
  * @time  2018-4-26 下午1:01:53
  */
 public class Personnel {
     private String name;
     public Personnel(String name){
         this.name=name;
     }
     @Override
     public String toString() {
         return this.name;
     }
 }

Elevator  电梯类

 package com.jason.models;
 import java.util.ArrayList;
 import java.util.List;
 /**
  * 多线程学习：生产者消费者模型·分析
  * @function  电梯类
  * @author 小风微凉
  * @time  2018-4-26 下午1:00:58
  */
 public class Elevator{
     //电梯编号:以后扩展
     private String eleNo;
     //电梯每次最大的载重人数为：15人
     private final int MAX_PERSON_LIMIT=15;
     //构造器
     public Elevator(String eleNo){
         this.eleNo=eleNo;
     }
     /**
      * //向上运送人员
      * @param list  上限运载的人数
      * @param exitFlag  true  终止线程   false 继续
      * @return 返回成功运载的人数
      */
     public synchronized void  upCarry(List<Personnel> list,boolean exitFlag){
         //当前电梯的乘坐人数
         int currCount=list.size();
         if(currCount==0){//没有人员乘坐
             System.out.println("（up）当前电梯没有人员乘坐，可以抢夺电梯的使用权！");
             this.notifyAll();//唤醒楼上-楼下的人争抢按电梯
         }
         if(currCount>MAX_PERSON_LIMIT){//人数超载
             System.out.println("（up）警告！人数超过运载上限："+currCount+","+MAX_PERSON_LIMIT+"人，电梯等候运行！");
             try {
                 Thread.sleep(1000);//带着电梯对象锁，休眠一会
             } catch (InterruptedException e) {
                 e.printStackTrace();
                 Thread.currentThread().interrupt();//中断线程
             }
         }
         if(currCount>0 && currCount<=MAX_PERSON_LIMIT){//正常运载范围
             System.out.println(Thread.currentThread().getName()+"：向上运载了第："+list.size()+"位乘客。抵达楼顶食堂");
             this.notifyAll();//只是为了唤醒其他线程，并释放当前线程（和下面wait()有重复）
             try {
                 this.wait();//此时电梯到达楼上，当前线程进入等待池
             } catch (InterruptedException e) {
                 e.printStackTrace();
                 Thread.currentThread().interrupt();//中断线程
             }
             System.out.println("---------------[继续UP]后续代码继续执行-------------");
         }
         if(exitFlag){
             //终止当前线程，唤醒其他线程
             this.notifyAll();
         }
     }
     /**
      * //向下运送人员
      * @param list  上限运载的人数
      * @return 返回成功运载的人数
      */
     public synchronized void  downCarry(List<Personnel> list,boolean exitFlag){
         //当前电梯的乘坐人数
         int currCount=list.size();
         if(currCount==0){//没有人员乘坐
             System.out.println("（downn）当前电梯没有人员乘坐，可以抢夺电梯的使用权！");
             this.notifyAll();//唤醒楼上-楼下的人争抢按电梯
         }
         if(currCount>MAX_PERSON_LIMIT){//人数超载
             System.out.println("（downn）警告！人数超过运载上限："+currCount+","+MAX_PERSON_LIMIT+"人，电梯等候运行！");
             try {
                 Thread.sleep(1000);//带着电梯对象锁，休眠一会
             } catch (InterruptedException e) {
                 e.printStackTrace();
                 Thread.currentThread().interrupt();//中断线程
             }
         }
         if(currCount>0 && currCount<=MAX_PERSON_LIMIT){//正常运载范围
             System.out.println(Thread.currentThread().getName()+"：向下运载了第："+list.size()+"位乘客。抵达一楼大厅");
             this.notifyAll();
             try {
                 this.wait();//此时电梯到达楼下，下送线程进入等待池，上送线程可以拿到电梯使用权
             } catch (InterruptedException e) {
                 e.printStackTrace();
                 Thread.currentThread().interrupt();//中断线程
             }
             System.out.println("---------------[继续DOWN]后续代码继续执行-------------");
         }
         if(exitFlag){
             //终止当前线程，唤醒其他线程
             this.notifyAll();
         }
     }
 }

　UpThread 电梯上送工作线程　

 /**
  * 上送工作线程
  * @function
  * @author 小风微凉
  * @time  2018-4-26 下午1:48:44
  */
 class UpThread implements Runnable{
     private Elevator elev;
     List<Personnel> list;
     public UpThread(Elevator elev,List<Personnel> list){
         this.elev=elev;
         this.list=list;
     }
     public void run() {
         for(int i=1;i<=list.size();i++){
             if(i==list.size()){
                 elev.upCarry(list.subList(0, i),true);
             }else{
                 elev.upCarry(list.subList(0, i), false);
             }
         }
         System.out.println("******[UP线程-END]******************");
     }
 }

DownThread  电梯下送工作线程　　　

/**
 * 下送工作线程
 * @function
 * @author 小风微凉
 * @time  2018-4-26 下午1:48:44
 */
class DownThread implements Runnable{
    private Elevator elev;
    List<Personnel> list;
    public DownThread(Elevator elev,List<Personnel> list){
        this.elev=elev;
        this.list=list;
    }
    public void run() {
        for(int i=1;i<=list.size();i++){
            if(i==list.size()){
                elev.downCarry(list.subList(0, i),true);
            }else{
                elev.downCarry(list.subList(0, i), false);
            }
        }
        System.out.println("******[DOWN线程-END]******************");
    }
}

一个测试类ThreadTest

 package com.jason.models;

 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;

 public class ThreadTest extends Thread{
     /**
      * @param args
      */
     public static void main(String[] args) {
         //假设楼上：20人在等待电梯
         List<Personnel> topList=new ArrayList<Personnel>();
         for(int i=1;i<=20;i++){
             topList.add(new Personnel("TOP"+i+"号"));
         }
         //假设楼下：30人在等待电梯
         List<Personnel> bottomList=new ArrayList<Personnel>();
         for(int i=1;i<=30;i++){
             bottomList.add(new Personnel("BOTTOM"+i+"号"));
         }
         //创建电梯对象
         Elevator elev=new Elevator("1号电梯");
         //2种工作线程，随即运载工作人员
         new Thread(new UpThread(elev,topList),"UP").start();
         new Thread(new DownThread(elev,bottomList),"DOWN").start();
     }
 }

运行结果：

UP：向上运载了第：1位乘客。抵达楼顶食堂
DOWN：向下运载了第：1位乘客。抵达一楼大厅
---------------[继续UP]后续代码继续执行-------------
UP：向上运载了第：2位乘客。抵达楼顶食堂
---------------[继续DOWN]后续代码继续执行-------------
DOWN：向下运载了第：2位乘客。抵达一楼大厅
---------------[继续UP]后续代码继续执行-------------
UP：向上运载了第：3位乘客。抵达楼顶食堂
---------------[继续DOWN]后续代码继续执行-------------
DOWN：向下运载了第：3位乘客。抵达一楼大厅
---------------[继续UP]后续代码继续执行-------------
UP：向上运载了第：4位乘客。抵达楼顶食堂
---------------[继续DOWN]后续代码继续执行-------------
DOWN：向下运载了第：4位乘客。抵达一楼大厅
---------------[继续UP]后续代码继续执行-------------
UP：向上运载了第：5位乘客。抵达楼顶食堂
---------------[继续DOWN]后续代码继续执行-------------
DOWN：向下运载了第：5位乘客。抵达一楼大厅
---------------[继续UP]后续代码继续执行-------------
UP：向上运载了第：6位乘客。抵达楼顶食堂
---------------[继续DOWN]后续代码继续执行-------------
DOWN：向下运载了第：6位乘客。抵达一楼大厅
---------------[继续UP]后续代码继续执行-------------
UP：向上运载了第：7位乘客。抵达楼顶食堂
---------------[继续DOWN]后续代码继续执行-------------
DOWN：向下运载了第：7位乘客。抵达一楼大厅
---------------[继续UP]后续代码继续执行-------------
UP：向上运载了第：8位乘客。抵达楼顶食堂
---------------[继续DOWN]后续代码继续执行-------------
DOWN：向下运载了第：8位乘客。抵达一楼大厅
---------------[继续UP]后续代码继续执行-------------
UP：向上运载了第：9位乘客。抵达楼顶食堂
---------------[继续DOWN]后续代码继续执行-------------
DOWN：向下运载了第：9位乘客。抵达一楼大厅
---------------[继续UP]后续代码继续执行-------------
UP：向上运载了第：10位乘客。抵达楼顶食堂
---------------[继续DOWN]后续代码继续执行-------------
DOWN：向下运载了第：10位乘客。抵达一楼大厅
---------------[继续UP]后续代码继续执行-------------
UP：向上运载了第：11位乘客。抵达楼顶食堂
---------------[继续DOWN]后续代码继续执行-------------
DOWN：向下运载了第：11位乘客。抵达一楼大厅
---------------[继续UP]后续代码继续执行-------------
UP：向上运载了第：12位乘客。抵达楼顶食堂
---------------[继续DOWN]后续代码继续执行-------------
DOWN：向下运载了第：12位乘客。抵达一楼大厅
---------------[继续UP]后续代码继续执行-------------
UP：向上运载了第：13位乘客。抵达楼顶食堂
---------------[继续DOWN]后续代码继续执行-------------
DOWN：向下运载了第：13位乘客。抵达一楼大厅
---------------[继续UP]后续代码继续执行-------------
UP：向上运载了第：14位乘客。抵达楼顶食堂
---------------[继续DOWN]后续代码继续执行-------------
DOWN：向下运载了第：14位乘客。抵达一楼大厅
---------------[继续UP]后续代码继续执行-------------
UP：向上运载了第：15位乘客。抵达楼顶食堂
---------------[继续DOWN]后续代码继续执行-------------
DOWN：向下运载了第：15位乘客。抵达一楼大厅
---------------[继续UP]后续代码继续执行-------------
（up）警告！人数超过运载上限：16,15人，电梯等候运行！
（up）警告！人数超过运载上限：17,15人，电梯等候运行！
（up）警告！人数超过运载上限：18,15人，电梯等候运行！
（up）警告！人数超过运载上限：19,15人，电梯等候运行！
（up）警告！人数超过运载上限：20,15人，电梯等候运行！
---------------[继续DOWN]后续代码继续执行-------------
******[UP线程-END]******************
（downn）警告！人数超过运载上限：16,15人，电梯等候运行！
（downn）警告！人数超过运载上限：17,15人，电梯等候运行！
（downn）警告！人数超过运载上限：18,15人，电梯等候运行！
（downn）警告！人数超过运载上限：19,15人，电梯等候运行！
（downn）警告！人数超过运载上限：20,15人，电梯等候运行！
（downn）警告！人数超过运载上限：21,15人，电梯等候运行！
（downn）警告！人数超过运载上限：22,15人，电梯等候运行！
（downn）警告！人数超过运载上限：23,15人，电梯等候运行！
（downn）警告！人数超过运载上限：24,15人，电梯等候运行！
（downn）警告！人数超过运载上限：25,15人，电梯等候运行！
（downn）警告！人数超过运载上限：26,15人，电梯等候运行！
（downn）警告！人数超过运载上限：27,15人，电梯等候运行！
（downn）警告！人数超过运载上限：28,15人，电梯等候运行！
（downn）警告！人数超过运载上限：29,15人，电梯等候运行！
（downn）警告！人数超过运载上限：30,15人，电梯等候运行！
******[DOWN线程-END]******************

运行结果的说明：

　　（1）程序运行，UP线程和DOWN线程第一时间开始抢夺电梯的使用权。

　　（2）UP线程和DOWN线程开始按顺序，一次UP，紧接着一次DOWN   交替（等待-唤醒）的轮转。

　　（3）当其中一个线程结束后，主动唤醒另外一个线程继续执行。

好像逻辑蛮简单的，我酝酿下，再出下一个版本吧~