黑马程序员技术交流社区

标题: 多线程问题 [打印本页]

---

作者: NewDemo    时间: 2014-5-5 15:58
标题: 多线程问题

1. public class ThreadTest2 {
   
2. 
   
3.         /**
   
4.          * @param args
   
5.          * 生产者消费例子实现
   
6.          * 思路：1.创建一个商品资源的类，并在其中定义两个加锁的方法用于模拟生产和消费的行为 2.定义生产者和消费者的类并实现Runnable接口
   
7.          * 3.主函数中创建线程并关联资源。
   
8.          */
   
9.         public static void main(String[] args) {
   
10.                 //创建线程并关联资源
    
11.                 Resource r = new Resource();
    
12.                 new Thread(new Producer(r)).start();
    
13.                 new Thread(new Producer(r)).start();
    
14.                 new Thread(new Producer(r)).start();
    
15.                 new Thread(new Producer(r)).start();
    
16.                 new Thread(new Consumer(r)).start();
    
17.                 new Thread(new Consumer(r)).start();
    
18. //                new Thread(new Consumer(r)).start();
    
19. //                new Thread(new Consumer(r)).start();
    
20.         }
    
21. 
    
22. }
    
23. //创建商品的类，公共资源
    
24. class Resource{
    
25.         private int count = 0;//用于记录商品的编号
    
26.         private boolean flag = false;//定义标记用来控制线程的运行交替
    
27.         //模拟生产行为
    
28.         public synchronized void set(){
    
29. while(flag)
    
30.                         try {
    
31.                                 this.wait();
    
32.                         } catch (InterruptedException e) {
    
33.                                 e.printStackTrace();
    
34.                         }
    
35.                 count++;
    
36.                 flag = true;
    
37.                 System.out.println(Thread.currentThread().getName()+"生产。。"+count);
    
38.                 this.notifyAll();
    
39.         }
    
40.         //模拟消费行为
    
41.         public synchronized void out(){
    
42. while(!flag)
    
43.                         try {
    
44.                                 this.wait();
    
45.                         } catch (InterruptedException e) {
    
46.                                 e.printStackTrace();
    
47.                         }
    
48.                 flag = false;
    
49.                 System.out.println(Thread.currentThread().getName()+"消费。。。。。"+count);
    
50.                 this.notifyAll();
    
51.         }
    
52. }
    
53. 
    
54. //生产者的类，实现接口，复写run方法
    
55. class Producer implements Runnable{
    
56.         private Resource r;
    
57.         Producer(Resource r){
    
58.                 this.r=r;
    
59.         }
    
60.         @Override
    
61.         public void run() {
    
62.                 while(true){
    
63.                         r.set();
    
64.                 }
    
65.         }
    
66. }
    
67. //消费者的类，实现接口，复写run方法
    
68. class Consumer implements Runnable{
    
69.         private Resource r;
    
70.         Consumer(Resource r){
    
71.                 this.r=r;
    
72.         }
    
73.         @Override
    
74.         public void run() {
    
75.                 while(true){
    
76.                         r.out();
    
77.                 }
    
78.         }
    
79. }

复制代码

毕老师在讲课时用生产者t1，t2，消费者t3，t4解释了判断标记的时候为什么不能用if，但是我想问的是t1等待的时候不是还没有释放锁吗，那t2是如何拿到锁并也等待了呢？
看下wait方法的注释，当调用wait方法时就会释放锁，并且这个方法应该一直在循环中使用。

---

作者: 随风而去    时间: 2014-5-5 17:11
这个是我写的一个生产消费者示例 你可以研究下

1. package test2;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.List;
   
5. 
   
6. /**
   
7. * 生成消费者模式
   
8. * @author 李昂志
   
9. *
   
10. */
    
11. public class ThreadRun {
    
12.        
    
13.         public static void main(String[] args) {
    
14.                 new Thread(new Factory("福特")).start();   //两家汽车店
    
15.                 new Thread(new Factory("宝马")).start();  
    
16.                 new Thread(new Customer("马晓")).start();  //5个客户
    
17.                 new Thread(new Customer("大米")).start();  
    
18.                 new Thread(new Customer("小跳")).start();  
    
19.                 new Thread(new Customer("Marry")).start();  
    
20.                 new Thread(new Customer("Jack")).start();  
    
21. 
    
22.         }
    
23. }
    
24. /**
    
25. *生成者
    
26. *生成汽车
    
27. */
    
28. class Factory  implements Runnable{
    
29.         String name ;
    
30.         public Factory(String name){
    
31.                 this.name = name;
    
32.         }
    
33. 
    
34.         @Override
    
35.         public void run() {
    
36.                 // TODO Auto-generated method stub
    
37.                 int i = 0 ;
    
38.                 while(true){
    
39.                         i++;
    
40.                         try {
    
41.                                 Thread.sleep(800); //每生产一辆汽车 休息0.8s
    
42.                         } catch (InterruptedException e) {
    
43.                                 // TODO Auto-generated catch block
    
44.                                 e.printStackTrace();
    
45.                         }
    
46.                         //生产汽车
    
47.                         Stores4S.getInstance().protect(name,i);
    
48.                 }
    
49.         }
    
50. }
    
51. /**
    
52. * 汽车
    
53. * @author 李昂志
    
54. */
    
55. class Car{
    
56.         String name;
    
57.         public Car(String name){
    
58.                 this.name = name;
    
59.         }
    
60.         public String getName() {
    
61.                 return name;
    
62.         }
    
63.         public void setName(String name) {
    
64.                 this.name = name;
    
65.         }
    
66.         public Car() {
    
67.         }
    
68.        
    
69. }
    
70. /**
    
71. * 消费者
    
72. * 消费汽车
    
73. */
    
74. class Customer implements Runnable{
    
75.         String name ;  //消费者的名字
    
76.         private Car c ;
    
77.         public Customer(String name){
    
78.                 this.name = name;
    
79.         }
    
80.        
    
81.         @Override
    
82.         public void run() {
    
83.                 while(true){
    
84.                         if(c != null ) break;  //如果消费者已经买到车 则退出买车的方法
    
85.                         try {
    
86.                                 Thread.sleep(1000); //消费者每买辆车 休息1s
    
87.                         } catch (InterruptedException e) {
    
88.                                 // TODO Auto-generated catch block
    
89.                                 e.printStackTrace();
    
90.                         }
    
91.                         c = Stores4S.getInstance().custom(name); //消费者买车
    
92.                 }
    
93.         }
    
94.        
    
95. }
    
96. /**
    
97. * 生产者用来卖东西
    
98. * 消费这买东西的地方 先叫做门店吧
    
99. * 一家4s汽车店  汽车店是唯一的
    
100. * @author 李昂志
     
101. */
     
102. class Stores4S  {
     
103.         private static Stores4S s = new Stores4S();
     
104.         private static final int MAX = 5;
     
105.         private List<Car> ls = new ArrayList<Car>();  //汽车店的容量
     
106.         private Stores4S(){};
     
107.         /**
     
108.          * 饿汉单利模式 唯一  且线程安全
     
109.          */
     
110.         public static  Stores4S getInstance(){
     
111.                 return s ;
     
112.         }
     
113.         /**
     
114.          * 卖汽车
     
115.          */
     
116.         public synchronized Car custom(String name){
     
117.                 while(ls.isEmpty()){
     
118.                         try {
     
119.                                 System.out.println("店里的汽车已销售完毕 请生产了再买 ！");
     
120.                                 wait();
     
121.                         } catch (InterruptedException e) {
     
122.                                 // TODO Auto-generated catch block
     
123.                                 e.printStackTrace();
     
124.                         }
     
125.                 }
     
126.                
     
127.                 Car c = ls.get(ls.size()-1);System.out.println(name +" 买了一辆型号为:"+c.getName()+" 的汽车");
     
128.                 ls.remove(c);
     
129.                
     
130.                
     
131.                 notifyAll();
     
132.                 return c;
     
133.         }
     
134.         /**
     
135.          * 4s店 去汽车商拿货
     
136.          * @param name
     
137.          * @param i
     
138.          */
     
139.         public synchronized void protect(String name, int i){
     
140.                 while(ls.size()>MAX){
     
141.                         try {
     
142.                                 System.out.println("店里的汽车已满 请消费了再生产 ！");
     
143.                                 wait();
     
144.                         } catch (InterruptedException e) {
     
145.                                 // TODO Auto-generated catch block
     
146.                                 e.printStackTrace();
     
147.                         }
     
148.                 }
     
149.                 ls.add(new Car(name+"_"+i));
     
150.                 System.out.println(name +"汽车商 生产了一辆型号为: "+ls.get(ls.size()-1).getName()+" 的汽车");
     
151.                 notifyAll();
     
152.         }
     
153. }

复制代码

---

作者: heima_xyu    时间: 2014-5-5 17:56
class Resource{
        private int count = 0;//用于记录商品的编号
        private boolean flag = false;//定义标记用来控制线程的运行交替
        //模拟生产行为
        public synchronized void set(){
if(flag)                                         //假设换成if， 假设       1.进入线程t1，因为flag为false   
try {                                                 //5.这时t2进来，也等待，然后执行消费行为的t3,t4
                                this.wait();             //4.因为flag为true,t1等待
                        } catch (InterruptedException e) {
                                e.printStackTrace();               //8.t1醒来，执行以下代码，在打印语句后，t2取得执行权，也打印了一次。
                        }                                                       //2.t1没有执行这段代码
                count++;                    
                flag = true;
                System.out.println(Thread.currentThread().getName()+"生产。。"+count);
                this.notifyAll();                                                    //3.flag变更为true，t1唤醒其他线程，但也可能继续循环，假设继续循环
        }


        //模拟消费行为
        public synchronized void out(){
if(!flag)                                         //6.t3进来，flag为！true,跳过try｛｝catch{}代码
                        try {
                                this.wait();
                        } catch (InterruptedException e) {
                                e.printStackTrace();
                        }
                flag = false;                        
                System.out.println(Thread.currentThread().getName()+"消费。。。。。"+count);
                this.notifyAll();                      //7.flag变更为false， t3唤醒其他线程，假设是t1和t2取得CPU使用权
        }
}

//1--8的步骤即线程不安全的原因所在，其实即使是while，该程序还是有微小的可能出错，notifyAll不如Lock系统的Condition的某个对象调用sig
nal()方法

---

作者: NewDemo    时间: 2014-5-5 18:03

heima_xyu 发表于 2014-5-5 17:56
class Resource{
        private int count = 0;//用于记录商品的编号
        private boolean flag = fa ...

你说的这个毕老师在视频里讲到了，我想问的是t1等待的时候不是还没有释放锁吗，那t2是如何拿到锁并也等待了呢？

---

作者: heima_xyu    时间: 2014-5-5 19:22

NewDemo 发表于 2014-5-5 18:03
你说的这个毕老师在视频里讲到了，我想问的是t1等待的时候不是还没有释放锁吗，那t2是如何拿到锁并也等待 ...

java的wait吊起线程的时候会释放synchronized锁

---

作者: NewDemo    时间: 2014-5-5 21:11

heima_xyu 发表于 2014-5-5 19:22
java的wait吊起线程的时候会释放synchronized锁

{:2_31:}原来是这样，刚才看了下源码，里面竟然还专门给出了例子，这个wait方法要一直在循环中使用，终于解决了这个疑惑，活到老，学到老。。

---

作者: wyqs92    时间: 2014-5-5 21:27

1. public class ThreadTest2 {
   
2. 
   
3.         /**
   
4.          * @param args
   
5.          * 生产者消费例子实现
   
6.          * 思路：1.创建一个商品资源的类，并在其中定义两个加锁的方法用于模拟生产和消费的行为 2.定义生产者和消费者的类并实现Runnable接口
   
7.          * 3.主函数中创建线程并关联资源。
   
8.          */
   
9.         public static void main(String[] args) {
   
10.                 //创建线程并关联资源
    
11.                 Resource r = new Resource();
    
12.                 new Thread(new Producer(r)).start();
    
13.                 new Thread(new Producer(r)).start();
    
14.                 new Thread(new Producer(r)).start();
    
15.                 new Thread(new Producer(r)).start();
    
16.                 new Thread(new Consumer(r)).start();
    
17.                 new Thread(new Consumer(r)).start();
    
18. //                new Thread(new Consumer(r)).start();
    
19. //                new Thread(new Consumer(r)).start();
    
20.         }
    
21. 
    
22. }
    
23. //创建商品的类，公共资源
    
24. class Resource{
    
25.         private int count = 0;//用于记录商品的编号
    
26.         private boolean flag = false;//定义标记用来控制线程的运行交替
    
27.         //模拟生产行为
    
28.         public synchronized void set(){
    
29. while(flag)//此处如果是while，它是一个循环。如果不满足就不执行。当条件满足时，向下执行wait()，下一次被唤醒之后还需要继续判断while中的条件。但是如果改为if，它表示的是判断，如果为真向下执行，就执行了wait()，当被唤醒后，它就直接执行wait()以下的语句。
    
30. 还有就是你要知道wait()表示等待，它要将正在执行的线程释放其执行资格和执行权，并存储到线程池中。
    
31. 
    
32.                      try {
    
33.                                 this.wait();
    
34.                         } catch (InterruptedException e) {
    
35.                                 e.printStackTrace();
    
36.                         }
    
37.                 count++;
    
38.                 flag = true;
    
39.                 System.out.println(Thread.currentThread().getName()+"生产。。"+count);
    
40.                 this.notifyAll();
    
41.         }
    
42.         //模拟消费行为
    
43.         public synchronized void out(){
    
44. while(!flag)
    
45.                         try {
    
46.                                 this.wait();
    
47.                         } catch (InterruptedException e) {
    
48.                                 e.printStackTrace();
    
49.                         }
    
50.                 flag = false;
    
51.                 System.out.println(Thread.currentThread().getName()+"消费。。。。。"+count);
    
52.                 this.notifyAll();
    
53.         }
    
54. }
    
55. 
    
56. //生产者的类，实现接口，复写run方法
    
57. class Producer implements Runnable{
    
58.         private Resource r;
    
59.         Producer(Resource r){
    
60.                 this.r=r;
    
61.         }
    
62.         @Override
    
63.         public void run() {
    
64.                 while(true){
    
65.                         r.set();
    
66.                 }
    
67.         }
    
68. }
    
69. //消费者的类，实现接口，复写run方法
    
70. class Consumer implements Runnable{
    
71.         private Resource r;
    
72.         Consumer(Resource r){
    
73.                 this.r=r;
    
74.         }
    
75.         @Override
    
76.         public void run() {
    
77.                 while(true){
    
78.                         r.out();
    
79.                 }
    
80.         }
    
81. }

复制代码

---

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

黑马程序员IT技术论坛 X3.2