Synchronization
Threads communicate primarily by sharing access to fields and the objects reference fields refer to. This form of communication is extremely efficient, but makes two kinds of errors possible: thread interference and memory consistency errors. The tool needed to prevent these errors is synchronization.
- Thread Interference describes how errors are introduced when multiple threads access shared data.
- Memory Consistency Errors describes errors that result from inconsistent views of shared memory.
- Synchronized Methods describes a simple idiom that can effectively prevent thread interference and memory consistency errors.
- Implicit Locks and Synchronization describes a more general synchronization idiom, and describes how synchronization is based on implicit locks.
- Atomic Access talks about the general idea of operations that can't be interfered with by other threads.
译文：
同步
线程间的通信主要是依靠共享域和引用相同的对象。这种通信是非常高效的，但是会出现两种错误：线程冲突和访问相同内存的错误。能够阻止这些错误的工具是Synchronization.
- 线程冲突 描述当多线程访问相同的数据时会出现的错误
- 访问相同内存错误 共享内存引起的不一致结果的错误
- 同步方法 能够有效的阻止线程冲突和访问相同内存错误的问题
- 隐式锁和同步 描述了更多的同步方法，以及同步方法如何基于隐式锁实现
- 原子性 描述了操作不能被其他线程所干扰的性质
Thread Interference
Consider a simple class called Counter
class Counter {
private int c = 0;
public void increment() {
c++;
}
public void decrement() {
c--;
}
public int value() {
return c;
}
}
Counter is designed so that each invocation of increment will add 1 to c, and each invocation of decrement will subtract 1 from c. However, if a Counter object is referenced from multiple threads, interference between threads may prevent this from happening as expected.
Interference happens when two operations, running in different threads, but acting on the same data, interleave. This means that the two operations consist of multiple steps, and the sequences of steps overlap.
It might not seem possible for operations on instances of Counter to interleave, since both operations on c are single, simple statements. However, even simple statements can translate to multiple steps by the virtual machine. We won't examine the specific steps the virtual machine takes — it is enough to know that the single expression c++ can be decomposed into three steps:
- Retrieve the current value of
c. - Increment the retrieved value by 1.
- Store the incremented value back in
c.
The expression c-- can be decomposed the same way, except that the second step decrements instead of increments.
Suppose Thread A invokes increment at about the same time Thread B invokes decrement. If the initial value of c is 0, their interleaved actions might follow this sequence:
- Thread A: Retrieve c.
- Thread B: Retrieve c.
- Thread A: Increment retrieved value; result is 1.
- Thread B: Decrement retrieved value; result is -1.
- Thread A: Store result in c; c is now 1.
- Thread B: Store result in c; c is now -1.
Thread A's result is lost, overwritten by Thread B. This particular interleaving is only one possibility. Under different circumstances it might be Thread B's result that gets lost, or there could be no error at all. Because they are unpredictable, thread interference bugs can be difficult to detect and fix.
1 class Counter { 2 private int c = 0; 3 4 public void increment() { 5 c++; 6 } 7 8 public void decrement() { 9 c--; 10 } 11 12 public int value() { 13 return c; 14 } 15 16 }
Counter类被设计成为，每次调用increment方法的时候，使c增加1；每次调用decrement方法的时候，使c减去1.但是，如果Counter对象被多线程引用了，那么线程间的冲突可能阻止这种期待的方法执行。
当两个操作，运行在不同的线程中，但是访问相同的代码，交叉运行，那么就会发生线程冲突。这意味着这两个操作有很多步骤，并且这些步骤中有重叠的地方。由于两个操作操作c的语句都是简单的单语句，这似乎不太可能引起Counter实例在执行过程中的交叉。然而，即使是简单的步骤也会被虚拟机转换为复杂的步骤。我们不太可能检查虚拟机指定的步骤，但是C++可以被分解为三个步骤：
1.获得当前c的值
2.对当前的值加1
3.将增加后的值赋给原来的c
对于c--可以分解为相同的步骤，除了第二步的操作是做减操作外。
假设线程A执行加操作同时线程B执行减操作。如果c的初始值为0，那么执行的序列如下：
1.线程A:获取c
2.线程B:获取c
3.线程A:增加获得的值，结果为1
4.线程B:减少获得的值，结果为-1
5.线程A:存储结果到c,c现在是1
6.线程A:存储结果到c,c现在是-1
线程A的结果丢失了，被线程B的结果重写了。这种实际的交叉是其中的一种可能。在不同的环境中，可能是线程B的值丢失，也可能不会出现问题。由于这种问题是不可预知的，因此线程冲突的bug是很难察觉和修复的。
养眼是必须滴^^
