并发机制：

• 内存共享: Java, C#, Pthread, win32
• 消息传递：JVM:Scale, Google:Go, Ericsson:Erlang

特点：

• 内存共享：显示同步，隐式通信
• 消息传递：显示通信，隐式同步

Java并发＝显示同步＋隐式通信

Java并发处理对象（Shared+Mutable对象）：

• 共享变量（需要处理）：实例域，静态域，数组元素
• 局部变量（不需处理）：局部变量，方法定义参数，异常处理参数

还有一个危险来源于64位类型long和double的非原子操作。

并发编程面对的问题：

• visibility
• ordering
• atomicity

指令重排序 Reordering

为了提高指令处理效率，存在以下三个级别的指令重排序：

• 编译器级(软): just-in-time compiler and bytecode compiler
• 指令级并行级(硬): Processer
• 内存系统级(硬): memory hierarchy

重排序的首要条件：保证数据依赖关系。

硬件(CPU)重排序类型，第一种所有平台都支持，后三种选择性支持：

• 写读(都支持)
• 写写
• 读写
• 读读

为了在硬件重排序的情况下也能保证内存可见性，需要在两个指令中间插入内存屏障指令。 内存屏障指令会保证第一个操作的对象写到主存，并把其它线程中引用该对象的内存设为失效。

Java简单内存模型

Java Memory Model(JMM)

synchronized 内置锁/监视器锁

• 锁保护的代码块
• 锁的对象：方法所在的this对象（一般方法）或Class对象（静态方法）

对象内置锁称为Monitor，每个对象一个。

Java获取锁的操作的粒度是线程，而不是调用。 就是说同时只能有一个线程进入同一个锁，其它想获得此锁的线程会阻塞。 并且这个线程对于此锁是可重入的，便于支持锁方法的继承。 每个锁记录了获取次数和一个所有者线程。

之所以每个对象都有一个内置锁，只是为了免去显示创建锁对象。 常见的加锁策略是把所有可变状态封装到对象内部，利用内置锁对访问这些可变状态的线程进行同步。

通过显示地加synchronized锁，JMM会隐式通过通信机制保证：

• 释放锁时，临界区的共享变量从本底内存同步到主内存
• 获取锁时，临接区的共享变量被置为无效，即再从主内存同步到本底内存

synchronized会引起上下文线程切换(?)。

key ideas about synchronized:

• Conflicting Access: at least one of accesses is a write
• Happen-Before Relationship: If one action happen before another, then the first is visible to and ordered before the second.Including:
  • Each action in a thread happens before every subsequent action in that thread.
  • An unlock on a monitor happens before every subsequent lock on that monitor.
  • A write to a volatile field happens before every subsequent read of that volatile.
  • A call to start() on a thread happens before any actions in the started thread.
  • All actions in a thread happen before any other thread successfully returns from a join() on that thread.
  • If an action a happens before an action b, and b happens before an action c, then a happens before c.

volatile

volatile是轻量级同步机制，也是由JMM隐式通信机制保证。 访问volatile变量时不会执行加锁操作，因此也就不会使执行线程阻塞。

• volatile变量写时：从本地内存同步到主内存，标记其它线程变量失效
• volatile变量读时：如果失效，从主内存同步到本地内存

volatile防止了指令重排序。

volatile常用于某个操作完成，发生中断或状态的标志。 但是volatile变量只能保证可见性，不能保证原子性。 如volatile的count++的原子性就不能保证。

final

除了final限制了成员的不变性之外， final成员和普通成员的区别是：final成员必需在新对象构造函数中赋值完成。

需要这点保证的直接原因是新对象的引用和初使化（构造函数）指令可能会重排序。 也就是说可能新对象的引用先被赋于某个变量，然后再使用构造函数初使化新对象成员， 直到第一次使用新对象成员之前完成即可。 这种情况在Java和CPP中都存在。 这样如果令一个线程在构造函数完成之前访问新对象的成员，就会是一个无效值。

因此，final成员在初次获得对象的引用之后（也就是构造函数完成之后），就保证了能在令一个线程正确读取到final值。这两个顺序是有保证的。

Reference

• JLS Chapter 17
• JSR 133