`

java并发编程不得不知道的几件事

    博客分类:
  • J2SE
阅读更多

 

多线程编程从来都是一件比较困难的事情,调试多线程程序也相当困难,这种困难来自于线程对共享资源操作的复杂性 ( 包括对于资源操作的线程间的先后顺序 ) 。对于 Java 来说,它封装了底层硬件和操作系统之间很多的细节,对于线程之间的调度底层细节我们大多数时候不用关心,然而真正编写 java 多线程程序时有一些东西我们却是不得不知道的。

在 java 中,

1、  多个线程之间数据交换是依靠内存来实现的。

2、  缓存:为了获得较高的性能,处理器读取内存中的数据后,可能会存储在自身缓存中,计算得到的新的结果值也可能直接写到自身缓存中,等待合适的时机再刷新到内存中去,在数据刷新到内存中之前,别的处理器是看不到这个更新的值的。 ( 这个造成的问题可能是缓存与主存中的数据不一致,这也就引出了值的可见性的问题 )

3、  次序:同样,为了获得最优性能, java 允许编译器在不修改程序语义的前提下,可以随意的排序某些指令的执行顺序,甚至允许处理器以颠倒的次序执行一些操作,例如,允许缓存以程序写入变量时不同的顺序把变量刷新到主存中。

 

  注意以上提到的几点,理解他们在 java 多线程编程中至关重要,再继续之前,我来举两个实际的例子来说明一下上面的 2 和 3 点。

对于第 2 点,先来 看这一段代码:
(1)y=5;
(2)b=y+3;

在单线程中执行这一段代码,处理器将 y 读入缓存,并且在执行 y+3 后,将计算到的结果再次存入缓存中,在某个时候 ( 可能立即,也可能在之后的某个合适的时间 ) 再将这个 b 值刷新到内存中。

换成多线程,线程 A 执行 (1)(2) ,而从另外一个线程 B 来读取 b 的值会有什么样的结果呢?答案是不确定。为什么呢 ? 即使是 A 线程先执行了 (1)(2) ,线程 B 再读取 b 的值,也有可能读取不到,因为有可能 b 的真正的值可能还在缓存中,而线程 B 只能从自己的缓存或者从内存中去读取所要的值,这就会造成 B 读到的可能是一个过期的内存值。

对于第 3 点,排序是什么意思呢?同样来看一段代码
(3) a=5
(4)b=6
(5)c=7
(6)d=8
(6)e=a+b
(7)f=c+d

我们直观会觉得,处理器会依次执行上面的代码,但是答案也是不确定的,因为不同的编译器或处理器为了获得最高性能,很可能会调整最终代码的执行顺序,只要最终不影响程序语义即可,例如,这里可以先执行 (3)(4)(6), 再执行 (5)(6)(7) ,这都是不影响最终结果和语义的,怎么调整都可以。更甚至对于这样的顺序操作 A. 从内存读取数值到缓存 B. 执行得到结果并放入缓存 C. 将缓存数据刷新到内存,这么几步操作都有可能被编译器给颠倒执行,本来正常应该 ABC 的顺序,最后真正执行的可能是 ACB 的顺序。

对于只在线程内执行的操作和访问的变量来讲,上面的几点都不会有问题,而对于会在多线程中来访问和操作的变量来说上面的优化可能会变成了灾难。

 

为了解决资源争用的问题, java 引入了 synchornized 关键字,同时它还有另外一层语义,那就是解决了值可见性问题。

Synchornized 关键字保证了:

1、  在进入同步块时,失效缓存,强制从内存读取最新值。

2、  在退出同步块时,将缓存值强制刷到内存中。

以上两点保证了同一个监视器保护下的多个线程都可以看到最新值,而不会读取到过期值,如果线程 A 进入同步块,执行后得到的所有共享变量值,在它退出后,对紧接着进入同一个同步块的线程 B 都是可见的,即线程 B 可以保证读取到线程 A 在同步块中计算到的共享变量的最新值。

在 java 中还定义另一个关键字,也一样可以保证变量的在跨线程中的可见性,那就是 volatile ,它保证读写直接在主存而不是寄存器或者本地处理器缓存中进行。即使用 volatile 修改的变量可以保证在其他线程中读取该变量时可以读取到,例如,如果上面 (2) 中 b 加上 volatile 关键字,那么在线程 B 中就可以立马看到该变量修改的最新值。

  如果既没有使用 synchornized ,也没有使用 volatile 的共享资源,那么在 java 中是不保证线程之间对最新值是可见的。

 

上面还谈到了编译器对内存操作重排序的问题,这有什么影响呢?看如下代码,
char[] config;
(8)boolean initialized = false;
// In Thread A
(9)config = readConfigFile(fileName);
(10)initialized = true;
// In Thread B
while (!initialized)
  sleep();
// use config  


原始想法是线程A 如果完成了对config 的初始化,设置initialized 为true表示初始化完成,B 线程如果检测到初始化完成,则执行use config 。然而这段代码可能并不会像我们想的那样运行,前面说过了,有可能线程B 永远都看不到initialized=true 的那一天,因为这里没有任何保证线程B能够看到initialized读取到最新值, 如果initialized 加上volatile 关键字会怎么样呢?将(8) 修改成 volatile boolean initialized = false; 就可以保证线程B 可以看到initialized 的最新值。在JDK1.5之前,解决了这个可见性问题,但是又有一个问题出现了,因为JDK1.5之前编译器对 volatile 变量的读和写不能与对其他 volatile 变量的读和写一起重新排序,但是它们仍然可以与对不是 volatile 变量的读写一起重新排序,意思是说,这里 (9) 和 (10) 的执行顺序有可能被编译器给颠倒了,此时如果线程 B 检测到 initialized 为true ,准备执行config 时,却因为config 没有被初始化导致代码出现严重错误,杯具。可见,这里编译器调换了执行顺序对于多线程来说有时候是多么可怕。但是在JDK1.5 中, volatile 又增加了一个语义,那就是申明了 volatile 的变量告诉编译器不能和其他非 volatile 变量一起排序,同时volatile 变量自身的所有内存操作也必须按照顺序执行,不能颠倒。因此 volatile 的变量其实是关闭了编译器对其的优化。

 

   前面也讲了,在线程内编译器对操作进行排序优化,只要其中不要涉及到公共资源的操作,并不会引起什么问题,但是一旦进行了排序,而我们在大多数时候又无法预料线程与线程之间的操作执行顺序,就可能会引起程序 crash.

   在 java 中,新的 java 内存模型定义了一部分线程与线程之间操作的执行顺序,叫做 happen-before ,它保证只要满足 happen-before 关系,那么后面的操作可以看到前面操作的结果。

 

 

 线程内的每个操作happen-before稍后按程序顺序传入的该线程中的每个操作。
 一个解除锁监视器的(synchronized阻塞或方法退出)happen-before相同监视器的每个后续锁(synchronized
阻塞或方法进入)。并且因为 happen-before 关系是可传递的,所以解除锁定之前的线程的所有操作 happen-before 锁定该监视器的任何线程后续的所有操作。
写入volatile字段happen-before每个后续读取相同字段。volatile字段的读取和写入与进入和退出监视器具有相似的内存一致性效果,但不需要互斥锁。
在线程上调用start() happen-before 在启动的线程中的所有操作。
线程中的所有操作 happen-before 从该线程上的 join 成功返回的任何其他线程。 
     当有一个变量被多个线程读、被至少一个线程写、并且读和写不是按 hanppens-before 关系排序的时,程序就称为有 数据争用 ,因而不是一个 “ 正确同步 ” 的程序。

 

    明白了以上几点,就可以解释一个经典 DCL 问题,例如:

public class Singleton {
private static Singleton instance=null;
public static Singleton getInstance()
{
  if (instance == null)
  {
    synchronized(Singleton.class) {  //1
      if (instance == null)          //2
        instance = new Singleton();  //3
    }
  }
  return instance;
}
}

 这段代码有问题么?标准的double check.instance = new Singleton()根据以上几点分析,
可能执行执行了下列伪代码:

mem = allocate();             //Allocate memory for Singleton object.
instance = mem;               //Note that instance is now non-null, but
                              //has not been initialized.
ctorSingleton(instance);      //Invoke constructor for Singleton passing
                              //instance. 注意,当线程A执行到instance = mem时,线程B 正好执行到外部的instance == null,此时,这个引用已经不为null,但是这个statnce
还没有构造完成,线程B的操作立即返回使用该instance,这是不安全的。这是从操作次序被重新排序得到的分析结果,从另外happen-before的角度来看,这里多个线程操作共享变量instance之间并没有明显的happen-before关系,因此多个线程对instanc的读写可能发生不可见的情况。instance变量申明为volatile即可,既保证了可见性,又保证了操作不会被排序。然而,使用volatile来实现毕竟有性能损耗,因此如果要实现单例,完全可以避免使用DCL,而采用static方式。例如:
要解决上面提到的问题,将该

public class Singleton { 
private static class Singleton Holder{ 
private static Singleton instance = new Singleton (); 

public static Singleton getInstance(){ 
return SingletonHolder.instance ; 

}

这种实现方式既保证了足够的惰性,又避免了同步或者保持可见性带来的性能损耗。

 


分享到:
评论

相关推荐

    Java编程之高并发核心源码

    首先,我们要了解Java并发编程的基础,即线程。Java提供了Thread类和Runnable接口来创建和管理线程。通过实现Runnable接口或继承Thread类,可以定义线程执行的逻辑。然而,线程的直接创建和管理可能会导致资源浪费,...

    Java工程师不得不看的几千份代码

    这份压缩包文件"Java工程师不得不看的几千份代码"显然是一份丰富的资源集合,旨在帮助Java开发者拓宽视野,掌握更多实践技巧,提升编程能力。下面我们将深入探讨其中可能涵盖的关键知识点。 1. **基础语法与最佳...

    高级java笔试题-Java-Concurrency-in-Practice:《Java并发编程实战》阅读整理笔记,附加了一些《Java并发编

    高级java笔试题 《Java 并发编程实战》阅读笔记 ...因为并发、并行本身,是有悖于我们大脑的工作模式的,也就是说,我们长期的写码不得不 而一旦将这一个一个的线程组合起来,奇妙的 bug 发生了...

    Java 7 Concurrency Cookbook pdf

    在技术细节上,书籍覆盖了Java 7并发工具包中的类和接口,诸如`java.util.concurrent`包下的工具类,比如`Executor`、`ReentrantLock`、`ConcurrentHashMap`等,这些都是Java并发编程中不可或缺的组件。 书中强调了...

    java并发笔记

    综上所述,Java并发编程涵盖了从基础概念到高级技巧的广泛知识领域。从JDK的发展历史可以看出,随着技术的进步,Java不断优化和完善其并发模型,以满足现代高性能、高并发应用的需求。理解并发的基本原理和技巧对于...

    Java面试专属视频

    面试必考之HashMap源码分析与实现 ,微服务架构之Spring Cloud Eureka 场景分析与实战,高性能必学之Mysql主从架构实践 ,架构师不得不知道的Spring事物不能回滚的深层次原因 ,分库分表之后分布式下如何保证ID全局...

    java习题不得不看

    "java习题不得不看"这个资源正是一份专为新手设计的Java学习资料,通过一系列习题帮助初学者巩固和提升Java编程能力。 首先,我们要理解Java的基础概念。Java是一种面向对象的编程语言,由Sun Microsystems(现已被...

    java网络编程技术与实践(源程序第15章)

    由于文件大小超过80兆,作者为了减小文件体积,不得不删除了`lib`目录下的所有`jar`库。尽管如此,我们依然可以从剩下的`chap15`文件中学习到很多核心概念。 1. **Java网络编程基础**:Java提供了丰富的API来支持...

    java编程思想第四版课后练习答案

    - **并发编程**:线程的概念、同步机制、并发工具类等。 - **输入/输出流**:文件读写操作、网络通信等。 - **设计模式**:介绍常用的软件设计模式,如工厂模式、单例模式、观察者模式等。 综上所述,《Java编程...

    Java Concurrency in Practice

    《Java Concurrency in Practice》是一本深入探讨Java并发编程的权威指南,由Brian Goetz、Tim Peierls、Joshua Bloch、Joseph Bowbeer、David Holmes 和 Doug Lea 合著。本书首次出版于2006年5月9日,出版社为...

    浅谈Java多线程编程.pdf

    进行多线程编程就不得不考虑访问共享资源的问题。Java同步机制可以控制线程代码重入,但很多时候多个线程在各自的执行过程中,会访问诸如存储处理等同一处资源,可能会导致线程阻塞和死锁的情况。

    最新Java面试题视频网盘,Java面试题84集、java面试专属及面试必问课程

    │ │ 9.JAVA并发编程之多线程并发同步业务场景与解决方案.wmv │ │ │ ├─10.微服务架构之Spring Cloud Eureka 场景分析与实战 │ │ 10.微服务架构之Spring Cloud Eureka 场景分析与实战.wmv │ │ │ ├─11....

    java知识集合

    Java并发编程: Java提供了强大的并发编程支持,包括线程的创建、运行、同步和通信等。 通过使用synchronized关键字和各种锁机制实现线程同步,保证线程安全。 Java虚拟机调优和性能监控工具: JVM性能调优涉及到...

    Java程序设计语言.(美国)阿诺德.清晰版.pdf

    还可能涉及Java的标准库,包括集合框架、输入/输出(I/O)系统、并发编程等。在一些高级的章节中,作者还可能介绍了一些Java新版本中的特性,例如泛型、注解、lambda表达式等。 电子书的使用注意事项表明,这本书是...

    JAVA 7 程序设计.part1.rar

    JAVA 7 程序设计.part1.rar(解压需2个文件part1,part2目前一次只能上传70M,不得不分卷,希望大家谅解下) 本书由全球资深Java技术专家、高级Java企业级应用架构师、《How Tomcat Works》作者亲自执笔,权威性...

    网络编程全能

    此外,Java还支持多线程编程,允许多个任务并发执行,提高了程序的效率。 在学习Java编程时,可能会遇到各种问题。例如,如果编程词典软件不能正常运行,应检查安装是否正确,并确认未删除注册后的.ini文件。若遇到...

    Java 9 High Performance

    书名《Java 9 High Performance》强调了对Java应用程序进行优化的重要性,特别是在并发编程和响应式编程方面。这些技术能够帮助开发者利用现代多核处理器的计算能力,设计出能够高效运行的应用程序。 书中的部分...

    JAVA 7 程序设计.part2.rar

    JAVA 7 程序设计.part2.rar(解压需2个文件part1,part2目前一次只能上传70M,不得不分卷,希望大家谅解下) 本书由全球资深Java技术专家、高级Java企业级应用架构师、《How Tomcat Works》作者亲自执笔,权威性...

Global site tag (gtag.js) - Google Analytics