在学习多线程中，在锁的使用问题上总是弄不清什么时候用什么样的锁最合适，希望能有个详细的解答最好带着实例解释

我觉得在使用synchronized代码块或函数中，只有一个锁的情况下，使用this锁就是最好的。

1. <span style="font-size:12px;">public class InputOutputDemo2
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 Res1 r=new Res1();
   
6.                 Thread t1=new Thread(new Input1(r));
   
7.                 Thread t2=new Thread(new Output1(r));
   
8.                 t1.start();
   
9.                 t2.start();
   
10.                
    
11.         }
    
12. }
    
13. class Res1
    
14. {
    
15.         private String name;
    
16.         private String sex;
    
17.         private boolean flag=false;
    
18.         public synchronized void set(String name,String sex)//set和out是同步的，只需要设置一个锁，那么用this就可以了。
    
19.         {
    
20.                 if(flag)
    
21.                         try{this.wait();}catch(InterruptedException e){}
    
22.                 this.name=name;
    
23.                 this.sex=sex;
    
24.                 flag=true;
    
25.                 this.notify();
    
26.         }
    
27.         public synchronized void out()
    
28.         {
    
29.                 if(!flag)
    
30.                         try{this.wait();}catch(InterruptedException e){}
    
31.                 System.out.println(name+"-----"+sex);
    
32.                 flag=false;
    
33.                 this.notify();
    
34.         }
    
35. }
    
36. class Input1 implements Runnable
    
37. {
    
38.         private Res1 r;
    
39.         Input1(Res1 r)
    
40.         {
    
41.                 this.r=r;
    
42.         }
    
43.         public void run()
    
44.         {
    
45.                 int x=0;
    
46.                 while(true)
    
47.                 {
    
48.                         if(x==0)
    
49.                                 r.set("zhangsan","man");
    
50.                         else
    
51.                                 r.set("lisi","woman");
    
52.                         x=(x+1)%2;
    
53.                 }
    
54.         }
    
55. }
    
56. class Output1 implements Runnable
    
57. {
    
58.         private Res1 r;
    
59.         Output1(Res1 r)
    
60.         {
    
61.                 this.r=r;
    
62.         }
    
63.         public void run()
    
64.         {
    
65.                 while(true)
    
66.                 {
    
67.                         r.out();
    
68.                 }
    
69.         }
    
70. }
    
71. </span>

复制代码

但是有两个以上的锁时，我们就需要另外建立对象，将其做为锁了。

1. public class DeadThreadDemo {
   
2.         public static void main(String[] args) {
   
3.                 // TODO Auto-generated method stub
   
4.                 Thread t1=new Thread(new Test(true));
   
5.                 Thread t2=new Thread(new Test(false));
   
6.                 t1.start();
   
7.                 t2.start();
   
8.         }
   
9. 
   
10. }
    
11. class Test implements Runnable
    
12. {
    
13.         private boolean flag;
    
14.         Test(boolean flag)
    
15.         {
    
16.                 this.flag=flag;
    
17.         }
    
18.         public void run()
    
19.         {
    
20.                 if (flag)
    
21.                 {
    
22.                         while (true)
    
23.                         {
    
24.                                 synchronized(MyLock.locka)//     1    1与2两个代码块不是同步的，我们就需要建立两个对象，成为两个不同的锁。
    
25.                                 {
    
26.                                         System.out.println("if locka");
    
27.                                         synchronized(MyLock.lockb)
    
28.                                         {
    
29.                                                 System.out.println("if lockb");
    
30.                                         }
    
31.                                 }
    
32.                         }
    
33.                 }
    
34.                 else
    
35.                 {
    
36.                         while(true)
    
37.                         {
    
38.                                 synchronized(MyLock.lockb)//    2
    
39.                                 {
    
40.                                         System.out.println("else lockb");
    
41.                                         synchronized(MyLock.locka)
    
42.                                         {
    
43.                                                 System.out.println("else locka");
    
44.                                         }
    
45.                                 }
    
46.                         }
    
47.                 }
    
48.         }
    
49. }
    
50. class MyLock
    
51. {
    
52.         static Object locka=new Object();
    
53.         static Object lockb=new Object();
    
54. }

复制代码

在线程间通讯的情况下，使用Lock更为方便更有针对性。

1. package day12;
   
2. 
   
3. import java.util.concurrent.locks.Condition;
   
4. import java.util.concurrent.locks.Lock;
   
5. import java.util.concurrent.locks.ReentrantLock;
   
6. 
   
7. public class ProducerCustomerDemo2
   
8. {
   
9.                 public static void main(String[] args)
   
10.                 {
    
11.                         Resource1 r=new Resource1();
    
12.                         Producer1 p=new Producer1(r);
    
13.                         Customer1 c=new Customer1(r);
    
14.                         Thread t1=new Thread(p);
    
15.                         Thread t2=new Thread(p);
    
16.                         Thread t3=new Thread(c);
    
17.                         Thread t4=new Thread(c);
    
18.                         t1.start();
    
19.                         t2.start();
    
20.                         t3.start();
    
21.                         t4.start();
    
22.                 }
    
23. }
    
24. class Resource1
    
25. {
    
26.         private String name;
    
27.         private int count;
    
28.         private boolean flag=false;
    
29.         private Lock lock=new ReentrantLock();//1.5版本新特性。相当与synchronized语句。
    
30.         //private Condition condition=lock.newCondition();//Condition相当与监视器方法，由lock的newCondition()方法获取。
    
31.         private Condition condition_pro=lock.newCondition();//每个lock可以建立多个condition，它们可以互相等待唤醒。
    
32.         private Condition condition_cus=lock.newCondition();
    
33.         public void set(String name)throws InterruptedException
    
34.         {
    
35.                 lock.lock();//上锁
    
36.                 try
    
37.                 {
    
38.                         while(flag)
    
39.                                 condition_pro.await();//由await()替换wait()方法
    
40.                         this.name=name+"----"+count++;
    
41.                         System.out.println(Thread.currentThread().getName()+"...生产者。。。"+this.name);
    
42.                         flag=true;
    
43.                         condition_cus.signal();//由signal()替换notify(),由signalAll()替换notifyAll()
    
44.                 }
    
45.                 finally
    
46.                 {
    
47.                         lock.unlock();
    
48.                 }
    
49.         }
    
50.         public void out()throws InterruptedException
    
51.         {
    
52.                 lock.lock();
    
53.                 try
    
54.                 {
    
55.                         while(!flag)
    
56.                                 condition_cus.await();
    
57.                         System.out.println(Thread.currentThread().getName()+"...消费者。。。。。。。。"+this.name);
    
58.                         flag=false;
    
59.                         condition_pro.signal();
    
60.                 }
    
61.                 finally
    
62.                 {
    
63.                         lock.unlock();
    
64.                 }
    
65.         }
    
66. }
    
67. class Producer1 implements Runnable
    
68. {
    
69.         private Resource1 r;
    
70.         Producer1(Resource1 r)
    
71.         {
    
72.                 this.r=r;
    
73.         }
    
74.         public void run()
    
75.         {
    
76.                 while(true)
    
77.                 {
    
78.                         try
    
79.                         {
    
80.                                 r.set("商品");
    
81.                         }
    
82.                         catch(InterruptedException e){}
    
83.                 }
    
84.         }
    
85. }
    
86. class Customer1 implements Runnable
    
87. {
    
88.         private Resource1 r;
    
89.         Customer1(Resource1 r)
    
90.         {
    
91.                 this.r=r;
    
92.         }
    
93.         public void run()
    
94.         {
    
95.                 while(true)
    
96.                 {
    
97.                         try
    
98.                         {
    
99.                                 r.out();
    
100.                         }
     
101.                         catch(InterruptedException e){}
     
102.                 }
     
103.         }
     
104. }

复制代码