今天我们来聊下线程中的悲观锁和乐观锁,首先提到"悲观锁","乐观锁"提到这两个名词,大家可能会先想到数据库。注意啦,我们这里讲的是多线程中的锁,而不是数据库中的锁(没听过的童鞋,可以百度了解下。大概思想同线程中的悲乐锁思想差不多)。在Java中,常用Api提供的锁就是synchronized和lock,以及CAS。不知道大家有没有这            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-09-30 15:03:25
                            
                                152阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            悲观锁总是假设最坏的情况,悲观锁认为被它保护的数据是极其不安全的,每时每刻都有可能变动,一个事务拿到悲观锁后(可以理解为一个用户),其他任何事务都不能对该数据进行修改,只能等待锁被释放才可以执行。当我们要对一个数据库中的一条数据进行修改的时候,为了避免同时被其他人修改,最好的办法就是直接对该数据进行加锁以防止并发。这种借助数据库锁机制,在修改数据之前先锁定,再修改的方式被称之为悲观并发控制(又名“            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-04-08 16:09:48
                            
                                63阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            考察点:数据库 参考回答: 悲观锁 悲观锁(Pessimistic Lock),顾名思义,就是很悲观,每次去拿数据的时候都认为别人会 修改,所以每次在拿数据的时候都会上锁,这样别人想拿这个数据就会 block 直到它拿到锁。 悲观锁:假定会发生并发冲突,屏蔽一切可能违反数据完整性的操作。 Java synchronized 就属于悲观锁的一种实现,每次线程要修改数据时都先获得锁,保证同 一时刻只有            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-08-11 09:40:48
                            
                                62阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            一. 为什么要引入锁多个用户同时对数据库的并发操作时会带来以下数据不一致的问题。二、锁的分类(1)从程序员的角度看锁分为以下两种类型:* 乐观锁(Optimistic Lock)乐观锁( Optimistic Locking ) 相对悲观锁而言,乐观锁机制采取了更加宽松的加锁机制。悲观锁大多数情况下依靠数据库的锁机制实现,以保证操作最大程度的独占性。但随之而来的就是数据库性能的大量开销,特别是对长            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-07-17 20:26:44
                            
                                117阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            乐观锁与悲观锁是一种广义上的概念,体现了看待线程同步的不同角度。在Java和数据库中都有此概念对应的实际应用。Java中synchronized关键字和Lock的实现类是悲观锁,线程一旦得到锁,其他需要锁的线程就挂起的情况就是悲观锁。 这种锁会让没有得到锁资源的线程进入阻塞状态,而后在争夺到锁资源后恢复为运行状态,这个过程中涉及到操作系统用户模式和内核模式的转换,代价比较高。乐观锁在Java中是通            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-06-02 21:44:22
                            
                                130阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            最近面试,面试官提到了悲观锁和乐观锁,感觉回答的不是很好,特此总结记录. 简单来说,悲观锁就是凡事都认为会出现最坏的情形,而乐观锁就是认为凡事都以最好的情形发展,对应一个消极,一个积极.悲观锁具有强烈的独占和排他特性。它指的是对数据被外界(包括本系统当前的其他事务,以及来自外部系统的事务处理)修改持保守态度,因此,在整个数据处理过程中,将数据处于锁定状态.(摘自百度百科) 传统关系型数据库里面的很            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-09-18 12:18:52
                            
                                98阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            什么是CAS(1)CAS(compare and swap) 比较并替换,比较和替换是线程并发算法时用到的一种技术 (2)CAS是原子操作,保证并发安全,而不是保证并发同步 (3)CAS是CPU的一个指令 (4)CAS是非阻塞的、轻量级的乐观锁为什么说CAS是乐观锁乐观锁,严格来说并不是锁,通过原子性来保证数据的同步,比如说数据库的乐观锁,通过版本控制来实现等,所以CAS不会保证线程同步。乐观的认            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-11-08 23:18:38
                            
                                76阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            Spring整合SpringDataJpa的乐观锁与悲观锁详情一、概述上一篇《Spring和SpringDataJpa整合详解》介绍了Spring如何结合Spring-data-jpa进行数据库访问操作。这一篇介绍下springmvc环境下spring-data-jpa如何进行乐观锁、悲观锁的使用。悲观锁和乐观锁的概念:悲观锁:就是独占锁,不管读写都上锁了。传统的关系型数据库里边就用到了很多这种锁            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-12-29 22:27:52
                            
                                157阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            乐观锁:每次去拿数据的时候都认为别人不会修改,所以不会上锁,但是在提交更新的时候会判断一下在 此期间别人有没有去更新这个数据。悲观锁:每次去拿数据的时候都认为别人会修改,所以每次在拿数据的时候都会上锁,这样别人想拿这个 数据就会阻止,直到这个锁被释放。数据库的乐观锁需要自己实现,在表里面添加一个 version 字段,每次修改成功值加 1,这样每次修改的时候先对比一下,自己拥有的 version            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-10-23 09:54:20
                            
                                102阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            java多线程中的锁分类多种多样,其中有一种主要的分类方式就是乐观和悲观进行划分的。这篇文章主要介绍如何自己手写一个乐观锁代码。不过文章为了保证完整性,会从基础开始介绍。一、乐观锁概念说是写乐观锁的概念,但是通常乐观锁和悲观锁的概念都要一块写。对比着来才更有意义。1、悲观锁概念悲观锁:总是假设最坏的情况,每次去拿数据的时候都认为别人会修改,所以每次在拿数据的时候都会上锁,这样别人想拿这个数据就会阻            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-03-14 21:56:22
                            
                                0阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            出现背景:在需要提高程序的并发量的时候就需要使用多线程,但是多线程中有时会有线程不安全的问题,使用锁的话,必然会降低程序的执行效率。使用场景:在一些场景下线程不安全出现的频率较小,特别是我们读数据的时候比较多,修改数据的时候比较少,这个时候就可以使用乐观锁来解决。传统的就是不管会不会出现线程安全,直接带上锁,也就是悲观锁。在写数据多的场景,使用悲观锁要好一点,不管三七二十一,直接synchroni            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-11-03 06:59:45
                            
                                95阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            先来说说什么是悲观锁、乐观锁:
悲观锁:总是假设最坏的情况,每次操作数据的时候都认为别人会修改,所以每次在拿数据的时候都会上锁,这样别人想拿这个数据就会阻塞,直到它拿到锁。Java中synchronized和ReentrantLock等独占锁就是悲观锁思想的实现。            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-07-18 09:10:22
                            
                                104阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            java锁分为三大类乐观锁、悲观锁、自旋锁乐观锁:乐观锁是一种乐观思想,即认为读多写少,遇到并发写的可能性低,每次去拿数据的时候都认为别人不会修改,所以不会上锁,但是在更新的时候会判断一下在此期间别人有没有去更新这个数据,采取在写时先读出当前版本号,然后加锁操作(比较跟上一次的版本号,如果一样则更新),如果失败则要重复读-比较-写的操作。java 中的乐观锁基本都是通过 CAS 操作实现的,CAS            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-09-23 20:46:14
                            
                                48阅读
                            
                                                                             
                 
                
                             
         
            
            
            
             乐观锁 VS 悲观锁 乐观锁与悲观锁是一种广义上的概念,体现了看待线程同步的不同角度,在Java和数据库中都有此概念对应的实际应用。1.乐观锁 顾名思义,就是很乐观,每次去拿数据的时候都认为别人不会修改,所以不会上锁,但是在更新的时候会判断一下在此期间别人有没有去更新这个数据,可以使用版本号等机制。乐观锁适用于多读的应用类型,乐观锁在Java中是通过使用无锁编程来实现,最常采用的是CA            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-07-16 12:28:05
                            
                                126阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            悲观锁认为随时有可能发生冲突,用锁保护所有临界区。日常使用的锁绝大多数都是悲观锁。优点:  1. 确保安全性,悲观锁临界区内不会发生并发问题。  2. 简单方便。  3. 使用悲观锁,在临界区内操作数据成功率高。缺点:  1. 如果临界区内耗时长,会影响程序整体工作效率。  2. 可能产生死锁。乐观锁乐观的认为不会发生并发冲突,不为临界区代码加锁,但会持有在运行临界区前的版本号。在完成临界区后对比            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-09-03 12:56:23
                            
                                217阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            什么时乐观锁?
第一步,先取出记录,获取当前version;第二步,当更新时,带上这个version;第三步:版本正确更新成功,错误更新失败。示例:
update user set name = '向南天,version =3 where id = 1094592041087729777 and version = 2乐观锁和悲观锁是两种思想,用于解决并发场景下的数据竞争问题。乐观锁:乐观锁在操作            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-08-03 14:40:59
                            
                                0阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            乐观锁是一种乐观思想,即认为读多写少,遇到并发写的可能性低,每次去拿数据的时候都认为别人不会修改,所以不会上锁。但是如果想要更新数据,则会在更新前检查在读取至更新这段时间别人有没有修改过这个数据。            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-07-20 09:49:31
                            
                                93阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            1:乐观锁乐观锁是对于数据冲突保持一种乐观态度,操作数据时不会对数据锁定(这使得多个任务可以并行的对数据进行操作),只有到数据提交的时候才通过一种机制来验证数据是否存在冲突(一般是通过加版本号然后进行比对的方式实现);特点:乐观锁是一种并发类型的锁,本身不对数据进行加锁通过业务实现锁的功能,不对数据进行加锁就意味着允许多个请求同时访问数据,这种方式大大的提高了并发数据请求的性能。Java JUC中            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-10-14 05:53:52
                            
                                123阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            悲观锁悲观锁(Pessimistic Lock),顾名思义,就是很悲观,每次去拿数据的时候都认为别人会修改,所以每次在拿数据的时候都会上锁,这样别人想拿这个数据就会block直到它拿到锁。悲观锁:假定会发生并发冲突,屏蔽一切可能违反数据完整性的操作。Java synchronized 就属于悲观锁的一种实现,每次线程要修改数据时都先获得锁,保证同一时刻只有一个线程能操作数据,其他线程则会被bloc            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-08-26 12:22:35
                            
                                98阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            乐观锁概念        乐观锁认为自己在使用数据时不会有别的线程修改数据,所以不会添加锁,只是在更新数据的时候去判断之前有没有别的线程更新了这个数据。如果这个数据没有被更新,当前线程将自己修改的数据成功写入。如果数据已经被其他线程更新,则根据不同的实现方式执行不同的操作                
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-06-23 17:51:41
                            
                                196阅读