线程锁(Lock)、读写锁(ReadWriteLock)及条件阻塞Condition

最新推荐文章于 2024-07-09 09:44:36 发布

Penny婷

最新推荐文章于 2024-07-09 09:44:36 发布

阅读量1.5k

点赞数

分类专栏： JAVA基础

本文链接：https://blog.csdn.net/Anna4/article/details/89680641

版权

本文详细介绍了Java并发编程中的线程锁（Lock）及其相较于`synchronized`的优势，包括其提供的更广泛的锁定操作和对条件阻塞Condition的支持。还讲解了读写锁（ReadWriteLock）的概念，强调读锁的并发访问能力与写锁的独占特性。最后，阐述了Condition在多线程通信中的作用，并给出了相关示例代码，如交替执行的线程场景和缓冲区实现。

摘要由CSDN通过智能技术生成

一、线程锁（Lock）

Lock实现提供比使用synchronized方法和语句可以获得的更广泛的锁定操作。它们允许更灵活的结构化，可能具有完全不同的属性，并且可以支持多个相关联的对象Condition 。
示例代码：

public class LockTest {

    public static void main(String[] args) {
        new LockTest().init();
    }

    private void init() {
        final Outputer outputer = new Outputer();
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    outputer.output("aaaaaaaaaaa");
                }

            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    outputer.output("bbbbbbbbbb");
                }

            }
        }).start();

    }

    static class Outputer {
        Lock lock = new ReentrantLock();

        public void output(String name) {
            int len = name.length();
            lock.lock();
            try{
                for (int i = 0; i < len; i++) {
                    System.out.print(name.charAt(i));
                }
                System.out.println();
            }finally {
            	//确保锁的释放,当获取多个锁时，它们必须以相反的顺序被释放
                lock.unlock();
            }
        }
    }
}

锁是用于通过多个线程控制对共享资源的访问的工具。通常，锁提供对共享资源的独占访问：一次只能有一个线程可以获取锁，并且对共享资源的所有访问都要求首先获取锁。但是，一些锁可能允许并发访问共享资源，如ReadWriteLock的读锁。

二、读写锁ReadWriteLock

读锁允许并发访问，写锁则要求独占访问。
读写锁测试：

/**
 * 读锁与读锁不互斥，读锁与写锁互斥，写锁与写锁互斥，这是由JVM控制的
 */
public class ReadWriteLockTest {
    public static void main(String[] args) {
        final Queue3 q3 = new Queue3();
        for(int i = 0;i<3;i++ ){
            new Thread(){