Java基础-Java中的并法库之重入读写锁（ReentrantReadWriteLock）

　　　　　　　　　Java基础-Java中的并法库之重入读写锁（ReentrantReadWriteLock）　　　　　　　　

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 　　作者：尹正杰

版权声明：原创作品，谢绝转载！否则将追究法律责任。

　　在学习Java的之前，你可能已经听说过读锁，写锁，读写锁，乐观锁，悲观锁。这些名词在学习数据库的时候几乎每个人都会有所了解的！当你学习java网络编程时，尤其是在处理多并发的情况时，你可能用过“synchronized”关键字是同步的方法，它可以用来同步代码块也可以用来同步方法。但JAVA中的锁并不是只有“synchronized”哟，在Java的并发库中你可能会进程看到一些可重入所（ReentrantLock）。

　　本篇博客就以重入读写锁（ReentrantReadWriteLock）来测试当两个线程的读锁和写锁是否可用同时访问。

一.两个线程同时上读锁的情况

1>.测试代码如下：

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */
 package cn.org.yinzhengjie.nio;

 import java.util.concurrent.locks.ReentrantReadWriteLock;

 /**
  * 重入锁测试
  */
 public class ReentrantLockDemo {
     public static void main(String[] args) {
         //通过并法库包的ReentrantReadWriteLock获取读写锁，里面既包含读锁也包含写锁。
         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock() ;

         //开启2个线程，看他们谁先抢到线程谁就会先打印数据。最好是通过IDE的调试方法查看他们的执行过程。
         new Thread(){
             public void run() {
                 //上读锁
                 lock.readLock().lock();
                 System.out.println("xxx");
                 //解读锁
                 lock.readLock().unlock();
             }
         }.start();

         new Thread(){
             public void run() {
                 //上读锁
                 lock.readLock().lock();
                 System.out.println("yyy");
                 //上读锁
                 lock.readLock().unlock();
             }
         }.start();
     }
 }

2>.IDEA打断点注意事项

3>.运行Debug模式并进入第一个线程

4>.查看控制台输出信息

5>.运行线程2的代码

6>.查看线程2的控制台

7>.得出结论

 　　答：在同一个程序中，一个线程拿到读锁且未释放锁时，另一个线程仍然可以继续使用读锁，他们之间并不互相影响！

 

二.两个线程一个上读锁，一个上写锁的情况

1>.测试代码

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */
 package cn.org.yinzhengjie.nio;

 import java.util.concurrent.locks.ReentrantReadWriteLock;

 /**
  * 重入锁测试
  */
 public class ReentrantLockDemo {
     public static void main(String[] args) {
         //通过并法库包的ReentrantReadWriteLock获取读写锁，里面既包含读锁也包含写锁。
         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock() ;

         //开启2个线程，看他们谁先抢到线程谁就会先打印数据。最好是通过IDE的调试方法查看他们的执行过程。
         new Thread(){
             public void run() {
                 //上读锁
                 lock.readLock().lock();
                 System.out.println("xxx");
                 //解读锁
                 lock.readLock().unlock();
             }
         }.start();

         new Thread(){
             public void run() {
                 //上写锁
                 lock.writeLock().lock();
                 System.out.println("yyy");
                 //解写锁
                 lock.writeLock().unlock();
             }
         }.start();
     }
 }

2>.执行第一个线程

3>.查看控制端是有内容输出的

4>.切换到第二个线程执行代码

5>.得出结论

　　答：当一个线程拿到读锁时，另一个线程无法使用写锁！

三.两个线程一个上写锁，一个上读锁的情况

1>.测试代码

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */
 package cn.org.yinzhengjie.nio;

 import java.util.concurrent.locks.ReentrantReadWriteLock;

 /**
  * 重入锁测试
  */
 public class ReentrantLockDemo {
     public static void main(String[] args) {
         //通过并法库包的ReentrantReadWriteLock获取读写锁，里面既包含读锁也包含写锁。
         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock() ;

         //开启2个线程，看他们谁先抢到线程谁就会先打印数据。最好是通过IDE的调试方法查看他们的执行过程。
         new Thread(){
             public void run() {
                 //上读锁
                 lock.writeLock().lock();
                 System.out.println("xxx");
                 //解读锁
                 lock.writeLock().unlock();
             }
         }.start();

         new Thread(){
             public void run() {
                 //上写锁
                 lock.readLock().lock();
                 System.out.println("yyy");
                 //解写锁
                 lock.readLock().unlock();
             }
         }.start();
     }
 }

2>.执行第一个线程

3>.查看第一个线程输出的内容

4>.执行第二线程

5>.得出结论

　答：当一个线程拿到写锁时，另一个线程无法使用读锁！

四.两个线程同时上写锁的情况

1>.测试代码

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */
 package cn.org.yinzhengjie.nio;

 import java.util.concurrent.locks.ReentrantReadWriteLock;

 /**
  * 重入锁测试
  */
 public class ReentrantLockDemo {
     public static void main(String[] args) {
         //通过并法库包的ReentrantReadWriteLock获取读写锁，里面既包含读锁也包含写锁。
         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock() ;

         //开启2个线程，看他们谁先抢到线程谁就会先打印数据。最好是通过IDE的调试方法查看他们的执行过程。
         new Thread(){
             public void run() {
                 //上读锁
                 lock.writeLock().lock();
                 System.out.println("xxx");
                 //解读锁
                 lock.writeLock().unlock();
             }
         }.start();

         new Thread(){
             public void run() {
                 //上写锁
                 lock.writeLock().lock();
                 System.out.println("yyy");
                 //解写锁
                 lock.writeLock().unlock();
             }
         }.start();
     }
 }

2>.执行第一个线程

 

3>.查看第一个线程输出的内容

 

4>.执行第二线程

 

5>.得出结论

　　答：当一个线程拿到写锁时，另一个线程无法使用写锁！