一个并发的例子,感觉对学习并发基础很有用

Question

    这个是 java编程思想 里仿真的最后一个例子,感觉挺不错的,对学习理解并发来说挺有用的,大家可以看看,也可以在此基础上添加别的功能.package concurrency;import java.util.*;
import java.util.concurrent.*;//MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
class Car {
  //---------------------------------------------------
  private final int id;
  private boolean engine = false, driveTrain = false, wheels = false;
  //---------------------------------------------------
  public Car(int id) {this.id = id;}
  //---------------------------------------------------
  public Car() {id = -1;}
  //---------------------------------------------------
  public synchronized int getId() {return id;}
  //---------------------------------------------------
  public synchronized void addEngine() {engine = true;}
  //---------------------------------------------------
  public synchronized void addDriveTrain() {driveTrain = true;}
  //---------------------------------------------------
  public synchronized void addWheels() {wheels = true;}
  //---------------------------------------------------
  @Override
  public synchronized String toString()
  {
    return "汽车" + id + " [发动机:" + (engine? "是" : "否") + 
      " - 传动系统:" + (driveTrain? "是" : "否") + " - 车轮:" + 
      (wheels? "是" : "否") + "]";
  }
}//MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
@SuppressWarnings("serial")
class CarQueue extends LinkedBlockingQueue<Car> {}//MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
class ChassisBuilder implements Runnable {
  //---------------------------------------------------
  private int counter = 0;
  private CarQueue carQueue;
  //---------------------------------------------------
  public ChassisBuilder(CarQueue q) {carQueue = q;}
  //---------------------------------------------------
  @Override
  public void run()
  {
    try
    {
      while(!Thread.interrupted())
      {
        //模拟制造底盘所需的时间
        TimeUnit.MILLISECONDS.sleep(500);
        Car c = new Car(counter++);
        System.out.println("底盘生产完成     " + c);
        //将制造好的底盘放入阻塞队列中
        carQueue.put(c);
      }
    }
    catch(InterruptedException e)
    {
      System.out.println("底盘生产被中断");
      return;
    }
    System.out.println("底盘生产结束");
  }
}//MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
class Assembler implements Runnable {
  //---------------------------------------------------
  private static int counter = 0;
  private final int id = counter++;
  private CarQueue chassisQueue, finishingQueue;
  private RobotPool robotPool;
  private Car car;
  //该对象应用于4个任务，4个任务都到达了屏蔽点则继续
  private CyclicBarrier barrier = new CyclicBarrier(4);
  //---------------------------------------------------
  public Assembler(CarQueue c, CarQueue f, RobotPool r)
  {
    chassisQueue = c;
    finishingQueue = f;
    robotPool = r;
  }
  //---------------------------------------------------
  public Car car() {return car;}
  //---------------------------------------------------
  public CyclicBarrier barrier() {return barrier;}
  //---------------------------------------------------
  public String toString() {return "装配工" + id;}
  //---------------------------------------------------
  @Override
  public void run()
  {
    try
    {
      while(!Thread.interrupted())
      {
        //装配工从队列中取出底盘，如果没有，在此等待
        car = chassisQueue.take();
        //雇佣机器人进行引擎、传动系统和车轮的组装，雇佣必须按以下顺序执行，实际装配顺序未限定
        robotPool.hire(EngineRobot.class, this);
        robotPool.hire(DriveTrainRobot.class, this);
        robotPool.hire(WheelsRobot.class, this);
        //等待其他三个任务(雇佣的相应机器人组装引擎、传动系统和车轮)到达barrier对象的屏蔽点
        barrier.await();
        //将装配好的汽车放入最终的队列中
        finishingQueue.put(car);
      }
    }
    catch(InterruptedException e)
    {
      System.out.println(this + "工作被中断");
      return;
    }
    catch(BrokenBarrierException e)
    {
      System.out.println(this + "工作异常");
      return;
    }
    System.out.println(this + "工作完成");
  }
}//MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
abstract class Robot implements Runnable {
  //---------------------------------------------------
  private RobotPool pool;
  private boolean engage = false;
  protected Assembler assembler;
  //---------------------------------------------------
  public Robot(RobotPool p) {pool = p;}
  //---------------------------------------------------
  protected abstract void performService();
  //---------------------------------------------------
  @Override
  public void run()
  {
    try
    {
      //将机器人放入队列，以供装配工雇佣
      powerDown();
      while(!Thread.interrupted())
      {
        //装配指定组件
        performService();
        TimeUnit.SECONDS.sleep(1);
        //等待其他组件装配完毕
        assembler.barrier().await();
        //将机器人重新放入队列，以供下次雇佣
        powerDown();
      }
    }
    catch(InterruptedException e)
    {
      System.out.println(this + " - 工作被中断");
      return;
    }
    catch(BrokenBarrierException e)
    {
      System.out.println(this + " - 工作异常");
      return;
    }
    System.out.println(this + " - 工作结束");
  }
  //---------------------------------------------------
  public synchronized void engage(Assembler assembler)
  {
    //该机器人被指定装配工雇佣
    this.assembler = assembler;
    engage = true;
    notifyAll();
  }
  //---------------------------------------------------
  private synchronized void powerDown() throws InterruptedException
  {
    //该机器人闲置
    engage = false;
    assembler = null;
    //将该机器人放入到机器人队列中以供装配工雇佣
    pool.add(this);
    //没被雇佣则在此等待，并释放该对象锁
    while(engage == false) wait();
  }
}//MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
class EngineRobot extends Robot {
  //---------------------------------------------------
  private static int counter = 0;
  private final int id = counter++;
  //---------------------------------------------------
  public EngineRobot(RobotPool p) {super(p);}
  //---------------------------------------------------
  @Override
  public String toString()
  {
    return (assembler == null? "闲置的 - " : "被 - " + assembler + " - 雇佣的 - ") + "发动机装配机器人" + id;
  }
  //---------------------------------------------------
  @Override
  protected void performService()
  {
    System.out.println(this + " - 为 - " + assembler.car() + " - 装配发动机");
    assembler.car().addEngine();
  }
}//MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
class DriveTrainRobot extends Robot {
  //---------------------------------------------------
  private static int counter = 0;
  private final int id = counter++;
  //---------------------------------------------------
  public DriveTrainRobot(RobotPool p) {super(p);}
  //---------------------------------------------------
  @Override
  public String toString()
  {
    return (assembler == null? "闲置的 - " : "被 - " + assembler + " - 雇佣的 - ") + "传动系统装配机器人" + id;
  }
  //---------------------------------------------------
  @Override
  protected void performService()
  {
    System.out.println(this + " - 为 - " + assembler.car() + " - 装配传动系统");
    assembler.car().addDriveTrain();
  }
}//MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
class WheelsRobot extends Robot {
  //---------------------------------------------------
  private static int counter = 0;
  private final int id = counter++;
  //---------------------------------------------------
  public WheelsRobot(RobotPool p) {super(p);}
  //---------------------------------------------------
  @Override
  public String toString()
  {
    return (assembler == null? "闲置的 - " : "被 - " + assembler + " - 雇佣的 - ") + "车轮装配机器人" + id;
  }
  //---------------------------------------------------
  @Override
  protected void performService()
  {
    System.out.println(this + " - 为 - " + assembler.car() + " - 装配车轮");
    assembler.car().addWheels();
  }
}//MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
class RobotPool {
  //---------------------------------------------------
  private Set<Robot> pool = new HashSet<Robot>();
  //---------------------------------------------------
  public synchronized void hire(Class<? extends Robot> robotType, Assembler a)
  throws InterruptedException
  {
    for(Robot r : pool)
      //判断队列中的机器人是否为指定类型的机器人
      if(r.getClass().equals(robotType))
      {
        //从队列中取出指定类型机器人
        pool.remove(r);
        //当前装配工雇佣了指定机器人
        r.engage(a);
        return;
      }
    //没有合适的机器人可雇佣则在此等待，并释放本类(RobotPool)对象的锁
    wait();
    //继续判断有无可雇佣的机器人(递归调用)
    hire(robotType, a);
  }
  //---------------------------------------------------
  public synchronized void add(Robot r)
  {
    pool.add(r);
    //唤醒调用本类对象的同步方法中阻塞于wait()方法的任务
    notifyAll();
  }
}//MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
class Reporter implements Runnable {
  //---------------------------------------------------
  private CarQueue carQueue;
  //---------------------------------------------------
  public Reporter(CarQueue q) {carQueue = q;}
  //---------------------------------------------------
  @Override
  public void run()
  {
    try
    {
      while(!Thread.interrupted())
      {
        System.out.println("\n--- " + carQueue.take() + " 装配完毕 --- \n");
      }
    }
    catch(InterruptedException e)
    {
      System.out.println("检验员工作被中断");
      return;
    }
    System.out.println("检验员工作结束");
  }
}

Answer 1

//MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
public class CarBuilderSimulation {
  //---------------------------------------------------
  public static void main(String[] args) throws Exception
  {
    CarQueue chassisQueue = new CarQueue(), finishingQueue = new CarQueue();
    RobotPool robotPool = new RobotPool();
    ExecutorService exec = Executors.newCachedThreadPool();
    
    //检验员开始工作
    exec.execute(new Reporter(finishingQueue));
    
    //底盘开始生产
    exec.execute(new ChassisBuilder(chassisQueue));
    
    //机器人开始工作
    for(int i = 0; i < 5; ++i)
      exec.execute(new EngineRobot(robotPool));
    for(int i = 0; i < 5; ++i)
      exec.execute(new DriveTrainRobot(robotPool));
    for(int i = 0; i < 5; ++i)
      exec.execute(new WheelsRobot(robotPool));
    
    //装配工开始工作
    for(int i = 0; i < 8; ++i)
      exec.execute(new Assembler(chassisQueue, finishingQueue, robotPool));    //整个生产装配检验持续一段时间后结束
    TimeUnit.SECONDS.sleep(15);
    exec.shutdownNow();
    
    //输出未装配的车辆
    TimeUnit.SECONDS.sleep(1);
    System.out.println("\n----------- 剩余未装配车辆: -----------");
    for(Car c : chassisQueue) System.out.println(c);
  }
}