1. 全栈程序员必看首页

【Java线程】锁机制：synchronized、Lock、Condition

全栈程序员-站长 • • 未分类 • 阅读 27

【Java线程】锁机制：synchronized、Lock、ConditionLock可以实现synchronized的相同功能，它能以更优雅的方式处理线程同步问题。与互斥锁定相比，读-写锁定允许对共享数据进行更高级别的并发访问。虽然一次只有一个线程（writer线程）可以修改共享数据，但在许多情况下，任何数量的线程可以同时读取共享数据（reader线程）Condition可以替代传统的线程间通信，用await()替换wait()，用signal()替换notify()，用signalAll()替换notifyAll()。Condition的强大之处在于它可以为多个线程间建

大家好，又见面了，我是你们的朋友全栈君。

  • http://www.infoq.com/cn/articles/java-memory-model-5  深入理解Java内存模型（五）——锁
  • http://www.ibm.com/developerworks/cn/java/j-jtp10264/  Java 理论与实践: JDK 5.0 中更灵活、更具可伸缩性的锁定机制
  • http://blog.csdn.net/ghsau/article/details/7481142

1、synchronized

把代码块声明为 synchronized，有两个重要后果，通常是指该代码具有 原子性（atomicity）和 可见性（visibility）。

1.1 原子性

原子性意味着个时刻，只有一个线程能够执行一段代码，这段代码通过一个monitor object保护。从而防止多个线程在更新共享状态时相互冲突。

1.2 可见性

可见性则更为微妙，它要对付内存缓存和编译器优化的各种反常行为。它必须确保释放锁之前对共享数据做出的更改对于随后获得该锁的另一个线程是可见的 。

作用：如果没有同步机制提供的这种可见性保证，线程看到的共享变量可能是修改前的值或不一致的值，这将引发许多严重问题。

原理：当对象获取锁时，它首先使自己的高速缓存无效，这样就可以保证直接从主内存中装入变量。 同样，在对象释放锁之前，它会刷新其高速缓存，强制使已做的任何更改都出现在主内存中。 这样，会保证在同一个锁上同步的两个线程看到在 synchronized 块内修改的变量的相同值。

一般来说，线程以某种不必让其他线程立即可以看到的方式（不管这些线程在寄存器中、在处理器特定的缓存中，还是通过指令重排或者其他编译器优化），不受缓存变量值的约束，但是如果开发人员使用了同步，那么运行库将确保某一线程对变量所做的更新先于对现有synchronized 块所进行的更新，当进入由同一监控器（lock）保护的另一个synchronized 块时，将立刻可以看到这些对变量所做的更新。类似的规则也存在于volatile变量上。

——volatile只保证可见性，不保证原子性！

1.3 何时要同步？

可见性同步的基本规则是在以下情况中必须同步：

  1. 读取上一次可能是由另一个线程写入的变量
  2. 写入下一次可能由另一个线程读取的变量

一致性同步：当修改多个相关值时，您想要其它线程原子地看到这组更改—— 要么看到全部更改，要么什么也看不到。

这适用于相关数据项（如粒子的位置和速率）和元数据项（如链表中包含的数据值和列表自身中的数据项的链）。

在某些情况中，您不必用同步来将数据从一个线程传递到另一个，因为 JVM 已经隐含地为您执行同步。这些情况包括：

  1. 由静态初始化器（在静态字段上或 static{} 块中的初始化器）
  2. 初始化数据时
  3. 访问 final 字段时 ——final对象呢？
  4. 在创建线程之前创建对象时
  5. 线程可以看见它将要处理的对象时

1.4 synchronize的限制

synchronized是不错，但它并不完美。它有一些功能性的限制：

  1. 它无法中断一个正在等候获得锁的线程；
  2. 也无法通过投票得到锁，如果不想等下去，也就没法得到锁；
  3. 同步还要求锁的释放只能在与获得锁所在的堆栈帧相同的堆栈帧中进行，多数情况下，这没问题（而且与异常处理交互得很好），但是，确实存在一些非块结构的锁定更合适的情况。

2、ReentrantLock

java.util.concurrent.lock 中的Lock 框架是锁定的一个抽象，它允许把锁定的实现作为 Java 类，而不是作为语言的特性来实现。这就为Lock 的多种实现留下了空间，各种实现可能有不同的调度算法、性能特性或者锁定语义。

ReentrantLock 类实现了Lock ，它拥有与synchronized 相同的并发性和内存语义，但是添加了类似锁投票、定时锁等候和可中断锁等候的一些特性。此外，它还提供了在激烈争用情况下更佳的性能。（换句话说，当许多线程都想访问共享资源时，JVM 可以花更少的时候来调度线程，把更多时间用在执行线程上。）

class Outputter1 {  
    private Lock lock = new ReentrantLock();// 锁对象  

    public void output(String name) {         
        lock.lock();      // 得到锁  

        try {  
            for(int i = 0; i < name.length(); i++) {  
                System.out.print(name.charAt(i));  
            }  
        } finally {  
            lock.unlock();// 释放锁  
        }  
    }  
}

区别：

需要注意的是，用sychronized修饰的方法或者语句块在代码执行完之后锁自动释放，而是用Lock需要我们手动释放锁，所以为了保证锁最终被释放(发生异常情况)，要把互斥区放在try内，释放锁放在finally内！！

3、读写锁ReadWriteLock

上例中展示的是和synchronized相同的功能，那Lock的优势在哪里？

例如一个类对其内部共享数据data提供了get()和set()方法，如果用synchronized，则代码如下：

class syncData {      
    private int data;// 共享数据      
    public synchronized void set(int data) {  
        System.out.println(Thread.currentThread().getName() + "准备写入数据");  
        try {  
            Thread.sleep(20);  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
        this.data = data;  
        System.out.println(Thread.currentThread().getName() + "写入" + this.data);  
    }     
    public synchronized  void get() {  
        System.out.println(Thread.currentThread().getName() + "准备读取数据");  
        try {  
            Thread.sleep(20);  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
        System.out.println(Thread.currentThread().getName() + "读取" + this.data);  
    }  
}

然后写个测试类来用多个线程分别读写这个共享数据： 

public static void main(String[] args) {  
//        final Data data = new Data();  
          final syncData data = new syncData();  
//        final RwLockData data = new RwLockData();  
        
        //写入
        for (int i = 0; i < 3; i++) {  
            Thread t = new Thread(new Runnable() {  
                @Override
		public void run() {  
                    for (int j = 0; j < 5; j++) {  
                        data.set(new Random().nextInt(30));  
                    }  
                }  
            });
            t.setName("Thread-W" + i);
            t.start();
        }  
        //读取
        for (int i = 0; i < 3; i++) {  
        	Thread t = new Thread(new Runnable() {  
                @Override
		public void run() {  
                    for (int j = 0; j < 5; j++) {  
                        data.get();  
                    }  
                }  
            });  
        	t.setName("Thread-R" + i);
        	t.start();
        }  
    }

运行结果： 

Thread-W0准备写入数据
Thread-W0写入0
Thread-W0准备写入数据
Thread-W0写入1
Thread-R1准备读取数据
Thread-R1读取1
Thread-R1准备读取数据
Thread-R1读取1
Thread-R1准备读取数据
Thread-R1读取1
Thread-R1准备读取数据
Thread-R1读取1
Thread-R1准备读取数据
Thread-R1读取1
Thread-R2准备读取数据
Thread-R2读取1
Thread-R2准备读取数据
Thread-R2读取1
Thread-R2准备读取数据
Thread-R2读取1
Thread-R2准备读取数据
Thread-R2读取1
Thread-R2准备读取数据
Thread-R2读取1
Thread-R0准备读取数据 //R0和R2可以同时读取，不应该互斥！
Thread-R0读取1
Thread-R0准备读取数据
Thread-R0读取1
Thread-R0准备读取数据
Thread-R0读取1
Thread-R0准备读取数据
Thread-R0读取1
Thread-R0准备读取数据
Thread-R0读取1
Thread-W1准备写入数据
Thread-W1写入18
Thread-W1准备写入数据
Thread-W1写入16
Thread-W1准备写入数据
Thread-W1写入19
Thread-W1准备写入数据
Thread-W1写入21
Thread-W1准备写入数据
Thread-W1写入4
Thread-W2准备写入数据
Thread-W2写入10
Thread-W2准备写入数据
Thread-W2写入4
Thread-W2准备写入数据
Thread-W2写入1
Thread-W2准备写入数据
Thread-W2写入14
Thread-W2准备写入数据
Thread-W2写入2
Thread-W0准备写入数据
Thread-W0写入4
Thread-W0准备写入数据
Thread-W0写入20
Thread-W0准备写入数据
Thread-W0写入29

现在一切都看起来很好！各个线程互不干扰！等等。。读取线程和写入线程互不干扰是正常的，但是两个读取线程是否需要互不干扰？？

对！读取线程不应该互斥！

我们可以用读写锁ReadWriteLock实现：

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock; 

    class Data {      
        private int data;// 共享数据  
        private ReadWriteLock rwl = new ReentrantReadWriteLock();     
        public void set(int data) {  
            rwl.writeLock().lock();// 取到写锁  
            try {  
                System.out.println(Thread.currentThread().getName() + "准备写入数据");  
                try {  
                    Thread.sleep(20);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
                this.data = data;  
                System.out.println(Thread.currentThread().getName() + "写入" + this.data);  
            } finally {  
                rwl.writeLock().unlock();// 释放写锁  
            }  
        }     

        public void get() {  
            rwl.readLock().lock();// 取到读锁  
            try {  
                System.out.println(Thread.currentThread().getName() + "准备读取数据");  
                try {  
                    Thread.sleep(20);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
                System.out.println(Thread.currentThread().getName() + "读取" + this.data);  
            } finally {  
                rwl.readLock().unlock();// 释放读锁  
            }  
        }  
    }

测试结果：

Thread-W1准备写入数据
Thread-W1写入9
Thread-W1准备写入数据
Thread-W1写入24
Thread-W1准备写入数据
Thread-W1写入12
Thread-W0准备写入数据
Thread-W0写入22
Thread-W0准备写入数据
Thread-W0写入15
Thread-W0准备写入数据
Thread-W0写入6
Thread-W0准备写入数据
Thread-W0写入13
Thread-W0准备写入数据
Thread-W0写入0
Thread-W2准备写入数据
Thread-W2写入23
Thread-W2准备写入数据
Thread-W2写入24
Thread-W2准备写入数据
Thread-W2写入24
Thread-W2准备写入数据
Thread-W2写入17
Thread-W2准备写入数据
Thread-W2写入11
Thread-R2准备读取数据
Thread-R1准备读取数据
Thread-R0准备读取数据
Thread-R0读取11
Thread-R1读取11
Thread-R2读取11
Thread-W1准备写入数据
Thread-W1写入18
Thread-W1准备写入数据
Thread-W1写入1
Thread-R0准备读取数据
Thread-R2准备读取数据
Thread-R1准备读取数据
Thread-R2读取1
Thread-R2准备读取数据
Thread-R1读取1
Thread-R0读取1
Thread-R1准备读取数据
Thread-R0准备读取数据
Thread-R0读取1
Thread-R2读取1
Thread-R2准备读取数据
Thread-R1读取1
Thread-R0准备读取数据
Thread-R1准备读取数据
Thread-R0读取1
Thread-R2读取1
Thread-R1读取1
Thread-R0准备读取数据
Thread-R1准备读取数据
Thread-R2准备读取数据
Thread-R1读取1
Thread-R2读取1
Thread-R0读取1

与互斥锁定相比，读-写锁定允许对共享数据进行更高级别的并发访问。虽然一次只有一个线程（writer 线程）可以修改共享数据，但在许多情况下，任何数量的线程可以同时读取共享数据（reader 线程）

从理论上讲，与互斥锁定相比，使用读-写锁定所允许的并发性增强将带来更大的性能提高。

在实践中，只有在多处理器上并且只在访问模式适用于共享数据时，才能完全实现并发性增强。——例如，某个最初用数据填充并且之后不经常对其进行修改的 collection，因为经常对其进行搜索（比如搜索某种目录），所以这样的 collection 是使用读-写锁定的理想候选者。

4、线程间通信Condition

Condition可以替代传统的线程间通信，用await()替换wait()，用signal()替换notify()，用signalAll()替换notifyAll()。

——为什么方法名不直接叫wait()/notify()/nofityAll()？因为Object的这几个方法是final的，不可重写！

传统线程的通信方式，Condition都可以实现。

注意，Condition是被绑定到Lock上的，要创建一个Lock的Condition必须用newCondition()方法。


Condition的强大之处在于它可以为多个线程间建立不同的Condition

看JDK文档中的一个例子：假定有一个绑定的缓冲区，它支持 put 和 take 方法。如果试图在空的缓冲区上执行 take 操作，则在某一个项变得可用之前，线程将一直阻塞；如果试图在满的缓冲区上执行 put 操作，则在有空间变得可用之前，线程将一直阻塞。我们喜欢在单独的等待 set 中保存put 线程和take 线程，这样就可以在缓冲区中的项或空间变得可用时利用最佳规划，一次只通知一个线程。可以使用两个Condition 实例来做到这一点。

——其实就是java.util.concurrent.ArrayBlockingQueue的功能

 class BoundedBuffer {
   final Lock lock = new ReentrantLock();          //锁对象
   final Condition notFull  = lock.newCondition(); //写线程锁
   final Condition notEmpty = lock.newCondition(); //读线程锁

   final Object[] items = new Object[100];//缓存队列
   int putptr;  //写索引
   int takeptr; //读索引
   int count;   //队列中数据数目

   //写
   public void put(Object x) throws InterruptedException {
     lock.lock(); //锁定
     try {
       // 如果队列满，则阻塞<写线程>
       while (count == items.length) {
         notFull.await(); 
       }
       // 写入队列，并更新写索引
       items[putptr] = x; 
       if (++putptr == items.length) putptr = 0; 
       ++count;

       // 唤醒<读线程>
       notEmpty.signal(); 
     } finally { 
       lock.unlock();//解除锁定 
     } 
   }

   //读 
   public Object take() throws InterruptedException { 
     lock.lock(); //锁定 
     try {
       // 如果队列空，则阻塞<读线程>
       while (count == 0) {
          notEmpty.await();
       }

       //读取队列，并更新读索引
       Object x = items[takeptr]; 
       if (++takeptr == items.length) takeptr = 0;
       --count;

       // 唤醒<写线程>
       notFull.signal(); 
       return x; 
     } finally { 
       lock.unlock();//解除锁定 
     } 
   } 
}

优点：

假设缓存队列中已经存满，那么阻塞的肯定是写线程，唤醒的肯定是读线程，相反，阻塞的肯定是读线程，唤醒的肯定是写线程。

那么假设只有一个Condition会有什么效果呢？缓存队列中已经存满，这个Lock不知道唤醒的是读线程还是写线程了，如果唤醒的是读线程，皆大欢喜，如果唤醒的是写线程，那么线程刚被唤醒，又被阻塞了，这时又去唤醒，这样就浪费了很多时间。

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请联系我们举报，一经查实，本站将立刻删除。

发布者：全栈程序员-站长，转载请注明出处：https://javaforall.net/156870.html原文链接：https://javaforall.net

赞 (0)
0 0

关于作者

全栈程序员-站长的头像

全栈程序员-站长

133.5K 文章
3 粉丝
本网站汇聚当前互联网主流语音，持续更新，欢迎关注公众号“全栈程序员社区”
上一篇 2022年7月8日 下午7:16
下一篇 2022年7月8日 下午7:16


相关推荐

  • 新手电子邮件营销必看法则

    新手电子邮件营销必看法则

    新手电子邮件营销必看法则新手接触电子邮件营销往往更多关注页面的美观 用户邮件列表是不是数量足够多 其实邮件营销需要注意的方面有很多 不仅可以帮助企业维护老客户 还可以挖掘新客户 给企业带来最直接的就是销量的提升以及品牌的建设 那么新手进行营销时应该注意哪些呢 定期整理用户列表 用户列表中不再打开你邮件的用户会浪费你的时间和金钱 因为大部分邮件发送系统的收费都是基于发送数量 所以每个月花点时间去整理下

    全栈程序员-站长的头像 全栈程序员-站长
    2026年3月18日
    2
  • pycharm 常用快捷键整理

    pycharm 常用快捷键整理

    pycharm 常用快捷键整理pycharm 常用快捷键 1 编辑 Editing Ctrl Space 基本的代码完成 类 方法 属性 Ctrl Alt Space 快速导入任意类 Ctrl Shift Enter 语句完成 Ctrl P 参数信息 在方法中调用参数 Ctrl Q 快速查看文档 F1 外部文档 Shift F1 外部文档 进入 web 文档主页 Ctrl Shift Z gt Redo 重做 Ctrl 鼠标简介 进入代码定

    全栈程序员-站长的头像 全栈程序员-站长
    2026年3月27日
    1
  • <span>移动站Web开发图片自适应两种常见情况解决方案</span>

    移动站Web开发图片自适应两种常见情况解决方案

    移动站Web开发图片自适应两种常见情况解决方案

    全栈程序员-站长的头像 全栈程序员-站长
    2021年11月17日
    46
  • ResNet34学习笔记+用pytorch手写实现

    ResNet34学习笔记+用pytorch手写实现

    ResNet34学习笔记+用pytorch手写实现看懂ResNet，需要理解两个点：shortcut的处理，以及网络结构理解1——IdentityMappingbyShortcuts（快捷恒等映射）我们每隔几个堆叠层采用残差学习。构建块如图2所示。在本文中我们考虑构建块正式定义为x和y是考虑的层的输入和输出向量。函数F(x,Wi)表示要学习的残差映射。图2中的例子有两层，F=W2σ(W1x)中σ表示ReLU[29]，为了…

    全栈程序员-站长的头像 全栈程序员-站长
    2022年10月5日
    4
  • 解决 用 Nginx 处理 跨域问题

    解决 用 Nginx 处理 跨域问题

    解决 用 Nginx 处理 跨域问题教你如何快速用 Nginx 轻松搞定跨域问题当你遇到跨域问题 不要立刻就选择复制去尝试 请详细看完这篇文章再处理 我相信它能帮到你 分析前准备 前端网站地址 http localhost 8080 服务端网址 http localhost 59200 首先保证服务端是没有处理跨域的 其次 先用 postman 测试服务端接口是正常的当网站 8080 去访问服务端接口时 就产生了跨域问题 那么如何解决 接下来我把跨域遇到的各种情况都列举出来并通过 nginx 代理的方式解决 后台也是一样的 只要

    全栈程序员-站长的头像 全栈程序员-站长
    2026年3月26日
    2
  • 解决多库冲突的方法

    解决多库冲突的方法

    解决多库冲突的方法

    全栈程序员-站长的头像 全栈程序员-站长
    2022年2月23日
    40

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

关注全栈程序员社区公众号