线程机制允许同时进行多个活动，因此线程过程中充满了同步和原子操作，以防操作不同步。

1.不同步访问可变数据的后果

同步的意义（synchronized）：

• 一种互斥的方式，即当一个对象被一个线程修改的时候，可以阻止另一个线程观察到对象内部不一致的状态。
• 保证进入同步方法或者同步代码块的每个线程，都看到由同一个锁保护的之前所有的修改成果。
  Java语言规范保证读或者写一个变量是原子的，除非这个变量的类型为long或者double。但是由于JVM的内存模型，往往保存在工作区域的内存值和JVM主存区是不同的。为了在线程之间进行可靠的通信，也为了互斥访问，同步是必要的。

下面的线程属于一个线程阻止另一个线程的的任务，正常情况下，一秒之后线程将结束，然后事实却并非如此，这个程序永远不会停止，后台线程在永远不间断得循环。

public class StopThread {
    private static boolean stopRequested;

    public static void main(String[] args) throws InterruptedException {
        Thread backgroundThread = new Thread(new Runnable() {
            @Override
            public void run() {
                int i = 0;
                while(!stopRequested)
                    i++;
            }
        });
        backgroundThread.start();
        TimeUnit.SECONDS.sleep(1);
        stopRequested = true;
    }
}

问题在于没有同步，就不能保证后台线程何时“看到”主线程对stopRequestd的更新，JVM将会将上述代码优化为这样的代码：

  while(!done)
          i++;

转变成这样：

  if(!done)
      while(true)
            i++;

这是JVM的优化提升，结果就造成了liveness failure。

2.同步方式

方法有多种，volatile、原子操作（例如AtomicInteger等）、synchronized、ThreadLocal。这里注意，volatile修饰的变量，当你使用这个变量进行以本身为基础的变化时，将会导致线程很可能没看见变量的最新状态导致safety-failure。
当多个线程共享可变数据的时候，每个读或者写数据的线程都必须执行同步。未能同步往往造成liveness failure 和 safety failure。
为避免死锁和数据破坏，千万不要从同步区域调用外来方法。

3.Executor和task优先于线程

Java1.5发行版中，Java平台增加了java.util.concurrent，这个包中增加了Executor Framework，这是一个很灵活基于接口的任务执行工具，它创建了一个很好的工作队列，只用一行：

ExecutorService executor = Executors.newSingleThreadExecutor();

下面是为执行提交一个runnable方法：

executor.execute(runnable);

下面是高速executor如何优雅终止（如果做不到，虚拟机可能不会退出）：

executor.shutdown();

根据《Effective Java》，我们应该尽量不要编写自己的工作队列，而且还应该尽量不要直接使用线程。现在关键的抽象不再是Thread了，他以前既充当工作党员又充当执行党员。现在则是已经分开。关键的抽象是工作单元，成为任务（task）。任务有两种Runnable以及近亲Callable（与Runnable相似，当时有返回值），执行任务的通用机制则是executor service。
总而言之，即使用executor来执行任务，在适当的执行策略方面就获得了极大的灵活性，本质上Executor Framework所做的工作是执行，犹如Collections Framework是聚集一样。

public class StopThread {
    private static boolean stopRequested;
    private static AtomicInteger atomicInteger = new AtomicInteger(1);
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        try{
            for(int i=0;i<10;i++)
                executorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread());
                    System.out.println(atomicInteger.incrementAndGet());
                }
            });
        }finally {
            System.out.println("end");
            executorService.shutdown();
        }
        System.out.println("out");
    }
}

输出的结果是：

end
out
Thread[pool-1-thread-1,5,main]
2
Thread[pool-1-thread-1,5,main]
3
Thread[pool-1-thread-1,5,main]
4
Thread[pool-1-thread-1,5,main]
5
Thread[pool-1-thread-1,5,main]
6
Thread[pool-1-thread-1,5,main]
7
Thread[pool-1-thread-1,5,main]
8
Thread[pool-1-thread-1,5,main]
9
Thread[pool-1-thread-1,5,main]
10
Thread[pool-1-thread-1,5,main]
11

确实是想当优雅，而在shutdown执行后如果在加入新的runable，则会抛出异常。

Executor框架图

4.并发工具优先于wait和notify

有了更高级别的并发工具，没必要再使用wait和notify了。

java.util.concurrent中更高级的工具分为三类：Executor Framework、并发集合（Concurrent Collection）以及同步器（Synchronizer）。上节已经提到过Executor Framework，所以本节将介绍另外两者。
并发集合为标准的集合接口（如List、Queue和Map）提供高性能的并发实现。为了提高并发性，这些实现在内部自己管理同步。因此，并发活动不可能排除并发活动；将它所动没有什么作用，只会使程序更慢

同步器是一些使线程能够等待另一个线程的对象，允许它们协调动作，最常用的是CountDownLatch和Semaphore。