并发编程-读写锁

读写锁

ReentrantReadWriteLock

当读操作远远髙于写操作时,这时候使用读写锁让读-读可以并发,提高性能。 类似于数据库中的 select...from...lock in share mode 提供一个数据容器类内部分别使用读锁保护数据的read()方法,写锁保护数据的write()方法

public class TestReadWriteLock {
    public static void main(String[] args) {

        DataContainer dataContainer = new DataContainer();
        new Thread(() -> {
            dataContainer.read();
        }, "read").start();

        new Thread(() -> {
            dataContainer.write();
        }, "write").start();

    }
}


@Slf4j
class DataContainer {
    private Object data;
    private ReentrantReadWriteLock rw = new ReentrantReadWriteLock();
    private ReentrantReadWriteLock.ReadLock r = rw.readLock();
    private ReentrantReadWriteLock.WriteLock w = rw.writeLock();

    public Object read() {
        log.debug("获取读锁。。。");
        r.lock();
        try {
            log.debug("read");
            sleep(1000);
            return data;
        } finally {
            log.debug("释放读锁。。。");
            r.unlock();
        }
    }

    public void write() {
        log.debug("获取写锁");
        w.lock();
        try {
            log.debug("write");
        } finally {
            log.debug("释放写锁");
            w.unlock();
        }
    }

}

输出：

00:29:24.932 [read] DEBUG com.tyroxyz.multithread.multi.DataContainer - 获取读锁。。。 00:29:24.932 [write] DEBUG com.tyroxyz.multithread.multi.DataContainer - 获取写锁 00:29:24.945 [read] DEBUG com.tyroxyz.multithread.multi.DataContainer - read 00:29:25.946 [read] DEBUG com.tyroxyz.multithread.multi.DataContainer - 释放读锁。。。 00:29:25.946 [write] DEBUG com.tyroxyz.multithread.multi.DataContainer - write 00:29:25.946 [write] DEBUG com.tyroxyz.multithread.multi.DataContainer - 释放写锁

注意事项

• 读锁不支持条件变量
• 重入时升级不支持:即持有读锁的情况下去获取写锁,会导致获取写锁永久等待

r.lock();
try {
    w.lock();
    try {
        //...
    } finally {
        w.unlock();
    }
} finally {
    r.unlock();
}

• 重入时降级支持：即持有写锁的情况下获取读锁

class CachedData {
    Object data;
    //是否有效，如果失效，需要重新计算data
    volatile boolean cacheValid;
    final ReentrantReadWriteLock rw1 = new ReentrantReadWriteLock();
    void processCachedDate() {
        rw1.readLock().lock();
        if(!cacheValid) {
            //获取写锁前必须释放读锁
            rw1.readLock().unlock();
            rw1.writeLock().lock();
            try {
                //判断是否有其他线程已经获取了写锁，更新了缓存，避免重复更新
                if(!cacheValid) {
                    data = ...;
                    cacheValid = true;                           
                }
                //降级为读锁，释放写锁，这样能够让其他线程读取缓存
                rw1.readLock().lock();
            } finally {
                rw1.writeLock().unlock();
            }
        }
        //自己用完数据，释放读锁
        try {
            use(data);
        } finally {
            rw1.readLock().unlock();
        }
    }
}