线程安全问题

我们先了解 Java 的内存模型，搞清楚线程的工作流程。
Java 内存模型 - JMM
JMM是一种基于计算机内存模型（定义了共享内存系统中多线程程序读写操作行为的规范），JMM作用于JVM和底层硬件之间，屏蔽了下游不同硬件模型带来的差异，为上游开发者提供了统一的使用接口,保证了Java程序在各种平台下对内存的访问都能保证效果一致的机制及规范。JMM是一个抽象的概念，并不是物理上的内存划分。
Java内存模型（JMM）定义了Java虚拟机（JVM）在计算机内存（RAM）中的工作规范。在硬件内存模型中，各种CPU架构的实现是不尽相同的，Java作为跨平台的语言，为了屏蔽底层硬件差异，定义了Java内存模型（JMM）。
JMM是JVM的内存使用规范，是一个抽象的概念。
　　　　　　　A线程　　　　　　　　　　　　　B线程
　　　　　　线程操作　　　　　　　　　　　　线程操作
　　　写　↓　　　　　读　↑　　　　　　　写　↓　　　　读　↑
　线程工作内存　　　变量副本　　　线程工作内存　　　变量副本
　—————————————　　　 ——————————————
　　　　　　　　↖—————读或写—————↗
　　　　　　　　　　　　　　　↓
　　　　　　　　　　　　　　JMM
　　　　　　　　　　　　　　　↑
　　　　　　　　　　　ｒｅａｄ＆ｓｙｎｃ
　　　　　　　　　　　　　　　↓
　　　主内存　　　　　　　　变量
上图概述：
两条线程分别对主内存的变量进行读写。主内存中的变量是共享变量,两条线程共享。但是线程不能直接读写主内存的变量，每个线程都有属于本线程的工作内存。
线程读写主内存的变量：先将该变量拷贝一份副本到自己的工作内存，然后本线程内的工作内存中对其变量进行操作，线程工作内存对拷贝的变量完成操作之后将结果同步至主内存，从以完成对变量的读写。
线程对变量赋值流程：
　　　线程工作内存　　　　　　　　　　　　主内存
　　　　　｜　　　　　　ｃｏｐｙ　　　　　　｜　　　
　　　　ｘ=０　　　　　　←——　　　　　　ｘ=０　　
　　　　　↓ｘ＋＋　　　　　　　　　　　　　　
　　　　ｘ=１　　　　　　——→　　　　　　ｘ=１
　　　　　　　　　　　　ｗｒｉｔｅ　　　　　
　　　　　
因为是共享变量，所有线程都可以对其操作，线程工作内存又是线程私有的，线程间也不可相互访问。在多线程情况下，多条线程同时操作共享变量，变量数据就会被破坏，所以主内存内的变量不是线程安全的。

代码举例:

public class Dome {
    public static void main(String[] args) {
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
    }
    static class Ticket implements Runnable{
        //票数
        private int count = 5;
        @Override
        public void run() {
            //票数到0 停止循环
            while(count>0){
                //卖票
                System.out.println("正在准备卖票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println("出票成功，余票为："+count);
            }
        }
    }
}
运行结果：
正在准备卖票
正在准备卖票
出票成功，余票为：4
正在准备卖票
出票成功，余票为：3
正在准备卖票
出票成功，余票为：2
正在准备卖票
出票成功，余票为：2
正在准备卖票
出票成功，余票为：1
正在准备卖票
出票成功，余票为：1
正在准备卖票
出票成功，余票为：0
出票成功，余票为：-1

以上代码单看逻辑，票数大于0的时候才会进入循环，不会出现负数，因为多个线程同时执行，争抢一个数据。在循环判断和循环内部数据操作之间被其他线程操作，导致运行结果不符合预期。

解决方案1：同步代码块

public class Dome {
    public static void main(String[] args) {
        //格式：synchronized(锁对象){}
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable {
        //票数
        private int count = 5;
        private Object o = new Object();

        @Override
        public void run() {

            //票数到0 停止循环
            while (count > 0) {
                synchronized (o) {
                    if (count > 0) {
                        //卖票
                        System.out.println("正在准备卖票");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        count--;
                        System.out.println(Thread.currentThread().getName() + "出票成功，余票为：" + count);
                    }else {
                        break;
                    }
                }
            }
        }
    }
}
运行结果：
正在准备卖票
Thread-0出票成功，余票为：4
正在准备卖票
Thread-0出票成功，余票为：3
正在准备卖票
Thread-1出票成功，余票为：2
正在准备卖票
Thread-1出票成功，余票为：1
正在准备卖票
Thread-0出票成功，余票为：0

解决方案2：同步方法

public class Dome {
    public static void main(String[] args) {
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable {
        //票数
        private int count = 5;

        @Override
        public void run() {
            //票数到0 停止循环
            while (true) {
                boolean flag = sale();
                if (!flag) {
                    break;
                }
            }
        }

        public synchronized boolean sale() {
            if (count > 0) {
                //卖票
                System.out.println("正在准备卖票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println(Thread.currentThread().getName() + "出票成功，余票为：" + count);
                return true;
            }
            return false;
        }
    }
}
//运行结果：
正在准备卖票
Thread-0出票成功，余票为：4
正在准备卖票
Thread-0出票成功，余票为：3
正在准备卖票
Thread-1出票成功，余票为：2
正在准备卖票
Thread-1出票成功，余票为：1
正在准备卖票
Thread-1出票成功，余票为：0

解决方案3：显示锁

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Dome {
    public static void main(String[] args) {
        //格式：synchronized(锁对象){}
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable {
        //票数
        private int count = 5;
        //显式锁
        private Lock l = new ReentrantLock();

        @Override
        public void run() {
            //票数到0 停止循环
            while (true) {
                l.lock();
                if (count > 0) {
                    //卖票
                    System.out.println("正在准备卖票");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    count--;
                    System.out.println(Thread.currentThread().getName() + "出票成功，余票为：" + count);
                } else {
                    break;
                }
                l.unlock();
            }
        }
    }
}
运行结果：
正在准备卖票
Thread-1出票成功，余票为：4
正在准备卖票
Thread-1出票成功，余票为：3
正在准备卖票
Thread-0出票成功，余票为：2
正在准备卖票
Thread-0出票成功，余票为：1
正在准备卖票
Thread-0出票成功，余票为：0