模拟线程安全问题与解决线程安全问题三种方案

线程安全问题的产生

	在使用多线程的过程中最让人头大的莫过于线程安全问题，线程安全问题是如何产生的呢？简短来说就是多线程在访问共享数据的时候破坏了数据的原子性。
	我们用举个卖票的例子探究一下这个问题。
	背景：某场演唱会发布100张门票，先有三个卖票窗口同时卖票，我们用代码模拟一下。

package com.leyou.item;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class DemoTicket {
    //本次售100张票
    static Integer ticketNum = 100;
    
    public static void main(String[] args) {
        //卖票任务
        Runnable task = () -> {
            while (true) {
                try {
                    if (ticketNum > 0) {
                        //提高线程安全出现的概率，让线程睡眠
                        Thread.sleep(100);
                        System.out.println(Thread.currentThread().getName() + "正在售卖第" + ticketNum + "张票");
                        ticketNum--;
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        //开启三个线程模拟三个售票窗口（使用线程池）
        ExecutorService es = Executors.newFixedThreadPool(3);
        //开启任务
        es.submit(task);
        es.submit(task);
        es.submit(task);
    }

}

控制台输出

pool-1-thread-3正在售卖第100张票
pool-1-thread-1正在售卖第100张票
pool-1-thread-2正在售卖第100张票
...
pool-1-thread-1正在售卖第1张票
pool-1-thread-3正在售卖第0张票
pool-1-thread-2正在售卖第-1张票

我们发现了一个很奇怪的现象，pool-1-thread-3，pool-1-thread-2，pool-1-thread-1同时卖出了第100张票，此时就出现了线程安全问题。分析一下代码。发布了一个卖票任务，首先判断是否有余票，有就卖出，对应的票数减1，但在if判断里面我们加入了 Thread.sleep(100);让线程睡眠了100ms，此时三个线程执行到此处睡眠。此时pool-1-thread-3被唤醒进入运行状态，打印出了卖票信息，票数减1，继续下一次循环。而pool-1-thread-2同时也被唤醒，打印出了第100张票的卖票信息，pool-1-thread-1同样如此。
pool-1-thread-3正在售卖第0张票出现的原因是因为pool-1-thread-3唤醒的比pool-1-thread-1晚，导致此时的ticketNum 已经为0了，打印卖票信息，减1此时已经为-1，pool-1-thread-2被唤醒，打印出了pool-1-thread-2正在售卖第-1张票，此时执行完 ticketNum–之后，ticketNum 为-2if判断不在生效，三个线程不再打印信息。

synchronized解决线程安全问题

1. 同步代码块
   格式：

            synchronized (锁对象){
                可能会出现线程安全问题的代码（访问共享数据的代码）
            }
            注意：代码块中的锁对象，可以使用任意对象。
                 必须保证多个线程使用的锁对象是同一个。
                 锁对象的作用：
                   把同步代码块的内容锁住，只让一个线程在同步代码块中执行。

代码示例：

package com.leyou.item;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class DemoTicket {
    //本次售100张票
    static Integer ticketNum = 100;

    //创建一个锁对象
    static Object obj = new Object();

    public static void main(String[] args) {
        //卖票任务
        Runnable task = () -> {
            while (true) {
                try {
                    //确保使用的是同一个锁对象
                    synchronized (obj){
                        if (ticketNum > 0) {
                            //提高线程安全出现的概率，让线程睡眠
                            Thread.sleep(100);
                            System.out.println(Thread.currentThread().getName() + "正在售卖第" + ticketNum + "张票");
                            ticketNum--;
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        //开启三个线程模拟三个售票窗口（使用线程池）
        ExecutorService es = Executors.newFixedThreadPool(3);
        //开启任务
        es.submit(task);
        es.submit(task);
        es.submit(task);
    }

}

把需要操作数据的代码块都包括在 synchronized (obj){}中，并保证多个线程使用的是同一个锁对象。
原理：
三个线程同时抢占cpu资源，谁先抢到，执行run()方法进行卖票，如pool-1-thread-3抢到了资源，执行run()方法遇到了同步代码块，然后首先会检查synchronize代码块是否有锁对象，有，取得对象锁(同步锁)，执行方法。pool-1-thread-2抢到cpu资源，首先检查synchronize代码块是否持有锁对象，没有进入阻塞状态，等待pool-1-thread-3执行完之后归还锁对象。
总结：同步中的线程没有执行完毕，不会释放锁。 同步外的线程没有锁就进不去synchronize代码块。
2. 同步方法
定义：使用synchronized修饰的方法就叫做同步方法，保证线程A在执行此方法时，其他线程只能在方法外等着。
格式：

    public synchronized void method() {
        //可能会出现线程安全的代码块
    }

代码实现：

package com.leyou.item;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 使用同步方法解决线程安全
 * 使用步骤：
 * 1.把访问共享数据的代码抽取出来，封装到一个方法中
 * 2.在方法上添加synchronized关键字
 */
public class DemoTicket {
    //本次售100张票
    static Integer ticketNum = 100;

      /**
     * 静态同步方法
     * 此时的锁对象不能是this,this是对象创建之后才存在的，静态方法优先于对象
     * 静态方法的锁对象是本类的class属性-->class文件对象
     */
    public static synchronized void method() {
        if (ticketNum > 0) {
            try {
                Thread.sleep(100);
                System.out.println(Thread.currentThread().getName() + "正在售卖第" + ticketNum + "张票");
                ticketNum--;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //卖票任务
        Runnable task = () -> {
            while (true) {
                method();
            }
        };
        //开启三个线程模拟三个售票窗口（使用线程池）
        ExecutorService es = Executors.newFixedThreadPool(3);
        //开启任务
        es.submit(task);
        es.submit(task);
        es.submit(task);
    }

}

3. 锁机制
   代码实现：

package com.leyou.item;

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

/**
 * 使用lock锁解决线程安全 java.util.concurrent.locks;
 * lock实现提供了比synchronized方法和语句更广泛的锁操作
 * lock接口中的方法：
 * void lock()//获取锁
 * void unlock()//释放锁
 * java.util.concurrent.locks.ReentrantLock implements Lock接口
 * 使用步骤：
 * 1.在成员位置创建一个ReentrantLock对象；
 * 2.在可能会出现安全问题的代码前调用ReentrantLock.lock();获取锁
 * 3.在可能会出现安全问题的代码后调用ReentrantLock.unlock();释放锁
 */
public class DemoTicket {
    //本次售100张票
    static Integer ticketNum = 100;
    //在成员位置创建一个ReentrantLock对象；
    static Lock lock = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {
        //卖票任务
        Runnable task = () -> {
            while (true) {
                //调用锁
                lock.lock();
                if (ticketNum > 0) {
                    try {
                        Thread.sleep(100);
                        System.out.println(Thread.currentThread().getName() + "正在售卖第" + ticketNum + "张票");
                        ticketNum--;
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    finally {
                        lock.unlock();//无论程序是否异常，都会把锁释放，提高程序效率
                    }
                }
            }
        };
        //开启三个线程模拟三个售票窗口（使用线程池）
        ExecutorService es = Executors.newFixedThreadPool(3);
        //开启任务
        es.submit(task);
        es.submit(task);
        es.submit(task);
    }

}