比较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() {@Overridepublic 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() {@Overridepublic 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 */@Overridepublic 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();/** * 读数据 */@Overridepublic 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锁}}/** * 写数据 */@Overridepublic 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];/** * 读数据 */@Overridepublic 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();}}}/** * 写数据 */@Overridepublic 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。