黑马程序员技术交流社区

标题: Java多线程中关于一个计数器问题 [打印本页]
作者: hello_csu    时间: 2014-12-1 22:18
标题: Java多线程中关于一个计数器问题
本帖最后由 hello_csu 于 2014-12-2 12:10 编辑

问题描述：
在看书中遇到如下一个仿真例子：小区委员会苏，希望了解每天通过各个大门进入公园的总人数，每个大门都安装了一个计数器，当人通过事后计数器就会递增，其递增，也表示说总人数的共享计数器也会递增。
需求：现在需要统计出来每个门进入的人数和总人数。
其设计思路：
采用多线程机制，对每个门通过的人数采用一个线程去实现,且通过让其之间共享一个Count计数器去统计总人数。
代码设计如下
  1. /**
  2. *
  3. */
  4. /**
  5. * @author bobwang
  6. *
  7. */
  8. package OrnamentalGarden;

  10. import java.util.concurrent.*;
  11. import java.util.*;
  12. import java.lang.*;

  14. /**
  15. * Descriptsion:Class Count for counting the total pepole.
  16. */
  17. class Count
  18. {

  20.   private int count =0 ;
  21.   private Random rand = new Random(47);
  22.   
  23.   public synchronized int increment() {
  24.         int temp = count;
  25.         if(rand.nextBoolean())
  26.                 Thread.yield();
  27.         return (count= ++temp);
  28.   }

  30.   
  31.   public synchronized int getvalue() {
  32.           return count;
  33.   }
  34. }
  35.   

  37. /**
  38. * Decription:Class Entrance for counting the people that enters this entrance.
  39. */
  40. class Entrance implements Runnable {
  41.         
  42.         //attribute area
  43.         private static Count count = new Count();
  44.         private static  List<Entrance> entrances = new ArrayList<Entrance>();
  45.         private int number = 0;
  46.         private int id;
  47.         private static volatile boolean canceled = false;
  48.         
  49.         //static method area
  50.         
  51.         public static void cancel() {
  52.                 canceled = true;
  53.         }
  54.         
  55.         public static int getTotalCount() {
  56.                 return count.getvalue();
  57.         }
  58.         
  59.         public static int sumEntrances() {
  60.                 int sum =0;
  61.                 for(Entrance e : entrances){
  62.                         sum +=e.getValue();
  63.                 }
  64.                 return sum;
  65.         }
  66.         
  67.         //Contructor area
  68.         public Entrance (int id) {
  69.                 this.id = id;
  70.                 entrances.add(this);
  71.         }

  73.         //Method area
  74.     public synchronized int getValue(){
  75.             return number;
  76.     }
  77.    
  78.     public String toString(){
  79.             return "Entrance"+ id+":"+getValue();
  80.     }
  81.    
  82.     //Override from interface Runnable
  83.         public void run() {
  84.                 while(!canceled)
  85.                 {
  86.                   synchronized(this)
  87.                   {
  88.                           number++;
  89.                   }
  90.                   System.out.println(this+"Total:"+count.increment());
  91.                   try {
  92.                           TimeUnit.MICROSECONDS.sleep(100);
  93.                   }
  94.                   catch(InterruptedException e) {
  95.                           System.out.println("sleep Interrupted");         
  96.                   }
  97.                 }
  98.                
  99.                 System.out.println("Stopping"+this);
  100.         }
  101. }

  103. public class OrnamentalGarden {
  104.         
  105.   public static void main(String[] args) throws Exception {
  106.           ExecutorService exec = Executors.newCachedThreadPool();
  107.           for(int i=0;i<5;i++)
  108.           {
  109.                  exec.execute(new Entrance(i));
  110.           }
  111.           TimeUnit.MILLISECONDS.sleep(20);
  112.           Entrance.cancel();
  113.           exec.shutdown();
  114.          
  115.           if(!exec.awaitTermination(250, TimeUnit.MILLISECONDS))
  116.           {
  117.                 System.out.println("Some task was not closed.");
  118.           }
  119.          
  120.           System.out.println("Total:"+Entrance.getTotalCount());
  121.           System.out.println("Total:"+Entrance.sumEntrances());
  122.   
  123.    }
  124.   
  125. }
复制代码
Output Result：
Entrance0:1Total:1
Entrance1:1Total:2
Entrance2:1Total:3
Entrance3:1Total:4
......
Entrance4:3Total:17
Entrance2:4Total:18
Entrance2:5Total:19
Entrance1:5Total:20
Entrance4:4Total:23
Entrance3:4Total:21
Entrance0:5Total:22
Entrance4:5Total:24
Entrance2:6Total:27
Entrance1:21Total:100
Entrance0:21Total:101
Entrance4:20Total:102
Entrance3:20Total:99
StoppingEntrance2:20
StoppingEntrance1:21
StoppingEntrance3:20
StoppingEntrance4:20
StoppingEntrance0:21
Total:102
Total:102
疑问点：现在Entrance4:4Total:23中是实现监控说每个门都通过的人数和这个时间点总人数，但依照我的理解Total的数目应该是一个递增的趋势值，但是从log输出来看，运行过程中是个比较随机的值，为什么会出现忽大忽小？
谁能帮解答一些，特别感谢。




作者: kerner    时间: 2014-12-1 23:52
朋友你代码写的真好，发现你发的帖子都不错，有营养。
线程同步有问题，你是保证了计数器同步，但是没有保证5个线程先后同步问题，你是用了5个不同的锁。
稍微改了一下你的代码。
  1. package myfirst;


  4. import java.util.concurrent.*;
  5. import java.util.*;
  6. import java.lang.*;

  8. /**
  9. * Descriptsion:Class Count for counting the total pepole.
  10. */
  11. class Count
  12. {

  14.   private int count =0 ;
  15.   private Random rand = new Random(47);
  16.   
  17.   public synchronized int increment() {
  18.         int temp = count;
  19.         if(rand.nextBoolean())
  20.                 Thread.yield();
  21.         return (count= ++temp);
  22.   }

  24.   
  25.   public synchronized int getvalue() {
  26.           return count;
  27.   }
  28. }
  29.   

  31. /**
  32. * Decription:Class Entrance for counting the people that enters this entrance.
  33. */
  34. class Entrance implements Runnable {
  35.         
  36.         //attribute area
  37.         private static Count count = new Count();
  38.         private static  List<Entrance> entrances = new ArrayList<Entrance>();
  39.         private int number = 0;
  40.         private int id;
  41.         private static volatile boolean canceled = false;
  42.         
  43.         //static method area
  44.         
  45.         public static void cancel() {
  46.                 canceled = true;
  47.         }
  48.         
  49.         public static int getTotalCount() {
  50.                 return count.getvalue();
  51.         }
  52.         
  53.         public static int sumEntrances() {
  54.                 int sum =0;
  55.                 for(Entrance e : entrances){
  56.                         sum +=e.getValue();
  57.                 }
  58.                 return sum;
  59.         }
  60.         
  61.         //Contructor area
  62.         public Entrance (int id) {
  63.                 this.id = id;
  64.                 entrances.add(this);
  65.         }

  67.         //Method area
  68.     public int getValue(){
  69.             synchronized(this.getClass()) {
  70.             return number;
  71.             }
  72.     }
  73.    
  74.     public String toString(){
  75.             return "Entrance"+ id+":"+getValue();
  76.     }
  77.    
  78.     //Override from interface Runnable
  79.         public void run() {
  80.                 while(!canceled)
  81.                 {
  82.                   synchronized(this.getClass())
  83.                   {
  84.                           number++;
  85.                           System.out.println(this+"Total:"+count.increment());   
  86.                   }
  87.                   
  88.                   try {
  89.                           TimeUnit.MICROSECONDS.sleep(100);
  90.                   }
  91.                   catch(InterruptedException e) {
  92.                           System.out.println("sleep Interrupted");         
  93.                   }
  94.                 }
  95.                
  96.                 System.out.println("Stopping"+this);
  97.         }
  98. }

  100. public class OrnametalGarden {
  101.         
  102.   public static void main(String[] args) throws Exception {
  103.           ExecutorService exec = Executors.newCachedThreadPool();
  104.           for(int i=0;i<5;i++)
  105.           {
  106.                  exec.execute(new Entrance(i));
  107.           }
  108.           TimeUnit.MILLISECONDS.sleep(20);
  109.           Entrance.cancel();
  110.           exec.shutdown();
  111.          
  112.           if(!exec.awaitTermination(250, TimeUnit.MILLISECONDS))
  113.           {
  114.                 System.out.println("Some task was not closed.");
  115.           }
  116.          
  117.           System.out.println("Total:"+Entrance.getTotalCount());
  118.           System.out.println("Total:"+Entrance.sumEntrances());
  119.   
  120.    }
  121.   
  122. }
复制代码
作者: hello_csu    时间: 2014-12-2 11:41
感谢kernel楼主，你这样子一解释，我豁然明白了，非常谢谢！



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2