多线程锁之乐观锁和悲观锁

最新推荐文章于 2024-07-19 17:37:28 发布
最新推荐文章于 2024-07-19 17:37:28 发布
阅读量758 收藏 1
点赞数
分类专栏： Java互联网架构师 文章标签： java 算法 jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46662378/article/details/125730746
版权

乐观锁和悲观锁是什么

悲观锁
认为自己在使用数据的时候一定会有别的线程来修改数据，因此在获取数据的时候会先加锁，确保数据不会被别的线程修改。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。synchronized和ReentrantLock实现类都是悲观锁。
适合写操作多的场景，现价所可以保证写操作时的数据正确。 狼性锁

乐观锁

认为自己在使用数据是不会有别的线程来修改数据或者资源，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号机制Version和CAS算法实现。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库提供的类似于write_condition机制，其实都是提供的乐观锁。在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁CAS自旋实现的。如果数据没有被更新，当前线程将自己修改的数据成功写入，如果这个数据已经被其他的线程更新，则根据不同的实现方式执行不同的操作，比如放弃修改，重试抢锁。 佛系锁

《阿里巴巴java开发手册》

【强制】高并发时，同步调用应该去考量锁的性能损耗。能用无锁数据结构，就不要用锁；能
锁区块，就不要锁整个方法体；能用对象锁，就不要用类锁。

8锁案例以及原理解释

第一种：原理我们在某个方法上加了synchronized ，锁的就不是这个方法，是整个资源类。
一个对象里面如果有多个synchronized方法，某一时刻，只要有一个线程去调用其中的synchronized方法了，其他的对象只能等待，换句话说，某一个时刻内，只能有唯一的一个线程去访问这些synchronized方法，锁的是当前this，被锁定后，其他的线程都不能进入到当前对象的其他的synchronized方法

class  Phone{
    public synchronized void sendEmail(){
        System.out.println("email");  }
    public synchronized  void  sendSMS(){
        System.out.println("sms");
    }   }

//线程操作资源类
public class LockDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();
        
        new Thread(()->{
            phone.sendEmail();
        },"a").start();
       
        try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {throw new RuntimeException(e);}
        
        new Thread(()->{
            phone.sendSMS();
        },"b").start();

    }
}
输出   email    sms

第二种：原理同上

class  Phone{
    public synchronized void sendEmail(){
        try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {throw new RuntimeException(e);}
        System.out.println("email");
    }
    public synchronized  void  sendSMS(){
        System.out.println("sms");
    }
    public void hello(){
        System.out.println("hello");
    }

        }

//线程操作资源类
public class LockDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{
            phone.sendEmail();
        },"a").start();


        try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {throw new RuntimeException(e);}


        new Thread(()->{
            phone.sendSMS();
        },"b").start();

    }
}
输出   email    sms

第三种：
加个普通方法后发现和同步锁无关换成两个对象后，不是同一把锁了，情况立刻变化。

class  Phone{
    public synchronized void sendEmail(){
        try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {throw new RuntimeException(e);}
        System.out.println("email");
    }
    public synchronized  void  sendSMS(){
        System.out.println("sms");
    }
    public void hello(){
        System.out.println("hello");
    }

        }

//线程操作资源类
public class LockDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{
            phone.sendEmail();
        },"a").start();


        try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {throw new RuntimeException(e);}


        new Thread(()->{
            phone.hello();
        },"b").start();

    }
}  输出 hello email

第四种：原理同上

class  Phone{
    public synchronized void sendEmail(){
        try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {throw new RuntimeException(e);}
        System.out.println("email");
    }
    public synchronized  void  sendSMS(){
        System.out.println("sms");
    }
    public void hello(){
        System.out.println("hello");
    }

        }

//线程操作资源类
public class LockDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();
        Phone phone2 = new Phone();
        new Thread(()->{
            phone.sendEmail();
        },"a").start();


        try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {throw new RuntimeException(e);}


        new Thread(()->{
            phone2.sendSMS();
        },"b").start();

    }
}输出 sms email

第五种方法：
都换成静态同步方法后，情况又变化
三种 synchronized 锁的内容有一些差别:
对于普通同步方法，锁的是当前实例对象，通常指this,具体的一部部手机,所有的普通同步方法用的都是同一把锁——>实例对象本身，
对于静态同步方法，锁的是当前类的Class对象，如Phone.class唯一的一个模板
对于同步方法块，锁的是 synchronized 括号内的对象

class  Phone{
   public static synchronized void sendEmail(){
       try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {throw new RuntimeException(e);}
       System.out.println("email");
   }
   public static synchronized  void  sendSMS(){
       System.out.println("sms");
   }
   public void hello(){
       System.out.println("hello");
   }

       }

//线程操作资源类
public class LockDemo {
   public static void main(String[] args) {
       Phone phone = new Phone();
       Phone phone2 = new Phone();
       new Thread(()->{
           phone.sendEmail();
       },"a").start();


       try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {throw new RuntimeException(e);}


       new Thread(()->{
           phone.sendSMS();
       },"b").start();

   }
} 输出  email  sms

第六种：类锁

 class  Phone{
    public static synchronized void sendEmail(){
        try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {throw new RuntimeException(e);}
        System.out.println("email");
    }
    public static synchronized  void  sendSMS(){
        System.out.println("sms");
    }
    public void hello(){
        System.out.println("hello");
    }

        }

//线程操作资源类
public class LockDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();
        Phone phone2 = new Phone();
        new Thread(()->{
            phone.sendEmail();
        },"a").start();

        try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {throw new RuntimeException(e);}

        new Thread(()->{
            phone2.sendSMS();
        },"b").start();

    }
} 输出  email  sms

第七种：
当一个线程试图访问同步代码时它首先必须得到锁，正常退出或抛出异常时必须释放锁。
所有的普通同步方法用的都是同一把锁——实例对象本身，就是new出来的具体实例对象本身,本类this
也就是说如果一个实例对象的普通同步方法获取锁后，该实例对象的其他普通同步方法必须等待获取锁的方法释放锁后才能获取锁。
所有的静态同步方法用的也是同一把锁——类对象本身，就是我们说过的唯一模板Class
具体实例对象this和唯一模板Class，这两把锁是两个不同的对象，所以静态同步方法与普通同步方法之间是不会有竞态条件的
但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁。

class  Phone{
    public static synchronized void sendEmail(){
        try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {throw new RuntimeException(e);}
        System.out.println("email");
    }
    public  synchronized  void  sendSMS(){
        System.out.println("sms");
    }
    public void hello(){
        System.out.println("hello");
    }

        }

//线程操作资源类
public class LockDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();
        Phone phone2 = new Phone();
        new Thread(()->{
            phone.sendEmail();
        },"a").start();


        try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {throw new RuntimeException(e);}


        new Thread(()->{
            phone.sendSMS();
        },"b").start();

    }
}输出sms email

第八种

class  Phone{
    public static synchronized void sendEmail(){
        try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {throw new RuntimeException(e);}
        System.out.println("email");
    }
    public  synchronized  void  sendSMS(){
        System.out.println("sms");
    }
    public void hello(){
        System.out.println("hello");
    }

        }

//线程操作资源类
public class LockDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();
        Phone phone2 = new Phone();
        new Thread(()->{
            phone.sendEmail();
        },"a").start();


        try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {throw new RuntimeException(e);}


        new Thread(()->{
            phone2.sendSMS();
        },"b").start();

    }
}输出sms email
Liguangyang01
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
乐观锁、悲观锁、CAS、synchronized、AQS、ReentrantLock、Semaphore
LYPvvvLYP的博客
08-08 760
文章目录参考 参考 https://mp.weixin.qq.com/s/WtAdXvaRuBZ-SXayIKu1mA 乐观锁和悲观锁，他们对应的实现 CAS ，Synchronized，ReentrantLock CAS（Compare And Swap 比较并且替换）是乐观锁的一种实现方式，是一种轻量级锁，JUC 中很多工具类的实现就是基于 CAS 的。 CAS 是怎么实现线程安全的？ 线程在读取数据时不进行加锁，在准备写回数据时，先去查询原值，操作的时候比较原值是否修改，若未被其他线程修改则写回，若已
谈谈悲观锁和乐观锁
qq_34136709的博客
08-10 139
谈谈悲观锁和乐观锁 1.出现的背景 当程序中可能出现并发的情况时，就需要通过一定的手段来保证在并发情况下数据的准确性，通过这种手段保证了当前用户和其他用户一起操作时，所得到的结果和他单独操作时的结果是一样的。这种手段就叫做并发控制。并发控制的目的是保证一个用户的工作不会对另一个用户的工作产生不合理的影响。 常说的并发控制，一般都和数据库管理系统（DBMS）有关。在DBMS中的并发控制的任务，是确保在多个事务同时存取数据库中同一数据时，不破坏事务的隔离性和统一性以及数据库的统一性。 实现并发控制的主要手段大致
ReentrantLock是一个悲观锁
服务端开发进阶之路
08-19 2181
ReentrantLock底层是由AQS实现的，ReentrantLock机制可以说是实打实的悲观锁。 来自：https://blog.csdn.net/qq_35688140/article/details/101223701 众所周知，ReentrantLock是一个悲观锁，但是查看源码，发现底层实现使用的是compareAndSet相关方法实现的， 于是产生疑问：为什么ReentrantLock使用的和CAS一样的compareAndSet相关的方法实现的， CAS确实乐观锁，ReentrantLo
关于为什么ReentrantLock不是乐观锁的一些猜想
流的博客
09-23 9445
1.众所周知，ReentrantLock是一个悲观锁，但是查看源码，发现底层实现使用的是compareAndSet相关方法实现的，于是产生疑问：为什么ReentrantLock使用的和CAS一样的compareAndSet相关的方法实现的，CAS确实乐观锁，ReentrantLock却是悲观锁？ 猜想一：仔细看代码发现ReentrantLock使用了setExclusiveOwnerThread...
悲观锁与乐观锁
进击的小白
07-22 386
悲观锁： 悲观的认为每次读取数据时，别人都会去修改数据，所有每次读取都会上锁。 synchronized,ReentrantLock等都属于悲观锁,使用redis和zk也可以实现分布式悲观锁。 问题： 1. 在多线程竞争下，加锁、释放锁会导致比较多的上下文切换和调度延时，引起性能问题。 2. 一个线程持有锁会导致其它所有需要此锁的线程挂起。 3. 如果一个优先级高的线程等待一个优先级低...
乐观锁和悲观锁
Life_Ding的博客
02-28 203
悲观锁： 对于并发间操作产生的线程安全问题持悲观状态,每次对某资源进行操作时，都会持有一个独占的锁,直接上了锁就操作资源了 synchronized 互斥锁 采用synchronized修饰符实现的同步机制叫做互斥锁机制，它所获得的锁叫做互斥锁。 每个对象都有一个monitor(锁标记)，当线程拥有这个锁标记时才能访问这个资源，没有锁标记便进入锁池。任何一个对象系统都会为其创建一个互斥锁，这个锁是为了分配给线程的，防止打断原子操作。每个对象的锁只能分配给一个线程，因此叫做互斥锁。 Reentrant
悲观锁及乐观锁
blog
04-15 195
一、三种典型不一致： 假设数据A=1 1.脏读： -> T1读取A=1 -> T1修改写入A=2 -> T2读取A=2 -> T1rollback，即A=1 T2读取的数据是错误的 2.丢失修改 -> T1读取A=1 -> T2读取A=1 -> T1修改A=A+1=2 -> T2修改A=A+1=2 -> T1写A=2 ...
p278 - p288 乐观锁和悲观锁
05-15
乐观锁和悲观锁 在编程世界中，锁是五花八门的，每种锁的加锁开销以及应用场景也可能会不同。如何用好锁，也是程序员的基本素养之一了。在高并发的场景下，如果选择了合适的锁，则会大大提高系统的性能，否则性能会...
Java并发问题之乐观锁与悲观锁
08-28
"Java并发问题之乐观锁与悲观锁" 在 Java 中，并发问题是非常重要的，因为多线程的存在会引起数据的不一致性和安全性问题。为了解决这些问题，Java 提供了多种锁机制，其中最常见的就是乐观锁和悲观锁。 悲观锁...
面试必备之乐观锁与悲观锁
04-12
【描述】：“面试必备之乐观锁与悲观锁.pdf”涉及的是并发控制中的两种重要锁机制——悲观锁和乐观锁，它们是多线程环境下确保数据一致性的重要手段。 【标签】：“求职面试 多线程” 【正文】： 悲观锁和乐观锁...
Java多线程并发编程和锁原理解析
08-25
在Java多线程并发编程中，锁机制是非常重要的，乐观锁和悲观锁是两种常见的锁机制。乐观锁顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有...
面试必备之乐观锁与悲观锁.pdf
03-11
面试必备之乐观锁与悲观锁.pdf
【六大锁策略-各种锁的对比-Java中的Synchronized锁和ReentrantLock锁的特点分析-以及加锁的合适时机】
学习愚公的博客
07-28 644
轻量级锁适用于竞争不激烈的情况，而重量级锁适用于竞争激烈的情况。在实际开发中，我们需要根据具体场景选择合适的锁机制，以达到最佳的性能
Java中锁的分类，公平锁、乐观锁、悲观锁、可重入锁
qq_54472227的博客
06-20 750
AQS就是AbstractQueueSynchronizer抽象类，是JUC包下的一个基类，JUC下的很多内容都是基于AQS实现了部分功能，比如ReentrantLock，ThreadPoolExecutor,阻塞队列，CountDownLatch,Semaphore,CyclicBarrier等等都是基于AQS实现。AQS提供了一个由volatile修饰，并且采用CAS方式修改的int类型的state变量；其次AQS维护了一个双向链表，有head，有tail,并且每个节点都是Node对象。
java lock unlock_详解Java中的ReentrantLock锁
weixin_33167456的博客
02-24 665
ReentrantLock锁ReentrantLock是Java中常用的锁，属于乐观锁类型，多线程并发情况下。能保证共享数据安全性，线程间有序性ReentrantLock通过原子操作和阻塞实现锁原理，一般使用lock获取锁，unlock释放锁，下面说一下锁的基本使用和底层基本实现原理，lock和unlock底层lock的时候可能被其他线程获得所，那么此线程会阻塞自己，关键原理底层用到Unsafe类...
悲观锁ReentrantLock ReentrantReadWriteLock VS 乐观锁Stampedlock
wtopps的专栏
05-18 1280
文章目录前言ReentrantLockReentrantReadWriteLockStampedLockReentrantLock VS ReentrantReadWriteLock VS StampedLock结语 前言 在JDK的J.U.C包中，提供了丰富类型的锁（Lock）的能力，它们均实现了Lock接口，并扩展了不同类型的锁的实现，其中我们比较常见的锁有ReentrantLock、ReentrantReadWriteLock、StampedLock，本篇，我们就对这三种类型的锁进行横向比较，来分析其
乐观锁和悲观锁的底层实现原理
qq_45725126的博客
08-15 1065
本文参考——敖丙——JavaFamily 概述 上一篇文章我们提到了乐观锁和悲观锁的工作方式和使用场景，那么这两种锁本身是如何实现的？ 这篇文章就来总结一下乐观锁和悲观锁，他们对应的实现—— CAS ，Synchronized，ReentrantLock 乐观锁——CAS 什么是CAS CAS（Compare And Swap 比较并且替换）是乐观锁的一种实现方式，是一种轻量级锁，JUC 中很多工具类的实现就是基于 CAS 的。 CAS是如何保证线程安全的？ 线程在读取数据时不进行加锁，在准备写回数据时，先
Java内存模型
最新发布
weixin_44267758的博客
07-19 337
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值