多线程问题， 正常来看两个线程应该锁上一个啊？怎么还是交替执行？
我在创建多线程时传入参数就是Ziyuan这个类的对象，也就是说两个多线程应该同时调用这一个对象Ziyuan，为什么还是锁不上？  我两个在synchronized锁的Object不是同一个对象？  疑惑中。。求各位解答下。。

1. class Ziyuan
   
2. {
   
3.         Object obj=new Object();
   
4.         public void shengchan()
   
5.         {
   
6.                 while(true)
   
7.                 {
   
8.                         synchronized(obj)
   
9.                         {
   
10.                                 System.out.println(Thread.currentThread().getName());
    
11.                         }
    
12.                 }
    
13.         }
    
14.         public void xiaofei()
    
15.         {
    
16.                 while(true)
    
17.                 {
    
18.                         synchronized(obj)
    
19.                         {
    
20.                                 System.out.println(Thread.currentThread().getName());
    
21.                         }
    
22.                 }
    
23.         }
    
24. }
    
25. class A implements Runnable
    
26. {
    
27.         Ziyuan z;
    
28.         A(Ziyuan z)
    
29.         {
    
30.                 this.z=z;
    
31.         }
    
32.         public void run()
    
33.         {        
    
34.                 z.shengchan();
    
35.         }
    
36. }
    
37. class B implements Runnable
    
38. {
    
39.         Ziyuan z;
    
40.         B(Ziyuan z)
    
41.         {
    
42.                 this.z=z;
    
43.         }
    
44.         public void run()
    
45.         {        
    
46.                 z.xiaofei();
    
47.         }
    
48. }
    
49. 
    
50. class Demo2
    
51. {
    
52.         public static void main(String args[])
    
53.         {
    
54.                 Ziyuan z=new Ziyuan();
    
55.                 A a=new A(z);
    
56.                 B b=new B(z);
    
57.                 new Thread(a).start();
    
58.                 new Thread(b).start();
    
59.         }
    
60. }

复制代码

1.   public void shengchan()
   
2.         {
   
3.                 while(true)
   
4.                 {
   
5.                         synchronized(obj)
   
6.                         {
   
7.                                 System.out.println(Thread.currentThread().getName());
   
8.                         }
   
9.                 }
   
10.         }
    
11.         public void xiaofei()
    
12.         {
    
13.                 while(true)
    
14.                 {
    
15.                         synchronized(obj)
    
16.                         {
    
17.                                 System.out.println(Thread.currentThread().getName());
    
18.                         }
    
19.                 }
    
20.         }

复制代码

这里2函数出了点小问题，你想想cpu处理速度很快，这两个函数都是while（true）
虽然共用同一个锁，他们分别由两线程执行，这样依然交替运行。
你得这样想，先生产出一件商品，我才可以消费，
所有我们需要再定义一个boolean flag=true
在生产函数，生产产品前加个if（flag）判断，当生产一件产品后，将flag改成false
然后再消费函数里，消费之前也价格判断if（！flag），当消费结束之后flag=true
这样设置的话，生产一件产品就消费一件商品，不知道符不符合楼主的需求，酱紫

展展 发表于 2014-4-29 10:37
这里2函数出了点小问题，你想想cpu处理速度很快，这两个函数都是while（true）
虽然共用同一个锁，他们分 ...

内个什么。。我知道你的意思 。。问题是现在我想让两个线程中的synchronized指向同一个锁  现在问题是锁不住。。我也不知道为什么 按理来说那两个锁应该是同一把锁的啊 为什么锁不住了？

张然龙 发表于 2014-4-29 10:55
内个什么。。我知道你的意思 。。问题是现在我想让两个线程中的synchronized指向同一个锁  现在问题是锁 ...

你可以使用wait和notify经行同一个锁的代码控制，他们在java.lang包Object类中有说明。。

展展 发表于 2014-4-29 11:02
你可以使用wait和notify经行同一个锁的代码控制，他们在java.lang包Object类中有说明。。 ...

wait  和notify 控制线程的前提是多个线程必须在同一把锁中运行才能控制其他线程  如果在这个代码中加上 wait 和notify肯定报错。。。 我现在疑惑的是如何才能一个线程运行 让另外一个挡在synchronized代码块的外边？？也就是说两个线程现在的synchronized的锁到底是不是一把锁啊？？

同步是为了解决多线程的安全问题，而多线程的安全问题是建立在多个线程执行共享数据上面的。你的代码分别是2个线程执行2个数据，虽然你谁用了同步，但是2个数据上不冲突。就算线程1进入后，线程2在外面等着，但是线程1很快就会从代码中出来，同事释放锁，线程2很快就会执行。

你为谁归来 发表于 2014-4-29 11:36
同步是为了解决多线程的安全问题，而多线程的安全问题是建立在多个线程执行共享数据上面的。你的代码分别是 ...

我晕啊 原来锁是同样的锁 之所以没锁上是因为一个线程释放了锁  其他线程就进来了 我还以为我的锁不是一个锁   呵呵 while循环应该写在synchronized代码块的里边！ 这样才能其中一个线程执行另外一个线程等待   我懂了   多谢多谢   ~ O(∩_∩)O~