1. import java.util.concurrent.locks.*;
   
2. 
   
3. class  ThreadTest
   
4. {
   
5.         public static void main(String[] args)
   
6.         {
   
7.                 Goods g = new Goods();
   
8.                 g.set("商品");
   
9.                 g.out();
   
10.         }
    
11. }
    
12. class Goods
    
13. {
    
14.         private String name;
    
15.         private int count = 1;
    
16.         private boolean flag = false;
    
17.         private Lock lock = new ReentrantLock();
    
18.         private Condition con_p = lock.newCondition();
    
19.         private Condition con_c = lock.newCondition();
    
20. 
    
21.         public void set(final String name)
    
22.                
    
23.         {
    
24.                
    
25.                 Runnable r = new Runnable()
    
26.                 {
    
27.                         public void run()
    
28.                         {        
    
29.                                 while (true)
    
30.                                 {
    
31.                                         lock.lock();
    
32.                                         try
    
33.                                         {
    
34.                                                 while(flag)
    
35.                                                         con_c.await();
    
36.                                                 Goods.this.name = name+"--"+count++;
    
37.                                                 System.out.println(Thread.currentThread().getName()+"..生产者.."+Goods.this.name);
    
38.                                                 flag = true;
    
39.                                                 con_p.signal();
    
40.                                         }
    
41.                                         catch (InterruptedException e)
    
42.                                         {
    
43.                                         }
    
44.                                 
    
45.                                         finally
    
46.                                         {
    
47.                                                 lock.unlock();
    
48.                                         }
    
49.                                 }
    
50.                         }
    
51.                 };
    
52.                 new Thread(r).start();
    
53.         }
    
54.         public void out()
    
55.         {
    
56.                
    
57.                 Runnable r = new Runnable()
    
58.                 {
    
59.                         public void run()
    
60.                         {
    
61.                                 while (true)
    
62.                             {
    
63.                                         lock.lock();
    
64.                                         try
    
65.                                         {
    
66.                                                 while(!flag)
    
67.                                                         con_p.await();
    
68.                                                 
    
69.                                                 System.out.println(Thread.currentThread().getName()+"..........消费者.."+Goods.this.name);
    
70.                                                 flag = false;
    
71.                                                 con_c.signal();
    
72.                                         }
    
73.                                         catch (InterruptedException e)
    
74.                                         {
    
75.                                         }
    
76.                                        
    
77.                                         finally
    
78.                                         {
    
79.                                                 lock.unlock();
    
80.                                         }
    
81.                                 }
    
82.                         }
    
83.                 };
    
84.                 new Thread(r).start();
    
85.                 new Thread(r).start();/*此处是自己试着看写上的，运行发现和普通写法{Thread t1 = new Thread(r)  Thread t2 = new Thread(r)  ,然后再各自start() }的 效果一样。 这里这样写是否正确，为什么参数是相同对象会建立不同的线程？*/
    
86.         }        
    
87. }

复制代码

new Thread(r).start();
new Thread(r).start();
参数是相同但是放在了2个不同的对象中所以还是两个不同的线程，但可以运行

你这边开启线程的条件是Thead类,你用了两个new字说明你开了两条线程.而那个参数是传递的是让你的Thread类启动的线程知道要运行的run()方法里面的代码在哪里.

这样写是正确的。new Thread()是创建了一个线程，你new了两个是两个不同的线程，里面传的相同的参数是让这两个线程都与这个对象联系起来，从而调用该对象的run方法。

new 了一个Thread就是创建了一个线程，给他传递参数是给线程分配任务，也就是说你是创建了两个线程，而他们执行的任务相同罢了