【并发编程JUC】synchronized原理

最新推荐文章于 2024-08-01 15:05:06 发布
最新推荐文章于 2024-08-01 15:05:06 发布
阅读量386 收藏 1
点赞数
分类专栏： 并发编程JUC Java 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/See_Star/article/details/122876473
版权

文章目录

1 字节码

在这里插入图片描述
对应字节码为
在这里插入图片描述

2 小故事（举例）

故事角色
■ 老王 - 操作系统
■ 小南 - 线程
■ 小女 - 线程
■ 房间 - 对象
■ 房间门上 - 防盗锁 - Monitor
■ 房间门上 - 小南书包 - 轻量级锁
■ 房间门上 - 刻上小南大名 - 偏向锁
■ 批量重刻名 - 一个类的偏向锁撤销到达20阈值
■ 不能刻名字 - 批量撤销该类对象的偏向锁，设置该类不可偏向

小南要使用房间保证计算不被其它人干扰(原子性)，最初，他用的是防盗锁，当上下文切换时，锁住门。这样，即使他离开了，别人也进不了门，他的工作就是安全的。

但是，很多情况下没人跟他来竞争房间的使用权。小女是要用房间，但使用的时间上是错开的，小南白天用，小女晚上用。每次上锁太麻烦了，有没有更简单的办法呢?

小南和小女商量了一下，约定不锁门了，而是谁用房间，谁把自己的书包挂在门口，但他们的书包样式都一样，因此每次进门前得翻翻书包，看课本是谁的，如果是自己的，那么就可以进门，这样省的上锁解锁了。万一书包不是自己的，那么就在门外等，并通知对方下次用锁门的方式。

后来，小女回老家了，很长一段时间都不会用这个房间。小南每次还是挂书包，翻书包，虽然比锁门省事了，但仍然觉得麻烦。

于是，小南干脆在门上刻上了自己的名字: 【小南专属房间， 其它人勿用】，下次来用房间时，只要名字还在，那么说明没人打扰，还是可以安全地使用房间。如果这期间有其它人要用这个房间，那么由使用者将小南刻的名字擦掉，升级为挂书包的方式。

同学们都放假回老家了，小南就膨胀了，在20个房间刻上了自己的名字，想进哪个进哪个。后来他自己放假回老家了，这时小女回来了(她也要用这些房间)，结果就是得一个个地擦掉小南刻的名字，升级为挂书包的方式。老王觉得这成本有点高，提出了一种批量重刻名的方法，他让小女不用挂书包了，可以直接在门上刻上自己的名字。

后来，刻名的现象越来越频繁，老王受不了了：算了，这些房间都不能刻名了，只能挂书包。

3 轻量级锁

轻量级锁的使用场景：如果一个对象虽然有多线程访问，但多线程访问的时间是错开的(也就是没有竞
争)，那么可以使用轻量级锁来优化。

轻量级锁对使用者是透明的，即语法仍然是synchronized

假设有两个方法同步块，利用同一个对象加锁

static final Object obj = new Object();
public static void method1() {
    synchronized (obj) {
        // 同步块A
        method2();
    }
}
public static void method2() {
    synchronized (obj) {
        // 同步块B
    }
}

创建锁记录(Lock Record)对象，每个线程都的栈帧都会包含一个锁记录的结构，内部可以存储锁定对象的Mark Word
在这里插入图片描述
让锁记录中Object reference指向锁对象，并尝试用cas替换Object的Mark Word，将Mark Word的值存入锁记录
在这里插入图片描述

加锁状态 轻量级锁 00 (Java对象头 部分有介绍）
正常状态 无锁 01

如果cas替换成功，对象头中存储了锁记录地址和状态00，表示由该线程给对象加锁，这时图示如下
在这里插入图片描述
如果cas失败，有两种情况

  • 如果是其它线程已经持有了该Object的轻量级锁，这时表明有竞争，进入锁膨胀过程
  • 如果是自己执行了synchronized 锁重入，那么再添加一条Lock Record作为重入的计数

在这里插入图片描述

当退出synchronized代码块(解锁时)如果有取值为null的锁记录，表示有重入，这时重置锁记录，表示重入计数减一。
在这里插入图片描述

当退出synchronized代码块(解锁时)锁记录的值不为null,这时使用cas将Mark Word的值恢复给对象头

  • 成功，则解锁成功
  • 失败，说明轻量级锁进行了锁膨胀或已经升级为重量级锁,进入重量级锁解锁流程

4 锁膨胀

如果在尝试加轻量级锁的过程中，CAS操作无法成功，这时一种情况就是有其它线程为此对象加上了轻量级锁(有竞争)，这时需要进行锁膨胀，将轻量级锁变为重量级锁。

static final Object obj = new Object();
public static void method1() {
    synchronized (obj) {
        // 同步块A
    }
}

当Thread-l进行轻量级加锁时，Thread-0 已经对该对象加了轻量级锁
在这里插入图片描述
这时Thread-1加轻量级锁失败，进入锁膨胀流程

  • 即为Object对象申请Monitor锁，让Object指向重量级锁地址
  • 然后自己进入Monitor的EntryList BLOCKED
    在这里插入图片描述

当Thread-0退出同步块解锁时，使用cas将Mark Word的值恢复给对象头，失败。这时会进入重量级解锁流程，即按照Monitor地址找到Monitor对象，设置Owner为null，唤醒EntryList中BLOCKED线程。

5 自旋优化

重量级锁竞争的时候，还可以使用自旋来进行优化，如果当前线程自旋成功(即这时候持锁线程已经退出了同步块，释放了锁)，这时当前线程就可以避免阻塞。

自旋重试成功的情况
在这里插入图片描述
自旋重试失败的情况
在这里插入图片描述

  • 在Java 6之后自旋锁是自适应的，比如对象刚刚的一-次自旋操作成功过，那么认为这次自旋成功的可能性会高，就多自旋几次;反之，就少自旋甚至不自旋，总之，比较智能。
  • 自旋会占用CPU时间，单核CPU自旋就是浪费，多核CPU自旋才能发挥优势。
  • Java 7之后不能控制是否开启自旋功能

6 偏向锁

轻量级锁在没有竞争时(就自己这个线程)，每次重入仍然需要执行CAS操作。

Java 6中引入了偏向锁来做进一步优化:只有第一次使用 CAS将线程ID设置到对象的Mark Word头，之后发现这个线程ID是自己的就表示没有竞争，不用重新CAS。以后只要不发生竞争，这个对象就归该线程所有

例如：

static final Object obj = new Object();
public static void method1() {
    synchronized (obj) {
        // 同步块A
        method2();
    }
}
public static void method2() {
    synchronized (obj) {
        // 同步块B
        method3();
    }
}
public static void method3() {
    synchronized (obj) {
        // 同步块C
    }
}

在这里插入图片描述
在这里插入图片描述

6.1 偏向状态

对象头格式：
在这里插入图片描述

Lightweight Locked：轻量级锁，00
Heavywight Locked：重量级锁，10
biased_lock：是否启用偏向锁，0不启用，1启用。

一个对象创建时：

  • 如果开启了偏向锁(默认开启)，那么对象创建后，markword值为0x05即最后3位为101， 这时它的thread、epoch、 age 都为0
  • 偏向锁是默认是延迟的，不会在程序启动时立即生效，如果想避免延迟，可以加VM参数 -XX:BiasedLockingStartupDelay=0来禁用延迟
  • 如果没有开启偏向锁，那么对象创建后，markword 值为0x01即最后3位为001，这时它的hashcode、age都为0，第一次用到hashcode时才会赋值

测试所需依赖：

<dependency>
    <groupId>org.openjdk.jol</groupId>
    <artifactId>jol-core</artifactId>
    <version>0.10</version>
</dependency>

测试：

@Slf4j(topic = "TestBiased")
public class TestBiased {
    public static void main(String[] args) throws InterruptedException {
        Dog dog = new Dog();
        log.debug(ClassLayout.parseInstance(dog).toPrintable());

        synchronized (dog) {
            log.debug(ClassLayout.parseInstance(dog).toPrintable());
        }

        log.debug(ClassLayout.parseInstance(dog).toPrintable());

    }
}

class Dog {
}

没上锁的时候是00，上锁的时候变成了101，10位以前的是线程id（操作系统的线程id）

12:05:19.629 [main] DEBUG TestBiased - Chapter4.Dog object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           95 ef 00 f8 (10010101 11101111 00000000 11111000) (-134156395)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

12:05:19.631 [main] DEBUG TestBiased - Chapter4.Dog object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           08 f7 ff cd (00001000 11110111 11111111 11001101) (-838863096)
      4     4        (object header)                           ba 00 00 00 (10111010 00000000 00000000 00000000) (186)
      8     4        (object header)                           95 ef 00 f8 (10010101 11101111 00000000 11111000) (-134156395)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

12:05:19.632 [main] DEBUG TestBiased - Chapter4.Dog object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           95 ef 00 f8 (10010101 11101111 00000000 11111000) (-134156395)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total


Process finished with exit code 0

6.2 撤销—调用对象hashCode

调用了对象的hashCode，但偏向锁的对象MarkWord中存储的是线程id，如果调用hashCode会导致偏向锁被撤销

  • 轻量级锁会在锁记录中记录hashCode
  • 重量级锁会在Monitor中记录hashCode

在调用hashCode后使用偏向锁，记得去掉-XX:-UseBiasedLocking

6.3 撤销—去他线程使用对象

当有其它线程使用偏向锁对象时，会将偏向锁升级为轻量级锁。

6.4 批量重偏向

如果对象虽然被多个线程访问，但没有竞争，这时偏向了线程T1的对象仍有机会重新偏向T2，重偏向会重置对象的Thread ID。

当撤销偏向锁阈值超过20次后，jvm 会这样觉得，我是不是偏向错了呢，于是会在给这些对象加锁时重新偏向至加锁线程。

6.5 批量撤销

当撤销偏向锁阈值超过40次后，jvm 会这样觉得，自己确实偏向错了，根本就不该偏向。于是整个类的所有对象都会变为不可偏向的，新建的对象也是不可偏向的。

7 锁消除

在这里插入图片描述

在这里插入图片描述
JIT 即时编译器发现这个锁没有用，就将其优化掉了，所以速度差不多。所以使用锁消除优化可以提高效率。

8 wait-notify

8.1 小故事

由于条件不满足，小南不能继续进行计算。

但小南如果一直占用着锁，其它人就得一直阻塞，效率太低。
在这里插入图片描述
于是老王单开了一间休息室(调用wait方法)，让小南到休息室(WaitSet) 等着去了，但这时锁释放开，其它人可以由老王随机安排进屋。

直到小M将烟送来，大叫一声[你的烟到了] (调用 notify方法)

小南于是可以离开休息室，重新进入竞争锁的队列
在这里插入图片描述

8.2 原理

在这里插入图片描述

  • Owner线程发现条件不满足，调用wait方法，即可进入WaitSet变为WAITING状态
  • BLOCKED和WAITING的线程都处于阻塞状态，不占用CPU时间片
  • BLOCKED线程会在Owner线程释放锁时唤醒
  • WAITING线程会在Owner线程调用notify或notifyAll时唤醒，但唤醒后并不意味者立刻获得锁，仍需进入EntryList重新竞争

8.3 API

obj.wait()：让进入object监视器的线程到waitSet等待
obj.notify()：在object上正在waitSet等待的线程中挑一个唤醒
obj.notifyAll()：让object上正在waitSet等待的线程全部唤醒

它们都是线程之间进行协作的手段，都属于Object对象的方法。必须获得此对象的锁，才能调用这几个方法

@Slf4j(topic = "TestWaitNotify")
public class TestWaitNotify {
    final static Object obj = new Object();

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            synchronized (obj) {
                log.debug("执行...");
                try {
                    obj.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.debug("其他代码...");
            }
        }, "t1").start();

        new Thread(() -> {
            synchronized (obj) {
                log.debug("执行...");
                try {
                    obj.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.debug("其他代码...");
            }
        }, "t2").start();

        Thread.sleep(2000);
        log.debug("唤醒obj上其他线程");
        synchronized (obj) {
            obj.notify(); // 唤醒obj上一个线程
            // obj.notifyAll(); // 唤醒obj上所有等待线程
        }
    }
}

notify输出：

14:51:14.144 [t1] DEBUG TestWaitNotify - 执行...
14:51:14.146 [t2] DEBUG TestWaitNotify - 执行...
14:51:16.144 [main] DEBUG TestWaitNotify - 唤醒obj上其他线程
14:51:16.144 [t1] DEBUG TestWaitNotify - 其他代码...

notifyAll输出：

14:51:55.485 [t1] DEBUG TestWaitNotify - 执行...
14:51:55.486 [t2] DEBUG TestWaitNotify - 执行...
14:51:57.484 [main] DEBUG TestWaitNotify - 唤醒obj上其他线程
14:51:57.484 [t2] DEBUG TestWaitNotify - 其他代码...
14:51:57.484 [t1] DEBUG TestWaitNotify - 其他代码...

8.4 使用

sleep(long n)和wait(long n)的区别？

  1. sleep是Thread方法，而wait是Object的方法
  2. sleep不需要强制和synchronized 配合使用，但wait需要和synchronized一起用
  3. sleep在睡眠的同时，不会释放对象锁的，但wait在等待的时候会释放对象锁。
  4. 他们状态都是TIMED_WAITING

线程1——小南：有烟才能干活，没烟不能干活。
线程2——小女：有外卖才能干活。
线程3、4、5、6、7：其他
线程8——外卖员：送外卖
线程9——松烟的：送烟

@Slf4j(topic = "step1")
public class TestStep1 {
    static final Object room = new Object();
    static boolean hasCigarette = false;  // 有没有烟
    static boolean hasTakeout = false;  // 外卖是否送到

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (room) {
                log.debug("有烟没？【{}】", hasCigarette);
                while (!hasCigarette) {
                    log.debug("没烟，歇会！");
                    try {
                        room.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("有烟没？【{}】", hasCigarette);
                if (hasCigarette) {
                    log.debug("可以开始干活了！");
                }
            }
        },"小南").start();

        new Thread(() -> {
            synchronized (room) {
                log.debug("外卖送到没？【{}】", hasTakeout);
                while (!hasTakeout) {
                    log.debug("没外卖，歇会！");
                    try {
                        room.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("外卖送到没？【{}】", hasTakeout);
                if (hasTakeout) {
                    log.debug("可以开始干活了！");
                }
            }
        },"小女").start();

        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                synchronized (room) {
                    log.debug("可以开始干活了！");
                }
            },"其他人").start();
        }

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            synchronized (room) {
                hasCigarette = true;
                log.debug("烟到了");
                room.notifyAll();
            }
        },"送烟的").start();

//        new Thread(() -> {
//            synchronized (room) {
//                hasTakeout = true;
//                log.debug("外卖到了");
//                room.notifyAll();
//            }
//        },"外卖员").start();
    }
}

输出

15:16:36.034 [小南] DEBUG step1 - 有烟没？【false】
15:16:36.036 [小南] DEBUG step1 - 没烟，歇会！
15:16:36.036 [其他人] DEBUG step1 - 可以开始干活了！
15:16:36.036 [其他人] DEBUG step1 - 可以开始干活了！
15:16:36.036 [其他人] DEBUG step1 - 可以开始干活了！
15:16:36.036 [其他人] DEBUG step1 - 可以开始干活了！
15:16:36.037 [其他人] DEBUG step1 - 可以开始干活了！
15:16:36.037 [小女] DEBUG step1 - 外卖送到没？【false】
15:16:36.037 [小女] DEBUG step1 - 没外卖，歇会！
15:16:37.033 [送烟的] DEBUG step1 - 烟到了
15:16:37.033 [小女] DEBUG step1 - 没外卖，歇会！
15:16:37.033 [小南] DEBUG step1 - 有烟没？【true】
15:16:37.033 [小南] DEBUG step1 - 可以开始干活了！

使用方法：

synchronized(lock) {
	while（条件不成立）{
		lock.wait();
	}
	// 干活
}


// 另一个线程
synchronized(lock) {
	lock.notifyAll();
}

9 同步模式之保护性暂停

即Guarded Suspension，用在一个线程等待另一个线程的执行结果

要点：

  • 有一个结果需要从一个线程传递到另一个线程，让他们关联同一个GuardedObject
  • 如果有结果不断从一个线程到另一个线程那么可以使用消息队列(见生产者/消费者)
  • JDK中，join的实现、Future的实现，采用的就是此模式
  • 因为要等待另一方的结果，因此归类到同步模式

在这里插入图片描述
示例代码：

@Slf4j(topic = "test20")
public class Test20 {
    // 线程1 等待 线程2
    public static void main(String[] args) {
        GuardedObject guardedObject = new GuardedObject();
        new Thread(() -> {
            log.debug("等待结果");
            // 等待结果
            List<String> list = (List<String>) guardedObject.get();
            log.debug("结果的大小：{}", list.size());
        }, "t1").start();

        new Thread(() -> {
            log.debug("执行下载");
            try {
                List<String> list = Downloader.download();
                // 产生结果
                guardedObject.complete(list);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }, "t2").start();
    }
}

/**
 * 保护性暂停
 */
class GuardedObject {
    // 结果
    private Object response;

    // 获取结果
    public Object get() {
        synchronized (this) {
            // 没有结果，一直等待
            while (response == null) {
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return response;
        }
    }

    // 产生结果
    public void complete(Object response) {
        synchronized (this) {
            this.response = response;
            this.notifyAll();
        }
    }
}

/**
 * 下载百度首页html
 */
class Downloader {
    public static List<String> download() throws IOException {
        // 与百度建立链接
        HttpURLConnection connection = (HttpURLConnection) new URL("https://www.baidu.com/").openConnection();
        ArrayList<String> lines = new ArrayList<>();
        // 通过缓冲流读取百度首页的html
        try(BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF_8))) {
            String line;
            while ((line = reader.readLine()) != null) {
                lines.add(line);
            }
        }
        return lines;
    }
}

需要结果的线程使用get()，提供结果的线程使用complete()。

对GuardObject进行功能增强，添加超时功能。

class GuardedObject {
    // 结果
    private Object response;

    // 获取结果
    public Object get(long timeout) {
        synchronized (this) {
            // 开始时间
            long begin = System.currentTimeMillis();
            // 经历时间
            long passedTime = 0;
            while (response == null) {
                // 这一轮循环应该等待的时间
                long waitTime = timeout - passedTime;
                // 经历的时间超过最大等待时间，退出循环
                if (waitTime <= 0) {
                    break;
                }
                try {
                    this.wait(waitTime);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 求得经历时间
                passedTime = System.currentTimeMillis() - begin;
            }
            return response;
        }
    }

    // 产生结果
    public void complete(Object response) {
        synchronized (this) {
            this.response = response;
            this.notifyAll();
        }
    }
}

9.1 join原理

使用了保护性暂停原理，当millis>0时，如果线程还存活，计算等待时间delay，如果delay<0退出等待，否则继续等待delay；并算出已等待时间now，为下一轮的计算进行准备。

public final synchronized void join(long millis)
throws InterruptedException {
    long base = System.currentTimeMillis();
    long now = 0;

    if (millis < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }

    if (millis == 0) {
        while (isAlive()) {
            wait(0);
        }
    } else {
        while (isAlive()) {
            long delay = millis - now;
            if (delay <= 0) {
                break;
            }
            wait(delay);
            now = System.currentTimeMillis() - base;
        }
    }
}

9.2 扩展、解耦

图中Futures就好比居民楼-层的信箱(每个信箱有房间编号)，左侧的t0, t2, t4 就好比等待邮件的居民，右侧的t1, t3，t5 就好比邮递员。

如果需要在多个类之间使用GuardedObject 对象，作为参数传递不是很方便，因此设计一个用来解耦的中间类，这样不仅能够解耦【结果等待者】和【结果生产者】，还能够同时支持多个任务的管理。
在这里插入图片描述
3个居民、3个邮递员进行送信。

@Slf4j(topic = "test20")
public class Test20 {
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 3; i++) {
            new People().start();
        }
        Thread.sleep(1000);
        for (Integer id : Mailboxes.getIds()) {
            new Postman(id, "内容" + id).start();
        }
    }
}

@Slf4j(topic = "People")
class People extends Thread {
    @Override
    public void run() {
        // 收信
        GuardedObject guardedObject = Mailboxes.createGuardedObject();
        log.debug("开始收信 id:{}", guardedObject.getId());
        Object mail = guardedObject.get(5000);
        log.debug("收到信 id:{}，内容：{}", guardedObject.getId(), mail);
    }
}

@Slf4j(topic = "Postman")
class Postman extends Thread {
    private int id;
    private String mail;
    public Postman (int id, String mail) {
        this.id = id;
        this.mail = mail;
    }
    @Override
    public void run() {
        GuardedObject guardedObject = Mailboxes.getGuardedObject(id);
        log.debug("开始送信 id:{}，内容：{}", id, mail);
        guardedObject.complete(mail);
    }
}
/**
 * 用于解耦的邮箱类
 */
class Mailboxes {
    private static Map<Integer, GuardedObject> boxes = new Hashtable<>();

    private static int id = 1;
    /** 产生唯一id 保证id线程安全*/
    public static synchronized int generateId() {
        return id++;
    }
    public static GuardedObject getGuardedObject(int id) {
        return boxes.remove(id);
    }
    public static GuardedObject createGuardedObject() {
        GuardedObject go = new GuardedObject(generateId());
        boxes.put(go.getId(), go);
        return go;
    }

    public static Set<Integer> getIds() {
        return boxes.keySet();
    }
}


/**
 * 保护性暂停
 */
class GuardedObject {
    /** 唯一表示Guarded Object */
    private int id;

    public GuardedObject(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }

    /** 结果 */
    private Object response;

    /** 获取结果 */
    public Object get(long timeout) {
        synchronized (this) {
            // 开始时间
            long begin = System.currentTimeMillis();
            // 经历时间
            long passedTime = 0;
            while (response == null) {
                // 这一轮循环应该等待的时间
                long waitTime = timeout - passedTime;
                // 经历的时间超过最大等待时间，退出循环
                if (waitTime <= 0) {
                    break;
                }
                try {
                    this.wait(waitTime);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 求得经历时间
                passedTime = System.currentTimeMillis() - begin;
            }
            return response;
        }
    }

    /** 产生结果 */
    public void complete(Object response) {
        synchronized (this) {
            this.response = response;
            this.notifyAll();
        }
    }
}

10 异步模式之生产者/消费者

要点：

  • 与前面的保护性暂停中的GuardObject不同，不需要产生结果和消费结果的线程一一对应
  • 消费队列可以用来平衡生产和消费的线程资源
  • 生产者仅负责产生结果数据，不关心数据该如何处理，而消费者专心处理结果数据
  • 消息队列是有容量限制的，满时不会再加入数据，空时不会再消耗数据
  • JDK中各种阻塞队列，采用的就是这种模式

在这里插入图片描述
测试：

@Slf4j(topic = "test21")
public class Test21 {
    public static void main(String[] args) {
        MessageQueue queue = new MessageQueue(2);

        for (int i = 0; i < 3; i++) {
            int id = i;
            new Thread(() -> {
                queue.put(new Message(id, "值" + id));
            }, "生产者" + i).start();

        }
        new Thread(() -> {
            while (true) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                Message message = queue.take();
            }
        }, "消费者").start();
    }
}

/**
 * 消息队列类，java线程间通信；
 * MQ是进程间的通讯，更复杂
 */
@Slf4j(topic = "MessageQueue")
class MessageQueue {
    /** 消息队列集合 */
    private LinkedList<Message> list = new LinkedList<>();
    /** 队列容量 */
    private int capacity;

    public MessageQueue(int capacity) {
        this.capacity = capacity;
    }

    /** 获取消息 */
    public Message take() {
        // 检测队列是否为空
        synchronized (list) {
            while (list.isEmpty()) {
                try {
                    log.debug("队列为空，消费者线程只能等待");
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 从队列头部获取消息并返回
            Message message = list.removeFirst();
            log.debug("已消费消息 {}", message);
            list.notifyAll();
            return message;
        }
    }

    /** 存入消息 */
    public void put(Message message) {
        synchronized (list) {
            // 检测队列是否已满
            while(list.size() == capacity) {
                try {
                    log.debug("队列已满，生产者线程等待");
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 将消息加入队列尾部
            list.addLast(message);
            log.debug("已生产消息 {}", message);
            list.notifyAll();
        }
    }
}

final class Message {
    private int id;
    private Object value;

    public Message(int id, Object value) {
        this.id = id;
        this.value = value;
    }

    public int getId() {
        return id;
    }

    public Object getValue() {
        return value;
    }

    @Override
    public String toString() {
        return "Message{" +
                "id=" + id +
                ", value=" + value +
                '}';
    }
}

11 Park & Unpark

11.1 基本使用

它们是LockSupport类中的方法：

// 暂停当前线程
LockSupport.park();

// 恢复某个线程的运行
LockSupport.unpark(暂停线程对象);

先park再unpark

@Slf4j
public class TestParkUnpark {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            log.debug("start...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.debug("park...");
            LockSupport.park();
            log.debug("resume...");
        }, "t1");
        t1.start();

        Thread.sleep(2000);
        log.debug("unpark...");
        LockSupport.unpark(t1);
    }
}

park后，进程将进入WAIT状态。

11.2 特点

与Object的wait & notify相比

  • wait、notify、notifyAll必须配合Object Monitor一起使用，而unpark不必。
  • park & unpark是以线程为单位来【阻塞】和【唤醒】线程，而notify只能随机唤醒一个等待线程，notifyAll是唤醒所有等待线程，就不那么【精确】。
  • park & unpark可以先unpark，而wait & notify不能先notify。

11.3 原理

每个线程都有自己的一个Parker 对象，底层C实现的，由三部分组成_counter，_cond 和_mutex，打个比方

  • 线程就像一个旅人，Parker就像他随身携带的背包，_cond条件变量就好比背包中的帐篷。_counter就好比背包中的备用干粮(0 为耗尽，1为充足)
  • 调用park就是要看需不需要停下来歇息
    • 如果备用干粮_counter耗尽，那么钻进帐篷歇息
    • 如果备用干粮_counter充足，那么不需停留，继续前进
  • 调用unpark, 就好比补充干粮
    • 如果这时线程还在帐篷，就唤醒让他继续前进
    • 如果这时线程还在运行，那么下次他调用park时，仅是消耗掉备用干粮，不需停留继续前进
      • 因为背包空间有限，多次调用unpark仅会补充一份备用干粮
        在这里插入图片描述

1 当前线程调用Unsafe.park()方法
2 检查_counter ，本情况为0，这时，获得_mutex互斥锁
3 线程进入_cond条件变量阻塞
4 设置_counter= 0
在这里插入图片描述

1 调用Unsafe.unpark(Thread_ 0)方法，设置_counter为1
2 唤醒_cond条件变量中的Thread_ 0
3 Thread_0恢复运行
4 设置_counter为0

在这里插入图片描述
1 调用Unsafe.unpark(Thread_ 0) 方法，设置_counter为1
2 当前线程调用Unsafe.park()方法
3 检查_counter，本情况为1，这时线程无需阻塞，继续运行
4.设置_counter为0

12 线程状态转换理解

在这里插入图片描述
情况1：NEW --> RUNNABLE

调用t.start()方法时

情况2：RUNNABLE --> WATTING

t线程用synchronized(obj)获取了对象锁后

  • 调用obj .wait()方法时，t线程从RUNNABLE --> WAITING
  • 调用obj.notify()， obj.notifyAll(), t.interrupt()时
    • 竞争锁成功，t 线程从WNAITING --> RUNNABLE
    • 竞争锁失败，t线程从WAITING --> BLOCKED

情况2：RUNNABLE --> WATTING

望天边星宿
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JUC并发编程.rar
12-14
"JUC并发编程.rar"这个压缩包文件包含了关于并发编程的相关案例源码和详细讲解，旨在帮助初学者和经验丰富的开发者深入理解并发编程的核心概念和技术。 首先，让我们来看看并发编程的基本概念。并发是指在一段时间...
深入理解JUC之Synchronized原理
Coder Xu
04-06 1133
文章目录1、理解Synchronized2、理解Java对象头3、Monitor管程（监视器）4、Synchronized进阶原理4.1、偏向锁4.2、轻量级锁4.3、重量级锁 1、理解Synchronized Synchronized是JDK为我们提供的锁，主要用于处理线程安全问题，线程安全问题的根本原因是线程上下文切换，导致字节码指令的交错，我们通过Synchronized保护共享资源，在并发场景下，采用上锁的方式使得资源只能某个时刻只能被一个线程操作，这样防止多个线程同时操作共享资源导致的错误问题，保
JUC知识点学习
weixin_43203363的博客
10-20 693
1. 什么是JUC? JUC就是java.util .concurrent工具包的简称。这是一个处理线程的工具包. 2. 并发和并行? 单核并发就是多个线程操作同一个资源.本质就是想让电脑效能更高.充分利用cpu资源. 并行就是多核执行多个任务. 3. 线程和进程 进程中至少包含一个线程.进程是程序的一次执行过程 一个程序可以有多个进程. 进程有:初始态，执行态，等待状态，就绪状态，终止状态。 线程:线程是CPU调度和分派的基本单位它可与同属一个进程的其他的线程共享进程所拥有的全部资源。. 进程和线程的区别
由浅到深分析Synchronized,彻底理解Synchronized底层实现原理
weixin_34143774的博客
06-12 386
这篇文章会记录Synchronized的常用使用场景与Synchronized的底层实现原理。虽然我们平时经常会在多线程中使用Synchronized关键字，但可能对于这个我们很熟悉的关键字的底层到底是怎样实现的没有过多关注。作为开发者，既然使用到了，可以试着去一步一步揭开下它的底层面纱。 为什么要使用Synchronized？ 首先我们来看下这段代码 public class Demo { ...
并发编程、juc工具包源码分析笔记
11-03
Java 并发库（Java Util Concurrency, JUC）是 Java 平台中用于处理并发问题的核心工具包，提供了丰富的类和接口来简化并发编程。 在计算机系统中，进程是操作系统资源分配的基本单位，它拥有独立的内存空间，而...
JUC并发编程.md
01-28
### JUC并发编程知识点 #### 一、JUC并发编程简介 JUC（Java Util Concurrency）是Java标准库中的一个子包，提供了一系列高级并发工具类和接口，旨在简化多线程编程的复杂性。它包括了各种锁机制、线程池、信号量...
java并发编程-AQS和JUC实战
04-29
### Java并发编程-AQS和JUC实战 #### 一、ReentrantLock 重入锁 **1.1 概述** - **基本介绍**: `ReentrantLock` 是一个实现了 `Lock` 接口的可重入互斥锁，提供比 `synchronized` 更丰富的功能。与 `synchronized...
JUC并发编程学习笔记(硅谷)
07-23
"JUC并发编程学习笔记(硅谷)"很可能包含了关于Java并发工具集（Java Util Concurrency, JUC）的深入理解和实战经验。JUC是Java标准库提供的一套强大的并发处理工具，它极大地简化了多线程编程，提高了程序的可读性...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 565
1.导入hutool的maven依赖。2.复制一下代码执行。
社区养老服务小程序的设计
Karen198的博客
07-31 419
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
深入理解Java注解
最新发布
weixin_55745942的博客
08-01 426
Java注解是用来描述程序元素（如类、方法、变量等）的一种机制。它们可以提供关于程序的补充信息，帮助编译器、框架或其他工具更好地理解和处理代码。注解通常以符号开头，后跟注解名称和可能的参数。要创建自定义注解，需要使用@interface关键字定义一个接口，并在接口中声明注解的属性。这个注解名为，可以被用来标记方法。它有一个名为value的属性，具有默认值"default"。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 333
1.导入hutool的maven依赖。2.直接复制一下代码运行。
26.jdk源码阅读之ConcurrentLinkedQueue
前端、移动端、后端源码级底层原理分享
07-29 948
ConcurrentLinkedQueue 是 Java 中提供的一个基于无界非阻塞算法的线程安全队列。它是一个适用于高并发环境的队列实现，基于链表结构。
Java并发（十一）一文搞懂Java并发各种容器
m0_58466443的博客
07-29 832
同步容器将所有对容器状态的访问都串行化，以保证线程安全性，这种策略会严重降低并发性。Java 1.5 后提供了多种并发容器，使用并发容器来替代同步容器，可以极大地提高伸缩性并降低风险。并发容器对应的普通容器描述HashMapJava 1.8 之前采用分段锁机制细化锁粒度，降低阻塞，从而提高并发性；Java 1.8 之后基于 CAS 实现。SortedMap基于跳表实现的ArrayListSet基于实现。SortedSet基于实现。Queue线程安全的无界队列。底层采用单链表。支持 FIFO。
【Java算法专场】二分查找(下）
zhyhgx的博客
07-27 913
本道题是要在一个从0~n-1的数组中找缺失的数，我们可以采用哈希表来解决，但此时时空复杂度达到了O(n),这是一个有序的数组，我们可以采用二分查找来解决，使时间复杂度达到O(logn).我们可以发现，每个数组的下标和其元素是相同的，那么我们可以通过判断下标和元素的大小，来确定缺失值的位置。3.mid=4+(5-4)/2=4,nums[mid]=5
javaweb_03：在ide中配置tomcat
qq_52200849的博客
08-01 83
④创建artifact。②点击加号创建，选择。
java中static关键字的作用
weixin_41020960的博客
08-01 463
这意味着这个变量被类的所有实例共享，而不是每个实例拥有自己的副本。类变量可以通过类名直接访问，而不需要创建类的实例。关键字是 Java 中一个非常重要的特性，它允许开发者在不创建对象的情况下访问类的方法和变量，这在很多场景下非常有用。这类方法可以在没有创建类的实例的情况下被调用，它们只能访问类的静态变量和静态方法。关键字也可以用于静态初始化块，这是一段在类加载时执行的代码块，用于初始化静态变量。: 静态变量是不变的，一旦在静态初始化块或静态方法中被初始化，它们的值就不能被修改。关键字可以声明静态内部类。
新建springboot项目找不到java版本8?
weixin_74009895的博客
07-28 248
新建springboot项目找不到java版本8?
高级java每日一道面试题-2024年7月29日-并发篇-什么时候用乐观锁,什么时候用悲观锁?
qq_43071699的博客
07-29 685
悲观锁适用于数据竞争激烈的场景，能够提供强一致性，但可能导致较多的线程等待。乐观锁适用于读多写少的场景，能够提供更高的并发性能，但可能需要多次尝试才能成功更新数据。
Java并发编程：JUC工具包与底层原理解析
"JUC并发编程+底层原理注意，一定要是JDK1.8、IDE一定要设置" Java并发编程是Java程序设计中的重要组成部分，尤其是Java Util Concurrent (JUC) 工具包，自JDK 1.5引入以来，它极大地简化了多线程和并发控制的实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

望天边星宿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值