Java并发编程之悲观锁和乐观锁机制

一、资源和加锁

十余年的九原网站建设经验，针对设计、前端、开发、售后、文案、推广等六对一服务，响应快，48小时及时工作处理。营销型网站建设的优势是能够根据用户设备显示端的尺寸不同，自动调整九原建站的显示方式，使网站能够适用不同显示终端，在浏览器中调整网站的宽度，无论在任何一种浏览器上浏览网站，都能展现优雅布局与设计，从而大程度地提升浏览体验。创新互联从事“九原网站设计”,“九原网站推广”以来，每个客户项目都认真落实执行。

1、场景描述

多线程并发访问同一个资源问题，假如线程A获取变量之后修改变量值，线程C在此时也获取变量值并且修改，两个线程同时并发处理一个变量，就会导致并发问题。

这种并行处理数据库的情况在实际的业务开发中很常见，两个线程先后修改数据库的值，导致数据有问题，该问题复现的概率不大，处理的时候需要对整个模块体系有概念，才能容易定位问题。

2、演示案例

 
 
 
 
    
  
  
  
  
  1. public class LockThread01 {
    2. 
  
  
  
  
  2.     public static void main(String[] args) {
    3. 
  
  
  
  
  3.         CountAdd countAdd = new CountAdd() ;
    4. 
  
  
  
  
  4.         AddThread01 addThread01 = new AddThread01(countAdd) ;
    5. 
  
  
  
  
  5.         addThread01.start();
    6. 
  
  
  
  
  6.         AddThread02 varThread02 = new AddThread02(countAdd) ;
    7. 
  
  
  
  
  7.         varThread02.start();
    8. 
  
  
  
  
  8.     }
    9. 
  
  
  
  
  9. }
    10. 
  
  
  
  
  10. class AddThread01 extends Thread {
    11. 
  
  
  
  
  11.     private CountAdd countAdd  ;
    12. 
  
  
  
  
  12.     public AddThread01 (CountAdd countAdd){
    13. 
  
  
  
  
  13.         this.countAdd = countAdd ;
    14. 
  
  
  
  
  14.     }
    15. 
  
  
  
  
  15.     @Override
    16. 
  
  
  
  
  16.     public void run() {
    17. 
  
  
  
  
  17.         countAdd.countAdd(30);
    18. 
  
  
  
  
  18.     }
    19. 
  
  
  
  
  19. }
    20. 
  
  
  
  
  20. class AddThread02 extends Thread {
    21. 
  
  
  
  
  21.     private CountAdd countAdd  ;
    22. 
  
  
  
  
  22.     public AddThread02 (CountAdd countAdd){
    23. 
  
  
  
  
  23.         this.countAdd = countAdd ;
    24. 
  
  
  
  
  24.     }
    25. 
  
  
  
  
  25.     @Override
    26. 
  
  
  
  
  26.     public void run() {
    27. 
  
  
  
  
  27.         countAdd.countAdd(10);
    28. 
  
  
  
  
  28.     }
    29. 
  
  
  
  
  29. }
    30. 
  
  
  
  
  30. class CountAdd {
    31. 
  
  
  
  
  31.     private Integer count = 0 ;
    32. 
  
  
  
  
  32.     public void countAdd (Integer num){
    33. 
  
  
  
  
  33.         try {
    34. 
  
  
  
  
  34.             if (num == 30){
    35. 
  
  
  
  
  35.                 count = count + 50 ;
    36. 
  
  
  
  
  36.                 Thread.sleep(3000);
    37. 
  
  
  
  
  37.             } else {
    38. 
  
  
  
  
  38.                 count = count + num ;
    39. 
  
  
  
  
  39.             }
    40. 
  
  
  
  
  40.             System.out.println("num="+num+";count="+count);
    41. 
  
  
  
  
  41.         } catch (Exception e){
    42. 
  
  
  
  
  42.             e.printStackTrace();
    43. 
  
  
  
  
  43.         }
    44. 
  
  
  
  
  44.     }
    45. 
  
  
  
  
  45. }
    46.

这里案例演示多线程并发修改count值，导致和预期不一致的结果，这是多线程并发下最常见的问题，尤其是在并发更新数据时。

出现并发的情况时，就需要通过一定的方式或策略来控制在并发情况下数据读写的准确性，这被称为并发控制，实现并发控制手段也很多，最常见的方式是资源加锁，还有一种简单的实现策略：修改数据前读取数据，修改的时候加入限制条件，保证修改的内容在此期间没有被修改。

二、锁的概念简介

1、锁机制简介

并发编程中一个最关键的问题，多线程并发处理同一个资源，防止资源使用的冲突一个关键解决方法，就是在资源上加锁：多线程序列化访问。锁是用来控制多个线程访问共享资源的方式，锁机制能够让共享资源在任意给定时刻只有一个线程任务访问，实现线程任务的同步互斥，这是最理想但性能最差的方式，共享读锁的机制允许多任务并发访问资源。

2、悲观锁

悲观锁，总是假设每次每次被读取的数据会被修改，所以要给读取的数据加锁，具有强烈的资源独占和排他特性，在整个数据处理过程中，将数据处于锁定状态，例如synchronized关键字的实现就是悲观机制。

悲观锁的实现，往往依靠数据库提供的锁机制，只有数据库层提供的锁机制才能真正保证数据访问的排他性，否则，即使在本系统中实现了加锁机制，也无法保证外部系统不会修改数据，悲观锁主要分为共享读锁和排他写锁。

排他锁基本机制：又称写锁，允许获取排他锁的事务更新数据，阻止其他事务取得相同的资源的共享读锁和排他锁。若事务T对数据对象A加上写锁，事务T可以读A也可以修改A，其他事务不能再对A加任何锁，直到T释放A上的写锁。

3、乐观锁

乐观锁相对悲观锁而言，采用更加宽松的加锁机制。悲观锁大多数情况下依靠数据库的锁机制实现，以保证操作最大程度的独占性。但随之而来的就是数据库性能的大量开销，特别是对长事务的开销非常的占资源，乐观锁机制在一定程度上解决了这个问题。

乐观锁大多是基于数据版本记录机制实现，为数据增加一个版本标识，在基于数据库表的版本解决方案中，一般是通过为数据库表增加一个version字段来实现。读取出数据时，将此版本号一同读出，之后更新时，对此版本号加一。此时，将提交数据的版本数据与数据库表对应记录的当前版本信息进行比对，如果提交的数据版本号等于数据库表当前版本号，则予以更新，否则认为是过期数据。乐观锁机制在高并发场景下，可能会导致大量更新失败的操作。

乐观锁的实现是策略层面的实现：CAS(Compare-And-Swap)。当多个线程尝试使用CAS同时更新同一个变量时，只有其中一个线程能成功更新变量的值，而其它线程都失败，失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次尝试。

4、机制对比

悲观锁本身的实现机制就以损失性能为代价，多线程争抢，加锁、释放锁会导致比较多的上下文切换和调度延时，加锁的机制会产生额外的开销，还有增加产生死锁的概率，引发性能问题。

乐观锁虽然会基于对比检测的手段判断更新的数据是否有变化，但是不确定数据是否变化完成，例如线程1读取的数据是A1，但是线程2操作A1的值变化为A2，然后再次变化为A1，这样线程1的任务是没有感知的。

悲观锁每一次数据修改都要上锁，效率低，写数据失败的概率比较低，比较适合用在写多读少场景。

乐观锁并未真正加锁，效率高，写数据失败的概率比较高，容易发生业务形异常，比较适合用在读多写少场景。

是选择牺牲性能，还是追求效率，要根据业务场景判断，这种选择需要依赖经验判断，不过随着技术迭代，数据库的效率提升，集群模式的出现，性能和效率还是可以两全的。

三、Lock基础案例

1、Lock方法说明

lock：执行一次获取锁，获取后立即返回;

lockInterruptibly：在获取锁的过程中可以中断;

tryLock：尝试非阻塞获取锁，可以设置超时时间，如果获取成功返回true，有利于线程的状态监控;

unlock：释放锁，清理线程状态;

newCondition：获取等待通知组件，和当前锁绑定;

2、应用案例

 
 
 
 
    
  
  
  
  
  1. import java.util.concurrent.locks.Lock;
    2. 
  
  
  
  
  2. import java.util.concurrent.locks.ReentrantLock;
    3. 
  
  
  
  
  3. public class LockThread02 {
    4. 
  
  
  
  
  4.     public static void main(String[] args) {
    5. 
  
  
  
  
  5.         LockNum lockNum = new LockNum() ;
    6. 
  
  
  
  
  6.         LockThread lockThread1 = new LockThread(lockNum,"TH1");
    7. 
  
  
  
  
  7.         LockThread lockThread2 = new LockThread(lockNum,"TH2");
    8. 
  
  
  
  
  8.         LockThread lockThread3 = new LockThread(lockNum,"TH3");
    9. 
  
  
  
  
  9.         lockThread1.start();
    10. 
  
  
  
  
  10.         lockThread2.start();
    11. 
  
  
  
  
  11.         lockThread3.start();
    12. 
  
  
  
  
  12.     }
    13. 
  
  
  
  
  13. }
    14. 
  
  
  
  
  14. class LockNum {
    15. 
  
  
  
  
  15.     private Lock lock = new ReentrantLock() ;
    16. 
  
  
  
  
  16.     public void getNum (){
    17. 
  
  
  
  
  17.         lock.lock();
    18. 
  
  
  
  
  18.         try {
    19. 
  
  
  
  
  19.             for (int i = 0 ; i < 3 ; i++){
    20. 
  
  
  
  
  20.                 System.out.println("ThreadName:"+Thread.currentThread().getName()+";i="+i);
    21. 
  
  
  
  
  21.             }
    22. 
  
  
  
  
  22.         } finally {
    23. 
  
  
  
  
  23.             lock.unlock();
    24. 
  
  
  
  
  24.         }
    25. 
  
  
  
  
  25.     }
    26. 
  
  
  
  
  26. }
    27. 
  
  
  
  
  27. class LockThread extends Thread {
    28. 
  
  
  
  
  28.     private LockNum lockNum ;
    29. 
  
  
  
  
  29.     public LockThread (LockNum lockNum,String name){
    30. 
  
  
  
  
  30.         this.lockNum = lockNum ;
    31. 
  
  
  
  
  31.         super.setName(name);
    32. 
  
  
  
  
  32.     }
    33. 
  
  
  
  
  33.     @Override
    34. 
  
  
  
  
  34.     public void run() {
    35. 
  
  
  
  
  35.         lockNum.getNum();
    36. 
  
  
  
  
  36.     }
    37. 
  
  
  
  
  37. }
    38.

这里多线程基于Lock锁机制，分别依次执行任务，这是Lock的基础用法，各种API的详解，下次再说。

3、与synchronized对比

基于synchronized实现的锁机制，安全性很高，但是一旦线程失败，直接抛出异常，没有清理线程状态的机会。显式的使用Lock语法，可以在finally语句中最终释放锁，维护相对正常的线程状态，在获取锁的过程中，可以尝试获取，或者尝试获取锁一段时间。

标题名称：Java并发编程之悲观锁和乐观锁机制
分享链接：http://www.mswzjz.cn/qtweb/news8/501358.html

攀枝花网站建设、攀枝花网站运维推广公司-贝锐智能，是专注品牌与效果的网络营销公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 贝锐智能

贝锐智能技术为您推荐以下文章

品牌网站建设知识

分类信息网

关键词排名　　 　成都众诚伟业　　 　成都棕数机房　　 　成都商城网站制作　　 　h5页面制作　　 　成都微信公众号开发　　 　定制网站　　 　成都开元　　 　成都移动托管　　 　江油网站建设　　 　成都装饰装修　　 　响应式网站　　 　成都网站建设　　 　微信公众号二次开发　　 　西信服务器托管　　 　成都400电话　　 　高端网站定制　　 　app开发公司　　 　建站公司　　 　成都标志设计