JAVA multithreading and concurrency learning summary

Reprinted from http://www.cnblogs.com/yshb/archive/2012/06/15/2550367.html

2. JAVA memory model

The goal is to define access rules for individual variables in the program. (including instance fields, static fields, and elements that make up arrays, excluding local variables and method parameters)

1. All variables are stored in main memory (part of virtual machine memory).
2. Each thread has its own working memory. The working memory of the thread saves a copy of the main memory of the variables used by the thread. All operations on the variables by the thread must be performed in the working memory, and cannot directly read and write the main memory. variables in .
3. Threads cannot directly access variables in each other's working memory, and the transfer of variables between threads needs to be done through the main memory.

 

Interaction between memory :

Lock (lock): acting on variables in main memory, marking a variable as the exclusive state of a thread .

Read: Acts on variables in main memory, transferring the value of a variable from main memory to the thread's working memory.

Load: Acts on the variables in the working memory, and puts the value of the variable obtained from the main memory by the read operation into the variable copy of the working memory.

Use: Act on variables in working memory and pass the value of a variable in working memory to the execution engine.

Assign (assignment): Acts on a variable in working memory, assigning a value received from the execution engine to a variable in working memory.

Store: Acts on variables in working memory and transfers the value of a variable in working memory to main memory.

Write (Write): Act on the variables in the main memory, and put the value of the variable obtained from the working memory by the store operation into the variable in the main memory.

Unlock: Acts on variables in main memory to release a variable in a locked state, which can then be locked by other threads.

 

Rules :

1. One of the read and load, store and write operations alone is not allowed.
2. A thread is not allowed to discard the most recent assign operation, after a variable has changed in working memory it must synchronize the change back to main memory.
3. A thread is not allowed to synchronize data from the thread's working memory back to main memory without any assign operations.
4. A new variable can only be created in main memory.
5. A variable only allows one thread to lock it at the same time, but it can be executed multiple times by the same thread.
6. If the lock operation is performed on a variable, the value of the variable in the working memory will be cleared. Before the execution engine uses the variable, the read and load operations need to be re-executed.
7. If a variable is not previously locked by a lock operation, the unlock operation is not allowed on it.
8. 8.      Before performing the unlock operation on a variable, the variable must be synchronized back to main memory.

 

3. volatile variables

1. Guarantees visibility of this variable to all threads . Before each thread uses this type of variable, it needs to be refreshed first, and the execution engine cannot see the inconsistency.

The result of the operation does not depend on the current value of the variable, or ensures that only a single thread modifies the value of the variable.

Variables do not need to participate in invariant constraints with other state variables.

1. Disable instruction reordering optimizations . Ordinary variables only guarantee that the correct result can be obtained in all places that depend on the result of the assignment during the execution of the method. There is no guarantee that the order of assignment operations is the same as the order in the program code.
2. load must appear at the same time as use; assign and store must appear at the same time.

 

4. Atomicity, Visibility, and Order

Atomicity : The access read and write of basic data types are atomic, and the operations between synchronized blocks are also atomic.

可见性：指当一个线程修改了共享变量的值，其他线程能够立即得知这个修改。synchronized(规则8)和final可以保证可见性。Final修饰的字段在构造器中一旦被初始化完成，并且构造器没有把this的引用传递出去，那么在其他线程中就能看见final字段的值。

有序性：volatile本身包含了禁止指令重排序的语义，而synchronized则是由规则5获得的，这个规则决定了持有同一个所的两个同步块只能串行地进入。

 

5.      先行发生原则

Java内存模型中定义的两项操作之间的偏序关系，如果操作A先行发生于操作B，其实就是说在发生操作B之前，操作A产生的影响能被操作B观察到。

程序次序规则：在一个线程内，按照代码控制流顺序，在前面的操作先行发生于后面的操作。

管程锁定规则：一个unlock操作先行发生于后面对同一个锁的lock操作。

Volatile变量规则：对一个volatile变量的写操作先行发生于后面对这个变量的读操作。

线程启动规则：Thread对象的start()方法先行发生于此线程的每个操作。

线程终止规则：线程中的所有操作都先行发生于对此线程的终止检测。

线程中断规则：对线程的interrupt()方法的调用先行发生于被中断线程的代码检测中断事件的发生。

对象终结过则：一个对象的初始化完成先行发生于它的finalize()方法的开始。

传递性：如果操作A先行发生于操作B，操作B现象发生于操作C，那么就可以得出操作A先行发生于操作C的结论。

 

时间上的先后顺序与先行发生原则之间基本上没有太大的关系。

 

6.      线程实现

使用内核线程实现：

       内核线程Kernel Thread：直接由操作系统内核支持的线程，这种线程由内核类完成线程切换，内核通过操纵调度器对线程进行调度，并负责将线程的任务映射到各个处理器上。

       轻量级进程Light Weight Process：每个轻量级进程都由一个内核线程支持。

       局限性：各种进程操作都需要进行系统调用(系统调用代价相对较高，需要在用户态和内核态中来回切换)；轻量级进程要消耗一定的内核资源，一次一个系统支持轻量级进程的数量是有限的。

 

使用用户线程实现：

       用户线程：完全建立在用户空间的线程库上，系统内核不能直接感知到线程存在的实现。用户线程的建立、同步、销毁和调度完全在用户态中完成，不需要内核的帮助。所有的线程操作都需要用户程序自己处理。

混合实现：

       将内核线程和用户线程一起使用的方式。操作系统提供支持的轻量级进程则作为用户线程和内核线程之间的桥梁。

 

Sun JDK，它的Windows版和Linux版都是使用一对一的线程模型来实现的，一条Java线程映射到一条轻量级进程之中。

 

7.      线程调度

线程调度是指系统为线程分配处理器使用权的过程：协同式、抢占式。

协同式：线程的执行时间由线程本身控制，线程把自己的工作执行完了之后，要主动通知系统切换到另一个线程上。坏处：线程执行时间不可控制。

抢占式：每个线程将由系统来分配执行时间，线程的切换不由线程本身来决定。Java使用该种调用方式。

线程优先级：在一些平台上(操作系统线程优先级比Java线程优先级少)不同的优先级实际会变得相同；优先级可能会被系统自行改变。

 

8.      线程状态

线程状态：

新建NEW：

运行RUNNABLE：

无限期等待WAITING：等得其他线程显式地唤醒。

       没有设置Timeout参数的Object.wait()；没有设置Timeout参数的Thread.wait()。

限期等待TIMED_WAITING：在一定时间之后会由系统自动唤醒。

       设置Timeout参数的Object.wait()；设置Timeout参数的Thread.wait()；Thread.sleep()方法。

阻塞BLOCKED：等待获取一个排它锁，等待进入一个同步区域。

结束TERMINATED：

 

9.      线程安全

线程安全：当多个线程访问一个对象时，如果不用考虑这些线程在运行时环境下的调度和交换执行，也不需要进行额外的同步，或者调用方进行任何其他的协调操作，调用这个对象的行为都可以获得正确的结果，那这个对象就是线程安全的。

 

不可变：只要一个不可变的对象被正确地构建出来。使用final关键字修饰的基本数据类型；如果共享数据是一个对象，那就需要保证对象的行为不会对其状态产生任何影响(String类的对象)。方法：把对象中带有状态的变量都申明为final，如Integer类。有：枚举类型、Number的部分子类(AtomicInteger和AtomicLong除外)。

绝对线程安全：

相对线程安全：对这个对象单独的操作是线程安全的。一般意义上的线程安全。

线程兼容：需要通过调用端正确地使用同步手段来保证对象在并发环境中安全地使用。

线程对立：不管调用端是否采取了同步措施，都无法在多线程环境中并发使用的代码。有：System.setIn()、System.setOut()、System.runFinalizersOnExit()

 

10.    线程安全的实现方法

1. 1.     互斥同步：同步是指在多个线程并发访问共享数据时，保证共享数据在同一个时刻只被一条线程使用。互斥方式：临界区、互斥量和信号量。

Synchronized关键字：编译后会在同步块前后分别形成monitorenter和monitorexit这两个字节码指令。这两个指令都需要一个引用类型的参数来指明要锁定和解锁的对象。如果没有明确指定对象参数，那就根据synchronized修饰的是实例方法还是类方法，去取对应的对象实例或Class对象来作为锁对象。

在执行monitorenter指令时，首先尝试获取对象的锁，如果没有被锁定或者当前线程已经拥有了该对象的锁，则将锁计数器加1，相应的执行moniterexit时，将锁计数器减1，当计数器为0时，锁就被释放了。如果获取对象锁失败，则当前线程就要阻塞等待。

 

ReentrantLock相对synchronized的高级功能：

等待可中断：当持有锁的线程长期不释放锁时，正在等待的线程可以选择放弃等待，改为处理其他事情。

公平锁：多个线程在等待同一个锁时，必须按照申请锁的事件顺序来一次获取锁；而非公平锁在被释放时，任何一个等待锁的线程都有机会获得锁。Synchronized中的锁是非公平锁，ReentrantLock默认也是非公平锁。

锁绑定多个条件：一个ReentrantLock对象可以同时绑定多个Condition对象。

 

1. 2.     非阻塞同步：

基于冲突检测的乐观并发策略：先进行操作，如果没有其他线程争用共享数据，那操作就成功了；如果共享数据有争用，产生了冲突，那就再进行其他的补偿措施(一般是不断的尝试，直到成功为止)。

AtomicInteger等原子类中提供了方法实现了CAS指令。

 

1. 3.     无同步方案：

可重入代码：可以在代码执行的任何时刻中断它，转而去执行另一段代码，而在控制权返回后，原来的程序不会出现任何错误。特征：不依赖存储在堆上的数据和公用的系统资源、用到的状态量都由参数传入，不调用非可重入的方法等。如果一个方法，它的返回结果是可以预测的，只要出入了相同的数据，就能返回相同的结果，那它就满足可重入性的要求。

线程本地存储：如果一段代码中所需要的数据必须与其它代码共享，那就看看这些共享数据的代码是否能保证在同一个线程中执行。

A.      ThreadLocal类

ThreadLocal：线程级别的局部变量，为每个使用该变量的线程提供一个独立的变量副本，每个线程修改副本时不影响其他线程对象的副本。ThreadLocal实例通常作为静态私有字段出现在一个类中。

 

11.    锁优化

1. 1.     自旋锁

为了让线程等待，让线程执行一个忙循环(自旋)。需要物理机器有一个以上的处理器。自旋等待虽然避免了线程切换的开销，带它是要占用处理器时间的，所以如果锁被占用的时间很短，自旋等待的效果就会非常好，反之自旋的线程只会白白消耗处理器资源。自旋次数的默认值是10次，可以使用参数-XX:PreBlockSpin来更改。

自适应自旋锁：自旋的时间不再固定，而是由前一次在同一个锁上的自旋时间及锁的拥有者的状态来决定。

 

1. 2.     锁清除

指虚拟机即时编译器在运行时，对一些代码上要求同步，但是被检测到不可能存在共享数据竞争的锁进行清除(逃逸分析技术：在堆上的所有数据都不会逃逸出去被其它线程访问到，可以把它们当成栈上数据对待)。

 

1. 3.     锁粗化

如果虚拟机探测到有一串零碎的操作都对同一个对象加锁，将会把加锁同步的范围扩展到整个操作序列的外部。

 

 

HotSpot虚拟机的对象的内存布局：对象头(Object Header)分为两部分信息吗，第一部分(Mark Word)用于存储对象自身的运行时数据，另一个部分用于存储指向方法区对象数据类型的指针，如果是数组的话，还会由一个额外的部分用于存储数组的长度。

32位HotSpot虚拟机中对象未被锁定的状态下，Mark Word的32个Bits空间中25位用于存储对象哈希码，4位存储对象分代年龄，2位存储锁标志位，1位固定为0。

HotSpot虚拟机对象头Mark Word

存储内容	标志位	状态
对象哈希码、对象分代年龄	01	未锁定
指向锁记录的指针	00	轻量级锁定
指向重量级锁的指针	10	膨胀(重量级锁)
空，不记录信息	11	GC标记
偏向线程ID，偏向时间戳、对象分代年龄	01	可偏向

 

1. 4.     轻量级锁

在代码进入同步块时，如果此同步对象没有被锁定，虚拟机首先将在当前线程的栈帧中建立一个名为锁记录(Lock Record)的空间，用于存储所对象目前的Mark Word的拷贝。然后虚拟机将使用CAS操作尝试将对象的Mark Word更新为执行Lock Record的指针。如果成功，那么这个线程就拥有了该对象的锁。如果更新操作失败，虚拟机首先会检查对象的Mark Word是否指向当前线程的栈帧，如果是就说明当前线程已经拥有了这个对象的锁，否则说明这个对象已经被其它线程抢占。如果有两条以上的线程争用同一个锁，那轻量级锁就不再有效，要膨胀为重量级锁。

解锁过程：如果对象的Mark Word仍然指向着线程的锁记录，那就用CAS操作把对象当前的Mark Word和和线程中复制的Displaced Mark Word替换回来，如果替换成功，整个过程就完成。如果失败，说明有其他线程尝试过获取该锁，那就要在释放锁的同时，唤醒被挂起的线程。

轻量级锁的依据：对于绝大部分的锁，在整个同步周期内都是不存在竞争的。

传统锁(重量级锁)使用操作系统互斥量来实现的。

 

1. 5.     偏向锁

目的是消除在无竞争情况下的同步原语，进一步提高程序的运行性能。锁会偏向第一个获得它的线程，如果在接下来的执行过程中，该锁没有被其它线程获取，则持有锁的线程将永远不需要再进行同步。

当锁第一次被线程获取的时候，虚拟机将会把对象头中的标志位设为01，同时使用CAS操作把获取到这个锁的线程的ID记录在对象的Mark Word之中，如果成功，持有偏向锁的线程以后每次进入这个锁相关的同步块时，都可以不进行任何同步操作。

当有另一个线程去尝试获取这个锁时，偏向模式就宣告结束。根据所对象目前是否处于被锁定的状态，撤销偏向后恢复到未锁定或轻量级锁定状态。

 

 

 

12.    内核态和用户态

操作系统的两种运行级别，intel cpu提供-Ring3三种运行模式。

Ring0是留给操作系统代码，设备驱动程序代码使用的，它们工作于系统核心态；而Ring3则给普通的用户程序使用，它们工作在用户态。运行于处理器核心态的代码不受任何的限制，可以自由地访问任何有效地址，进行直接端口访问。而运行于用户态的代码则要受到处理器的诸多检查，它们只能访问映射其地址空间的页表项中规定的在用户态下可访问页面的虚拟地址，且只能对任务状态段（TSS）中I/O许可位图（I/O Permission Bitmap）中规定的可访问端口进行直接访问。

 

13.    常用方法

 

1. 1.     object.wait()：

在其他线程调用此对象的notify()或者notifyAll()方法，或超过指定时间量前，当前线程T等待(线程T必须拥有该对象的锁)。线程T被放置在该对象的休息区中，并释放锁。在被唤醒、中断、超时的情况下，从对象的休息区中删除线程T，并重新进行线程调度。一旦线程T获得该对象的锁，该对象上的所有同步申明都被恢复到调用wait()方法时的状态，然后线程T从wait()方法返回。如果当前线程在等待之前或在等待时被任何线程中断，则会抛出 InterruptedException。在按上述形式恢复此对象的锁定状态时才会抛出此异常。在抛出此异常时，当前线程的中断状态被清除。

只有该对象的锁被释放，并不会释放当前线程持有的其他同步资源。

 

1. 2.     object.notify()

唤醒在此对象锁上等待的单个线程。此方法只能由拥有该对象锁的线程来调用。

 

1. 3.     Thread.sleep()

在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。监控状态依然保持、会自动恢复到可运行状态，不会释放对象锁。如果任何线程中断了当前线程。当抛出InterruptedException异常时，当前线程的中断状态被清除。让出CPU分配的执行时间。

 

thread.join()：在一个线程对象上调用，使当前线程等待这个线程对象对应的线程结束。

Thread.yield()：暂停当前正在执行的线程对象，并执行其他线程。

thread.interrupt()

       中断线程，停止其正在进行的一切。中断一个不处于活动状态的线程不会有任何作用。

      如果线程在调用Object类的wait()方法、或者join()、sleep()方法过程中受阻，则其中断状态将被清除，并收到一个InterruptedException。

Thread.interrupted()：检测当前线程是否已经中断，并且清除线程的中断状态(回到非中断状态)。

thread.isAlive()：如果线程已经启动且尚未终止，则为活动状态。

thread.setDaemon()：需要在start()方法调用之前调用。当正在运行的线程都是后台线程时，Java虚拟机将退出。否则当主线程退出时，其他线程仍然会继续执行。

 

14.    其他

1. 当调用Object的wait()、notify()、notifyAll()时，如果当前线程没有获得该对象锁，则会抛出IllegalMonitorStateException异常。

 

1. 如果一个方法申明为synchronized，则等同于在这个方法上调用synchronized(this)。

如果一个静态方法被申明为synchronized，则等同于在这个方法上调用synchronized(类.class)。当一个线程进入同步静态方法中时，其他线程不能进入这个类的任何静态同步方法。

 

 

1. 线程成为对象锁的拥有者：
   1. 通过执行此对象的同步实例方法
   2. 通过执行在此对象上进行同步的synchronized语句的正文
   3. 对于Class类型的对象，可以通过执行该类的同步静态方法。

 

1. 死锁：

死锁就是两个或两个以上的线程被无限的阻塞，线程之间相互等待所需资源。

可能发生在以下情况：

        当两个线程相互调用Thread.join()；

        当两个线程使用嵌套的同步块，一个线程占用了另外一个线程必须的锁，互相等待时被阻塞就有可能出现死锁。

 

1. 调用了Thread类的start()方法(向CPU申请另一个线程空间来执行run()方法里的代码)，线程的run()方法不一定立即执行，而是要等待JVM进行调度。

run()方法中包含的是线程的主体，也就是这个线程被启动后将要运行的代码。