比较ReentrantReadWriteLock和synchronized

synchronized我们都不陌生，我们使用他可以让我们的代码变的线程安全；而ReentrantReadWriteLock也可以达到相同的效果，但是ReentrantReadWriteLock相比synchronized有一些不同，synchronized同时只能有一个线程得到相同对象的锁，我得到了其他任何人都不能得到。而ReentrantReadWriteLock中有读锁和写锁，读读不互斥，ReentrantReadWriteLock可以允许多个线程同时得到读锁，这样在值变更比较少的情况是很实用的，大家（线程）都只是读，那么我们都可以得到读锁，这样不像synchronized那样同时只能有一个线程得到锁。他两的详细介绍和使用大家可以自己百度。

下面是对ReentrantReadWriteLock和synchronized实现的测试：

import java.util.Random;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.locks.ReentrantReadWriteLock;

import com.ys.concurrent.lock.MyReadWriteLockTest.MyTest;

public class MyReadWriteLockTest implements Runnable {
	boolean flag = true;
	//定义接口主要是方便测试
	interface MyTest{
		 void getObj();
		 void setObj(Object obj);
	}

	public static void main(String[] args) {
		final MyTest mydata = new MyDataReadAndWriteLock();
		final MyTest dataSynchronized = new MyDataSynchronized();
		startRun(mydata);
	}

	/**
	 * 开始运行
	 * @param obj
	 */
	private static void startRun(final MyTest obj) {
		//CountDownLatch latch = new CountDownLatch(55);
		//CyclicBarrier的计数的个数为实际线程数+1，多出的一个是在主线程中控制完成方便记录时间
		/**
		 * public CyclicBarrier(int parties, Runnable barrierAction) 
 		   barrierAction就是当计数器一次计数完成后，系统会执行的动作
		 */
		CyclicBarrier barrier = new CyclicBarrier(56,new MyReadWriteLockTest());
		for (int i = 0; i < 50; i++) {//50个读线程，每个线程要读50次
			new Thread(new Runnable() {
				@Override
				public void run() {
					try {
						barrier.await();
					} catch (InterruptedException | BrokenBarrierException e) {
						e.printStackTrace();
					}
					for (int j = 0; j <50; j++) {
						obj.getObj();
					}
					try {
						barrier.await();
					} catch (InterruptedException | BrokenBarrierException e) {
						e.printStackTrace();
					}
					//latch.countDown();
				}
			}).start();
		}
		
		
		for (int i = 0; i < 5; i++) {//5个写线程，每个线程写10次
			new Thread(new Runnable() {
				@Override
				public void run() {
					try {
						barrier.await();
					} catch (InterruptedException | BrokenBarrierException e) {
						e.printStackTrace();
					}
					for (int j = 0; j <10; j++) {
						obj.setObj(new Random().nextInt(10000));
					}
					try {
						barrier.await();
					} catch (InterruptedException | BrokenBarrierException e) {
						e.printStackTrace();
					}
					//latch.countDown();
				}
			}).start();
		}
		
		long startTime = System.currentTimeMillis();
		try {
			//latch.await();
			barrier.await();
			//线程创建完成
			barrier.await();
			//线程运行完成
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println("用时："+(System.currentTimeMillis() - startTime));
	}

	/**
	 * CyclicBarrier每一次计数完成做的action
	 */
	@Override
	public void run() {
		if (flag) {
			System.out.println("创建线程完成!!!");
			flag = false;
		} else {
			System.out.println("运行结束!!!");
		}
	}
}
class MyDataReadAndWriteLock implements MyTest {
	private Object obj = null;
	private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
	
	/**
	 * 读数据
	 */
	@Override
	public void getObj() {
		//读锁，读读不互斥，一个线程得到了读锁，另一个线程也可以得到读锁
		lock.readLock().lock();
//		System.out.println(Thread.currentThread().getName()+ " be getObj to read data!"+ obj);
		try {
			Thread.sleep(10);
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			lock.readLock().unlock(); // 释放读锁，最好放在finnaly里面以免发生异常导致没有unlock锁
		}
	}
	/**
	 * 写数据
	 */
	@Override
	public void setObj(Object obj) {
		//得到写锁，同时只有一个线程能得到写锁，当一个线程得到写锁之后，读锁变得不可获取（读写互斥）
		lock.writeLock().lock();
		this.obj = obj;
//		System.out.println(Thread.currentThread().getName()+ " be setObj to write data!"+ obj);
		try {
			Thread.sleep(10);
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			lock.writeLock().unlock(); // 释放读锁，最好放在finnaly里面以免发生异常导致没有unlock锁
		}
	}
}

class MyDataSynchronized implements MyTest {
	private Object obj = "";
	private byte[] b = new byte[0];
	/**
	 * 读数据
	 */
	@Override
	public void getObj() {
		synchronized (b) {
//			System.out.println(Thread.currentThread().getName()+ " be ready to read data!"+ obj);
			try {
				Thread.sleep(10);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		
	}
	/**
	 * 写数据
	 */
	@Override
	public void setObj(Object obj) {
		synchronized (b) {
			this.obj = obj;
//			System.out.println(Thread.currentThread().getName()+ " be ready to write data!"+ obj);
			try {
				Thread.sleep(10);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		
	}
}

我们首先测试的是ReentrantReadWriteLock实现的读写程序，结果如下：

在main函数中startRun(mydata);参数换为dataSynchronized，Synchronized实现的读写程序，结果如下：

在读和写差距越明显的情况下结果相差也会越大，在读的使用较多的情况下不如考虑一下ReentrantReadWriteLock。