线程安全的定义

《Java Concurrency In Practice》的作者Brian Goetz 对线程安全是这样理解的，当多个线程访问一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行问题，也不需要 进行额外的同步，而调用这个对象的行为都可以获取 正确的结果，那这个对象便是线程安全的。

事实上 Brian Goetz 想表达的意思是 如果某个对象是线程安全的，那么对于使用者来说 ，在使用时就不需要考虑方法间的协调问题，比如说 不需要考虑不能同时写入或者写不能并行的问题，也不需要考虑额外的同步问题，比如不需要额外自己加 synchronized锁
那么它才是线程安全的 可以看出对线程安全的定义还是非常苛刻的

3种典型的线程安全问题

运行结果错误

多个线程操作同一个变量导致的运行结果错误

  1. public class WrongResult {
  3.    volatile static int i;
  5.    public static void main(String[] args) throws InterruptedException {
  6.        Runnable r = new Runnable() {
  7.            @Override
  8.            public void run() {
  9.                for (int j = 0; j < 10000; j++) {
  10.                    i++;
  11.                }
  12.            }
  13.        };
  14.        Thread thread1 = new Thread(r);
  15.        thread1.start();
  16.        Thread thread2 = new Thread(r);
  17.        thread2.start();
  18.        thread1.join();
  19.        thread2.join();
  20.        System.out.println(i);
  21.     }
  22. }

显然 成员变量i 的值在多个线程赋值的时候 会有问题

发布和初始化导致线程安全问题；

我们创建对象进行发布和初始化供其他类或对象使用是常见的操作，但如果我们操作的时间或地点不对 ，就有可能导致线程问题

  1. public class WrongInit {
  3.     private Map<Integer, String> students;
  5.     public WrongInit() {
  6.         new Thread(new Runnable() {
  7.             @Override
  8.             public void run() {
  9.                 students = new HashMap<>();
  10.                 students.put(1, "王小美");
  11.                 students.put(2, "钱二宝");
  12.                 students.put(3, "周三");
  13.                 students.put(4, "赵四");
  14.             }
  15.         }).start();
  16.      }
  18.     public Map<Integer, String> getStudents() {
  19.         return students;
  20.     }
  22.     public static void main(String[] args) throws InterruptedException {
  23.         WrongInit multiThreadsError6 = new WrongInit();
  24.         System.out.println(multiThreadsError6.getStudents().get(1));
  26.     }
  27. }

先说结果 会报空指针异常

  1. Exception in thread "main" java.lang.NullPointerException
  2. at lesson6.WrongInit.main(WrongInit.java:32)

原因在于 students这个成员变量在构造函数中新建的线程中进行初始化和赋值操作，而线程的启动需要一定的时间，但我们的main并没有sleep 就直接获取数据，此时 students为null。

活跃性问题

活跃性问题 典型的有三种

死锁

死锁是指2个线程之间互相等待对方资源，但同时又互不相让，都想自己先执行

  1.  public class MayDeadLock {
  3.     Object o1 = new Object();
  4.     Object o2 = new Object();
  6.     public void thread1() throws InterruptedException {
  7.         synchronized (o1) {
  8.             Thread.sleep(500);
  9.             synchronized (o2) {
  10.                 System.out.println("线程1成功拿到两把锁");
  11.            }
  12.         }
  13.     }
  15.     public void thread2() throws InterruptedException {
  16.         synchronized (o2) {
  17.             Thread.sleep(500);
  18.             synchronized (o1) {
  19.                 System.out.println("线程2成功拿到两把锁");
  20.             }
  21.         }
  22.     }
  24.     public static void main(String[] args) {
  25.         MayDeadLock mayDeadLock = new MayDeadLock();
  26.         new Thread(new Runnable() {
  27.             @Override
  28.             public void run() {
  29.                 try {
  30.                     mayDeadLock.thread1();
  31.                 } catch (InterruptedException e) {
  32.                     e.printStackTrace();
  33.                 }
  34.             }
  35.         }).start();
  36.         new Thread(new Runnable() {
  37.             @Override
  38.             public void run() {
  39.                 try {
  40.                     mayDeadLock.thread2();
  41.                 } catch (InterruptedException e) {
  42.                     e.printStackTrace();
  43.                 }
  44.             }
  45.         }).start();
  46.     }
  47. }

首先，代码中创建了两个 Object 作为 synchronized 锁的对象，线程 1 先获取 o1 锁，sleep(500) 之后，获取 o2 锁；线程 2 与线程 1 执行顺序相反，先获取 o2 锁，sleep(500) 之后，获取 o1 锁。 假设两个线程几乎同时进入休息，休息完后，线程 1 想获取 o2 锁，线程 2 想获取 o1 锁，这时便发生了死锁，两个线程不主动调和，也不主动退出，就这样死死地等待对方先释放资源，导致程序得不到任何结果也不能停止运行。

活锁

第二种活跃性问题是活锁，活锁与死锁非常相似，也是程序一直等不到结果，但对比于死锁，活锁是活的，什么意思呢？因为正在运行的线程并没有阻塞，它始终在运行中，却一直得不到结果。

举一个例子，假设有一个消息队列，队列里放着各种各样需要被处理的消息，而某个消息由于自身被写错了导致不能被正确处理，执行时会报错，可是队列的重试机制会重新把它放在队列头进行优先重试处理，但这个消息本身无论被执行多少次，都无法被正确处理，每次报错后又会被放到队列头进行重试，周而复始，最终导致线程一直处于忙碌状态，但程序始终得不到结果，便发生了活锁问题。

饥饿

第三个典型的活跃性问题是饥饿，饥饿是指线程需要某些资源时始终得不到，尤其是CPU 资源，就会导致线程一直不能运行而产生的问题。在 Java 中有线程优先级的概念，Java 中优先级分为 1 到 10，1 最低，10 最高。如果我们把某个线程的优先级设置为 1，这是最低的优先级，在这种情况下，这个线程就有可能始终分配不到 CPU 资源，而导致长时间无法运行。或者是某个线程始终持有某个文件的锁，而其他线程想要修改文件就必须先获取锁，这样想要修改文件的线程就会陷入饥饿，长时间不能运行。