java并发学习02---ReadWriteLock 读写锁

同步器--读写锁

java并发包中帮咱们进行了一系列的封装，以前的重入锁须要咱们手动的加锁和释放锁，而同步器只须要咱们简单的去使用就能够了。

以前咱们不管是使用synchronized仍是ReentrantLock，都是对整个操做进行了加锁，但咱们能够想象到，若是两个线程都进行的知识读取的操做，那么实际上咱们是不须要加锁的。

而读写，包括写与写之间仍是须要加锁的。

而读写锁就是帮咱们来作这件事情的，若是连续两次操做都是读的话，那么咱们就不须要加锁了

关于读写锁的具体原理笔者能力有限，暂时还没法给出本身的理解，这里给出一篇并发编程网的文章供你们参考

java中的读写锁

 

这里给出一个简单的例子，说明读写锁的使用：

package thread.thread_util;

import java.util.Random;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 展现读写锁的基本应用
 * 读读之间不加锁
 * 读写和写写之间才加锁
 */
public class Lesson18_ReadWriteLock {
    private static Lock lock = new ReentrantLock();
    private static ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    private static Lock readLock = rwLock.readLock();
    private static Lock writeLock = rwLock.writeLock();
    private int value = 1;

    //模拟读操做
    public void handleRead(Lock lock) throws InterruptedException{
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + "进入了线程\n");
            Thread.sleep(1000);
            System.out.println(value);
        } finally {
            lock.unlock();
        }

    }

    //模拟写操做
    public void handleWrite(Lock lock, int index) throws InterruptedException{
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + "进入了线程");
            Thread.sleep(3000);
            value = index;
            System.out.println("共享资源修改以后： "+value);
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        final Lesson18_ReadWriteLock demo = new Lesson18_ReadWriteLock();

        //给读线程加上读锁
        Runnable readTarget = new Runnable() {
            @Override
            public void run() {
                try {
                    demo.handleRead(readLock);
//                    demo.handleRead(lock);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        //给写线程加上写锁
        Runnable writeTarget = new Runnable() {
            @Override
            public void run() {
                try {
                    demo.handleWrite(writeLock,new Random().nextInt());
//                    demo.handleWrite(lock,new Random().nextInt());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        for (int i = 0; i < 8 ; i++) {
            Thread thread = new Thread(readTarget);
            thread.setName("线程" + i);
            thread.start();
        }

        for (int i = 8; i < 10; i++) {
            Thread thread = new Thread(writeTarget);
            thread.setName("线程" + i);
            thread.start();
        }
    }
}

最后的运行结果：

’

线程0进入了线程

线程2进入了线程

线程3进入了线程

线程1进入了线程

线程7进入了线程

线程6进入了线程

线程5进入了线程

1
1
1
1
1
1
1
线程9进入了线程
共享资源修改以后： -1565636082
线程8进入了线程
共享资源修改以后： 641779894
线程4进入了线程

641779894

Process finished with exit code 0

线程8和线程9都是写锁锁住的线程，因此当涉及到他们的时候，线程就会被阻塞

也就是说会在进入写线程以前会停顿几秒钟，写线程执行完以后再执行写线程或者是读线程也须要停顿几秒钟。

总结一下就是   读 —— 写，   写 —— 读 ， 写 —— 写 之间都会进行阻塞。

而前面8个线程（0 ~ 7）则是一瞬间完成的，由于读与读之间是能够并行的。

 

这里本身的理解，根据代码的执行结果，本身有一些理解，但不必定正确，详细的原理你们仍是能够去参考上面给出的那篇文章。

这里的读写锁的名称是 ReentrantReadWriteLock ，它也是一种可重入的锁，只不过以前的重入锁是互斥的，只容许同一个线程重入，而读写锁也是重入的，但它是容许两个连续的读线程重入。

 

关于读写锁就小结到这里了。

 

"C:\Program Files\Java\jdk1.8.0_161\bin\java.exe" "-javaagent:D:\program files\IntelliJ IDEA 2018.1.2\lib\idea_rt.jar=45972:D:\program files\IntelliJ IDEA 2018.1.2\bin" -Dfile.encoding=UTF-8 -classpath "C:\Program Files\Java\jdk1.8.0_161\jre\lib\charsets.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\deploy.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\access-bridge-64.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\cldrdata.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\dnsns.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\jaccess.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\jfxrt.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\localedata.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\nashorn.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\sunec.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\sunjce_provider.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\sunmscapi.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\sunpkcs11.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\zipfs.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\javaws.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\jce.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\jfr.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\jfxswt.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\jsse.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\management-agent.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\plugin.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\resources.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\rt.jar;F:\codingfiles\learn\learn_java\javase\out\production\javase" thread.thread_util.Lesson18_ReadWriteLock线程1进入了线程线程0进入了线程线程4进入了线程线程2进入了线程线程3进入了线程线程7进入了线程线程10进入了线程线程8进入了线程线程13进入了线程线程11进入了线程线程6进入了线程线程5进入了线程线程9进入了线程线程15进入了线程线程16进入了线程线程12进入了线程线程14进入了线程线程17进入了线程111111111111111111线程18进入了线程共享资源修改以后： 22031275线程19进入了线程共享资源修改以后： 709636739Process finished with exit code 0