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

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

keywordsynchronized能够保证在同一时刻，仅仅有一个线程能够运行某一个方法，或者某一个代码块。

同步并非单单指线程之间的相互排斥。

假设没有同步，一个线程的变化就不能被其它线程看到。

同步不仅能够阻止一个线程看到对象处于不一致的状态之中， 它还能够保证进入同步方法或者同步代码块的每一个线程，都看到由同一个锁保护的之前的全部改动效果。

思考以下这个程序的执行过程是什么样的。

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往往能够大显身手~