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

news/2024/5/20 7:53:17 标签: java, jvm, juc, 并发

三 共享模型之管程（上）

4.1 共享问题

问题发现

java">@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 字节码指令：

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

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

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

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

在这里插入图片描述

临界区 Critical Section

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

竞态条件 Race Condition

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

4.2 synchronized解决方案

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

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

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

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

解决方案

java">@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 实际上是用对象锁保证了临界区内代码的原子性，临界区内的代码对外是不可分割的，不会被线程切换所打断

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

java">@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

java">	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变量的线程安全分析

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

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

局部变量是否线程安全

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

局部变量的例子

java">@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 ，并没有共享，线程是安全的

成员变量的例子

java">@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 分析相同

将成员变量修改为局部变量：

java">@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方法
java">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防止子类覆盖方法。

常见的线程安全类

java">String
Integer
StringBuffer
Random
Vector
Hashtable
java.util.concurrent 包下的类

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

  • 每个方法都可以保证原子性
  • 但注意多个方法组合不是原子

http://www.niftyadmin.cn/n/133901.html

相关文章

go modules

go modules

文章目录1. 简介示例1. 示例——同一项目2. 示例——不同项目3. 示例——添加远程模块依赖库1. 简介 go module是Go1.11版本之后官方推出的版本管理工具&#xff0c;并且从Go1.13版本开始&#xff0c;go module将是Go语言默认的依赖管理工具。到今天Go1.14版本推出之后Go modu…
阅读更多...
SpringBatch简介

SpringBatch简介

参考&#xff1a;https://cloud.tencent.com/developer/article/1456757简介SpringBatch主要是一个轻量级的大数据量的并行处理(批处理)的框架。作用和Hadoop很相似&#xff0c;不过Hadoop是基于重量级的分布式环境(处理巨量数据)&#xff0c;而SpringBatch是基于轻量的应用框架…
阅读更多...
linux segfault at 问题定位实践

linux segfault at 问题定位实践

问题&#xff1a;程序崩溃&#xff0c;打印为&#xff1a;app[13016]: segfault at 7fb668d29930 ip 00007fb668d3c23c sp 00007fb668e7de20 error 7 in mydefine.so[7fb668d3400011000]定位步骤&#xff1a;基础分析数据&#xff0c;大概了解反馈信息&#xff08;根据chatGPT&…
阅读更多...
Allegro如何知道单个操作命令的拼写

Allegro如何知道单个操作命令的拼写

Allegro如何知道单个操作命令的拼写 在用Allegro做PCB设计的时候，时常需要给某些命令设置一些快捷键，但是有时候无法知道命令的拼写是什么，就无法定义到env文件里面去 如下图 如何知道上方图标的命令拼写，下面介绍两种方法 方法一 鼠标左键移动到图标的位置，就会出现命令…
阅读更多...
固定资产管理5大难题？一招破解，现学现用

固定资产管理5大难题？一招破解，现学现用

随着国有企业改革的不断深化&#xff0c;国有固定资产管理越来越受到人们重视&#xff0c;然而国有固定资产管理的好坏在一定程度上影响着国有企业的经济效益&#xff0c;如果不处理好必定影响国有企业的发展。 固定资产存在的5大难题 01.资产流程和管理方式相对落后&#xff0…
阅读更多...
言简意赅，三分钟了解什么是IaaS，PaaS，SaaS？有何区别？

言简意赅，三分钟了解什么是IaaS，PaaS，SaaS？有何区别？

言简意赅&#xff0c;三分钟了解什么是IaaS&#xff0c;PaaS&#xff0c;SaaS&#xff1f;有何区别&#xff1f;导读它们有什么区别呢&#xff1f;方案一&#xff1a;IaaS方案二&#xff1a;PaaS方案三&#xff1a;SaaS小结导读 越来越多的软件&#xff0c;开始采用云服务。 …
阅读更多...
栈和队列的基本操作

栈和队列的基本操作

文章目录栈基本概念顺序栈的初始化进栈出栈读取栈顶元素栈的应用-括号匹配栈的应用-求表达式的值队列基本概念顺序队列的初始化入队出队读取队首元素链式队列的实现初始化入队出队栈 基本概念 栈是只允许在一端进行插入或删除操作的线性表 顺序栈的初始化 #include <ios…
阅读更多...
Tech Talk | 电致变色技术带来的智能AR体验

Tech Talk | 电致变色技术带来的智能AR体验

2023年2月27日&#xff0c;小米在2023MWC世界移动通信大会上&#xff0c;正式发布了小米无线AR眼镜探索版。这款产品搭载了创新的数控电致变色镜片&#xff0c;能适应不同光环境&#xff0c;遮光模式可以在观影时更沉浸&#xff0c;通透模式又能让AR虚实结合的体验更生动。“ 本…
阅读更多...
最新文章

Copyright @ 2022~2023