【Java 进阶】P24 线程安全

1.线程安全

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
下面通过一个案例，演示线程的安全问题：
电影院卖票，我们模拟电影院的卖票过程。假设要播放的电影是《爱情公寓》，本次电影的座位共 100 个（本场电影只能卖 100 张票）
我们来模拟电影院的售票窗口，实现多个窗口同时卖票（多个窗口一起卖这 100 张票）
用线程对象来模拟窗口，Runnable 接口子类来模拟售票
模拟售票

public class SellTicket implements Runnable {
    // 模拟100张票
    private int tickets = 100;

    /**
     * 执行卖票操作
     */
    @Override
    public void run() {
        // 每个窗口的卖票操作
        // 窗口永远开启
        while (true) {
            // 使用sleep模拟一下卖票前操作
            try {
                Thread.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 当有票的时候
            if (tickets > 0) {
                // 出票操作
                // 获取当前线程名称
                String name = Thread.currentThread().getName();
                System.out.println(name + "正在卖第" + tickets + "张票");
                tickets--;
            }
        }
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        // 创建线程任务对象
        SellTicket sell = new SellTicket();
        // 创建三个同时卖票窗口对象
        Thread thread1 = new Thread(sell, "窗口一");
        Thread thread2 = new Thread(sell, "窗口二");
        Thread thread3 = new Thread(sell, "窗口三");

        // 同时卖票
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

运行结果

发现了程序的两个问题

1. 相同的票会被多次卖出，像第 100 张票被卖了 3 次
2. 票数不对，一共 100 张票，却卖出了 102 张票

这种现象，几个窗口（线程）票数不同步的问题，称为线程不安全
线程安全问题都是由全局变量及静态变量引起的，若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则就可能影响线程安全

2.线程同步

当我们使用多个线程访问同一资源的时候，且多个线程资源中对资源有写的操作，就容易出现线程安全问题
要解决上述多线程并发访问一个资源的安全性问题：也就是解决重复票与多卖票问题，Java 中提供了同步机制（synchronized）来解决
根据案例简述解决办法
窗口 1 进行出票操作的时候，窗口 2 和窗口 3 只能做其他无关事情，不能出票。窗口 1 操作结束，窗口 1 和窗口 2 和窗口 3 才有机会执行出票操作。也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺 CPU 资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的问题
为了保证每个线程都能正常执行原子操作，java 引入了线程同步机制
那么该怎么去使用呢？有三种方式完成同步操作

1. 同步代码块
2. 同步方法
3. 锁机制

3.同步代码块

同步代码块：synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问
格式

synchronized(同步锁){
    // 需要同步操作的代码
}

同步锁
对象的同步锁只是一个概念，可以理解为在对象上标记了一个锁

1. 锁对象：可以是任意类型
2. 多个线程对象，使用的同一把锁

注意：在任何时候，最多允许一个线程拥有同步锁，谁拿到锁就进入代码块，其他的线程不能进入该代码块（BLOCKED）
使用同步代码块解决

public class SellTicket implements Runnable {
    // 模拟100张票
    private int tickets = 100;

    Object obj = new Object();

    /**
     * 执行卖票操作
     */
    @Override
    public void run() {
        // 每个窗口的卖票操作
        // 窗口永远开启
        while (true) {
            // 使用sleep模拟一下卖票前操作
            try {
                Thread.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 将对票进行的操作加入到同步代码块中
            synchronized (obj) {
                // 当有票的时候
                if (tickets > 0) {
                    // 出票操作
                    // 获取当前线程名称
                    String name = Thread.currentThread().getName();
                    System.out.println(name + "正在卖第" + tickets + "张票");
                    tickets--;
                }
            }
        }
    }
}

运行结果

当使用了同步代码块后，上述的线程安全问题，就解决了

4.同步方法

同步方法：使用 synchronized 修饰的方法，就叫做同步方法，保证 A 线程执行该方法的时候，其他线程只能在方法外等着
格式

public synchronized void method() {
    // 可能会产生线程安全问题的代码
}

同步锁是谁？
对于非 static 方法，同步锁就是 this
对于 static 方法，使用的是当前方法所在类的字节码对象（类名.class）
使用同步方法代码如下

public class SellTicket implements Runnable {
    // 模拟100张票
    private int tickets = 100;

    Object obj = new Object();

    /**
     * 执行卖票操作
     */
    @Override
    public void run() {
        // 每个窗口的卖票操作
        // 窗口永远开启
        while (true) {
            // 使用sleep模拟一下卖票前操作
            try {
                Thread.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            sell();
        }
    }

    /**
     * 锁对象：谁调用这个方法就是谁
     * 隐含锁对象就是this
     */
    private synchronized void sell() {
        // 当有票的时候
        if (tickets > 0) {
            // 出票操作
            // 获取当前线程名称
            String name = Thread.currentThread().getName();
            System.out.println(name + "正在卖第" + tickets + "张票");
            tickets--;
        }
    }
}

运行结果

5.Lock 锁

java.util.concurrent.locks.Lock 机制提供了比 synchronized 代码块和 synchronized 方法更加广泛的锁定操作，同步代码块/同步方法具有的功能 Lock 都有，除此之外更强大，更能体现面向对象
Lock 锁也称同步锁，加锁与释放锁方法化了，如下
  public void lock()：加同步锁
  public void unloack()：释放同步锁

使用如下

public class SellTicket implements Runnable {
    // 模拟100张票
    private int tickets = 100;

    // 初始化一个锁对象
    Lock myLock = new ReentrantLock();
    /**
     * 执行卖票操作
     */
    @Override
    public void run() {
        // 每个窗口的卖票操作
        // 窗口永远开启
        while (true) {
            // 使用sleep模拟一下卖票前操作
            try {
                Thread.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            myLock.lock(); // 加同步锁
            // 当有票的时候
            if (tickets > 0) {
                // 出票操作
                // 获取当前线程名称
                String name = Thread.currentThread().getName();
                System.out.println(name + "正在卖第" + tickets + "张票");
                tickets--;
            }
            myLock.unlock(); // 释放同步锁
        }
    }
}

运行结果