使用ReentrantReadWriteLock类

类ReentrantLock具有完全互斥排他的效果，即同一时刻只有一个线程在执行ReentrantLock.lock（）方法后面的任务。这样虽然保证了实例变量的线程安全性，但是效率确实非常低下的。所以在JDK中提供了一种读写锁ReentrantReadWriteLock类，使用它可以加快运行效率，在某些不需要操作实例变量的方法中，完全可以使用读写锁ReentrantReadWriteLock来提升该方法的代码运行速度。

读写锁表示有两种锁，一个是读操作相关的锁，也称为共享锁；另一个是写相关的锁，也称为排它锁。多个读锁之间不互斥，读锁与写锁互斥，写锁与写锁互斥。在没有线程进行写入操作时，进行读操作的多个线程都可以获取读锁，而进行写入操作的线程只有在获取写锁后才能进行写入操作。

使用ReentrantReadWriteLock进行同步示例如下：

Service类，持有ReentrantReadWriteLock引用，包含只写和只读的方法，只读方法中用的是读锁，只写方法中用的是写锁。

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class MyService {
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public void read(){
        try{
            lock.readLock().lock();         //读锁
            System.out.println("获得读锁 "+Thread.currentThread().getName()+" "+System.currentTimeMillis());
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.readLock().unlock();
        }
    }

    public void write(){
        try{
            lock.writeLock().lock();        //写锁
            System.out.println("获得写锁 "+Thread.currentThread().getName()+" "+System.currentTimeMillis());
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.writeLock().unlock();
        }
    }
}

线程A，执行读操作。

public class ThreadA extends Thread{

    private MyService service;

    public ThreadA(MyService service){
        super();
        this.service = service;
    }

    @Override
    public void run(){
        service.read();
    }
}

线程B，执行写操作

public class ThreadB extends Thread{

    private MyService service;

    public ThreadB(MyService service){
        super();
        this.service = service;
    }

    @Override
    public void run(){
        service.write();
    }
}

测试类

public class Run {

    public static void main(String[] args) throws InterruptedException {
        MyService service = new MyService();
        ThreadA a = new ThreadA(service);
        a.setName("A");
        a.start();
        ThreadB b = new ThreadB(service);
        b.setName("B");
        b.start();
    }
}

运行结果如下，线程A执行完成之后，线程B才获得锁：

获得读锁 A 1462172338496
获得写锁 B 1462172348497

参考《Java多线程编程核心技术》

 

• 上一篇ReentrantLock使用Condition实现通知部分线程
• 下一篇关于equals和hashcode方法

我的同类文章

Java/多线程（34）

http://blog.csdn.net

• •Java阻塞队列ArrayBlockingQueue和LinkedBlockingQueue实现原理分析（还没看，先马）2016-09-12阅读283
• •并行编程框架 ForkJoin（介绍了一点原理，可扩展）2016-09-09阅读414
• •akka introduce2016-08-18阅读134
• •《实战Java...》读书笔记22016-08-14阅读95
• •Java NIO 总结与示例2016-08-14阅读240
• •倒计时器：CountDownLatch2016-08-12阅读76

• •Java 理论与实践: 应用 fork-join 框架（转自ibm）2016-09-09阅读104
• •《Java性能优化...》读书笔记2016-08-20阅读207
• •Java AIO总结与示例2016-08-16阅读1261
• •《实战Java...》读书笔记2016-08-14阅读80
• •一个并行搜索算法2016-08-13阅读289

更多文章