Java Synchronized 块
Synchronized块是用来解决race condition。Synchronized块是基于对象，作用在同一对象的同步快保证在同一时间只有一个线程处理。Synchronized关键字可以作用于一下四种情况：
- 实例方法
- 静态方法
- 实例方法内的代码块
- 静态方法内的代码块
Synchronized Instance Methods
public synchronized void add(int value){
this.count += value;
}
实例方法加synchronized是同步的其拥有该方法的对象。如果有多个实例对象，那么每个对象在同一时间都只能有一个线程执行同步方法。
Synchronized Static Methods
public static synchronized void add(int value){
this.count += value;
}
静态方法加synchronized是同步其拥有该方法的类。由于一个JVM里面只有一个类，所以在同一个类中只能有一个线程执行同步方法。
Synchronized Blocks in Instance Methods
public void add(int value){
synchronized(this){
this.count += value;
}
}
实例方法内的代码块通过指定加锁对象（monitor object）来进行同步。有时候不需要对整个方法加锁，只需要对方法内的一部分加锁，可以使用该方法。
Synchronized Blocks in Static Methods
public class MyClass {
public static synchronized void log1(String msg1, String msg2){
log.writeln(msg1);
log.writeln(msg2);
}
public static void log2(String msg1, String msg2){
synchronized(MyClass.class){
log.writeln(msg1);
log.writeln(msg2);
}
}
}
静态方法内的代码块同步的是拥有该方法的类。在上述例子中，一个线程在同一时刻只能执行一个方法。如果log2同步快内加锁的是不同的类，那么一个线程可以同时执行这两个方法。
Java Volatile关键字
volatile关键字保证变量的可见性
多线程应用在处理非volatile变量的时候，先把变量的值拷贝一份放到cpu cache里面，以此提高效率。
volatile变量保证每次从main memory里面读取变量最新的值，每次修改以后将变量的值更新到main memory里面。Java5以后的volatile关键字提供了Happens Before Guarantee
- 如果线程A写了一个volatile变量，接着线程B读取了同一个volatile变量。那么线程A更新volatile变量之前的所有变量，在线程B读取volatile变量之后，都是可见的。
- 读写volatile变量的操作不能被JVM重新排序，但是volatile变量之前和之后的操作可以被重新排序。
public class Exchanger {
private Object object = null;
private volatile hasNewObject = false;
public void put(Object newObject) {
while(hasNewObject) {
//wait - do not overwrite existing new object
}
object = newObject;
hasNewObject = true; //volatile write
}
public Object take(){
while(!hasNewObject){ //volatile read
//wait - don't take old object (or null)
}
Object obj = object;
hasNewObject = false; //volatile write
return obj;
}
}
可以利用这个特性，不用每个变量都加volatile。上面的例子中，如果只有一个线程执行put()， 另外一个线程执行take()，那么不需要同步块也能保证线程安全。
sharedObject.nonVolatile1 = 123;
sharedObject.nonVolatile2 = 456;
sharedObject.nonVolatile3 = 789;
sharedObject.volatile = true; //a volatile variable
int someValue1 = sharedObject.nonVolatile4;
int someValue2 = sharedObject.nonVolatile5;
int someValue3 = sharedObject.nonVolatile6;
volatile保证了sharreObject.volatile的顺序不被重排，但是前3个变量和后面3个变量的执行顺序可能被JVM重排。
仅仅volatile是不够的
只要一个线程需要先读一个volatile变量，然后在需要在这个变量值的基础之上生成一个新的值，那么volatile变量不再试线程安全的。
当有多个线程对volatile变量进行写操作的时候，就有可能造成race condition。
什么时候volatile变量是可靠的
当一个线程进行volatile变量的读写，另外一个变量只进行volatile变量的读的时候，变量是线程安全的额。
volatile变量的性能
由于volatile变量需要从main memory里面读取数据，多以性能比直接从cpu 缓存中读取数据要高。多以在必要的时候再使用volatile关键字。
ThreadLocal
ThreadLocal类允许生成一个只能被一个线程进行读写的变量。即使两个线程执行同一段代码，两个线程也不能看到对方的ThreadLocal变量
public class ThreadLocalExample {
public static class MyRunnable implements Runnable {
private ThreadLocal<Integer> threadLocal =
new ThreadLocal<Integer>();
@Override
public void run() {
threadLocal.set( (int) (Math.random() * 100D) );
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
}
System.out.println(threadLocal.get());
}
}
public static void main(String[] args) {
MyRunnable sharedRunnableInstance = new MyRunnable();
Thread thread1 = new Thread(sharedRunnableInstance);
Thread thread2 = new Thread(sharedRunnableInstance);
thread1.start();
thread2.start();
thread1.join(); //wait for thread 1 to terminate
thread2.join(); //wait for thread 2 to terminate
}
}
在上面的例子中，虽然是同一个ThreadLocal成员变量，但是两个的值取出来是不相同的。
