3. Java多线程同步

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变量读取方法

多线程应用在处理非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变量的性能

由于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成员变量，但是两个的值取出来是不相同的。