Java线程同步的解决方案——synchronized与Lock

港控/mmm° 2022-09-30 06:29 202阅读 0赞

要说明线程同步问题首先要说明Java线程的两个特性，**可见性和有序性**。

多个线程之间是不能直接传递数据交互的，它们之间的**交互只能通过共享变量来实现**。例如，假设在多个线程之间共享了Count类的一个对象，Count类有一个私有域num和一个公有方法count(),count()方法对num进行加1操作。这个对象是被创建在主内存(堆内存)中，每个线程都有自己的工作内存(线程栈)，工作内存存储了主内存Count对象的一个副本，当线程操作Count对象时，首先从主内存复制Count对象到工作内存中，然后执行代码count.count()，改变了num值，最后用工作内存Count刷新主内存Count。当一个对象在多个内存中都存在副本时，如果一个内存修改了共享变量，其它线程也应该能够看到被修改后的值，此为可见性。多个线程执行时，CPU对线程的调度是随机的，我们不知道当前程序被执行到哪步就切换到了下一个线程，一个最经典的例子就是银行汇款问题，一个银行账户存款100，这时一个人从该账户取10元，同时另一个人向该账户汇10元，那么余额应该还是100。那么此时可能发生这种情况，A线程负责取款，B线程负责汇款，A从主内存读到100，B从主内存读到100，A执行减10操作，并将数据刷新到主内存，这时主内存数据100-10=90，而B内存执行加10操作，并将数据刷新到主内存，最后主内存数据100+10=110，显然这是一个严重的问题，我们要保证A线程和B线程有序执行，先取款后汇款或者先汇款后取款，此为有序性。

先用代码来展示一下线程同步问题：

public class TraditionalThreadSynchronized {  
        public static void main(String[] args) {  
            final Outputter output = new Outputter();  
            new Thread() {  
                public void run() {  
                    output.output("zhangsan");  
                }  
            }.start();        
            new Thread() {  
                public void run() {  
                    output.output("lisi");  
                }  
            }.start();  
        }  
    }  
    class Outputter {  
        public void output(String name) {  
            // TODO 为了保证对name的输出不是一个原子操作，这里逐个输出name的每个字符  
            for(int i = 0; i < name.length(); i++) {  
                System.out.print(name.charAt(i));  
                Thread.sleep(10);  
            }  
        }  
    }

运行结果：

zhliansigsan

输出的字符串被打乱了，我们期望的输出结果是zhangsanlisi。这就是线程同步问题，我们希望output方法被一个线程完整的执行完之后再切换到下一个线程。

下面介绍线程同步的解决方案——synchronized关键字和Lock框架。

**一、synchronized实现线程同步**

Java中使用synchronized保证一段代码在多线程执行时是互斥的，有两种用法：

1、使用synchronized将需要**互斥的代码包含起来**，并上一把锁。

{  
        synchronized (this) {  
            for(int i = 0; i < name.length(); i++) {  
                System.out.print(name.charAt(i));  
            }  
        }  
    }

这把锁必须是需要互斥的多个线程间的共享对象。

2、将synchronized加在需要互斥的方法上。

public synchronized void output(String name) {  
        // TODO 线程输出方法  
        for(int i = 0; i < name.length(); i++) {  
            System.out.print(name.charAt(i));  
        }  
    }

这种方式就相当于用this锁住整个方法内的代码块，如果用synchronized加在静态方法上，就相当于用Outputter.class锁住整个方法内的代码块。使用synchronized在某些情况下会造成死锁。使用synchronized修饰的方法或者代码块可以看成是一个原子操作。

每个锁对象都有两个队列，一个是就绪队列，一个是阻塞队列，就绪队列存储了将要获得锁的线程，阻塞队列存储了被阻塞的线程，当一个线程被唤醒(notify)后，才会进入到就绪队列，从而有了获取CPU执行时间的可能，反之，当一个线程被wait后，就会进入阻塞队列，等待下一次被唤醒。上面例子中，当第一个线程执行输出方法时，获得同步锁，执行输出方法，恰好此时第二个线程也要执行输出方法，但发现同步锁没有被释放，第二个线程就会进入就绪队列，等待锁被释放。一个线程执行互斥代码过程如下：

1. 获得同步锁；

2. 清空工作内存；

3. 从主内存拷贝对象副本到工作内存；

4. 执行代码(计算或者输出等)；

5. 刷新主内存数据；

6. 释放同步锁。

所以，synchronized关键字既保证了多线程的并发有序性，又保证了多线程的内存可见性。

除去synchronized关键字之外，增加语义后的volatile关键字提供了另一种实现同步的方法。如果一个变量被volatile修饰，那么Java内存模型(主内存和线程工作内存)确保所有线程都可以看到一致的最新的该变量的值，来看一段代码：

class Test {  
        static int i = 0, j = 0;  
        static void write() {  
            i+=10;  
            j+=5;  
        }  
        static void read() {  
            System.out.println("i=" + i + " j=" + j);  
        }  
    }

一些线程执行write方法，另一些线程执行read方法，read方法有可能打印出j的值比i的值更大，按照之前分析的线程执行过程分析一下：

1. 将变量i从主内存拷贝到工作内存；

2. 改变i的值；

3. 刷新主内存数据；

4. 将变量j从主内存拷贝到工作内存；

5. 改变j的值；

6. 刷新主内存数据；

这个时候执行read方法的线程先读取了主存i原来的值又读取了j更新后的值，这就导致了程序的输出不是我们预期的结果，要阻止这种不合理的行为的一种方式是在write方法和read方法前面加上synchronized修饰符：

class Test {  
        static int i = 0, j = 0;  
        static synchronized void write() {  
            i+=10;  
            j+=5;  
        }  
        static synchronized void read() {  
            System.out.println("i=" + i + " j=" + j);  
        }  
    }

根据前面的分析，我们可以知道，这时write方法和read方法再也不会并发的执行了，i和j的值在主内存中会一直保持最新值供其他线程读取，并且read方法输出的也是一致的。但是synchronized在保证了write方法和read方法不能并发执行的同时，也让多个线程的read方法不能并发执行，这样的同步太过”重量级“。不利于提高read性能。使用在共享变量前加上volatile实现同步的方法，能够提供更”轻量级“的同步：

class Test {  
        static volatile int i = 0, j = 0;  
        static void write() {  
            i+=10;  
            j+=5;  
        }  
        static void read() {  
            System.out.println("i=" + i + " j=" + j);  
        }  
    }

write方法和read方法还会并发的去执行，但是**加上volatile可以将共享变量i和j的改变直接响应到主内存中**，这样保证了主内存中i和j的值一致性，然而在执行read方法时，在read方法获取到i的值和获取到j的值中间的这段时间，write方法也许被执行了好多次，导致j的值会大于i的值。所以volatile可以保证内存可见性，不能保证并发有序性。

Java 中的 volatile 变量可以被看作是一种 “程度较轻的 synchronized”；与 synchronized 块相比，volatile 变量所需的编码较少，并且运行时开销也较少，但是它所能实现的功能也仅是 synchronized 的一部分。**volatile 变量具有 synchronized 的可见性特性，但是不具备原子特性。这就是说线程能够自动发现 volatile 变量的最新值**。您只能在有限的一些情形下使用 volatile 变量替代锁。要使 volatile 变量提供理想的线程安全，必须同时满足下面两个条件：  
       1、对变量的**写操作不依赖于当前值**。  
       2、该变量没有包含在具有其他变量的不变式中。

实际上，这些条件表明，可以被写入 volatile 变量的这些有效值独立于任何程序的状态，包括变量的当前状态。第一个条件的限制使 **volatile 变量不能用作线程安全的计数器**。虽然增量操作（x++）看上去类似一个单独操作，实际上它是一个由读取－修改－写入操作序列组成的组合操作，必须以原子方式执行，而 volatile 不能提供必须的原子特性。实现正确的操作需要使 x 的值在这个组合操作的期间保持不变，而 volatile 变量无法实现这点（然而，如果将值调整为只从单个线程写入，那么可以忽略第一个条件）。

大多数编程情形都会与这两个条件的其中之一冲突，使得 volatile 变量不能像 synchronized 那样普遍适用于实现线程安全。在JDK5.0之前，如果没有参透volatile的使用场景，还是不要使用了，**尽量用synchronized来处理同步**问题，线程阻塞这玩意简单粗暴。

**二、Lock框架实现同步**

我们已经知道，synchronized 是Java的关键字，是Java的内置特性，在JVM层面实现了对临界资源的同步互斥访问，**但 synchronized 粒度有些大，在处理实际问题时存在诸多局限性，比如响应中断等**。Lock 提供了比 synchronized更广泛的锁操作，它能以更优雅的方式处理线程同步问题。

如果一个代码块被synchronized关键字修饰，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待直至占有锁的线程释放锁。事实上，占有锁的线程释放锁一般会是以下三种情况之一：

1）占有锁的线程执行完了该代码块，然后释放对锁的占有；  
       2）占有锁线程执行发生异常，此时JVM会让线程自动释放锁；  
       3）占有锁线程进入 WAITING 状态从而释放锁，例如在该线程中调用wait()方法等。  
       synchronized 是Java语言的内置特性，可以轻松实现对临界资源的同步互斥访问。那么，为什么还会出现Lock呢？试考虑以下三种情况：

Case 1 ：在使用synchronized关键字的情形下，假如**占有锁的线程由于要等待IO或者其他原因（比如调用sleep方法）被阻塞了，但是又没有释放锁，那么其他线程就只能一直等待，别无他法**。这会极大影响程序执行效率。因此，就需要有一种机制可以不让等待的线程一直无期限地等待下去（比如只等待一定的时间 (解决方案：tryLock(long time, TimeUnit unit)) 或者 能够响应中断 (解决方案：lockInterruptibly())），这种情况可以通过 Lock 解决。

Case 2 ：我们知道，当多个线程读写文件时，读操作和写操作会发生冲突现象，写操作和写操作也会发生冲突现象，但是读操作和读操作不会发生冲突现象。但是如果采用synchronized关键字实现同步的话，就会导致一个问题，即当**多个线程都只是进行读操作时，也只有一个线程在可以进行读操作，其他线程只能等待锁的释放而无法进行读操作**。因此，需要一种机制来使得当多个线程都只是进行读操作时，线程之间不会发生冲突。同样地，Lock也可以解决这种情况 (解决方案：ReentrantReadWriteLock) 。  
       Case 3 ：我们可以**通过Lock得知线程有没有成功获取到锁** (解决方案：ReentrantLock) ，但这个是synchronized无法办到的。

上面提到的三种情形，我们都可以通过Lock来解决，但 synchronized 关键字却无能为力。事实上，Lock 是 java.util.concurrent.locks包 下的接口，Lock 实现提供了比 synchronized 关键字 更灵活、更广泛、粒度更细的锁操作，它能以更优雅的方式处理线程同步问题。也就是说，Lock提供了比synchronized更多的功能。但是要注意以下几点：

1）synchronized是Java的关键字，因此是Java的内置特性，是基于JVM层面实现的。而Lock是一个Java接口，是基于JDK层面实现的，通过这个接口可以实现同步访问；

2）采用synchronized方式不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而 Lock则必须要用户去手动释放锁 (发生异常时，不会自动释放锁)，如果没有主动释放锁，就有可能导致死锁现象。

**2.1 Lock接口**

通过查看Lock的源码可知，Lock 是一个接口：

public interface Lock {
        void lock();
        void lockInterruptibly() throws InterruptedException;  // 可以响应中断
        boolean tryLock();
        boolean tryLock(long time, TimeUnit unit) throws InterruptedException;  // 可以响应中断
        void unlock();
        Condition newCondition();
    }

lock()、tryLock()、tryLock(long time, TimeUnit unit) 和 lockInterruptibly()都是用来获取锁的。unLock()方法是用来释放锁的。newCondition() 返回 绑定到此 Lock 的新的 Condition 实例 ，用于线程间的协作。

在Lock接口中声明了四个方法来获取锁，那么这四个方法有何区别呢？首先，lock()方法是平常使用得最多的一个方法，就是**用来获取锁。如果锁已被其他线程获取，则进行等待**。在前面已经讲到，如果采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此，一般来说，使用Lock必须在try…catch…块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。通常使用Lock来进行同步的话，是以下面这种形式去使用的：

Lock lock = ...;
    lock.lock();
    try{
        //处理任务
    }catch(Exception ex){
    
    }finally{
        lock.unlock();   //释放锁
    }

tryLock()方法是有返回值的，它表示**用来尝试获取锁，如果获取成功，则返回true；如果获取失败（即锁已被其他线程获取），则返回false，也就是说，这个方法无论如何都会立即返回**（在拿不到锁时不会一直在那等待）。

tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的，只不过区别在于**这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false，同时可以响应中断**。如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。一般情况下，通过tryLock来获取锁时是这样使用的：

Lock lock = ...;
    if(lock.tryLock()) {
         try{
             //处理任务
         }catch(Exception ex){
    
         }finally{
             lock.unlock();   //释放锁
         } 
    }else {
        //如果不能获取锁，则直接做其他事情
    }

lockInterruptibly()方法比较特殊，当通过这个方法去获取锁时，如果线程正在等待获取锁，则这个线程能够响应中断，即中断线程的等待状态。例如，当两个线程A与B同时通过lock.lockInterruptibly()想获取某个锁时，假若此时线程A获取到了锁，而线程B只能继续等待，那么**对线程B调用threadB.interrupt()方法就能够中断线程B的等待过程**。所以lock.lockInterruptibly()必须放在try块中或者在调用lockInterruptibly()的方法外声明抛出 InterruptedException，但推荐使用后者，原因稍后阐述。因此，lockInterruptibly()一般的使用形式如下：

public void method() throws InterruptedException {
       //将异常抛出，交给上层调用者处理
        lock.lockInterruptibly();
        try {  
         //.....
        }
        finally {
            lock.unlock();
        }  
    }

注意，当**一个线程获取了锁之后，是不会被interrupt()方法中断的**。因为**interrupt()方法只能中断阻塞过程中的线程而不能中断正在运行过程中的线程**。因此，当通过lockInterruptibly()方法获取某个锁时，如果不能获取到，那么只有在继续等待的情况下，才可以响应中断的。**使用synchronized 获取锁，当一个线程处于等待某个锁的状态时，是无法被中断的，只有一直等待下去**。

需要特别注意的是，在使用Lock时，无论以哪种方式获取锁，习惯上最好一律将获取锁的代码放到 try…catch…，因为我们一般将锁的unlock操作放到finally子句中，如果线程没有获取到锁，在执行finally子句时，就会执行unlock操作，从而抛出 IllegalMonitorStateException，因为该线程并未获得到锁却执行了解锁操作。

**2.2、ReentrantLock**  
  
  
       ReentrantLock，即可重入锁。ReentrantLock是唯一实现了Lock接口的类，并且ReentrantLock提供了更多的方法。下面通过一些实例学习如何使用 ReentrantLock。

public class Test {
        private ArrayList<Integer> arrayList = new ArrayList<Integer>();
    
        public static void main(String[] args) {
            final Test test = new Test();
    
            new Thread("A") {
                public void run() {
                    test.insert(Thread.currentThread());
                };
            }.start();
    
            new Thread("B") {
                public void run() {
                    test.insert(Thread.currentThread());
                };
            }.start();
        }
    
        public void insert(Thread thread) {
            Lock lock = new ReentrantLock();  // 注意这个地方:lock被声明为局部变量
            lock.lock();
            try {
                System.out.println("线程" + thread.getName() + "得到了锁...");
                for (int i = 0; i < 5; i++) {
                    arrayList.add(i);
                }
            } catch (Exception e) {
    
            } finally {
                System.out.println("线程" + thread.getName() + "释放了锁...");
                lock.unlock();
            }
        }
    }

运行结果：

线程A得到了锁...
    线程B得到了锁...
    线程A释放了锁...
    线程B释放了锁...

结果或许让人觉得诧异。第二个线程怎么会在第一个线程释放锁之前得到了锁？原因在于，**在insert方法中的lock变量是局部变量，每个线程执行该方法时都会保存一个副本，那么每个线程执行到lock.lock()处获取的是不同的锁**，所以就不会对临界资源形成同步互斥访问。因此，我们只需要将lock声明为成员变量即可，代码修改如下所示。

public class Test {
        private ArrayList<Integer> arrayList = new ArrayList<Integer>();
        private Lock lock = new ReentrantLock();  // 注意这个地方:lock被声明为成员变量
        ...
    }

修改后的运行结果：

线程A得到了锁...
    线程A释放了锁...
    线程B得到了锁...
    线程B释放了锁...

tryLock() 与 tryLock(long time, TimeUnit unit)的使用

public class Test {
        private ArrayList<Integer> arrayList = new ArrayList<Integer>();
        private Lock lock = new ReentrantLock(); // 注意这个地方：lock 被声明为成员变量
    
        public static void main(String[] args) {
            final Test test = new Test();
    
            new Thread("A") {
                public void run() {
                    test.insert(Thread.currentThread());
                };
            }.start();
    
            new Thread("B") {
                public void run() {
                    test.insert(Thread.currentThread());
                };
            }.start();
        }
    
        public void insert(Thread thread) {
            if (lock.tryLock()) {     // 使用 tryLock()
                try {
                    System.out.println("线程" + thread.getName() + "得到了锁...");
                    for (int i = 0; i < 5; i++) {
                        arrayList.add(i);
                    }
                } catch (Exception e) {
    
                } finally {
                    System.out.println("线程" + thread.getName() + "释放了锁...");
                    lock.unlock();
                }
            } else {
                System.out.println("线程" + thread.getName() + "获取锁失败...");
            }
        }
    }

运行结果：

线程A得到了锁...
    线程B获取锁失败...
    线程A释放了锁...

与 tryLock() 不同的是，tryLock(long time, TimeUnit unit) 能够响应中断，即支持对获取锁这个过程的中断，但尝试获取一个内部锁的操作（进入一个 synchronized 块）是不能被中断的。如下所示：

public class Test {
        private Lock lock = new ReentrantLock();   
        public static void main(String[] args)  {
            Test test = new Test();
            MyThread thread1 = new MyThread(test,"A");
            MyThread thread2 = new MyThread(test,"B");
            thread1.start();
            thread2.start();
    
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            thread2.interrupt();
        }  
    
        public void insert(Thread thread) throws InterruptedException{
            if(lock.tryLock(4, TimeUnit.SECONDS)){
                try {
                    System.out.println("time=" + System.currentTimeMillis() + " ,线程 " + thread.getName()+"得到了锁...");
                    long now = System.currentTimeMillis();
                    while (System.currentTimeMillis() - now < 5000) {
                        // 为了避免Thread.sleep()而需要捕获InterruptedException而带来的理解上的困惑,
                        // 此处用这种方法空转5秒
                    }
                }finally{
                    lock.unlock();
                }
            }else {
                System.out.println("线程 " + thread.getName()+"放弃了对锁的获取...");
            }
        }
    }
    
    class MyThread extends Thread {
        private Test test = null;
    
        public MyThread(Test test,String name) {
            super(name);
            this.test = test;
        }
    
        @Override
        public void run() {
            try {
                test.insert(Thread.currentThread());
            } catch (InterruptedException e) {
                System.out.println("time=" + System.currentTimeMillis() + " ,线程 " + Thread.currentThread().getName() + "被中断...");
            }
        }
    }

运行结果：

time=1486693682559, 线程A 得到了锁...
    time=1486693684560, 线程B 被中断...(响应中断，时间恰好间隔2s)

使用 lockInterruptibly() 响应中断

public class Test {
        private Lock lock = new ReentrantLock();   
        public static void main(String[] args)  {
            Test test = new Test();
            MyThread thread1 = new MyThread(test,"A");
            MyThread thread2 = new MyThread(test,"B");
            thread1.start();
            thread2.start();
    
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            thread2.interrupt();
        }  
    
        public void insert(Thread thread) throws InterruptedException{
            //注意，如果需要正确中断等待锁的线程，必须将获取锁放在外面，然后将 InterruptedException 抛出
            lock.lockInterruptibly(); 
            try {  
                System.out.println("线程 " + thread.getName()+"得到了锁...");
                long startTime = System.currentTimeMillis();
                for(;;) {              // 耗时操作
                    if(System.currentTimeMillis() - startTime >= Integer.MAX_VALUE)
                        break;
                    //插入数据
                }
            }finally {
                System.out.println(Thread.currentThread().getName()+"执行finally...");
                lock.unlock();
                System.out.println("线程 " + thread.getName()+"释放了锁");
            } 
            System.out.println("over");
        }
    }
    
    class MyThread extends Thread {
        private Test test = null;
    
        public MyThread(Test test,String name) {
            super(name);
            this.test = test;
        }
    
        @Override
        public void run() {
            try {
                test.insert(Thread.currentThread());
            } catch (InterruptedException e) {
                System.out.println("线程 " + Thread.currentThread().getName() + "被中断...");
            }
        }
    }

运行结果：

线程A得到了锁...
    线程B被中断...

运行上述代码之后，发现 thread2 能够被正确中断，放弃对任务的执行。特别需要注意的是，如果需要正确中断等待锁的线程，必须将获取锁放在外面（try 语句块外），然后将 InterruptedException 抛出。如果不这样做而是将获取锁的lock.lockInterruptibly();放在try语句块里，则必定会执行finally语句块中的解锁操作。在准备获取锁的线程B 被中断后，再执行解锁操作就会抛出 IllegalMonitorStateException，因为该线程并未获得到锁却执行了解锁操作。

**2.3 ReadWriteLock**

ReadWriteLock也是一个接口，在它里面只定义了两个方法：

public interface ReadWriteLock {
        /**
         * Returns the lock used for reading.
         *
         * @return the lock used for reading.
         */
        Lock readLock();
    
        /**
         * Returns the lock used for writing.
         *
         * @return the lock used for writing.
         */
        Lock writeLock();
    }

一个用来获取读锁，一个用来获取写锁。也就是说，将对临界资源的读写操作分成两个锁来分配给线程，从而使得多个线程可以同时进行读操作。 ReentrantReadWriteLock 类实现了 ReadWriteLock 接口。

ReentrantReadWriteLock 类提供了很多丰富的方法，不过最主要的有两个方法：readLock()和writeLock()用来获取读锁和写锁。下面通过几个例子来看一下ReentrantReadWriteLock具体用法。假如有多个线程要同时进行读操作的话，先看一下synchronized达到的效果：

public class Test {
        public static void main(String[] args)  {
            final Test test = new Test();
    
            new Thread("A"){
                public void run() {
                    test.get(Thread.currentThread());
                };
            }.start();
    
            new Thread("B"){
                public void run() {
                    test.get(Thread.currentThread());
                };
            }.start();
    
        }  
    
        public synchronized void get(Thread thread) {
            long start = System.currentTimeMillis();
            System.out.println("线程"+ thread.getName()+"开始读操作...");
            while(System.currentTimeMillis() - start <= 1) {
                System.out.println("线程"+ thread.getName()+"正在进行读操作...");
            }
            System.out.println("线程"+ thread.getName()+"读操作完毕...");
        }
    }

运行结果：

线程A开始读操作...
    线程A正在进行读操作...
    ...
    线程A正在进行读操作...
    线程A读操作完毕...
    线程B开始读操作...
    线程B正在进行读操作...
    ...
    线程B正在进行读操作...
    线程B读操作完毕...

这段程序的输出结果会是，直到线程A执行完读操作之后，才会打印线程B执行读操作的信息。而改成使用读写锁的话：

public class Test {
        private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    
        public static void main(String[] args) {
            final Test test = new Test();
    
            new Thread("A") {
                public void run() {
                    test.get(Thread.currentThread());
                };
            }.start();
    
            new Thread("B") {
                public void run() {
                    test.get(Thread.currentThread());
                };
            }.start();
        }
    
        public void get(Thread thread) {
            rwl.readLock().lock(); // 在外面获取锁
            try {
                long start = System.currentTimeMillis();
                System.out.println("线程" + thread.getName() + "开始读操作...");
                while (System.currentTimeMillis() - start <= 1) {
                    System.out.println("线程" + thread.getName() + "正在进行读操作...");
                }
                System.out.println("线程" + thread.getName() + "读操作完毕...");
            } finally {
                rwl.readLock().unlock();
            }
        }
    }

运行结果：

线程A开始读操作...
    线程B开始读操作...
    线程A正在进行读操作...
    线程A正在进行读操作...
    线程B正在进行读操作...
    ...
    线程A读操作完毕...
    线程B读操作完毕...

我们可以看到，线程A和线程B在同时进行读操作，这样就大大提升了读操作的效率。不过要注意的是，如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，则申请的线程也会一直等待释放写锁。

# **三、Lock和synchronized的选择** #

总的来说，Lock和synchronized有以下几点不同：  
       (1) Lock是一个接口，是JDK层面的实现；而synchronized是Java中的关键字，是Java的内置特性，是JVM层面的实现；   
       (2) **synchronized 在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生**；而**Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁**；   
       (3) Lock 可以**让等待锁的线程响应中断，而使用synchronized时，等待的线程会一直等待下去**，不能够响应中断；   
       (4) 通过Lock可以知道有没有成功获取锁，而synchronized却无法办到；   
       (5) Lock可以**提高多个线程进行读操作的效率**。

在性能上来说，**如果竞争资源不激烈，两者的性能是差不多的**。而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。所以说，在具体使用时要根据适当情况选择。