阻塞悲观锁-synchronized

已于 2022-10-02 20:43:10 修改
阅读量883 收藏 1
点赞数
分类专栏： 多线程 文章标签： java jvm 数据结构
于 2022-10-02 20:37:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_48468380/article/details/127104879
版权

程序运行环境

maven

<dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.10</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>
    </dependencies>

logback.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration >
    <statusListener class="ch.qos.logback.core.status.NopStatusListener" />

    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%date{HH:mm:ss} [%t] %logger - %m%n</pattern>
        </encoder>
    </appender>


    <logger name="com.laowa" level="debug" additivity="false">
        <appender-ref ref="STDOUT"/>
    </logger>
</configuration>

线程安全问题

  • 一个程序运行多个线程本身是没有问题的，问题出现在多个线程访问共享资源（多个线程对共享资源读写操作时发生指令交错），一段代码内如果存在对共享资源的多线程读写操作，这段程序称为临界区
  • 多个线程在临界区执行，由于代码的执行序列不同而导致结果无法预测，称之为发生了竞态条件
@Slf4j
public class Demo {
    static int counter = 0;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                counter++;
            }
        },"t1");

        Thread t2 = new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                counter++;
            }
        },"t2");

        t1.start();
        t2.start();

        t1.join();
        t2.join();
        log.debug("counter={}",counter);

    }
}

在这里插入图片描述
预期结果为10000，实际结果为6979

synchronized解决方案

synchronized是阻塞式的解决方案，俗称对象锁，他会采用互斥的方式让同一时刻至多只有一个线程能持有对象锁，其他线程再想获取这个对象锁就会被阻塞住。这样就能保证拥有锁的线程可以安全的执行临界区内的代码，不用担心线程上下文的切换

@Slf4j
public class Demo {
    static int counter = 0;
    static Object lock = new Object();
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            synchronized (lock){
                for (int i = 0; i < 5000; i++) {
                    counter++;
                }
            }

        },"t1");

        Thread t2 = new Thread(()->{
            synchronized (lock){
                for (int i = 0; i < 5000; i++) {
                    counter++;
                }
            }

        },"t2");

        t1.start();
        t2.start();

        t1.join();
        t2.join();
        log.debug("counter={}",counter);

    }
}

在这里插入图片描述
synchronized实际是用对象锁保证了临界区内代码的原子性，临界区的代码对外是不可分割的，不会被线程切换所打断

面向对象改进

@Slf4j
public class Demo {
    public static void main(String[] args) throws InterruptedException {
        Room room = new Room();
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                room.increment();
            }
        },"t1");

        Thread t2 = new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                room.decrement();
            }
        },"t2");

        t1.start();
        t2.start();

        t1.join();
        t2.join();
        log.debug("counter={}",room.getCounter());
    }
}
class Room{
    private int counter = 0;
    public void increment(){
    	//锁住自身对象，不用额外创建一个属性用于加锁
        synchronized (this){
            counter++;
        }
    }
    public void decrement(){
        synchronized (this){
            counter--;
        }
    }
    public int getCounter(){
        return counter;
    }
}

方法锁

public synchronized void m(){
}
等价于
public void m(){
	synchronized(this){
	}
}

两个方式都是对当前对象实例加锁

class Test{
	public synchronized static void m(){
	}
}
等价于
class Test{
	public static void m(){
		synchronized(Test.class){
		}
	}
}

两个方式都是锁住当前类的class对象

线程安全性分析

变量的线程安全性

  1. 成员变量和静态变量：如果被多个线程共享了，并且同时有读写操作，则需要考虑线程安全
  2. 局部变量：如果局部变量的作用范围逃离了方法的作用范围（作为返回值和参数）

常见的线程安全类

  • String
  • Integer
  • StringBuffer（StringBuilder线程不安全）
  • Random
  • Vector
  • HashTable（HashMap线程不安全）
  • java.util.concurrent包下的类

这里所述的线程安全是指，多个线程调用他们同一个实例的某个方法时，是线程安全的。也可以他们的每个方法是原子的，但是多个方法组合在一起可能出现线程问题

多个方法组合导致线程不安全例子

Hashtable table = new Hashtable();
new Thread(()->{
	if(table.get("key")!=null){
		table.put("key",1);
	}
}).start();
new Thread(()->{
	if(table.get("key")!=null){
		table.put("key",2);
	}
}).start();

两个线程可能同时进入if条件中，同时执行了put操作，其中一个put操作就会失效

不可变类的线程安全性

String、Integer等都是不可变类，因为其内部的状态不可改变
在这里插入图片描述
对象内部的操作都不会在原有的对象内部进行改变，而是创建新的对象，内部的字符串不会收到任何的改动（没有写操作，不会有线程安全问题）

synchronized工作原理(Monitor)

Java对象头

普通对象：Mark Word(32bit)+Klass Word(32bit)
数组对象：Mark Word(32bit)+Klass Word(32bit)+array length(32bit)

其中Mark Word在不同状态下的内容为：
在这里插入图片描述

Monitor工作原理

Monitor翻译为监视器或管程，每个对象都会关联一个Monitor，synchronized的加锁就基于这个Monitor(不论synchornized是加在对象、类、方法上，实际都是对某个对象加了锁)
在这里插入图片描述
从字节码层面，synchornized在修饰同步代码块和修饰同步方法时，采用的方式不同

修饰同步代码块

public final class Demo{
    public static void main(String[] args) {
        Demo.getInstance();
    }
    private Demo(){}
    private static Demo instance = null;
    public static Demo getInstance(){
        if(instance==null){
            synchronized (Demo.class){
                if(instance==null){
                    instance = new Demo();
                }
            }
        }
        return instance;
    }
}

在这里插入图片描述
修饰同步方法

public final class Demo{
    public static void main(String[] args) {
        Demo.getInstance();
    }
    private Demo(){}
    private static Demo instance = null;
    public static synchronized Demo getInstance(){
        if(instance==null){
            instance = new Demo();
        }
        return instance;
    }
}

在这里插入图片描述

等待/通知机制

场景

当一个线程的运行需要建立在某个变量的变化，或某个线程的运行基础之上（join是建立在父子线程的关系上，而且与锁无关），例如：

@Slf4j
public final class Demo{
    static boolean flag = true;
    static Object lock = new Object();
    public static void main(String[] args) {
        Thread t1 = new Thread(()->{
            synchronized (lock){
                while (flag){
                    try {
                        // 使用sleep方法不会释放锁，当前线程就无效的占用资源
                        // 并且使用sleep时间不好掌控，如果太长导致对flag的变化不能即使的响应，如果太短则一直占用cpu空转，造成资源浪费
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 进行下一步操作
            }
        },"t1");

        Thread t2 = new Thread(()->{
            flag = false;
        },"t2");
    }
}

解决这样一个生产者-消费者的同步问题，使用sleep的方式就会有如下两个缺陷：

  1. 难以保证及时性，如果睡得太久，就无法对flag的改变做出及时的响应
  2. 难以降低开销，如果睡眠时间减少，线程能够及时做出反应，但是空转导致一直占用处理器资源，早曾无端的资源浪费

解决方案

Object中有两个方法：wait、notify；这两个方法就可以解决这个问题：当一个对象调用wait，当前执行的线程会被挂起，同时释放掉对象锁；只有另一个线程在调用该对象的notify方法，重新唤醒wait中的线程，这样就可以保证线程能够在满足执行需求时迅速的开始行动

@Slf4j
public final class Demo{
    static boolean flag = true;
    static Object lock = new Object();
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            synchronized (lock){
                while (flag){
                    try {
                        // 挂起，释放当前锁，等待其他线程的唤醒
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 进行下一步操作
                log.debug("ok");
            }
        },"t1");

        Thread t2 = new Thread(()->{
            // 调用notify的线程需要先获取对象的锁
            synchronized (lock){
                flag = false;
                lock.notify();
            }

        },"t2");

        t1.start();
        t2.start();

        t1.join();
        t2.join();
    }
}

相关方法

方法名称描述
notify()通知一个在对象上等待的线程，使其从wait()方法返回；返回的前提是这个线程抢到了对象锁(即只有抢到锁的一个线程才会被唤醒)
notifyAll()通知所有在该对象上等待的线程
wait()线程进入WAITING状态，只有等待另外线程调用notify或者线程中断才会返回
wait(long)等待一段时间，当时间达到参数指定的毫秒数还没有通知，就会返回
wait(long,int)对超时时间进行更细粒度的控制，可以达到纳秒

wait/notify原理

在这里插入图片描述

  • 当Owner线程发现条件不满足，调用wait方法，即可进入WaitSet变为WAITING状态
  • 其他线程调用notify方法时，会通知WaitSet，随机挑选一个线程进入EntryList进行锁竞争
  • 被唤醒的线程不会立即获得锁，仍然需要进入EntryList变成BLOCK状态

等待/通知范式

优化前的代码

@Slf4j
public final class Demo{
    static boolean flag1 = true;
    static boolean flag2 = true;
    static Object lock = new Object();
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            synchronized (lock){
                if(flag1){
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                if(flag1){
                    log.debug("1操作失败");
                }else{
                    log.debug("执行操作1");
                }
            }
        },"t1");
        Thread t2 = new Thread(()->{
            synchronized (lock){
                if(flag2){
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                if(flag2){
                    log.debug("2操作失败");
                }else{
                    log.debug("执行操作2");
                }
            }
        },"t2");

        Thread t3 = new Thread(()->{
            synchronized (lock){
                flag2 = false;
                lock.notify();
            }
        },"t2");

        t1.start();
        t2.start();
        Thread.sleep(1000);
        t3.start();

    }
}

如果t3线程在唤醒时，t1争抢到了锁，就会出现这样的矛盾：t3的目的是唤醒t2，却错误的唤醒了t1，这种矛盾称为虚假唤醒；这样会导致t2没能正常工作，同时t1也无法再正常工作了

于是推出这样一种范式：

等待方
synchronized(lock){
	while(条件不满足){
		lock.wait()
	}
	处理操作
}

通知方
synchronized(lock){
	改变条件
	lock.notifyAll();
}

对应如上代码

@Slf4j
public final class Demo{
    static boolean flag1 = true;
    static boolean flag2 = true;
    static Object lock = new Object();
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            synchronized (lock){
                while(flag1){
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("执行操作1");
            }
        },"t1");
        Thread t2 = new Thread(()->{
            synchronized (lock){
                while(flag2){
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("执行操作2");

            }
        },"t2");

        Thread t3 = new Thread(()->{
            synchronized (lock){
                flag2 = false;
                lock.notifyAll();
            }
        },"t2");

        t1.start();
        t2.start();
        Thread.sleep(1000);
        t3.start();

    }
}

这样一来，通过notifyAll可以保证所有线程都被唤醒；在while循环中，没有满足继续执行条件的线程会再次进入等待

Park/Unpark

LockSupport工具类中的park和unpark方法也能够对线程进行阻塞和唤醒

@Slf4j
public final class Demo{
    static boolean flag1 = true;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            while(flag1){
                LockSupport.park();
            }
            log.debug("执行操作1");
        },"t1");

        t1.start();
        Thread.sleep(1000);
        flag1 = false;
        LockSupport.unpark(t1);
    }
}

与wait/notify对比

  • wait/noify必须配合Object Monitor一起使用，即必须获取对象锁，而park/unpark不用
  • park/unpark是以线程为单位来阻塞和唤醒线程，而wait/notify只能随机唤醒一个线程；park/unpark比wait/notify更精确
  • park/unpark可以先执行unpark，后park仍然可以接受唤醒；而wait/notify不能先执行notify，后wait不能接受唤醒

原理

每个线程都关联一个Parker对象，由三部分组成：_counter，_cond，_mutex

调用park

  1. 检查_counter，如果_counter为0，获得_mutex互斥锁
  2. 线程进入_cond条件变量阻塞
  3. 设置_counter=0

调用unpark

  1. 设置_counter=1
  2. 唤醒_cond条件变量中的线程
  3. 设置_counter为0

活跃性

死锁

假设有两个线程：
t1获得了A锁，想要获取B锁
t2获得了B锁，想要获得A锁
两个线程就会陷入矛盾，互不相让

@Slf4j
public final class Demo{
    static Object lockA = new Object();
    static Object lockB = new Object();
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            synchronized (lockA){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lockB){

                }
            }
        },"t1");

        Thread t2 = new Thread(()->{
            synchronized (lockB){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lockA){

                }
            }
        },"t2");
        t1.start();
        t2.start();
    }
}

避免死锁的方法

  1. 避免一个线程同时获取多个锁
  2. 避免一个线程在锁内同时占有多个资源，尽量保证每个锁只占用一个资源
  3. 尝试使用定时锁，使用lock.tryLock(timeout)来替代使用内部锁机制
  4. 对于数据库锁，加锁和解锁必须在一个数据库连接里，否则会出现解锁失败的情况

活锁

活锁出现在两个线程互相改变对方的结束条件，最后谁也无法结束

@Slf4j
public final class Demo{
    static volatile int count = 10;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            while(count>0){
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                log.debug("t1-{}",count);
            }
        },"t1");

        Thread t2 = new Thread(()->{
            while(count<20){
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count++;
                log.debug("t2-{}",count);
            }
        },"t2");
        t1.start();
        t2.start();
    }
}

饥饿

一个线程由于优先级太低，每次锁竞争都被其他线程抢走锁，导致该线程一直得不到运行

老蛙@
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java并发问题之乐观锁与悲观锁
08-28
再比如 Java 里面的同步原语 synchronized 关键字的实现也是悲观锁。 悲观锁机制存在以下问题： 1. 在多线程竞争下，加锁、释放锁会导致比较多的上下文切换和调度延时，引起性能问题。 2. 一个线程持有锁会导致...
【Java】synchronized同步锁详解
12-22
Java 中的同步机制主要用于解决多线程环境下的数据安全问题，其中synchronized关键字是Java提供的一种内置锁，也称为监视器锁或悲观锁。synchronized可以确保在同一时刻，只有一个线程能执行特定的代码块，从而保证...
Java中的悲观锁机制----synchronized 关键字原理
m0_53327171的博客
03-16 1358
sychronized是Java原生的一个同步锁机制，可以保证在多线程并发的情况下，仅允许一个线程执行加锁的方法和代码块，保证了线程安全。在Java1.5之前，sychronized关键字实现的同步锁，底层是一种悲观锁的理念，在1.6版本后，Java对该关键字进行了优化，使得该锁在某些情况下呈现轻量锁的作用（这个后面介绍，先有个印象）
synchronized实现原理——悲观锁机制
小小本科生
01-19 1129
线程通过CAS去尝试获取锁，一旦获得，那么将会复制该对象的Mark Word到虚拟机栈的Lock Record中，并且将Lock Record中的Owner指针指向该对象锁。这时，这个对象被锁定了，获取了这个对象锁的线程就可以去执行一些任务。其实很简单，在Mark Word中，当锁标志位是01，那么判断倒数第三个bit是否为1，如果是1，代表当前对象的锁状态为偏向锁，于是再去读Mark Word的前23个bit，这23个bit就是线程ID，通过线程ID来确认想要获得对象锁的线程是不是"被偏爱的线程"。
悲观锁(Synchronized)和乐观锁(CAS)
wyplj2015的博客
04-29 2506
文章目录悲观锁和乐观锁SynchronizedSynchronized使用Synchronized底层原理Java1.6对Synchronized的优化synchronized的等待唤醒机制CASCAS使用CAS底层原理CAS的缺陷1.ABA问题2.循环开销过大3.只能保证一个共享变量的原子操作concurrent包的实现 悲观锁和乐观锁 悲观锁：总是假设最坏的情况，每次去拿数据的时候都认为别人...
面试必备之乐观锁与悲观锁
热门推荐
JavaGuide
07-16 29万+
悲观锁总是假设最坏的情况，认为共享资源每次被访问的时候就会出现问题(比如共享数据被修改)，所以每次在获取资源操作的时候都会上锁，这样其他线程想拿到这个资源就会阻塞直到锁被上一个持有者释放。也就是说，共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程。像 Java 中和等独占锁就是悲观锁思想的实现。悲观锁通常多用于写多比较多的情况下（多写场景），避免频繁失败和重试影响性能。
面试题精讲系列之锁-synchronized与Lock锁
liuerchong的博客
03-20 1729
锁分类 Java锁分类 分类标准 分类 根据线程是否需要对资源加锁 悲观锁/乐观锁 根据多个线程是否能获取同一把锁 共享锁/独享(独占、排他)锁 根据锁是否能够重复获取 可重入锁/不可重入锁 根据锁的公平性进行区分 公平锁/非公平锁 当多个线程并发访问资源时，当使用synchronized时 锁升级(偏向锁/轻量级锁/重量级锁) 根据资源被锁定后，线程是否阻塞 自旋锁/适应性自旋锁 悲观锁 VS 乐观锁 首先我们来看看悲观锁与乐观锁。 其实这里无论是悲观锁还是乐观锁，都
悲观锁Synchronized和乐观锁CAS
Sandul的博客
04-19 314
CAS与Synchronized CAS和Synchronized都可以保证多线程环境下共享数据的安全性。那么他们两者有什么区别？ Synchronized是从悲观的角度出发： 总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这 样别人想拿这个数据就会阻塞直到它拿到锁 （共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。因此 Synchronized我们也将其称之为悲观锁。jdk中的ReentrantLock也是一种悲观锁。 CAS是从乐观的
大聪明教你学Java | 深入浅出聊乐观锁与悲观锁（synchronized 悲观锁）
不肯过江东丶
12-29 1万+
“锁”一直是一个老生常谈问题，其中就数“悲观锁”和“乐观锁”出现的频率最高，尤其是在面试的过程中我们常常会被问到“悲观锁”和“乐观锁”相关的问题，那么今天就和大家聊聊 Java 中“悲观锁”和“乐观锁”的区别和应用。
乐观锁(CAS)和悲观锁(synchronized)的详细介绍
m0_57640408的博客
10-21 9246
在代码中多个线程需要同时操作共享变量，这时需要给变量上把锁，保证变量值是线程安全的。锁的种类非常多，比如：互斥锁、自旋锁、重入锁、读写锁、行锁、表锁等这些概念，总结下来就两种类型，乐观锁和悲观锁。CAS 即 Compare and Swap，它体现的一种乐观锁的思想，比如：多个线程要对一个共享的整型变量执行 +1 操作：// 需要不断尝试int 旧值 = 共享变量;// 比如拿到了当前值 0int 结果 = 旧值 + 1;// 在旧值 0 的基础上增加 1 ，正确结果是 1。
锁进阶 -- synchronized 的锁优化
想听风雨的博客
12-11 647
介绍 synchronized 锁的优化，包括锁升级、锁消除、锁粗化。
面试必备之乐观锁与悲观锁.pdf
03-11
在Java中，`synchronized`关键字和`ReentrantLock`类都是悲观锁的典型实现。 **特点**： - 数据访问前必须获得锁。 - 只有获得锁的线程才能访问共享资源。 - 其他线程在等待锁时会被阻塞。 **优势**： - 适用于高...
面试必备之乐观锁与悲观锁.docx
07-15
Java 中的 synchronized 和 ReentrantLock 等独占锁就是悲观锁思想的实现。悲观锁的优点是可以确保数据的一致性，防止数据不一致和混乱的情况。但是，悲观锁也有缺点，即锁的开销较高，可能会导致性能下降。 乐观锁...
Java并发篇乐观锁，悲观锁，自旋锁
06-26
本文主要讨论了四种锁类型：乐观锁、悲观锁、自旋锁以及Java中的synchronized同步锁，并深入解析了synchronized锁的内部机制，包括其核心组件、实现方式以及锁的状态。 1. **乐观锁**：乐观锁假设在多线程环境下，...
java springboot 集成 阿里通义千问
qq_25987725的博客
07-25 393
一、在阿里云https://www.aliyun.com官网直接搜索“通义千问”，点击“开通DashScope”进行服务激活。四、在config目录添加配置 TongYiAiConfiguration.java。三、在yml中配置中配置key。二、加入Maven依赖。
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 444
1.导入hutool的maven依赖。2.复制一下代码执行。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 243
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 616
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
synchronized悲观锁效率高吗
06-29
`synchronized`关键字在Java中用于实现悲观锁，也称为互斥锁，它确保在同一时刻只有一个线程可以访问特定的代码段或资源。悲观锁的基本思想是在访问资源之前先尝试获取锁，如果锁被其他线程持有，则当前线程会阻塞...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值