java读写锁

java提供了锁机制，如果是普通的锁或者同步监视器，使用该同步监视器的方法或者代码块一定会串行执行，但是如果是你想用一个同步监视器控制几个方法中的某些串行，某些并行，从而提高执行效率，那么可以用java提供的读写锁。

读写锁，顾名思义，就是分为读锁和写锁，读读可同时，读写不能同时，写写不能同时。

看下面的例子：

class ReadWrite {
	private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
	
	public void read() throws InterruptedException{
		lock.readLock().lock();
		for(int i=0;i<100;i++){
			System.out.println("---read---"+Thread.currentThread().getName());
			if(i/2==0){
				Thread.sleep(500);
			}
		}
		lock.readLock().unlock();
	}
	
	public void write() throws InterruptedException{
		lock.writeLock().lock();
		for(int i=0;i<100;i++){
			System.out.println("---write---"+Thread.currentThread().getName());
			if(i/2==0){
				Thread.sleep(1000);
			}
		}
		lock.writeLock().unlock();
	}
}

class ReadThread implements Runnable{
	ReadWrite wr ; 
	ReadThread(ReadWrite wr){
		this.wr=wr;
	}
	@Override
	public void run() {
		try {
			wr.read();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

class WriteThread implements Runnable{
	ReadWrite wr ; 
	WriteThread(ReadWrite wr){
		this.wr=wr;
	}
	@Override
	public void run() {
		try {
			wr.write();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

public class ReadWriteLockTest {
	public static void main(String[] args) {
		//开启3个读线程读 3个线程写
		ReadWrite wr = new ReadWrite();
		for(int i=0;i<3;i++){
			WriteThread w = new WriteThread(wr);
			ReadThread r = new ReadThread(wr);
			new Thread(w).start();
			new Thread(r).start();
		}
	}
}

声明了一个读写类，里面分别提供了读方法和写方法，读方法使用的是ReentrantReadWriteLock的readLock,分别打印100次线程名，然后偶数时候就睡眠；同理，写方法使用的是writeLock,功能与读方法一致。

声明读线程和写线程，调用读方法和写方法。

一个测试类，开启了3个读线程和3个写线程，注意，此处传入的是一个ReadWrite实例，这样才能保证用的是一把读写锁，反之，如果不用同一个线程同步监视器，是不能控制并发的。

这样，运行结果应该是读线程之间可并发，其他的组合不行。

看测试结果：