JAVA内存模型与线程

Java内存模型

介绍

1. 在JDK1.5发布后,Java内存模型已经成熟和完善,其主要目标就是定义程序中各个变量的访问规则,即虚拟机将变量存储到内存和从内存中取出变量(包括实例字段,静态字段,构成数组对象的元素,但不包括局部变量和方法参数,因为后者是线程私有)的细节.
2. Java内存模型规定了所有的变量都存储在主内存中,每个线程都有自己的工作内存,保存了被该线程使用的变量的主内存副本拷贝,线程对变量的所有操作都必须在工作内存中进行,线程间变量值的传递均需要通过主内存来完成.
3. 主内存和工作内存与java堆,栈,方法区不是同一层次的内存划分,两者基本上没有关系.如果从变量,主内存,工作内存的定义来看,主内存相当于java堆中的实例对象的数据部分,工作内存相对于栈中的部分数据

 

内存间的交互操作

java内存模型定义了8种操作来完成变量从主内存拷贝到工作内存,从工作内存同步回主内存的实现.每种操作都是原子的,不可再分的.

1.local(锁定):作用于主内存,将一个变量标识成一条线程独占的状态

2.unlock(解锁):作用于主内存,将锁定的变量释放,变量释放后,才能被其他的线程锁定.

3.read(读取):作用于主内存,把变量的值从主内存传输到线程的工作内存,以便随后的load动作使用

4.load(载入):作用于工作内存的变量,把read操作的变量放入工作内存的副本中

5.use(使用):作用于工作内存的变量,把工作内存中的一个变量的值传递给执行引擎,当虚拟机遇到一个需要使用到变量的值得字节码指令时,就会执行这个操作.

6.assige(赋值):作用于工作内存的变量,把执行引擎接收到的值赋给工作内存的变量,当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作.

7.store(存储):作用于工作内存的变量,把工作内存中一个变量的值传送到主内存中,以便随后的write操作使用

8.write(写入):作用于主内存,把store操作从工作内存中得到的变量的值放入主内存的变量中.

如果一个变量从主内存复制到工作内存,那么就要顺序执行read和load操作,如果要把变量从工作内存同步回主内存,就要顺序执行store和write操作.(可以是read A, read B, load B, load A)

这8种访问操作以及这8种操作的规范,再加上对volatile的一些特殊规定,就已经完全确定了Java程序中那些内存访问操作在并发下是安全的.

假设两个线程的副本都是8,然后每个线程都减少了1,然后都同步回主内存,主内存变成了7,但是实际上是减少了2,这样就产生了线程安全问题.

 

volatile变量特殊规则

关键字volatile可以说是java虚拟机提供的最轻量级的同步机制.一个变量被定义成volatile之后,会具备以下两种特性:

(1)此变量对所有线程可见(一条线程修改了这个变量的值,其他线程可以立即得知这个新值),由于java中的运算并非原子性的操作,导致volatile变量也可以存在不一致的问题.---->只能保证变量的可见性

(2)禁止指令重排序优化,指令重排序是机器级的优化操作.volatile修饰的变量赋值后,相当于有了一个内存屏障(指重排序时,不能把后面的指令重排序到内存屏障之前的位置),只有一个CPU访问内存时,不需要内存屏障,但是如果有多个CPU访问同一块内存,且其中一个在观测另一个,就需要内存屏障来保障一致性了.

 

使用volatile的场景:

(1)运算结果不依赖变量的当前值,或者能保证只有单一的线程修改变量的值

(2)变量不需要与其他状态变量共同参与不变的约束

 

long和double型变量的特殊规则

java内存模型的8个操作,允许虚拟机将没有被volatile修饰的64位数据的读写操作划分为两次32位的操作来进行,即允许虚拟机实现选择可以不保证64位数据类型的load,store,read和write这个4个操作的原子性,这就是所谓的long和double的非原子协定

在多线程并发下,可能出现某些线程读取到一个即非原值,也不是其他线程修改的值(代表了'半个变量'的数值).但是虚拟机允许选择把这些操作实现为具有原子性的操作(强烈建议),所以我们再把使用到long和double变量的时候,不需要专门声明成volatile

 

原子性,可见性,有序性

原子性:我们大致可以认为基本数据类型的访问读写具备原子性(除非原子协定),更大原子性的保证,使用lock和unlock(未直接开放给用户使用).但是提供了更高层次的字节码指令monitorenter和monitorexit来隐式使用这两个操作,这个两个字节码指令反映到java代码中,就是同步块synchronized关键字

 

 

 

 

1:变量的复制(原子)

2:两步操作,先读x的值,再复制(非原子)

3.读取自己的值,自增,返回(非)

4.同3(非)

可见性:指当一个线程修改了共享变量的值,其他线程能够立即得知这个修改,这个是通过依赖主内存作为传递媒介的方式来实现的,这个不管是volatile变量,还是普通变量,都是如此,区别是volatile变量的特殊规则保证了新值可以立即同步到主内存,以及每次使用前立即从主内存刷新

Java中的关键字synchronized和final也能实现可见性.同步块的可见性是由"对一个变量执行unlock操作之间,必须先把此变量同步回主内存"这条规则获得的;final的可见性是指"被final修饰的字段在构造器中一旦初始化完成,并且构造器没有把'this'的引用传递出去(this引用逃逸),那么其他线程中就能看见final字段的值"

有序性:如果在本线程内观察,所有操作都是有序的(线程内表现为串行),如果在一个线程中观察另一个线程,所有操作都是无序的(指令重排序).java提过了volatile和synchronized来保证线程之间的操作的有序性,volatile本身包含禁止指令重排序,synchronized是由"一个变量在同一时刻只允许一条线程对其进行lock操作"

 

先行发生原则

它是判断数据是否存在竞争,线程是否安全的主要依据

java内存模型的先行发生原则:

程序次序规则:一个线程内,按照程序代码顺序指行(控制流顺序)

管程锁定规则:unlock操作先行发生于后面对同一个锁的lock操作(后面指时间上的先后)

volatile变量规则:对一个volatile变量的写操作先行发生于后面对这个变量的读操作(后面指时间上的先后)

线程启动规则:Thread的start()先行于发生于此线程的每一个动作

线程终止规则:线程中的所有操作都先行发生于对此线程的终止检测(join,isAlive)

线程中断规则:对线程的interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生,可以通过Thread.interrupted()检测到是否有中断发生

对象终结规则:一个对象的初始化先行于它的finallize()

传递性:A先行B,B先行C,得出A先行C

 

时间先后顺序于先行发生原则之间基本没有太大关系,所以我们衡量并发安全问题的时候不能受到时间顺序的干扰,一切必须以先行发生原则为准

时间上的先发生-->先行发生:多线程并发

先行发生-->时间上的先发生:同一线程,指令重排序先行发生不代表先行被处理器执行,因为同一线程内无法感知到,所以不影响先行发生原则(程序次序)的正确性

 

 

Java与线程

线程的实现

Java的Thread类的大部分API都是native的,一个native()往往意味着这个方法没有使用或无法使用平台无关的手段来实现,实现线程的主要方式有3种:使用内核线程实现,使用用户线程实现,使用用户线程加轻量级进程混合实现

使用内核线程实现:直接由操作系统支持的线程,由内核完成线程切换.通过操纵调度器对线程进行调度,并负责将线程任务映射到各个处理器上.

程序一般不是使用内核线程,而是使用一种高级接口(轻量级进程),也就是我们通常意义上所讲的线程.每个轻量级进程都由一个内核线程支持,这种轻量级进程与内核线程之间的比例是1:1,也称一对一线程模型

优点:每个轻量级进程都是一个独立的调度单元,即使阻塞了,也不会影响整个进程的继续工作

局限性:各种线程操作(创建,析构,同步)都需要进行系统调用,代价较高,需要在用户态和内核态中来回切换;每个轻量级进程都需要一个内核线程支持,数量有限

使用用户线程实现:广义上将,不是内核线程,就是用户线程;狭义上将,用户线程是完全建立在用户空间的线程库上,系统内核不能感知线程存在的实现,如果程序实现得当,这种线程不需要切换到内核态.进程和用户线程之间1:N的关系称为一对多的线程模型

优点:不需要系统内核的支援

缺点:没有内核的支援,所有线程操作都需要用户程序自己处理.操作系统只把处理器资源分配给进程,那么"阻塞如何处理?","多处理器系统中如何将线程映射到其他处理器上"这类问题处理起来非常麻烦

使用用户线程加轻量级进程混合实现:用户线程还是完全建立在用户空间中,因此用户线程的创建,切换,析构等操作依旧廉价,并且可以支持大规模的用户线程并发,而操作系统支持的轻量级进程则作为用户线程和内核线程的桥梁,这样可以使用内核线程提供的线程调度功能及处理器映射,并且用户线程的系统调用要通过轻量级线程来完成,大大降低了整个进程被完全阻塞的风险.用户线程与轻量级进程N:M的关系,叫做多对多线程模型

 

Java线程的实现

线程模型只对线程的并发规模和操作成本产生影响,对Java程序的编码和运行过程来说,这些差异都是透明的.

 

Java线程调度

线程调度是指系统为线程分配处理器使用权的过程,主要有两种方式,协同式线程调度和抢占式线程调度

协同式线程调度:线程的执行时间由自己控制,自己的工作执行完成后,主动通知系统切换到另外一个线程上.

实现简单,没有同步问题,但是相当不稳定,可能导致整个系统崩溃.

抢占式线程调度:每个线程由操作系统分配执行时间,线程的切换不由线程本身来决定.

线程执行时间是系统可控的,不会因为一个线程阻塞导致进程阻塞的问题

线程的优先级可以给操作系统建议分配给每个线程的时间,但是并不靠谱,因为Java的线程是通过映射到系统的原生线程上来实现的,所以线程调度最终还是取决于操作系统.同事,优先级还可能被系统"优先级推进器"自行改变(发现一个线程特别'勤奋',可能会越过优先级为它分配时间)

 

线程状态

 

阻塞状态:等待着获取一个排他锁,这个事件将在另一个线程放弃这个锁的时候发生

等待状态:在等待一段时间,或者唤醒动作的发生,在程序等待进入同步区域的时候,线程将进入这种状态.

 

通信方式

1.同步(synchronized)

使用的是同一个对象的锁,本质上就是"共享内存"式的通信.多个线程需要访问同一个共享变量,谁拿到了锁(获得了访问权限),谁就可以执行。

synchronized后面的线程会做一种自旋

 

2.wait/notify机制

wait会释放执行权,执行资格,以及释放锁;sleep会释放执行权,执行资格,但是不释放锁

 

1.同步(synchronized)

由于线程A和线程B持有同一个MyObject类的对象object，尽管这两个线程需要调用不同的方法，但是它们是同步执行的，

比如：线程B需要等待线程A执行完了methodA()方法之后，它才能执行methodB()方法。这样，线程A和线程B就实现了通信。

这种方式，本质上就是“共享内存”式的通信。多个线程需要访问同一个共享变量，谁拿到了锁（获得了访问权限），谁就可以执行。

 

2.while轮询的方式

线程A不断地改变条件，线程ThreadB不停地通过while语句检测这个条件(list.size()==5)是否成立 ，从而实现了线程间的通信。

但是这种方式会浪费CPU资源。之所以说它浪费资源，是因为JVM调度器将CPU交给线程B执行时，它没做啥“有用”的工作，

只是在不断地测试某个条件是否成立。就类似于现实生活中，某个人一直看着手机屏幕是否有电话来了，而不是：在干别的事情，当有电话来时，响铃通知TA电话来了。

这种方式还存在另外一个问题：轮询的条件的可见性问题.

线程都是先把变量读取到本地线程栈空间，然后再去再去修改的本地变量。

因此，如果线程B每次都在取本地的条件变量，那么尽管另外一个线程已经改变了轮询的条件，它也察觉不到，这样也会造成死循环。

 

3.wait/notify机制

线程A要等待某个条件满足时(list.size()==5)，才执行操作。线程B则向list中添加元素，改变list的size。

那么A,B之间如何通信的呢？也就是说，线程A如何知道 list.size()已经为5了呢？

这里用到了Object类的wait()和notify()方法。

当条件未满足时(list.size() !=5)，线程A调用wait()放弃CPU，并进入阻塞状态。(不像②while轮询那样占用CPU)

当条件满足时，线程B调用notify()通知线程A，所谓通知线程A，就是唤醒线程A，并让它进入可运行状态。这种方式的一个好处就是CPU的利用率提高了。

但是也有一些缺点：比如，线程B先执行，一下子添加了5个元素并调用了notify()发送了通知，而此时线程A还执行；当线程A执行并调用wait()时，那它永远就不可能被唤醒了。因为，线程B已经发了通知了，以后不再发通知了。这说明：通知过早，会打乱程序的执行逻辑。