线程安全问题

线程安全问题指的是: 多个线程同时操作同一个共享资源的时候可能会出现业务安全问题，称为线程安全问题。

举例: 取钱模型演示

需求：小明和小红是一对夫妻，他们有一个共同的账户，余额是10万元。

如果小明和小红同时来取钱，而且2人都要取钱10万元，可能出现什么问题呢？

线程同步和异步的区别_线程同步机制_线程同步

在取钱之前都需要判断余额是否足够, 例如两个线程同时执行, 两个线程都进行了余额判断, 发现余额充足;

此时小明线程取走10万, 账户余额为0; 小红线程由于此时已经判断过余额, 继续取钱的时候就不会继续判断余额, 直接将余额取出来; 那么两个人都取走了10万, 银行就亏了10万, 这就是多线程带来的安全问题

线程安全问题模拟, 我们将上面的例子用代码模拟出来多线程的安全隐患:

需求:

小明和小红是一对夫妻，他们有一个共同的账户，余额是10万元，模拟2人同时去取钱10万。

分析:

需要提供一个账户类，创建一个账户对象代表2个人的共享账户。

需要定义一个线程类，线程类可以处理账户对象。

创建2个线程对象，传入同一个账户对象。

启动2个线程，去同一个账户对象中取钱10万。

实现步骤:

模拟一个账户类给小明线程和小红线程, 我们模拟关键信息即可

public class Account {    private double money;
    public  Account() {}
    public Account(double money) {        this.money = money;    }
    /**        取钱方法     */    public void drawMoney(double money) {        // 获取取钱人的名字        String name = Thread.currentThread().getName();        if (this.money >= money) { // 判断余额是否充足            System.out.println(name + "取走了" + money + "元");            this.money -= money;        } else {            System.out.println("余额不足");        }    }
    public double getMoney() {        return money;    }
    public void setMoney(double money) {        this.money = money;    }}

定义一个线程类用来处理账户对象

public class DrawThread extends Thread {    private Account acc;
    public DrawThread(Account acc, String name) {        super(name);        this.acc = acc;    }
    @Override    public void run() {        acc.drawMoney(100000);    }}

在主类中, 创建2个线程对象，传入同一个账户对象; 启动2个线程，去同一个账户对象中取钱10万

public class ThreadDemo {    public static void main(String[] args) throws Exception {        // 创建账户对象        Account acc = new Account(100000);
        // 创建两个子线程, 并启动线程        new DrawThread(acc, "小明").start(); // 小明取走了100000.0元        new DrawThread(acc, "小红").start(); // 小红取走了100000.0元
        // 主线程睡眠两秒后, 查看余额        Thread.sleep(2000);        System.out.println(acc.getMoney()); // -100000.0    }}

线程同步

为了解决上面线程安全的问题。

取钱案例出现问题的原因？

多个线程同时执行，发现账户都是够钱的。

如何才能保证线程安全呢？

让多个线程实现先后依次排队访问共享资源，这样就解决了安全问题

线程同步的核心:

线程同步的核心是加锁，把共享资源进行上锁，每次只能一个线程进入访问完毕以后解锁，然后其他线程才能进来。

加锁的方式有三种方式: 同步代码块, 同步方法和Lock锁, 下面我们来分别学习加锁的方法

方式一: 同步代码块

作用：将出现线程安全问题的核心代码给上锁。

原理：每次只能一个线程进入，执行完毕后自动解锁，其他线程才可以进来执行。

同步代码块上锁的格式:

synchronized(同步锁对象) {    // 操作共享资源的代码(核心代码)}

例如我们给上面模拟的线程安全例子中的核心代码进行加锁操作:

进行加锁操作就解决了线程安全问题

public class Account {    private double money;
    public  Account() {}
    public Account(double money) {        this.money = money;    }
    /**        取钱方法     */    public void drawMoney(double money) {        String name = Thread.currentThread().getName();
        // 对核心代码进行加锁, 这里锁对象随便使用了一个字符串模拟(无实际代表意义)        synchronized ("chen") {            if (this.money >= money) {                System.out.println(name + "取走了" + money + "元");                this.money -= money;            } else {                System.out.println("余额不足");            }        }    }
    public double getMoney() {        return money;    }
    public void setMoney(double money) {        this.money = money;    }}

锁对象注意:

理论上：锁对象只要对于当前同时执行的线程来说是唯一的一个对象即可。

但是实际上使用任意唯一的锁对象并不好, 会影响其他无关线程的执行, 例如上面例子中, 会将其他无关的账户也锁起来。

锁对象的规范要求:

规范上：建议使用共享资源作为锁对象。

// 加锁, 使用共享资源作为锁对象synchronized (this) {}

// 加锁, 使用共享资源作为锁对象synchronized (类名.class) {}

方式二: 同步方法

作用: 将出现线程安全问题的核心方法给上锁。

原理：每次只能一个线程进入，执行完毕以后自动解锁，其他线程才可以进来执行。

同步方法的上锁格式:

修饰符 synchronized 返回值类型 方法名称(形参列表) {    // 操作共享资源的代码}

同步方法上锁演示代码:

// 给核心方法上锁public synchronized void drawMoney(double money) {    String name = Thread.currentThread().getName();
    if (this.money >= money) {        System.out.println(name + "取走了" + money + "元");        this.money -= money;    } else {        System.out.println("余额不足");    }}

同步方法底层原理:

同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。

如果方法是实例方法：同步方法默认用this作为的锁对象。但是代码要高度面向对象！

如果方法是静态方法：同步方法默认用类名.class作为的锁对象。

方式三: Lock锁

Lock锁

为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock，更加灵活、方便。

Lock实现提供比使用synchronized方法和语句可以获得更广泛灵活的锁定操作。

Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来构建Lock锁对象。

Lock的API:

线程同步和异步的区别_线程同步_线程同步机制

Lock使用演示代码:

基本使用如下, 我们可以看出Lock使用是非常灵活的

public class Account {    private double money;    // 定义一个示例变量锁对象, 每创建一个类就会创建一个锁对象, 加final修饰, 表示不可替换    private final Lock lock = new ReentrantLock();
    public  Account() {}    public Account(double money) {        this.money = money;    }        public synchronized void drawMoney(double money) {        String name = Thread.currentThread().getName();
        // 调用锁对象上锁        lock.lock();        if (this.money >= money) {            System.out.println(name + "取走了" + money + "元");            this.money -= money;        } else {            System.out.println("余额不足");        }        // 调用锁对象解锁        lock.unlock();    }
    public double getMoney() {        return money;    }
    public void setMoney(double money) {        this.money = money;    }}

但是如果我们上锁和解锁之间的代码出现了异常, 永远都不会执行解锁操作, 所以更严谨的写法是将解锁的操作放到try…finally中, 保证会执行解锁的操作

public synchronized void drawMoney(double money) {    String name = Thread.currentThread().getName();
    // 调用锁对象上锁    try {        lock.lock();        if (this.money >= money) {            System.out.println(name + "取走了" + money + "元");            this.money -= money;        } else {            System.out.println("余额不足");        }    } finally {        // 调用锁对象解锁        lock.unlock();    }}