多线程下的线程安全

最新推荐文章于 2022-06-27 21:29:39 发布
最新推荐文章于 2022-06-27 21:29:39 发布
阅读量211 收藏
点赞数
分类专栏： 高性能编程 文章标签： cas java锁 synchronized juc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Larry_zhu_123/article/details/119838901
版权

线程安全

一. 线程安全之可见性

1. JVM运行时数据区

在这里插入图片描述

2. Java内存模型（Java Memory Model ,JMM） VS JVM运行时数据区

在这里插入图片描述

2.1 初看Java内存模型

在这里插入图片描述

2.2 多线程中的问题

  1. 所见非所得, 无法肉眼去检测程序的准确性
  2. 不同的运行平台有不同的表现
  3. 错误很难重现
    eg 问题：(t1总的线程会一直执行下去为什么呢？jit对这种频繁调用的代码做了优化 会先取demo1.flag 赋值给一个局部变量 然后去判断这个局部变量的值 后面又详细的图)
    在这里插入图片描述在这里插入图片描述

2.3. 内存缓存

在这里插入图片描述

2.4. CPU指令重排

在这里插入图片描述

2.5. JIT编译器（Just in time compiler）

脚本语言与编译语言的区别？
解释执行：即咱们说的脚本，在执行时，由语言的解释器将其一条条翻译成机器可识别的指令
编译执行：将我们写的程序，直接编译成机器可以识别的代码。
java是什么语言：解释 编译执行的混合体。
在这里插入图片描述
在这里插入图片描述

2.6. volatile关键字

在这里插入图片描述

public class VisibilityDemo {
    // 运行标志
//    public volatile boolean flag = true;
    /*
     *不带volatitle的时候thread1不会停止  jit 做了优化对于循环取值的时候
     * boolean aa=demo1.flag
     * if(aa){
     *  while(true){
     *      i++
     *  }
     * }
     */
    public boolean flag = true;

    public static void main(String[] args) throws InterruptedException { //思维逻辑上看
        VisibilityDemo demo1 = new VisibilityDemo();
        System.out.println("代码开始了");
        Thread thread1 = new Thread(new Runnable() {
            public void run() {
                int i = 0;
                while (demo1.flag) {
                    i++;
                }
                System.out.println(i);
            }
        });
        thread1.start();
        TimeUnit.SECONDS.sleep(2); //JMM 必要性
        // 设置is为false，使上面的线程结束while循环
        demo1.flag = false;
        System.out.println("被置为false了.");
    }
}

2.7.shared variables 定义

在这里插入图片描述

2.8. 线程间操作的定义

在这里插入图片描述

在这里插入图片描述

2.9. 对于同步的规则定义

在这里插入图片描述

对于监视器m的解锁与所有后续操作对于m的加锁同步
–即1.加锁解锁不能进行指令重排 2.加锁后的操作，对于解锁后的其他获取锁的线程内容可见
在这里插入图片描述
在这里插入图片描述

对于每个属性写入的默认值（0，false,null)与每个线程对其进行的操作同步
new 一个对象初始值会是乱码，然后是默认的0，false等，然后再赋值50，james等。
在这里插入图片描述

启动线程的操作与线程中的第一个操作同步
– 启动线程的第一个操作 即将线程的状态由NEW改为Runnable. 即只有t2线程状态变更为Runnble的时候才能执行t2线程的第一行代码
在这里插入图片描述

线程T2的最后操作与线程T1发现线程T2已经结束同步。（isAlive,join可以判断线程时否终止）
在这里插入图片描述

如果线程T1中断了T2,那么线程T1的中断操作与其他所有线程发现T2被中断了同步
通过抛出InterruptedException异常，或者调用Thread.interrupted或Thread.isInterrupted.
在这里插入图片描述

2.10 Happens-before先行发生原则

在这里插入图片描述

2.11 final 在jvm中的处理–没看懂 但是感觉不重要此处进记录

在这里插入图片描述

2.12 word tearing 字节处理

在这里插入图片描述

2.13 double和long的特殊处理

在这里插入图片描述

二. 线程安全之原子操作

1. 概念

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

2. CAS (Compare and swap)

在这里插入图片描述

在这里插入图片描述

public class CounterUnsafe {
    volatile int i = 0; //cas 硬件  内存地址 --Long 232323523454235

    private static  Unsafe unsafe =null;//Unsafe类时final修饰的

    private static  long valueOffSet;// 初始话的时用来存储 变量i对应的内存地址

    static {
        try {
//            unsafe = Unsafe.getUnsafe(); **该方法禁止程序直接调用会抛出异常 , 对于属性静止调用的我们可以通过发射机制来获取值**
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            unsafe = (Unsafe) field.get(null);

            Field field1 = CounterUnsafe.class.getDeclaredField("i");
            valueOffSet = unsafe.objectFieldOffset(field1);
        } catch (NoSuchFieldException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }


    public void add() {
        for(;;) {
            int current = unsafe.getIntVolatile(this, valueOffSet); //**性能 : 分析 解决原子性问题 方式有： 阻塞 或 自旋(cas)   分别损失的是谁? 自旋属于计算损失cpu 阻塞hunt住线程 损失内存(某种意义上也会损失cpu)**
            //**系统中 内存 和  cpu 哪个更容易出现异常或 100% ？cpu更容易出事 内存出问题大概率是程序的问题 ---更多情况下我们会选择损耗内存**
            if (unsafe.compareAndSwapInt(this, valueOffSet, current, current + 1)){ //要么成功，要么失败
                break;
            };
        }

    }
}

2.1 JUC包内的原子操作封装类

在这里插入图片描述

public class CounterAtomic {
    //volatile int i = 0;
    AtomicInteger i = new AtomicInteger(0); //封装了CAS机制.
    public void add() {
        i.incrementAndGet();
    }
}

2.3 CAS的三个问题

在这里插入图片描述

在这里插入图片描述ABA 问题是由于仅仅比较值的时候可能在并发情况下与预期不一致的结果，解决方案：添加版本号


import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.LockSupport;

// 实现一个 栈（后进先出）
public class Stack {
  // top cas无锁修改
  AtomicReference<Node> top = new AtomicReference<Node>();

  public void push(Node node) { // 入栈
    Node oldTop;
    do {
      oldTop = top.get();
      node.next = oldTop;
    }
    while (!top.compareAndSet(oldTop, node)); // CAS 替换栈顶
  }


  // 出栈 -- 取出栈顶 ,为了演示ABA效果， 增加一个CAS操作的延时
  public Node pop(int time) {

    Node newTop;
    Node oldTop;
    do {
      oldTop = top.get();
      if (oldTop == null) {   //如果没有值，就返回null
        return null;
      }
      newTop = oldTop.next;
      if (time != 0) {    //模拟延时
        LockSupport.parkNanos(1000 * 1000 * time); // 休眠指定的时间
      }
    }
    while (!top.compareAndSet(oldTop, newTop));     //将下一个节点设置为top
    return oldTop;      //将旧的Top作为值返回
  }
}



public class ConcurrentStack {
  // top cas无锁修改
  //AtomicReference<Node> top = new AtomicReference<Node>();
  AtomicStampedReference<Node> top =
      new AtomicStampedReference<>(null, 0);

  public void push(Node node) { // 入栈
    Node oldTop;
    int v;
    do {
      v = top.getStamp();
      oldTop = top.getReference();
      node.next = oldTop;
    }
    while (!top.compareAndSet(oldTop, node, v, v+1)); // CAS 替换栈顶
  }


  // 出栈 -- 取出栈顶 ,为了演示ABA效果， 增加一个CAS操作的延时
  public Node pop(int time) {

    Node newTop;
    Node oldTop;
    int v;

    do {
      v = top.getStamp();
      oldTop = top.getReference();
      if (oldTop == null) {   //如果没有值，就返回null
        return null;
      }
      newTop = oldTop.next;
      if (time != 0) {    //模拟延时
        LockSupport.parkNanos(1000 * 1000 * time); // 休眠指定的时间
      }
    }
    while (!top.compareAndSet(oldTop, newTop, v, v+1));     //将下一个节点设置为top
    return oldTop;      //将旧的Top作为值返回
  }
}
// 存储在栈里面元素 -- 对象
public class Node {
  public final String value;
  public Node next;

  public Node(String value) {
    this.value = value;
  }

  @Override
  public String toString() {
    return "value=" + value;
  }
}

// 实现一个 栈（后进先出）
public class Stack {
  // top cas无锁修改
  AtomicReference<Node> top = new AtomicReference<Node>();

  public void push(Node node) { // 入栈
    Node oldTop;
    do {
      oldTop = top.get();
      node.next = oldTop;
    }
    while (!top.compareAndSet(oldTop, node)); // CAS 替换栈顶
  }


  // 出栈 -- 取出栈顶 ,为了演示ABA效果， 增加一个CAS操作的延时
  public Node pop(int time) {

    Node newTop;
    Node oldTop;
    do {
      oldTop = top.get();
      if (oldTop == null) {   //如果没有值，就返回null
        return null;
      }
      newTop = oldTop.next;
      if (time != 0) {    //模拟延时
        LockSupport.parkNanos(1000 * 1000 * time); // 休眠指定的时间
      }
    }
    while (!top.compareAndSet(oldTop, newTop));     //将下一个节点设置为top
    return oldTop;      //将旧的Top作为值返回
  }
}


public class Test {
  public static void main(String[] args) throws InterruptedException {
    Stack stack = new Stack();
    //ConcurrentStack stack = new ConcurrentStack();

    stack.push(new Node("B"));      //B入栈
    stack.push(new Node("A"));      //A入栈

    Thread thread1 = new Thread(() -> {
      Node node = stack.pop(800);
      System.out.println(Thread.currentThread().getName() +" "+ node.toString());

      System.out.println("done...");
    });
    thread1.start();

    Thread thread2 = new Thread(() -> {
      LockSupport.parkNanos(1000 * 1000 * 300L);

      Node nodeA = stack.pop(0);      //取出A
      System.out.println(Thread.currentThread().getName()  +" "+  nodeA.toString());

      Node nodeB = stack.pop(0);      //取出B，之后B处于游离状态
      System.out.println(Thread.currentThread().getName()  +" "+  nodeB.toString());

      stack.push(new Node("D"));      //D入栈
      stack.push(new Node("C"));      //C入栈
      stack.push(nodeA);                    //A入栈

      System.out.println("done...");
    });
    thread2.start();

    LockSupport.parkNanos(1000 * 1000 * 1000 * 2L);


    System.out.println("开始遍历Stack：");
    Node node = null;
    while ((node = stack.pop(0))!=null){
      System.out.println(node.value);
    }
  }
}

2.4 线程安全的概念

可见性问题
原子性问题
在这里插入图片描述

2.5 共享资源

在这里插入图片描述

三. java锁相关

3.1 java中锁的概念

在这里插入图片描述

3.2 synchronized

1. 锁优化

在这里插入图片描述

在这里插入图片描述

2. 锁的原理

在这里插入图片描述

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

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

3. 锁的升级过程

在这里插入图片描述

4. 对象头详解

在这里插入图片描述

https://zhuanlan.zhihu.com/p/138582291
下面这篇文章貌似讲的更为详细 可以参考
https://blog.csdn.net/tongdanping/article/details/79647337
这篇文章讲解了如何在cpu高的情况下找到对应的线程然后根据Jstack来查看问题
https://www.cnblogs.com/wuchanming/p/7766994.html
https://www.jianshu.com/p/9e02bed1387c

larzhu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程安全问题
XPmai的博客
12-22 769
在多线程编程中，线程安全问题是比较难，非常重要的问题。不管是在面试过程中还是在实际的工作中，也都是经常出错的地方。因此本篇文章着重介绍一下线程的安全问题。
多线程——保证线程安全
小叮当不懒的博客
09-09 7977
目录多线程——保证线程安全含义如何保证线程安全具体方法volatile关键字保证可见性禁止重排序synchronized关键字保证原子性防止死锁原因后果检查死锁解决方法 不积跬步，无以至千里；不积小流，无以成江海。要沉下心来，诗和远方的路费真的很贵！ 多线程——保证线程安全 含义 线程安全：指在多线程对一个共享资源同时进行操作的时候，所得到的结果每次都是一样的。 如何保证线程安全 方法：要保证线程安全，就必须保证线程同步。保证线程的可见性，有序性和原子性。 线程同步 线程同步的含义和字面意义相反。同步
java多线程之--(2)实现线程安全的三种方式
weixin_44232093的博客
01-10 1221
我们在开发中直接使用线程是无法保证线程安全的,有可能出现多个线程先后更改数据造成所得到的数据是脏数据,那么怎么解决这种问题呢,就要应用到线程安全的三种解决方法了 1. 线程安全 线程安全: 如果有多个线程在同时运行，而这些线程可能会同时运行某段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的 线程不安全: 当有多个线程在同时运行，这些线程同...
java 实现线程有返回值 Callable 接口
10-12 1935
大家已经习惯用Runnable接口了，先看看Callable和Runnable接口的区别 /** *     * Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。      * Callab
C#多线程List的非线程安全性
11-07
最近在做多线程方面的工作，工作中发现多线程中很多坑，这里就有一个List添加对象的误区，解释了List容量扩展后内存开辟导致的线程不安全性的问题，这里做个分享跟大家讲讲这个坑是怎么形成的怎么样避免。
ArrayList源码和多线程安全问题分析
08-25
主要介绍了ArrayList源码和多线程安全问题，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，下面小编和大家一起来学习一下吧
Java多线程安全问题和锁
01-20
多线程安全问题和锁 文章目录多线程安全问题和锁线程在jvm中的特点锁的出现synchronized 关键字-监视器锁monitor lock死锁的产生和避免 什么是线程安全问题？ 当多个线程同时操作同一个数据是，可能会出现数据不一样...
php 多线程上下文中安全写文件实现代码
10-29
提供一个php多线程上下文中安全写文件的实现方法。这个实现没有使用php 的file lock机制，使用的是临时文件机制。多线程中的各个线程都是对各自（每个线程独占一个）的临时文件写，然后再同步到原文件中。
Java多线程之CAS算法实现线程安全
08-25
主要介绍了java中如何通过CAS算法实现线程安全，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，下面小编和大家一起来学习一下吧
线程安全详解
qq_46804966的博客
05-16 4878
文章目录1.非线程安全2.volatile3.解决线程不安全3.1synchronized3.1.1操作锁的流程3.1.2代码示例3.1.3注意3.1.4三种使用场景3.2Lock手动锁3.3公平锁与非公平锁3.4两种锁区别 1.非线程安全 使用多线程执行任务，最终得到的结果和预期不一致 代码示例： package thread_5_10; public class Demo26 { static int a = 0; public static void main(String[
【多线程】如何保证线程安全
后而来者
09-13 2271
原文链接 一、线程安全等级 之前的博客中已有所提及“线程安全”问题，一般我们常说某某类是线程安全的，某某是非线程安全的。其实线程安全并不是一个“非黑即白”单项选择题。按照“线程安全”的安全程度由强到弱来排序，我们可以将java语言中各种操作共享的数据分为以下5类：不可变、绝对线程安全、相对线程安全、线程兼容和线程对立。 1、不可变 在java语言中，不可变的对象一定是线程安全的，无论是对象的方法实现还是方法的调用者，都不需要再采取任何的线程安全保障措施。如final关键字修饰的数据不可修改，可靠性最高。
【多线程】线程安全问题
qq_48848473的博客
06-27 1141
一，介绍 二，原子性 三，可见性 四，有序性 五，Java内存模型
多线程六（线程安全）
Dream_Ryoma的博客
08-22 501
定义 广泛的一种说法是如果一个对象可以安全地被多个线程同时使用，那它就是线程安全的。 严谨的说，当多个线程访问一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行，也不需要进行额外的同步，或者在调用方进行任何其他的协调操作，调用这个对象的行为都可以获得正确的结果，那这个对象是线程安全。  线程安全的代码都必须具备一个特征：代码本身封装了所有必要的正确性保障手段（如互斥同步），令调用者...
多线程下的线程安全问题
wangtaojiushiwo的博客
07-08 275
多线程情况下，很容发生线程安全问题，那么我们在程序中应该怎样避免呢？ 1>全局变量使用final修饰 像Integer,String这样的类其实都是用final修饰的，比如我们在代码中这样声明一个全局变量int a = 0;那么这个变量接下来是不能被更改的，否则编译会报错，但是final修饰的Map，值却可以被修改，所以说HashMap是线程不安全的！ 2>堆栈封闭：局部变量，无...
java 多线程详解（持续更新）
Ferao的博客
05-28 2282
目录 认识cpu、核心与线程 java多线程系列（一）之java多线程技能 认识cpu、核心与线程 cpu与核心 物理核 物理核数量=cpu数(机子上装的cpu的数量)*每个cpu的核心数 虚拟核 ● 所谓的4核8线程，4核指的是物理核心。通过超线程技术，用一个物理核模拟两个虚拟核，每个核两个线程，总数为8线程。 ● 在操作系统看来是8个核，但是实际上是4个物理核。 ● 通过超线程技术可以实现单个物理核实现线程级别的并行计算，但是比不上性能两个物理核。 单核cpu和多核cpu
多线程并发原理，解决线程安全问题
Get
03-20 1596
线程安全问题，归根到底一句话：在多线程之间修改共享数据引起的。 解决线程安全问题 ：关键词：修改，共享 1、不共享 没变量 （无状态类 （不做值的修改，只有方法）） 变量不可变 （Akka） 栈封闭 （方法内部定义变量） 2、共享但加锁 CAS操作（乐观锁）：操作时先判断下，拿到的数据是否跟主内存的数据是否相同，如不相同则取到主内存的值再操作。 乐观锁： 乐观的认为，这个数值只有我自己...
c++ gethostbyname 多线程下安全吗？
最新发布
05-25
在C++中，gethostbyname函数并不是线程安全的。这是因为在多线程环境下，如果多个线程同时调用gethostbyname函数，会导致数据竞争...总之，在多线程环境下使用gethostbyname函数时，需要采取适当的措施来确保线程安全。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值