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

同步器--读写锁

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

之前我们无论是使用synchronized还是ReentrantLock，都是对整个操作进行了加锁，但我们可以想象到，如果两个线程都进行的知识读取的操作，那么实际上我们是不需要加锁的。

而读写，包括写与写之间还是需要加锁的。

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

关于读写锁的具体原理笔者能力有限，暂时还无法给出自己的理解，这里给出一篇并发编程网的文章供大家参考

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

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进入了线程共享资源修改之后： 709636739
Process finished with exit code 0

posted @ 2018-11-11 21:38 calmbook 阅读(675) 评论(0) 编辑收藏举报

刷新页面返回顶部

calmbook 随记

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

公告