高并发--卷4--读写锁

ReentrantLock锁的互斥性决定了同一时间内lock()下只能有一个线程在执行。
但是对于读和读的情况，却没必要让两个线程互斥，对于读写，写读，写写需要进行互斥，所以，JDK中提出了一种读写锁的机制，ReentrantReadWriteLock()，比如，你在更新一个用户的时候，不能让其他线程进行读，因为有可能线程1更新到一半呢，线程2读取出来的数据就是“脏数据”。

读读

读读不会互斥。

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class T{
    public static void main(String[] args) throws InterruptedException {
        final Config config = new Config();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    config.read();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A" ).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    config.read();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }               
            }
        },"B").start();
    }
}

class Config{
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    public void read() throws InterruptedException{
        try{
            lock.readLock().lock();
            System.out.println(Thread.currentThread().getName() + "-" + System.currentTimeMillis());
            Thread.sleep(5000);
        }finally{
            lock.readLock().unlock();
        }
    }
}

输出结果：
A-1532191985368
B-1532191985369

由输出结果可以看出读读并不会互斥。

读写

读写互斥

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class T{
    public static void main(String[] args) throws InterruptedException {
        final Config config = new Config();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    config.read();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A" ).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    config.write();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }               
            }
        },"B").start();
    }
}

class Config{
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    public void read() throws InterruptedException{
        try{
            lock.readLock().lock();
            System.out.println(Thread.currentThread().getName() + "-" + System.currentTimeMillis());
            Thread.sleep(5000);
        }finally{
            lock.readLock().unlock();
        }
    }
    Thread.sleep(100);
    public void write() throws InterruptedException{
        try{
            lock.writeLock().lock();
            System.out.println(Thread.currentThread().getName() + "-" + System.currentTimeMillis());
            Thread.sleep(5000);
        }finally{
            lock.writeLock().unlock();
        }
    }
}

输出结果：
A-1532192608317
B-1532192613317

从输出结果可以看出，读写互斥。

写写

写写互斥。lock.writeLock().lock()

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class T{
    public static void main(String[] args) throws InterruptedException {
        final Config config = new Config();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    config.write();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A" ).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    config.write();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }               
            }
        },"B").start();
    }
}

class Config{
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    public void read() throws InterruptedException{
        try{
            lock.readLock().lock();
            System.out.println(Thread.currentThread().getName() + "-" + System.currentTimeMillis());
            Thread.sleep(5000);
        }finally{
            lock.readLock().unlock();
        }
    }

    public void write() throws InterruptedException{
        try{
            lock.writeLock().lock();
            System.out.println(Thread.currentThread().getName() + "-" + System.currentTimeMillis());
            Thread.sleep(5000);
        }finally{
            lock.writeLock().unlock();
        }
    }
}

输出结果：
A-1532236406586
B-1532236411586

写读

写读互斥

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class T{
    public static void main(String[] args) throws InterruptedException {
        final Config config = new Config();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    config.write();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A" ).start();
        Thread.sleep(100);
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    config.read();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }               
            }
        },"B").start();
    }
}

class Config{
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    public void read() throws InterruptedException{
        try{
            lock.readLock().lock();
            System.out.println(Thread.currentThread().getName() + "-" + System.currentTimeMillis());
            Thread.sleep(5000);
        }finally{
            lock.readLock().unlock();
        }
    }

    public void write() throws InterruptedException{
        try{
            lock.writeLock().lock();
            System.out.println(Thread.currentThread().getName() + "-" + System.currentTimeMillis());
            Thread.sleep(5000);
        }finally{
            lock.writeLock().unlock();
        }
    }
}

输出结果：
A-1532236406586
B-1532236411586