Java基础__交通管理灯

 

交通灯管理系统：

    模拟实现十字路口的交通灯管理系统逻辑

需求：

  1、异步随机生成按照各个路线行驶的车辆：

         由南向北----直行车辆

         由西向南----右转车辆

         由东向南----左转车辆

         ……

  2、信号灯忽略黄灯，只考虑红灯和绿灯。

  3、右转车辆不受信号灯控制。

  4、具体逻辑与现实生活中交通逻辑相同。注：南北向车辆和东西向车辆交替放行，同方向等待车辆应先放行直行车辆，再放行左转车辆。

  5、每辆车通过路口的时间为1秒。提示：可通过线程Sleep的方式模拟。

  6、随机生成车辆时间间隔以及红绿灯交换时间间隔自定，可以设置。

  7、不要求实现GUI，只考虑系统逻辑实现，可通过Log方式展现程序运行结果。

 

如图理解和分析：

  1、总共有12条线，每个方向的车有3种走法，直行、左转、右转，4个方向就12条线路。

  2、每个方向的右转弯路线不受控制的限制，考虑这4条线路灯为常绿状态。

  3、另外8条线路是两两成对的，比如南向北、北向南是一对，8条线就归纳为4组，所以，程序只考虑4条线路的控制灯的切换顺序。

  4、设想有哪些对象：红绿灯、红绿灯的控制系统、路、车辆。

  5、汽车什么情况下可以穿过路口：1、所在路线对应的灯绿了；2、前面没有车。有没有车问路这个对象，路是存储车辆的集合，有着增加和减少车辆的方法。

    面向对象的实例分析：

    一、人在黑板上画圆：

        对象有：人、黑板、圆。

            draw(){  x,y --> radius  }画圆的方法应该属于圆，因为只有圆才有圆心、半径这两个属性。也就是说方法的成员变量属于哪个对象，调用这些属性的方法就属于哪个对象。

    二、司机踩刹车：

    三、人把门关上了：

    结论：谁拥有数据，谁就对外提供操作这些数据的方法。

  6、程序并不要体现车辆移动的过程，只是捕捉车辆穿过路口的过程，也就是车辆在路上减少的过程，所以车不需要单独设计成一个对象，用一个字符串表示就可以了。

    设计：

  1、设计一个Road类来表示路线，每个Road对象代表一条路线，总共有12条路线，即总共要产生12个Road实例对象。

    每条路线上随机增加新的车辆，增加到一个集合中保存。

    每条路线每隔一秒都会检查本路线对应的灯是否为绿，是绿则将本路线保存的车的集合第一辆车移除，表示车穿过了路口。

  2、设计一个Lamp类来表示一个交通灯，每个灯都维护一个状态：亮或不亮，亮表示绿，不亮表示红，一个灯由绿变红时，就该将下一个方向的灯变绿。

    每个交通灯都有变亮和变黑的方法，并且返回自己的亮黑状态。

    总共12条线，系统中共要产生12个交通灯，右拐弯的路线不受灯控制，永远为亮。

    除了4个右拐变的灯一直为亮外，其他8条路线的灯，它们归为4组，所以从这4组中各取出一灯，对这4个灯轮回变亮，与这4个灯对应方向的灯随之一同变化，因此在Lamp类中要有一个变量来记住自己相反方向的灯，在一个Lamp对象的变亮变黑方法中，将对应方向的灯也变亮变黑。

    线程池：

    线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。如果某个线程在托管代码中空闲（如正在等待某个事件）,则线程池将插入另一个辅助线程来使所有处理器保持繁忙。如果所有线程池线程都始终保持繁忙，但队列中包含挂起的工作，则线程池将在一段时间后创建另一个辅助线程但线程的数目永远不会超过最大值。超过最大值的线程可以排队，但他们要等到其他线程完成后才启动。

    定时器：

ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);//参数1为线程数。

timer.scheduleAtFixedRate(XXX, //参数1：定期执行的程序

      num, //参数2：每一次执行的延迟时间

      num, //参数3：以后每次执行的时间间隔

      TimeUnit.SECONDS);//参数4：参数2、3的单位。

 

源代码：

package com.heima.interview; 

import java.util.ArrayList;

import java.util.List;

import java.util.Random;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.TimeUnit;

 

public class Road {

   //定义一个集合，用来存储路上的车，车都用字符串表示。

   private List che =new ArrayList();  

   private String name =null;

   //构造方法，一有路，就初始化有车，name为车名，并且车辆随机产生数量。

   public Road(String name){

      this.name = name;

      //创建线程池，定义在构造方法里，

      ExecutorService pool = Executors.newSingleThreadExecutor();

      pool.execute(new Runnable(){

        public void run(){

            //只让999通过此路。

           for(int i=0; i<1000; i++){

               try {

                   //随机生成一个整数+1*1000表示随机1～10秒间隔就产生一辆车。

                   Thread.sleep((new Random().nextInt(10)+1)*1000);

                }catch (Exception e) {

                   e.printStackTrace();

                  }

                //向集合中添加车辆

                che.add(Road.this.name+"方向上  第"+(i+1)+"辆车上路");             

            }

         }

      });     

      //制作定时器，每隔1秒去判断车辆是否能通过，能则向集合中移除每一辆车，判断的条件是路上有车且灯为绿。

      ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);//参数1为线程数。

      timer.scheduleAtFixedRate(

           new Runnable(){

               public void run(){

                   //如果路上有车，如果灯为绿色，车就通过，在路上的车就减少。

                  if(che.size()>0){

                  boolean lighted = Lamp.valueOf(Road.this.name).isLighted();

                     if(lighted)

                         System.out.println(che.remove(0)+"已经通过路口");

                   }                 

                }

            }, //参数1：定期执行的程序

            1, //参数2：每一次执行的延迟时间

            1, //参数3：以后每次执行的时间间隔

            TimeUnit.SECONDS);//参数4：参数2、3的单位。

   }

} 

//枚举类，12条线路所对应的灯为对象元素

public enum Lamp {

   //对象元素

S2N("N2S","S2W",false),S2W("N2E","E2W",false),E2W("W2E","E2S",false),E2S("W2N","S2N",false),

N2S(null,null,false),N2E(null,null,false),W2E(null,null,false),W2N(null,null,false),

   S2E(null,null,true),E2N(null,null,true),N2W(null,null,true),W2S(null,null,true);

   //构造函数，参数1对应的灯、2下一盏灯，3灯的状态。

   private Lamp(String opposite,String next,boolean lighted){

      this.opposite = opposite;//对应的灯

      this.next = next;//下一盏灯

      this.lighted = lighted;//灯的状态

   }  

   private boolean lighted;//类的状态。true为绿，false为红。

   private String opposite;//对应的灯，伴随着与之对应的灯亮与不亮。

   private String next;//下一个要亮的灯。

   //获取灯的状态。

   public boolean isLighted(){

      return lighted;

   }

   //置灯为绿色，并且也将对应的灯也置为绿色，并且把下一盏灯置为红色。

   public void green(){

      this.lighted = true;

      if(opposite != null)

         Lamp.valueOf(opposite).green();

      System.out.println(name()+"灯变绿了！");

   }

   //置灯为红色，并且也将对应的灯也置为红色，并且把下一盏灯置为绿色。

   public Lamp red(){

      this.lighted = false;

      if(opposite != null)

         Lamp.valueOf(opposite).red();

      //定义下一盏灯。

      Lamp nextLamp =null;   

      if(next != null)

         nextLamp = Lamp.valueOf(next);

      System.out.println("绿灯从"+name()+"变成了"+next);

         nextLamp.green();//将下一盏灯变绿后，返回下一盏灯。

      return nextLamp;

   }  

}

//红绿灯控制器

public class LampController {

   private Lamp currentLamp;//定义最开始的灯。  

   public LampController(){

      currentLamp = Lamp.S2N;//初始化最开始的灯为南到北的灯。

      currentLamp.green();//初始化最开始的灯为绿色的。

   //定义红绿灯定时地相互转换时间间隔。

   ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);

   timer.scheduleAtFixedRate(

        new Runnable(){

           public void run(){

                currentLamp = currentLamp.red();//红绿灯相互转换。

            }

         },

         10, //第一次执行延迟时间10秒。

         10, //往后每次执行时间间隔10秒。

         TimeUnit.SECONDS);

   }  

}

//主函数 

public class MainClass { 

   public static void main(String[] args) {

      //12个方向。

      String[] directions = {"S2N","S2W","E2W","E2S","N2S","N2E","W2E","W2N","S2E","E2N","N2W","W2S"};

      //创建12个方向上每路路的对象。

      for(int i=0; i

        new Road(directions[i]);

      }

      new LampController();//红绿灯控制器。

   }

}