多线程读写共享变量时，synchronized与volatile的作用

在《effective java》中看的的知识点，在工作中确实遇到了~

关键字synchronized可以保证在同一时刻，只有一个线程可以执行某一个方法，或者某一个代码块。

同步并不是单单指线程之间的互斥。如果没有同步，一个线程的变化就不能被其他线程看到。同步不仅可以阻止一个线程看到对象处于不一致的状态之中， 它还可以保证进入同步方法或者同步代码块的每个线程，都看到由同一个锁保护的之前的所有修改效果。

思考下面这个程序的运行过程是什么样的。

import java.util.concurrent.TimeUnit;
public class StopThread {
  private static boolean stopRequested;
  public static void main(String[] args) throws InterruptedException {
    Thread backgroundThread =new Thread(new Runnable(){
      public void run() {
        int i=0;
        while(!stopRequested){          
          i++;
        }
      }
    });
    backgroundThread.start();
    TimeUnit.SECONDS.sleep(1);
    stopRequested=true;
  }
}

你可能以为的这个程序大约运行一秒左右，之后主线程将stopRequested设置为true，从而导致后台线程终止。但是结果不是这样的！

问题在于，由于没有同步，就不能保证后台线程何时“看到”主线程对stopRequested的值所做的改变。Java语言规范保证读或写一个变量是原子的（atomic）long和double除外。但是它并不保证一个线程写入的值对于另一个线程将是可见的。

下面看下解决方案

import java.util.concurrent.TimeUnit;
public class StopThread {
  private static boolean stopRequested;
  private static synchronized void requestStop(){
    stopRequested=true;
  }
  private static synchronized boolean stopRequested(){
    return stopRequested;
  }
  public static void main(String[] args) throws InterruptedException {
    Thread backgroundThread =new Thread(new Runnable(){
      public void run() {
        int i=0;
        while(!stopRequested()){          
          i++;
        }
      }
    });
    backgroundThread.start();
    TimeUnit.SECONDS.sleep(1);
    //stopRequested=true;
    requestStop();
  }
}

写入方法（requestStop()）和读取（stopRequest()）方法作 都被同步了 。只同步写方法是不够的，实际上，如果读和写操作没有都被同步，同步就不会起作用。

StopThread中方法的同步是为了它的 通信效果 ，而不是为了互斥访问。一种更加简洁，性能也可能更好的方法是将stopRequested声明为 volatile 。虽然volatile修饰符不执行互斥访问，但 它可以保证任何一个线程在读取该field的时候都将看到最近刚刚被写入的值：

import java.util.concurrent.TimeUnit;
public class StopThread {
  private static volatile boolean stopRequested;
  public static void main(String[] args) throws InterruptedException {
    Thread backgroundThread =new Thread(new Runnable(){
      public void run() {
        int i=0;
        while(!stopRequested){         
          i++;
        }
      }
    });
    backgroundThread.start();
    TimeUnit.SECONDS.sleep(1);
    stopRequested=true;
  }
}

锁提供了两种主要特性：互斥(mutual exclusion) 和可见性(visibility)。互斥即一次只允许一个线程持有某个特定的锁，因此可使用该特性实现对共享数据的协调访问协议，这样，一次就只有一个线程能够使用该共享数据。可见性要更加复杂一些，它必须确保释放锁之前对共享数据做出的更改对于随后获得该锁的另一个线程是可见的 —— 如果没有同步机制提供的这种可见性保证，线程看到的共享变量可能是修改前的值或不一致的值，这将引发许多严重问题。
Volatile 变量具有 synchronized 的可见性特性。这就是说线程能够自动发现 volatile 变量的最新值。

但要始终牢记使用 volatile 的限制 —— 只有在状态真正独立于程序内其他内容时才能使用 volatile —— 这条规则能够避免将这些模式扩展到不安全的用例。

如果严格遵循 volatile 的使用条件 —— 即变量真正独立于其他变量和自己以前的值 —— 在某些情况下可以使用 volatile 代替 synchronized 来简化代码

在多线程场景中，如果需要使用标记的时候，volatile往往可以大显身手~