Thread之ReentrantReadWriteLock

目录

• • 前言
  • 读锁不互斥，可同时获得
  • • 运行结果
  • 写锁互斥，不可同时获得
  • • 结论

---

前言

读锁不互斥，可同时获得

import lombok.SneakyThrows;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
 * @author layman
 * @date 2021/2/9
 */
public class Demo07 {
    public static void main(String[] args) {
        Demo07Service service = new Demo07Service();
        Demo07ThreadA t1 = new Demo07ThreadA(service);
        Demo07ThreadA t2 = new Demo07ThreadA(service);
        t1.setName("读线程01");
        t2.setName("读线程02");
        t1.start();
        t2.start();
    }
}
class Demo07Service{
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public void read() throws InterruptedException {
        lock.readLock().lock();
        System.out.println(Thread.currentThread().getName()+" 获得读锁于："+System.currentTimeMillis());
        Thread.sleep(1000L);
        System.out.println(Thread.currentThread().getName()+" 释放读锁于："+System.currentTimeMillis());
        lock.readLock().unlock();
    }
    public void write() throws InterruptedException {
        lock.writeLock().lock();
        System.out.println(Thread.currentThread().getName()+" 获得写锁于："+System.currentTimeMillis());
        Thread.sleep(1000L);
        System.out.println(Thread.currentThread().getName()+" 释放写锁于："+System.currentTimeMillis());
        lock.writeLock().unlock();
    }
}
class Demo07ThreadA extends Thread{
    private Demo07Service service;
    public Demo07ThreadA(Demo07Service service){
        this.service = service;
    }
    @SneakyThrows
    @Override
    public void run() {
        service.read();
    }
}
class Demo07ThreadB extends Thread{
    private Demo07Service service;
    public Demo07ThreadB(Demo07Service service){
        this.service = service;
    }
    @SneakyThrows
    @Override
    public void run() {
        service.write();
    }
}

运行结果

写锁互斥，不可同时获得

t4.start();
    }
}
class Demo07Service{
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public void read() throws InterruptedException {
        lock.readLock().lock();
        System.out.println(Thread.currentThread().getName()+" 获得读锁于："+System.currentTimeMillis());
        Thread.sleep(1000L);
        System.out.println(Thread.currentThread().getName()+" 释放读锁于："+System.currentTimeMillis());
        lock.readLock().unlock();
    }
    public void write() throws InterruptedException {
        lock.writeLock().lock();
        System.out.println(Thread.currentThread().getName()+" 获得写锁于："+System.currentTimeMillis());
        Thread.sleep(1000L);
        System.out.println(Thread.currentThread().getName()+" 释放写锁于："+System.currentTimeMillis());
        lock.writeLock().unlock();
    }
}
class Demo07ThreadA extends Thread{
    private Demo07Service service;
    public Demo07ThreadA(Demo07Service service){
        this.service = service;
    }
    @SneakyThrows
    @Override
    public void run() {
        service.read();
    }
}
class Demo07ThreadB extends Thread{
    private Demo07Service service;
    public Demo07ThreadB(Demo07Service service){
        this.service = service;
    }
    @SneakyThrows
    @Override
    public void run() {
        service.write();
    }
}

结论

• 读写与写读都是互斥的，只要出现写操作，都是互斥的
• 读读是共享的