Java并发编程Bug的源头

告别密码!用VScode+SSH一键连接树莓派,再也不用每次输密码了 本文详细介绍了如何通过VScode和SSH密钥实现树莓派的免密连接,告别繁琐的密码输入。从开发环境准备、SSH密钥生成与配置,到VScode远程连接优化和常见问题排查,提供了一套完整的解决方案,帮助开发者提升工作效率。 阅读详情

相信大家都听说过并发编程,面试中也经常会被提问这一知识点,有时候让讲讲自己有没有并发编程的经验,细致地讲一下。结果可想而知,理论知识还可以说一说,但没多少实践经验,更让人头疼的是理论与实践差距极大。在工作中,系统的并发量比较低,借助数据库和类似 Tomcat 这种中间件,我们基本上不用写并发程序。

总之一句话, 系统并发量不高的时候,并发问题基本上都被中间件和数据库解决了,或者系统数据量比较庞大,对性能有所要求,此时就需要用到并发编程了。

并发编程是个好东西,但天下没有免费的午餐,凡事都是有代价的,获得高性能的同时,也要承受并发程序带来的诸多问题。

缓存导致的可见性问题

可见性(共享对象可见性):线程对共享变量修改的可见性。当一个线程修改了共享变量的值,其他线程能够立刻得知这个修改。

在Java内存模型一文中有介绍线程与工作内存、主内存之间的关系,没啥印象可以去回顾一下。

如果两个或者更多的线程共享一个对象,一个线程更新这个共享对象可能对其它线程来说是不可见的:共享对象被初始化在主存中。跑在CPU上的一个线程将这个共享对象读到CPU缓存中,然后修改了这个对象。只要CPU缓存没有被刷新会主存,对象修改后的版本对跑在其它CPU上的线程都是不可见的。这种方式可能导致每个线程拥有这个共享对象的私有拷贝,每个拷贝停留在不同的CPU缓存中。

下图示意了这种情形。跑在左边 CPU 的线程拷贝这个共享对象到它的 CPU 缓存中,然后将 count 变量的值修改为2。这个修改对跑在右边CPU 上的其它线程是不可见的,因为修改后的 count 的值还没有被刷新回主存中去。

我们通过下属案例进行演示,当线程B更改了 stopRequested 变量的值之后,但是还没来得及写入主存当中,线程B转去做其他事情了,那么线程A由于不知道线程B对 stopRequested 变量的更改,因此还会一直循环下去。

public class VisibilityCacheTest {

  private static boolean stopRequested = false;

  public static void main(String[] args) throws InterruptedException {
    Thread thread1 = new Thread(() -> {
      int i = 0;
      while (!stopRequested) {
        i++;
      }
    },"A");

    Thread thread2 = new Thread(() -> {
      stopRequested = true;
    },"B");

    thread1.start();
    TimeUnit.SECONDS.sleep(1);	//为了演示死循环,特意sleep一秒
    thread2.start();
  }
}

这段代码是很典型的一段代码,很多人在中断线程时可能都会采用这种标记办法。但是事实上,这段代码会完全运行正确么?即一定会将线程中断么?不一定,也许在大多数时候,这个代码能够把线程中断,但是也有可能会导致无法中断线程(虽然这个可能性很小,但是只要一旦发生这种情况就会造成死循环了)。

线程切换带来的原子性问题

即使是单核处理器也支持多线程执行代码,CPU通过给每个线程分配CPU时间片来实现这个机制。时间片是CPU分配给各个线程的时间,因为时间片非常短,所以CPU通过不停地切换线程执行,让我们感觉多个线程是同时执行的,时间片一般是几十毫秒(ms)。

CPU 通过时间片分配算法来循环执行任务,当前任务执行一个时间片后会切换到下一个任务。但是,在切换前会保存上一个任务的状态,以便下次切换回这个任务时,可以再加载这个任务的状态。所以任务从保存到再加载的过程就是一次上下文切换。

线程切换示意图如下所示:

我们还是通过一个经典案例来进行演示:

public class AtomicityTest {

  static int count = 0;

  public static void main(String[] args) throws InterruptedException {
    AtomicityTest obj = new AtomicityTest();
    Thread t1 = new Thread(() -> {
      obj.add();
    }, "A");

    Thread t2 = new Thread(() -> {
      obj.add();
    }, "B");

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

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

    System.out.println("main线程输入结果为==>" + count);
  }

  public void add() {
    for (int i = 0; i < 100000; i++) {
      count++;
    }
  }
}

上面这段代码做的事情很简单,开了 2 个线程对同一个共享整型变量分别执行十万次加1操作,我们期望最后打印出来 count 的值为200000,但事与愿违,运行上面的代码,count 的值是极有可能不等于 20万的,而且每次运行结果都不一样,总是小于 20万。为什么会出现这个情况呢?

自增操作是不具备原子性的,它包括读取变量的原始值、进行加1操作、写入工作内存。那么就是说自增操作的三个子操作可能会分割开执行,就有可能导致下面这种情况出现:

假如某个时刻变量 count 的值为10,

线程A对变量进行自增操作,线程A先读取了变量 count 的原始值,然后线程A被阻塞了(可能存在的情况);

然后线程B对变量进行自增操作,线程B也去读取变量 count 的原始值,由于线程A只是对变量 count 进行读取操作,而没有对变量进行修改操作,所以主存中 count 的值未发生改变,此时线程B会直接去主存读取 count 的值,发现 count 的值为10,然后进行加1操作,并把11写入工作内存,最后写入主存。

然后线程A接着进行加1操作,由于已经读取了 count 的值,注意此时在线程A的工作内存中 count 的值仍然为10,所以线程A对 count 进行加1操作后 count 的值为11,然后将11写入工作内存,最后写入主存。

那么两个线程分别进行了一次自增操作后,inc只增加了1。

编译优化带来的有序性问题

在 Java 高并发系列开始时,第一篇文章介绍了计算机的一些基础知识。处理器为了提高 CPU 的效率,通常会采用指令乱序执行的技术,即将两个没有数据依赖的指令乱序执行,但并不会影响最终的结果。与处理器的乱序执行优化类似,Java 虚拟机的即时编译器中也有类似的指令重排序(Instruction Reorder)优化。

在 Java 领域一个经典的案例就是利用双重检查创建单例对象,例如下面的代码:在获取实例 getInstance() 的方法中,我们首先判断 instance 是否为空,如果为空,则锁定 Singleton.class 并再次检查 instance 是否为空,如果还为空则创建 Singleton 的一个实例。

public class Singleton {
  static Singleton instance;
  static Singleton getInstance(){
    if (instance == null) {
      synchronized(Singleton.class) {
        if (instance == null)
          instance = new Singleton();
        }
    }
    return instance;
  }
}

假设有两个线程 A、B 同时调用 getInstance() 方法,他们会同时发现 instance == null ,于是同时对 Singleton.class 加锁,此时 JVM 保证只有一个线程能够加锁成功(假设是线程 A),另外一个线程则会处于等待状态(假设是线程 B);线程 A 会创建一个 Singleton 实例,之后释放锁,锁释放后,线程 B 被唤醒,线程 B 再次尝试加锁,此时是可以加锁成功的,加锁成功后,线程 B 检查 instance == null 时会发现,已经创建过 Singleton 实例了,所以线程 B 不会再创建一个 Singleton 实例。

实例化一个对象其实可以分为三个步骤:

(1)分配内存空间。

(2)初始化对象。

(3)将内存空间的地址赋值给对应的引用。

但是由于操作系统可以对指令进行重排序,所以上面的过程也可能会变成如下过程:

(1)分配内存空间。

(2)将内存空间的地址赋值给对应的引用。

(3)初始化对象s

如果是这个流程,多线程环境下就可能将一个未初始化的对象引用暴露出来,从而导致不可预料的结果。

总结

要写好并发程序,首先要知道并发程序的问题在哪里,只有确定了“靶子”,才有可能把问题解决,毕竟所有的解决方案都是针对问题的。

缓存、线程、编译优化的目的和我们写并发程序的目的是相同的,都是提高程序性能。但是技术在解决一个问题的同时,必然会带来另外一个问题,所以在采用一项技术的同时,一定要清楚它带来的问题是什么,以及如何规避。

前言:为什么要学习爬虫和逆向,该如何学习? 学习爬虫和逆向技术是当今数字化时代的重要技能,尤其在数据分析、安全研究、自动化工具开发等领域有广泛应用。以下是详细的学习理由、路径和方法: 阅读详情

相关推荐

Diffusion Model进阶解析:从SDE到概率流ODE的连续化生成建模

本文深入解析了Diffusion Model的连续化生成建模,从离散DDPM和SGM模型引入,阐述了采用随机微分方程(SDE)统一视角的必要性与优势。文章详细拆解了SDE的构成,揭示了其如何统一描述扩散过程,并重点介绍了逆向SDE与确定性的概率流ODE,后者为高效、确定的图像生成提供了理论基础。最后,文章对比了朗之万动力学、数值SDE求解器和数值ODE求解器(如DPM-Solver)等主流采样方法的实战应用与选择策略。

weixin_29099217的博客 437

关于多线程操作单个变量进行加1问题的分析

摘要:在多线程的学习中,我们经常会接触到一个例子,这个例子也是一个重要的面试题,在此我详细的分析这个问题。

云杉木屋 1657

Prokka实战:10分钟搞定细菌基因组注释(附详细参数解析)

本文深入解析Prokka细菌基因组注释工具的核心参数与实战策略。通过拆解其集成化工作流程,详细解读物种分类、功能注释、输出控制等关键参数,并提供快速初筛、高质量发表、质粒注释及批量处理四种典型场景的高效参数组合方案,帮助用户精准掌控注释过程,将原始序列转化为有价值的生物学见解。

weixin_29271053的博客 447

Java - Synchronized(六)

在Java中,“synchronized” 是一个关键字,用于实现多线程的同步机制,其含义是“同步”的意思。在多线程编程中,当多个线程同时访问共享资源时,可能会导致竞态条件(Race Condition)和数据不一致的问题。为了避免这些问题,可以使用 synchronized 关键字来标记一个代码块或方法,使得同一时间只有一个线程可以进入该代码块或方法,从而保证了对共享资源的互斥访问。

qq_42583549的博客 500

如何用YOLOv5改进无人机小目标检测?MFFSODNet实战教程(附代码)

本文详细介绍了如何利用YOLOv5框架结合MFFSODNet网络结构优化无人机航拍图像中的小目标检测。通过引入微小目标预测头、多尺度特征提取模块(MSFEM)和双向密集特征金字塔网络(BDFPN)等核心技术,显著提升了小目标检测精度。文章提供了完整的代码实现方案,并展示了在农业监测、电力巡检等实际场景中的应用效果。

sre5engineer的博客 741

git连接华为软件开发云

我用的是github客户端的git shell 连接。用git bash也可以github客户端下载地址:https://desktop.github.com/1.在华为软件开发云上创建代码仓库2.在本地创建密钥SSH密钥帮助文档公钥是代码托管服务(CodeHub)识别您的用户身份的一种认证方式,通过公钥,您可以将本地git项目与代码托管服务(CodeHub)建立联系, 然后您就可以很方便的将本地...

sigmeta的博客 2114

Java并发编程【并发BUG的源头】

1. 缓存导致的可见性问题 在多核cpu时代,cpu缓存的同步会导致共享变量的操作结果在多个线程之间不可见,进而导致并发问题。 int count=0; 如图若线程A和线程B同时做 count+=1;操作,得到的结果可能并不是我们想要的 count=2 而是 count=1 如此若循环加 1万 次 count 的结果接近 2万 而不是 2万。若循环 1亿 次效果将更明显 count 的结果接近 1...

dying 搁浅 637

XC7Z010-1CLG400C开发板ADC引脚配置全攻略(附完整引脚列表)

本文详细解析了XC7Z010-1CLG400C开发板的ADC引脚配置方法,涵盖XADC模块基础、CLG400封装的引脚布局、硬件设计规范及Vivado工程配置实战。特别提供了完整的引脚列表和性能优化技巧,帮助开发者高效实现模拟信号采集,适用于Zynq-7000系列开发。

weixin_29188043的博客 467

Java并发编程实战 01并发编程的Bug源头

摘要 本文为学习极客时间:Java并发编程实战 01的总结,文章取图也是来自于该文章 并发Bug源头 并发编程的Bug源头主要为可见性、有序性、原子性 源头之一:CPU缓存导致的可见性问题 一个线程对共享变量的修改,另外一个线程能够立即看到,那么就称为可见性。 现在多核CPU时代中,每颗CPU都有自己的缓存,CPU之间并不会共享缓存; 如线程A从内存读取变量V到CPU-1的缓存中,线程B也从内存...

Lin_JunSheng的博客 541

硬件基础(4):(6)高精度ADC设计中模拟地与数字地的划分与连接

在实际 PCB 设计中,**接地与布线**对于获得干净的参考电压和高精度 ADC 测量至关重要。下面详细阐述**如何在硬件层面减少数字噪声耦合到模拟电路、保障参考电压的稳定性**。

FCZlll的博客 2649

从0到全栈:C#/.NET/.NET Core终极学习路线——2025年开发者必修的12个阶段与30个实战项目

【代码】从0到全栈:C#/.NET/.NET Core终极学习路线——2024年开发者必修的12个阶段与30个实战项目。

墨夶的博客 2042

Java并发编程 | 并发编程BUG的源头

对于并发编程的Bug,它经常是很诡异的出现,难以复现,一般来说我们就说这个方法或者这个变量是不安全的,需要加锁。 但是为什么会出现这些Bug,这个就涉及了一些计算机的知识,必须要清楚这些Bug出现的源头,这样才可以理解不同的并发策略是为什么这样设计的,以及如何解决的。...

m0_71682321的博客 239

多准则决策方法体系(AHP、熵权法、随机森林、加权线性法、TOPSIS、模糊综合评价)

多准则决策方法体系的基础,是由三大赋权方法和三大评价框架构成的 “3+3” 核心模块。赋权方法聚焦于准则重要性的量化,评价框架则专注于多准则信息的综合集成,二者共同覆盖了从 “确定权重” 到 “输出结果” 的全流程决策需求。

```On Earth, Be Water, By Coding``` 524

java并发编程实战之并发编程bug的源头

源头之一:缓存导致的可见性问题 一个线程对共享变量的修改,另外一个线程能够立刻看到,我们称为可见性。 多核时代,每颗 CPU 都有自己的缓存,这时 CPU 缓存与内存的数据一致性就没那么容易解决了,当多个线程在不同的 CPU 上执行时,这些线程操作的是不同的 CPU 缓存。比如下图中,线程 A 操作的是 CPU-1 上的缓存,而线程 B 操作的是 CPU-2 上的缓存,很明显,这个时候线程 A 对变量 V 的操作对于线程 B 而言就不具备可见性了。这个就属于硬件程序员给软件程序员挖的“坑”。 源头之二:线程

whutrenzhe的博客 226

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

Day821.并发编程Bug的源头 -Java 并发编程实战

Hi,我是,今天学习记录的是关于。哪一门编程语言,并发类的知识都是在高级篇里。换句话说,这块知识点对于程序员来说,是比较进阶的知识。这么多年学习过来,也确实觉得并发是比较难的,因为它会涉及到很多的底层知识,比如若你对操作系统相关的知识一无所知的话,那去理解一些原理就会费些力气。编写正确的并发程序是一件极困难的事情,并发程序的 Bug 往往会诡异地出现,然后又诡异地消失,很难重现,也很难追踪,很多时候都让人很抓狂。这些年,CPU、内存、I/O 设备都在不断迭代,不断朝着更快的方向努力。但是,在这个快速发展的过

阿昌爱Java 506

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

java 并发编程实战代码_Java并发编程实战 01并发编程的Bug源头

摘要编写正确的并发程序对我来说是一件极其困难的事情,由于知识不足,只知道synchronized这个修饰符进行同步。 本文为学习极客时间:Java并发编程实战 01的总结,文章取图也是来自于该文章 并发Bug源头在计算机系统中,程序的执行速度为: CPU > 内存 > I/O设备 ,为了平衡这三者的速度差异,计算机体系机构、操作系统、编译程序都进行了优化: 1.CPU增加了缓存,...

weixin_39605647的博客 104

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

高薪程序员必修课-java并发编程的bug源头

Java并发编程虽然强大,但也容易引发复杂的bug。并发编程的bug主要源自以下几个方面:竞态条件、死锁、内存可见性问题和线程饥饿。了解这些bug的源头及其原理,可以帮助开发者避免和解决这些问题。以下是详细的讲解和相应的示例。原理:多个线程同时访问和修改共享资源。示例:多个线程同时增加共享变量。

qq_31095905的博客 1235

Java并发编程实战 代码bug,Java并发编程实战(1)- 并发程序的bug源头

概述并发编程一般属于编程进阶部分的知识,它会涉及到很多底层知识,包括操作系统。编写正确的并发程序是一件很困难的事情,由并发导致的bug,有时很难排查或者重现,这需要我们理解并发的本质,深入分析Bug的源头。并发程序问题的源头为了提升系统性能,在过去几十年中,我们一直在不断的提升硬件的设计,包括CPU、内存以及I/O设备,但存在一个主要矛盾:三者之间速度有很大差异,CPU最快,内存其次,I/O设备最...

weixin_30679649的博客 172

[Java并发-1]入门:并发编程Bug的源头

背景介绍 如何解决并发问题,首先要理解并发问题的实际源头怎么发生的。 现代计算机的不同硬件的运行速度是差异很大的,这个大家应该都是知道的。 计算机数据传输运行速度上的快慢比较: CPU > 缓存 > I/O 如何最大化的让不同速度的硬件可以更好的协调执行,需要做一些“撮合”的工作 CUP增加了高速缓存来均衡与缓存间的速度差异 操作系统增加了 进程,线程,以分时复用CPU,进而均衡CPU与I/O的速度差异(当等待I/O的时候系统切换CPU给系统程序使用) 现代编程语言的编译器优化指令顺序,使

df007df的博客 261

《Java 并发编程实战》——可见性、原子性和有序性问题:并发编程Bug的源头

Java领域一个经典的案例就是利用双重检查创建单例对象,例如下面的代码在获取实例getInstance()的方法中,我们首先判断instance是否为空,如果为空,则锁定Singleton.class并再次检查instance是否为空,如果还为空则创建Singleton的一个实例。早期的操作系统基于进程来调度CPU,不同进程间是不共享内存空间的,所以进程要做任务切换就要切换内存映射地址,而一个进程创建的所有线程,都是共享一个内存空间的,所以线程做任务切换成本就很低了。...

逾越的博客 4185

【Java并发入门】01 并发编程Bug的源头

并发编程Bug的源头:可见性、原子性和有序性问题。 「CPU、内存、磁盘之间的速度差异」 - 为了能同时执行多个任务,CPU 发展出时间片轮转、多核等 - CPU 要从内存中读数据太慢了,所以给自己设置了缓存 - CPU 读磁盘更慢了,所以可以让该线程阻塞

笨鸟先飞的博客 382

Java并发编程Bug源头:可见性、原子性和有序性问题

并发编程的起源硬件设备发展的核心矛盾:CPU、内存、I/O设备三者间存在的速度差异。根据木桶原理,程序整体性能最终受制于速度最慢的I/O设备。为了平和三者速度差异,计算机体系结构、操作系统、编译程序都做出了贡献,主要体现为:CPU增加了缓存,以均衡与内存的速度差异;操作系统增加了进程、线程,以分时复用CPU,进而均衡CPU与I/O设备的速度差异;编译程序优化指令执行顺序,使得缓存能够得到更加合理地...

weixin_33883178的博客 148

JAVA并发编程三大Bug源头(可见性、原子性、有序性),彻底弄懂

某日,胖滚猪写的代码导致了一个生产bug,奋战到凌晨三点依旧没有解决问题。胖滚熊一看,只用了一个volatile就解决了。并告知胖滚猪,这是并发编程导致的坑。这让胖滚猪坚定了要学好并发编程的决心。。于是,开始了我们并发编程的第一课。 序幕 BUG源头之一:可见性 刚刚我们说到,CPU缓存可以提高程序性能,但缓存也是造成BUG源头之一,因为缓存可以导致可见性问题。我们先来看一段代码: priva...

weixin_47082274的博客 336

Java并发编程:可见性、原子性和有序性问题:并发编程Bug的源头

可见性是指当一个线程修改了共享变量的值,其他线程能够立即看到这个修改。在Java中,volatile关键字可以保证可见性。原子性是指一个操作要么全部完成,要么全部不完成。在Java中,基本类型的读取和写入操作通常是原子的,但是对于复合操作,如i++;则不是原子的。有序性是指程序执行的顺序按照代码的先后顺序进行。然而,在并发环境中,编译器和处理器为了优化性能可能会重新排序指令,从而破坏代码的顺序性。

qq_33240556的博客 415
上一篇: Java 通用配置(三)用户配置实现
下一篇: JAVA中简单的for循环竟有这么多坑,你踩过吗
javaYY_
博客等级 码龄4年 148粉丝 69原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值