在看线程的时候突然看到了线程监听器的两种方法一个是用同步代码块synchronized 一个可以用Lock
突然一下子没明白Lock是怎么控制资源共享问题的？？？就是转不过弯来 求解

这是一个使用Lock在两个线程中访问资源A和B的例子

1. import java.util.concurrent.locks.Lock;
   
2. import java.util.concurrent.locks.ReentrantLock;
   
3. 
   
4. class ThreadA extends Thread {
   
5.         ReentrantLock lock1 = null;
   
6.         ReentrantLock lock2 = null;
   
7. 
   
8.         public ThreadA(ReentrantLock lock1, ReentrantLock lock2) {
   
9.                 this.lock1 = lock1;
   
10.                 this.lock2 = lock2;
    
11.         }
    
12. 
    
13.         @Override
    
14.         public void run() {
    
15. 
    
16.                 try {
    
17.                         lock1.lock();
    
18.                         System.out.println("ThreadA----获取资源A");
    
19.                         sleep(3000);
    
20.                         System.out.println("ThreadA----释放资源A");
    
21.                 } catch (InterruptedException e) {
    
22.                         e.printStackTrace();
    
23.                 } finally {
    
24.                         lock1.unlock();
    
25.                 }
    
26. 
    
27.                 try {
    
28.                         lock2.lock();
    
29.                         System.out.println("ThreadA----获取资源B");
    
30.                         sleep(3000);
    
31.                         System.out.println("ThreadA----释放资源B");
    
32.                 } catch (InterruptedException e) {
    
33.                         e.printStackTrace();
    
34.                 } finally {
    
35.                         lock2.unlock();
    
36.                 }
    
37. 
    
38.         }
    
39. }
    
40. 
    
41. class ThreadB extends Thread {
    
42.         ReentrantLock lock1 = null;
    
43.         ReentrantLock lock2 = null;
    
44. 
    
45.         public ThreadB(ReentrantLock lock1, ReentrantLock lock2) {
    
46.                 this.lock1 = lock1;
    
47.                 this.lock2 = lock2;
    
48.         }
    
49. 
    
50.         @Override
    
51.         public void run() {
    
52. 
    
53.                 try {
    
54.                         lock2.lock();
    
55.                         System.out.println("ThreadB----获取资源B");
    
56.                         sleep(3000);
    
57.                         System.out.println("ThreadB----释放资源B");
    
58.                 } catch (InterruptedException e) {
    
59.                         e.printStackTrace();
    
60.                 } finally {
    
61.                         lock2.unlock();
    
62.                 }
    
63.                 try {
    
64.                         lock1.lock();
    
65.                         System.out.println("ThreadB----获取资源A");
    
66.                         sleep(3000);
    
67.                         System.out.println("ThreadB----释放资源A");
    
68.                 } catch (InterruptedException e) {
    
69.                         e.printStackTrace();
    
70.                 } finally {
    
71.                         lock1.unlock();
    
72.                 }
    
73. 
    
74.         }
    
75. }
    
76. 
    
77. public class LockDemo {
    
78.         public static void main(String[] args) {
    
79.                 ReentrantLock lock1 = new ReentrantLock(false);
    
80.                 ReentrantLock lock2 = new ReentrantLock(false);
    
81.                
    
82.                 new ThreadA(lock1,lock2).start();
    
83.                 new ThreadB(lock1,lock2).start();
    
84.         }
    
85. }
    

复制代码

个人在学习线程过程中，对Lock的一点小结，希望对楼主有用：
多线程在JDK1.5版本升级时，推出一个接口Lock接口。

解决线程安全问题使用同步的形式。(同步代码块，要么同步函数)
其实最终使用的都是锁机制。

到了后期版本，直接将锁封装成了对象。
线程进入同步就是具备了锁，执行完，离开同步，就是释放了锁。

所以同步是隐士的锁操作，
而Lock对象是显示的锁操作。

它的出现就替代了同步。

要想实现生产一个才消费一个的效果，就需要用到等待唤醒机制。

在之前的版本中使用Object类中wait notify notifyAll的方式来完成的。
那是因为同步中的锁是任意对象，所以操作锁的等待唤醒的方法都定义在Object类中。

而现在锁是指定对象Lock。所以查找等待唤醒机制方式需要通过Lock接口来完成。

而Lock接口中并没有直接操作等待唤醒的方法，而是将这些方式又单独封装到了一个对象中。
这个对象就是Condition，将Object中的三个方法进行单独的封装。

并提供了功能一致的方法 await(),signal(),signalAll();

在来一个简单的等待/唤醒机制的例子：
class Res
{
        private String name;
        private int count;
        private boolean flag;
        private Lock lock = new ReentrantLock();//创建了一个锁对象。

        private Condition con = lock.newCondition();
       
        public  void set(String name)
        {
                lock.lock();//获取锁。
                try
                {
                        while(flag)
                                try{con.await();}catch(InterruptedException e){}
                        this.name = name+"---"+count;

                        count++;

                        System.out.println(Thread.currentThread().getName()+"...........生产者...."+this.name);
                        flag = true;
                        con.signalAll();
                }
                finally
                {
                        lock.unlock();//释放锁
                       
                }

        }

        public void get()
        {
                lock.lock();
                try
                {
                        while(!flag)
                                try{con.await();}catch(InterruptedException e){}

                        System.out.println(Thread.currentThread().getName()+"....消费者...."+this.name);
                        flag = false;
                        con.signalAll();
                       
                }
                finally
                {
                        lock.unlock();       
                }
               
        }
}

class Producer implements Runnable
{
        private Res r;
        Producer(Res r)
        {
                this.r = r;
        }
        public void run()
        {
                while(true)
                {
                        r.set("产品");
                }
        }
}

class Consumer implements Runnable
{
        private Res r;
        Consumer(Res r)
        {
                this.r = r;
        }
        public void run()
        {
                while(true)
                {
                        r.get();
                }
        }
}


class ProConDemo2
{
        public static void main(String[] args)
        {
                Res r = new Res();
                Producer pro = new Producer(r);
                Consumer con = new Consumer(r);

                Thread t0 = new Thread(pro);
                Thread t1 = new Thread(pro);
                Thread t2 = new Thread(con);
                Thread t3 = new Thread(con);

                t0.start();
                t1.start();
                t2.start();
                t3.start();
        }
}

Lock
底层就是wait........ noity进行操作的 实行同步的

我的理解就是：Lock 的功能更为强大一些，毕竟是jdk1.5新出来的东西

比如 Lock 可以产生多个条件变量，可以实现多个类似于 wait, notifyAll 的等待及唤醒功能。
而 synchronized 只有一个条件变量，也就是锁对象的 wait 和 notifyAll毕竟
Lock 的锁定是通过代码实现的，而 synchronized 是在 JVM 层面上实现的
希望能对你理解有帮助