今天总结多线程，在自己写的一个多线程程序中，我想要线程处理客户类100次，但是这个 循环次数 应该定义在哪儿呢？ 按理说应该定义在主函数中，便于修改，但是我把循环次数SUM定义在了主函数中后，在线程类中引用SUM则找不到常量，如果在SUM前面加了PUBLIC的话，直接提示非法的开头~~郁闷了。最后我只能定义在客户类中，和计数变量count一样的定义和引用，倒是没问题。但是觉得这样很麻烦。下面是我的程序代码，大家看看我该怎么改，才能保证能让循环次数SUM作为一个常量，保存在主函数中便于修改~

1. import java.util.concurrent.locks.*;
   
2. 
   
3. class Demo
   
4. {
   
5. public static void main(String[] args)
   
6. {
   
7. 
   
8. //创建客户对象
   
9. Food f = new Food();
   
10. 
    
11. //创建两个厨师线程，开始线程
    
12. new Thread(new Chef(f)).start();
    
13. new Thread(new Chef(f)).start();
    
14. 
    
15. //创建两个吃货线程，开始线程
    
16. new Thread(new Eater(f)).start();
    
17. new Thread(new Eater(f)).start();
    
18. }
    
19. }
    
20. 
    
21. //创建客户类
    
22. 
    
23. class Food
    
24. {
    
25. private String name;
    
26. private int count = 1; //计数器
    
27. private int SUM = 100; //循环次数
    
28. private boolean flag = false;//定义标志，
    
29. 
    
30. private Lock lock = new ReentrantLock(); //创建锁
    
31. 
    
32. private Condition con_cook = lock.newCondition(); //创建厨师的条件队列
    
33. private Condition con_eat = lock.newCondition(); //创建吃货的条件队列
    
34. 
    
35. public int getCount()
    
36. {
    
37. return count;
    
38. }
    
39. 
    
40. public int getSum()
    
41. {
    
42. return SUM;
    
43. }
    
44. 
    
45. //创建厨师类线程的执行函数内容，将其封装起来
    
46. public void cook(String name) throws InterruptedException
    
47. {
    
48. lock.lock();//为线程上锁，此时在解锁之前，cpu的执行权只所属一个线程
    
49. try
    
50. {
    
51. while(flag)
    
52. con_cook.await();//使当前厨师线程进入等待状态
    
53. 
    
54. this.name = count++ + name;
    
55. System.out.println(Thread.currentThread().getName()+"厨子：......第"+this.name+"做好了，快吃吧");
    
56. flag = true;
    
57. con_eat.signal();//唤醒一个吃货线程
    
58. }
    
59. finally
    
60. {
    
61. lock.unlock();//为线程解锁，释放资源
    
62. }
    
63. }
    
64. 
    
65. public void eat() throws InterruptedException
    
66. {
    
67. lock.lock();//为线程上锁，此时在解锁之前，cpu的执行权只所属一个线程
    
68. try
    
69. {
    
70. while(!flag)
    
71. con_eat.await();//使当前吃货线程进入等待状态
    
72. System.out.println(Thread.currentThread().getName()+"吃货：......第"+this.name+"吃完了，快做吧");
    
73. flag = false;
    
74. con_cook.signal();//唤醒一个厨师线程
    
75. }
    
76. finally
    
77. {
    
78. lock.unlock();//为线程解锁,释放资源
    
79. }
    
80. }
    
81. 
    
82. }
    
83. 
    
84. //定义厨师类，为实现接口型
    
85. class Chef implements Runnable
    
86. {
    
87. private Food f;
    
88. 
    
89. Chef(Food f)
    
90. {
    
91. this.f = f;
    
92. }
    
93. public void run()
    
94. {
    
95. while(f.getSum()>f.getCount())
    
96. {
    
97. try
    
98. {
    
99. f.cook("盘");
    
100. }
     
101. catch (InterruptedException e)
     
102. {
     
103. }
     
104. }
     
105. }
     
106. }
     
107. 
     
108. //定义吃货类，为继承Thread类
     
109. class Eater extends Thread
     
110. {
     
111. private Food f;
     
112. 
     
113. Eater(Food f)
     
114. {
     
115. this.f = f;
     
116. }
     
117. public void run()
     
118. {
     
119. while(f.getSum()>f.getCount())
     
120. {
     
121. try
     
122. {
     
123. while(true)
     
124. f.eat();
     
125. }
     
126. catch (InterruptedException e)
     
127. {
     
128. }
     
129. }
     
130. }
     
131. }

复制代码

为什么我打的字有阴影。。。郁闷

没人帮忙吗？？？？？顶起 ~~

突然想明白了，我这个问题好愚蠢~~定义静态常量应该定义在Demo类中，而不知Main函数中。定义在Demo类中后，在下面的线程类中
直接使用 Demo.SUM 便可引用。

帖子挺好， 我带厂里 慢慢看，看看能不能解决