JUC包中多线程之读写锁

当多个线程同时对一个类的属性进行读写操作时，往往会涉及到多线程之间的通信问题。

如果是多线程同时（写写）或者多线程同时（读写），往往希望线程之间是“互斥的”，也就是当其中一个线程访问该类的一个熟悉时（不管是读还是写）都需要对该读写方法进行加锁，以免其他线程在此期间争抢该读写方法导致多线程访问的数据有误。

以上的情况不可避免的带来效率的下降，那么我们现在来考虑下面这种情况，如果是多线程同时进行读，这种情况是允许他们同时访问的，效率会提高。

jdk1.5之后提供了Java.util.concurrent包，其中提供了ReadWriteLock这个接口，提供了ReentrantReadWriteLock的实现类，内部有readlock和writelock两个方法，用于实现单独对读写锁进行区别，这个避免了Lock类的加锁方法对读的方法单独占用。

package xianchengtest;

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class TestReadWriteLock {

    public static void main(String[] args) {
        ReadWriteLockDemo rw = new ReadWriteLockDemo();
        //一个写线程
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                rw.set((int)(Math.random() * 101));
            }
        },"Write").start();
        //多个读线程
        for (int i = 0; i < 100; i++) {
            
            new Thread(new Runnable() {
                @Override
                public void run() {
                    rw.get();
                }
            },"Read").start();
        }
    }
}

class ReadWriteLockDemo {
    private int number= 0;
    private ReadWriteLock lock = new ReentrantReadWriteLock();
    
    //read
    public void get() {
        lock.readLock().lock();
        try {
            
            System.out.println(Thread.currentThread().getName()+ " : " + number);
        } finally {
            lock.readLock().unlock();
        }
    }
    
    //write
    public void set(int number) {
        lock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName());
            this.number = number;
        } finally {
            lock.writeLock().unlock();
        }
    }
}