JUC并发编程共享模型之管程（三）(上)

最新推荐文章于 2024-07-14 22:18:32 发布
最新推荐文章于 2024-07-14 22:18:32 发布
阅读量171 收藏
点赞数
分类专栏： JUC 文章标签： java jvm juc 并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_55993923/article/details/129413508
版权

三 共享模型之管程（上）

4.1 共享问题

问题发现

@Slf4j
public class ShareTest01 {

    static int count = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for(int i = 0; i < 5000; i++){
                count++;
            }
        });

        Thread t2 = new Thread(() -> {
            for(int i = 0; i < 5000; i++){
                count--;
            }
        },"t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("{}",count);
    }
}

问题分析：

  • 这个程序每次运行结果都不一样，这就是共享问题。
    • 对于程序共享的资源进行读写，会发生交错运行。
    • 由于i++和i–都不是原子操作在运行过程中会发生上下文切换。
    • 这边修改的值还没有同步到主内存中，另一个线程就已经从主存中取出未修改的值进行其他操作，导致出现共享问题。

对于 i++ 而言（i 为静态变量），实际会产生如下的 JVM 字节码指令：

getstatic i // 获取静态变量i的值
iconst_1 // 准备常量1
iadd // 自增
putstatic i // 将修改后的值存入静态变量i

对于 i- - 而言（i为静态变量）， 实际会产生如下的JVM字节码指令:

getstatic i // 获取静态变量i的值
iconst_1 // 准备常量1
isub // 自减
putstatic i // 将修改后的值存入静态变量i

而java的内存模型如下，完成静态变量的自增、自减需要在主存和工作内存中进行数据交换。（单线程下不会出现问题）

在这里插入图片描述

临界区 Critical Section

  • 一个程序多个线程运行本身没有问题
  • 问题出现在多个线程访问共享资源
    • 多个线程读共享资源没有问题
    • 问题在多个线程对共享资源进行读写操作时发生指令交错
  • 一段代码块内如果存在对共享资源的多线程读写操作，这段代码块被称为临界区
static int count = 0;
static void increment() 
// 临界区
{ 
 count++;
}
static void decrement() 
// 临界区
{ 
 count--;
}

竞态条件 Race Condition

多个线程在临界区内执行，由于代码的执行序列不同而导致结果无法预测，称之为发生了竞态条件

4.2 synchronized解决方案

为了避免临界区的竞态条件发生

  • 阻塞式：synchronized , Lock （加锁）
  • 非阻塞式 ： 原子变量

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

synchronized(对象) // 线程1， 线程2(blocked)
{
 临界区
}

解决方案

@Slf4j
public class ShareTest02 {

    static int count = 0;
    // 创建一个对象，想成一个房间，一回里面只能有一个
    static final Object room = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for(int i = 0; i < 5000; i++){
                // 房间大门
                synchronized(room){
                    count++;
                }
            }
        });

        Thread t2 = new Thread(() -> {
            for(int i = 0; i < 5000; i++){
                // 房间大门
                synchronized(room){
                    count--;
                }
            }
        },"t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("{}",count);
    }
}

在这里插入图片描述

  • synchronized 实际上是用对象锁保证了临界区内代码的原子性，临界区内的代码对外是不可分割的，不会被线程切换所打断

使用面向对象的思想，将需要保护的共享变量放入一个类中

@Slf4j
public class ShareTest03 {

    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 j = 0; j < 5000; j++){
                room.decrement();
            }
        },"t2");

        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("count: {}" , room.getValue());
    }

}

class Room {

    int value = 0;

    public void increment(){
        synchronized (this){
            value++;
        }
    }

    public void decrement(){
        synchronized (this){
            value--;
        }
    }

    public int getValue(){
        synchronized (this){
            return value;
        }
    }

}

4.3 写在方法上的synchronized

	class Test{
        public synchronized void test() {

        }
    }
    等价于
    class Test{
        public void test() {
            synchronized(this) {

            }
        }
    }

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

        	}
        }
	}

不加synchronized的方法

不加synchronized的方法在多线程中就会发生混乱，指令交错。

4.4变量的线程安全分析

成员变量和静态变量是否线程安全

  • 如果没有共享，则线程安全
  • 如果被共享了
    • 如果只是读操作，则线程安全
    • 如果有读写操作，则这段代码是临界区，需要考虑线程安全

局部变量是否线程安全

  • 局部变量是线程安全
  • 局部变量引用的对象未必是线程安全
    • 如果该对象没有逃离方法的作用访问，线程安全
    • 如果该对象逃离方法的作用范围，则需要考虑线程安全
局部变量的例子
@Slf4j
public class ThreadSafe01 {

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            int i = 10;
            i++;
            log.debug("局部变量i:{}",i);

        });

        Thread t2 = new Thread(() -> {
            int i = 10;
            i++;
            log.debug("局部变量i:{}",i);
        });

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

}

在这里插入图片描述

局部变量 i ，并没有共享，线程是安全的

成员变量的例子
@Slf4j
public class ThreadMemberTest01 {

    public static void main(String[] args) {
        ThreadUnSafe unSafe = new ThreadUnSafe();
        Thread t1 = new Thread(() -> {
           unSafe.method1(5000);
            log.debug("成员变量：{}",Arrays.asList(unSafe));
        });

        Thread t2 = new Thread(() -> {
            unSafe.method1(5000);
            log.debug("成员变量：{}",Arrays.asList(unSafe));
        });

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

}


class ThreadUnSafe {

    ArrayList<String> list = new ArrayList<>();

    public  void method1(int loopNum){

        for (int i = 0; i < loopNum; i++){
            // 临界区 产生竞态条件
            method2();

            method3();
        }
    }

    private  void  method3() {
        list.remove(0);
    }

    private  void method2() {
        list.add("1");
    }
}

在这里插入图片描述

这个多运行几次。

在这里插入图片描述

  • list成员变量被共享了，一旦多个线程进入就可能发生线程安全问题
    • 无论哪个线程中的 method2 引用的都是同一个对象中的 list 成员变量
    • method3 与 method2 分析相同
将成员变量修改为局部变量：
@Slf4j
public class ThreadMemberTest02 {

    public static void main(String[] args) {
        ThreadUnSafe unSafe = new ThreadUnSafe();
        Thread t1 = new Thread(() -> {
           unSafe.method1(5000);
            log.debug("成员变量：{}",Arrays.asList(unSafe));
        });

        Thread t2 = new Thread(() -> {
            unSafe.method1(5000);
            log.debug("成员变量：{}",Arrays.asList(unSafe));
        });

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

    }

}
class ThreadSafe {

    public final  void method1(int loopNum){
        ArrayList<String> list = new ArrayList<>();
        for (int i = 0; i < loopNum; i++){
            // 临界区 产生竞态条件
            method2(list);

            method3(list);
        }

    }

    private  void  method3( ArrayList<String> list) {
        list.remove(0);
    }

    private  void method2( ArrayList<String> list) {
        list.add("1");
    }

}

在这里插入图片描述

  • list是局部变量，每个线程调用会创建其不同的实例，没有共享
  • method2的参数是从method1中传来的，与method1中引用同一个对象
  • method3和method2一样
修改方法访问修饰符

方法访问修饰符带来的思考，如果把method2和method3的方法修改为public会不会代理线程安全问题?

  • 情况1：有其它线程调用method2和method3
    • 将method2和method3的权限修饰符改为public，此时仍线程安全。因为，在调用method2和method3是，操作的list并不是在method1内的list。
  • 情况2：在情况1的基础上，为ThreadSafe类添加子类，子类覆盖method2或method3方法
class ThreadSafe{
    public void method1(int loopNumber) {
        ArrayList<String> list = new ArrayList<>();
        for (int i = 0; i < loopNumber; i++) {
            method2(list);
            method3(list);
        }
    }

    public void method2(ArrayList<String> list) { list.add("1"); }
    public void method3(ArrayList<String> list) { list.remove(0); }
}

class ThreadSafeSubClass extends ThreadSafe{
    @Override
    public void method3(ArrayList<String> list) {
        new Thread(() -> {
            list.remove(0);
        }).start();
    }
}

此时会出现线程安全问题，因为method1创建list对象操作list，调用method3时会创建另一个线程操作这个list，多个线程共享list，将出现线程安全问题。

  • private修饰的方法不能被重写。
  • final防止子类覆盖方法。
常见的线程安全类
String
Integer
StringBuffer
Random
Vector
Hashtable
java.util.concurrent 包下的类

线程安全指的是，多个线程调用他们同一实例的某个方法是线程安全的

  • 每个方法都可以保证原子性
  • 但注意多个方法组合不是原子
晓风残月Lx
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
juc并发编程脑图以及相关示例代码
07-30
juc并发编程脑图以及相关示例代码
尚硅谷大厂必备技术之JUC并发编程基础视频 配套资料（自己根据视频整理课件，和代码）
09-23
【尚硅谷】大厂必备技术之JUC并发编程视频 配套资料，自己根据视频整理 pdf 课件，和代码 视频地址：...
3_线程安全
Zelda_xz的博客
08-08 190
Java中的锁
list修改元素的值_ArrayList的并发修改异常
weixin_39787628的博客
12-04 737
在看这篇文章之前建议看下之前的内部类的源码分析↓ArrayList-1-迭代器内部类1 ArrayList的并发修改异常  当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。2 现象  现象一：  遍历List集合时删除或者添加元素时会出现并发修改异常。ArrayListlist=newArrayList<>();list.add("A...
共享带来的问题、synchronized 解决方案、变量的线程安全分析
张大安的博客
03-06 610
文章目录1.共享带来的问题1.1 小故事1.2 Java代码的体现1.3 问题分析1.4 临界区 Critical Section1.5 竞态条件 Race Condition2.synchronized 解决方案2.1 synchronized 语法2.2 上下文切换-synchronized理解2.3 synchronized 加在方法上3.变量的线程安全分析3.1 局部变量线程安全分析3.2 成员变量线程安全分析3.3 局部变量暴露引用 1.共享带来的问题 1.1 小故事 1.2 Java代码
并发编程（二）共享模型之管程
LeslieGuGu的博客
01-18 379
文章目录共享模型之管程1.1 线程出现问题的根本原因分析问题的进一步描述临界区竞态条件1.2 synchronized 解决方案synchronizedsynchronized原理synchronized 加在方法上“线程八锁”1.3 变量的线程安全分析1.3.1 成员变量和静态变量的线程安全分析1.3.2 局部变量线程安全分析线程安全的情况线程不安全的情况不安全原因分析解决方法思考 private 或 final的重要性1.3.3 常见线程安全类线程安全类方法的组合不可变类的线程安全示例分析-是否线程安
Java并发编程 - 共享模型之管程
OneFine的技术博客
08-29 350
Monitor 被翻译为**监视器**或**管程** 每个 Java 对象都可以关联一个 Monitor 对象，如果使用 synchronized 给对象上锁（重量级）之后，该对象头的Mark Word 中就被设置指向 Monitor 对象的指针
JUC并发编程共享模型之管程（三）(中)
m0_55993923的博客
03-08 142
JUC并发编程共享模型之管程，本文包含内容有Monitor、Java对象头、轻量级锁、重量级锁、锁膨胀、偏向锁、批量重偏向、锁消除知识点，对synchronized的原理和synchronized锁进行了详细的说明
JUC并发编程共享模型之管程（三）(下)
m0_55993923的博客
03-13 195
本文是JUC并发编程之共享模型管程，主要讲解了wait notify的使用方法、原理和应用，同步模式之保护性暂停和异步模式之生产者消费者；还有park和unpark的介绍和原理，还有重新对于线程状态的深度理解；死锁的检测方法和多把锁的简单介绍，ReentrantLock的基本使用和特性以及应用，同步模式之顺序控制是本章的一个小总结，使用多种方式进行了实现
并发编程JUC深度学习(三）共享模型之管程
左灯右行的爱情
07-28 312
管程深入学习
JUC并发编程视频教程
11-28
视频详细讲解，需要的小伙伴自行网盘下载，链接见附件，永久有效...进程与线程第三章：Java 线程第四章：共享模型之管程第五章：共享模型之内存第六章：共享模型之无锁第七章：共享模型之不可变第八章：共享模型之工具
Java后端开发，JUC并发编程Java后端开发，JUC并发编程
04-14
Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程...
JUC并发编程.rar
12-14
"JUC并发编程.rar"这个压缩包文件包含了关于并发编程的相关案例源码和详细讲解，旨在帮助初学者和经验丰富的开发者深入理解并发编程的核心概念和技术。 首先，让我们来看看并发编程的基本概念。并发是指在一段时间...
java学习----递归
qq_56798493的博客
07-13 138
【代码】java学习----递归。
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
最新发布
m0_73456341的博客
07-14 603
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
Spring Security 授权
persistence_PSH的博客
07-14 835
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 969
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
Java 线程池详解
qq_41591215的博客
07-13 912
线程池是一组已经初始化并等待执行任务的线程集合。通过使用线程池，我们可以避免频繁地创建和销毁线程，从而节省资源和减少系统开销。线程池的核心思想是通过复用线程来提高性能。
JUC代码演示 Java多线程并发
05-03
本资源主要介绍Java并发编程中的Java.util.concurrent (JUC) 库，以及多线程和同步机制。首先，我们探讨了用户线程与守护线程的区别。在Java中，用户线程（非守护线程）是主线程执行的主要工作单元，它们不会自动随...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

晓风残月Lx

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

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

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

打赏作者

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

抵扣说明：

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

余额充值