张老师的代码基本上不怎么耗费cpu。
下面是我自己的代码，非常占用cpu。
不知有什么工具能帮忙找出耗费cpu的代码？

1. import java.util.*;
   
2. public class Traffic{
   
3.         public static void main (String[] args){
   
4.                 //定义一个字典，准备用来建立Road对象，不然会搞死人
   
5.                 String[] dics = {"S2N","S2W","E2W","E2S","N2S","N2E","W2E","W2N","S2E","E2N","N2W","W2S"};
   
6.                 //两句话建立12个road对象，爽
   
7.                 for(int i = 0; i <dics.length;i++){
   
8.                         new Road(dics[i]);
   
9.                 }
   
10.                 //建立交通灯控制对象
    
11.                 LampController lc =  new LampController();
    
12.                 //设置初始灯为S2N
    
13.                 Lamp currentLamp = Lamp.S2N;
    
14.                 //交通灯控制对象在主线程中
    
15.                 while (true){
    
16.                         //每11秒对把当前的绿灯关闭，返回下一组灯。
    
17.                         mySleep(11000);
    
18.                         currentLamp = lc.offLamp(currentLamp);
    
19.                 }
    
20.         }
    
21.         //避免多次try catch，定义一个mysleep方法。
    
22.         public static void mySleep(long millinSec){
    
23.                 try {
    
24.                         Thread.sleep(millinSec);
    
25.                 }
    
26.                 catch(Exception e){
    
27.                 }
    
28.         }
    
29. }
    
30. //交通灯控制，很简单，就一个方法，关闭灯。
    
31. class LampController{
    
32.         Lamp Lamp;
    
33.         LampController(){
    
34.         }
    
35.         Lamp offLamp(Lamp lamp){
    
36.                 return lamp.setBlank();
    
37.         }
    
38. }
    
39. 
    
40. class Road{
    
41.         private String name= null;
    
42.         //因为是先进先出，所以只适用列表的头和尾，所以使用LinkedList，另外加上同步代码保证线程安全。
    
43.         private List<Integer> cars = Collections.synchronizedList( new LinkedList<Integer>());
    
44.         //一生成Road对象，就开始来车和车通过的线程。
    
45.         Road(String name){
    
46.                 this.name =name;
    
47.                 Thread t1 = new Thread(new RoadAddCar(name, cars));
    
48.                 Thread t2 = new Thread(new RoadCarPass(name, cars));
    
49.                 t1.start();
    
50.                 t2.start();
    
51.         }
    
52. }
    
53. //实现Runnable接口，准备来车的线程
    
54. class RoadAddCar implements Runnable{
    
55.         //定义使用到的变量，用于构造函数和打印结果。
    
56.         private String name ;
    
57.         private Integer carID = 1;
    
58.         private List<Integer> cars;
    
59.         //传入路名和车的队列。
    
60.         RoadAddCar(String name,List<Integer> cars){
    
61.                 this.name = name;
    
62.                 this.cars = cars;
    
63.         }
    
64.         public void run(){
    
65.                 while (true){
    
66.                         //0.5秒-2.5秒时间，随机来车。来一辆车就打印一次。
    
67.                         cars.add(carID);
    
68.                         System.out.println(name+"来车ID：" + carID);
    
69.                         carID = carID + 1;
    
70.                         Traffic.mySleep((long)(Math.random()*2000 + 500));
    
71.                 }
    
72.         }
    
73. 
    
74. }
    
75. //实现Runnable，准备车通行的线程
    
76. class RoadCarPass implements Runnable{
    
77.         private List<Integer> cars;
    
78.         private String name ;
    
79.         private Integer carID;
    
80.         //构造函数传入路名和车的队列。
    
81.         RoadCarPass(String name,List<Integer> cars){
    
82.                 this.name = name;
    
83.                 this.cars = cars;
    
84.         }
    
85.         public void run (){
    
86.                 while (true){
    
87.                         //如果绿灯则考虑通行
    
88.                         if (Lamp.valueOf(name).isLighted()){
    
89.                                 //当然这条路还得有车才行。
    
90.                                 if (cars.size() > 0){
    
91.                                         carID = cars.remove(0);
    
92.                                         //因为是只有花1秒时间通过了路口，才会打印结果，所以会在运行结果中看到，红灯亮了，车才通过。
    
93.                                         //因为Lamp.setBlank()中，红灯亮了，过1秒之后，下组灯的绿灯才会亮，所以不会出现交通事故。
    
94.                                         Traffic.mySleep(1000);
    
95.                                         System.out.println("  "+name+"路，ID："+carID+"通过路口，耗时1000毫秒");
    
96.                                 }
    
97.                         }
    
98.                         //因为如果此路口是红灯，则上述判断不成立，如果下面不休息，系统资源消耗过大。
    
99.                         else
    
100.                                 Traffic.mySleep(1000);
     
101.                 }
     
102.         }
     
103. }
     
104. //枚举，虽然在基础视频上没有讲，但这两个面试题，让我觉得枚举很有用。这个题目做完之后，对枚举的认识有提高了。
     
105. enum Lamp{
     
106.         //定义了每个灯所对应的灯和下一个灯，默认为红灯。
     
107.         S2N("N2S","S2W",false),        S2W("N2E","E2W",false),        E2W("W2E","E2S",false),        E2S("W2N","S2N",false),
     
108.         N2S("S2N","N2E",false),        N2E("S2W","W2E",false),        W2E("E2W","W2N",false),        W2N("E2S","N2S",false),
     
109.         //右转的路的都为绿灯
     
110.         S2E(null,null,true),        E2N(null,null,true),        N2W(null,null,true),        W2S(null,null,true);
     
111.         private String opposite = null;
     
112.         private String next = null;
     
113.         private boolean lighted = false;
     
114.         //Lamp对象的构造方法。
     
115.         Lamp(String opposite,String next,boolean lighted){
     
116.                 this.opposite = opposite;
     
117.                 this.next = next;
     
118.                 this.lighted = lighted;
     
119.         }
     
120.         public boolean isLighted(){
     
121.                 return this.lighted;
     
122.         }
     
123.         public String nextLamp(){
     
124.                 return this.next;
     
125.         }
     
126.         //开绿灯，打印到控制台
     
127.         private void setL(Lamp lamp){
     
128.                 lamp.lighted = true;
     
129.                 System.out.println("== "+lamp.name() + "路绿灯亮,车辆可以通过");
     
130.         }
     
131.         private void setLight(){
     
132.                 //一次开2个绿灯，比感觉比递归更容易让人理解
     
133.                 setL(this);
     
134.                 setL(valueOf(this.opposite));
     
135.         }
     
136.         //开红灯，打印到控制台
     
137.         private void setO(Lamp lamp){
     
138.                 lamp.lighted = false;
     
139.                 System.out.println("XX "+lamp.name() + "路红灯亮,车辆停止");
     
140.         }
     
141.         public Lamp setBlank(){
     
142.                 //一次开2个红灯，比感觉比递归更容易让人理解
     
143.                 setO(this);
     
144.                 setO(valueOf(this.opposite));
     
145.                 //因为车辆通过需时1秒，所以在红灯亮了之后1s，才打开下一轮灯的绿灯。
     
146.                 Traffic.mySleep(1000);
     
147.                 valueOf(this.next).setLight();
     
148.                 return valueOf(this.next);
     
149.         }
     
150.        
     
151. }

复制代码

张老师的代码基本上不怎么耗费cpu。
下面是我自己的代码，非常占用cpu。
不知有什么工具能帮忙找出耗费cpu的代码？

1. import java.util.*;
   
2. public class Traffic{
   
3.         public static void main (String[] args){
   
4.                 //定义一个字典，准备用来建立Road对象，不然会搞死人
   
5.                 String[] dics = {"S2N","S2W","E2W","E2S","N2S","N2E","W2E","W2N","S2E","E2N","N2W","W2S"};
   
6.                 //两句话建立12个road对象，爽
   
7.                 for(int i = 0; i <dics.length;i++){
   
8.                         new Road(dics[i]);
   
9.                 }
   
10.                 //建立交通灯控制对象
    
11.                 LampController lc =  new LampController();
    
12.                 //设置初始灯为S2N
    
13.                 Lamp currentLamp = Lamp.S2N;
    
14.                 //交通灯控制对象在主线程中
    
15.                 while (true){
    
16.                         //每11秒对把当前的绿灯关闭，返回下一组灯。
    
17.                         mySleep(11000);
    
18.                         currentLamp = lc.offLamp(currentLamp);
    
19.                 }
    
20.         }
    
21.         //避免多次try catch，定义一个mysleep方法。
    
22.         public static void mySleep(long millinSec){
    
23.                 try {
    
24.                         Thread.sleep(millinSec);
    
25.                 }
    
26.                 catch(Exception e){
    
27.                 }
    
28.         }
    
29. }
    
30. //交通灯控制，很简单，就一个方法，关闭灯。
    
31. class LampController{
    
32.         Lamp Lamp;
    
33.         LampController(){
    
34.         }
    
35.         Lamp offLamp(Lamp lamp){
    
36.                 return lamp.setBlank();
    
37.         }
    
38. }
    
39. 
    
40. class Road{
    
41.         private String name= null;
    
42.         //因为是先进先出，所以只适用列表的头和尾，所以使用LinkedList，另外加上同步代码保证线程安全。
    
43.         private List<Integer> cars = Collections.synchronizedList( new LinkedList<Integer>());
    
44.         //一生成Road对象，就开始来车和车通过的线程。
    
45.         Road(String name){
    
46.                 this.name =name;
    
47.                 Thread t1 = new Thread(new RoadAddCar(name, cars));
    
48.                 Thread t2 = new Thread(new RoadCarPass(name, cars));
    
49.                 t1.start();
    
50.                 t2.start();
    
51.         }
    
52. }
    
53. //实现Runnable接口，准备来车的线程
    
54. class RoadAddCar implements Runnable{
    
55.         //定义使用到的变量，用于构造函数和打印结果。
    
56.         private String name ;
    
57.         private Integer carID = 1;
    
58.         private List<Integer> cars;
    
59.         //传入路名和车的队列。
    
60.         RoadAddCar(String name,List<Integer> cars){
    
61.                 this.name = name;
    
62.                 this.cars = cars;
    
63.         }
    
64.         public void run(){
    
65.                 while (true){
    
66.                         //0.5秒-2.5秒时间，随机来车。来一辆车就打印一次。
    
67.                         cars.add(carID);
    
68.                         System.out.println(name+"来车ID：" + carID);
    
69.                         carID = carID + 1;
    
70.                         Traffic.mySleep((long)(Math.random()*2000 + 500));
    
71.                 }
    
72.         }
    
73. 
    
74. }
    
75. //实现Runnable，准备车通行的线程
    
76. class RoadCarPass implements Runnable{
    
77.         private List<Integer> cars;
    
78.         private String name ;
    
79.         private Integer carID;
    
80.         //构造函数传入路名和车的队列。
    
81.         RoadCarPass(String name,List<Integer> cars){
    
82.                 this.name = name;
    
83.                 this.cars = cars;
    
84.         }
    
85.         public void run (){
    
86.                 while (true){
    
87.                         //如果绿灯则考虑通行
    
88.                         if (Lamp.valueOf(name).isLighted()){
    
89.                                 //当然这条路还得有车才行。
    
90.                                 if (cars.size() > 0){
    
91.                                         carID = cars.remove(0);
    
92.                                         //因为是只有花1秒时间通过了路口，才会打印结果，所以会在运行结果中看到，红灯亮了，车才通过。
    
93.                                         //因为Lamp.setBlank()中，红灯亮了，过1秒之后，下组灯的绿灯才会亮，所以不会出现交通事故。
    
94.                                         Traffic.mySleep(1000);
    
95.                                         System.out.println("  "+name+"路，ID："+carID+"通过路口，耗时1000毫秒");
    
96.                                 }
    
97.                         }
    
98.                         //因为如果此路口是红灯，则上述判断不成立，如果下面不休息，系统资源消耗过大。
    
99.                         else
    
100.                                 Traffic.mySleep(1000);
     
101.                 }
     
102.         }
     
103. }
     
104. //枚举，虽然在基础视频上没有讲，但这两个面试题，让我觉得枚举很有用。这个题目做完之后，对枚举的认识有提高了。
     
105. enum Lamp{
     
106.         //定义了每个灯所对应的灯和下一个灯，默认为红灯。
     
107.         S2N("N2S","S2W",false),        S2W("N2E","E2W",false),        E2W("W2E","E2S",false),        E2S("W2N","S2N",false),
     
108.         N2S("S2N","N2E",false),        N2E("S2W","W2E",false),        W2E("E2W","W2N",false),        W2N("E2S","N2S",false),
     
109.         //右转的路的都为绿灯
     
110.         S2E(null,null,true),        E2N(null,null,true),        N2W(null,null,true),        W2S(null,null,true);
     
111.         private String opposite = null;
     
112.         private String next = null;
     
113.         private boolean lighted = false;
     
114.         //Lamp对象的构造方法。
     
115.         Lamp(String opposite,String next,boolean lighted){
     
116.                 this.opposite = opposite;
     
117.                 this.next = next;
     
118.                 this.lighted = lighted;
     
119.         }
     
120.         public boolean isLighted(){
     
121.                 return this.lighted;
     
122.         }
     
123.         public String nextLamp(){
     
124.                 return this.next;
     
125.         }
     
126.         //开绿灯，打印到控制台
     
127.         private void setL(Lamp lamp){
     
128.                 lamp.lighted = true;
     
129.                 System.out.println("== "+lamp.name() + "路绿灯亮,车辆可以通过");
     
130.         }
     
131.         private void setLight(){
     
132.                 //一次开2个绿灯，比感觉比递归更容易让人理解
     
133.                 setL(this);
     
134.                 setL(valueOf(this.opposite));
     
135.         }
     
136.         //开红灯，打印到控制台
     
137.         private void setO(Lamp lamp){
     
138.                 lamp.lighted = false;
     
139.                 System.out.println("XX "+lamp.name() + "路红灯亮,车辆停止");
     
140.         }
     
141.         public Lamp setBlank(){
     
142.                 //一次开2个红灯，比感觉比递归更容易让人理解
     
143.                 setO(this);
     
144.                 setO(valueOf(this.opposite));
     
145.                 //因为车辆通过需时1秒，所以在红灯亮了之后1s，才打开下一轮灯的绿灯。
     
146.                 Traffic.mySleep(1000);
     
147.                 valueOf(this.next).setLight();
     
148.                 return valueOf(this.next);
     
149.         }
     
150.        
     
151. }

复制代码