多线程：线程安全、线程同步

线程安全

什么是线程安全问题？

• 多个线程，同时操作同一个共享资源的适合，可能会出现业务安全问题。

取钱的线程安全问题

• 场景：小明和小红是一对夫妻，他们有一个共同的账户，余额是10万元，如果小明和小红同时来取钱，并且2人各自都在取钱10万元，可能会出现什么问题？

线程安全问题出现的原因

• 存在多个线程在同时执行
• 同时访问一个共享资源
• 存在修改该共享资源

用程序模拟线程安全问题

Account类

public class Account {
    private String cardId; //卡号
    private double money; //余额

    public Account() {
    }

    public Account(String cardId, double money) {
        this.cardId = cardId;
        this.money = money;
    }

    public String getCardId() {
        return cardId;
    }

    public void setCardId(String cardId) {
        this.cardId = cardId;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(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;
            System.out.println(name + "来取钱后，余额剩余：" + this.money);
        }else {
            System.out.println(name + "来取钱，余额不足");
        }
    }
}

DrawThread类

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);
    }
}

ThreadTest类

public class ThreadTest {
    public static void main(String[] args) {
        // 创建一个账户对象，代表两个人的共享账户
        Account acc = new Account("ICBC-100",100000);
        // 创建两个线程，分别代表小明，小红，再去同一个账户对象中取钱10万
        new DrawThread(acc,"小明").start();
        new DrawThread(acc,"小红").start();
    }
}

线程同步

• 解决线程安全问题的方案。

线程同步的思想

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

线程同步的常见方案

• 加锁：每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动解锁，然后其他线程才能再加锁进来。

方式一：同步代码块

• 作用：把访问共享资源的核心代码给锁上，以此保证线程安全。

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

同步锁的注意事项

• 对于当前同时执行的线程来说，同步锁必须是同一把（同一个对象），否则会出bug。

锁对象随便选择一个唯一的对象好不好呢？ 

• 不好，会影响其他无关线程的执行。

锁对象的使用规范

• 建议使用共享资源作为锁对象，对于实例方法建议使用this作为锁对象。
• 对于静态方法建议使用字节码（类名.class）对象作为锁对象。

用上述小明、小红取钱的代码为例 

 Account类

public class Account {
    private String cardId; //卡号
    private double money; //余额

    public Account() {
    }

    public Account(String cardId, double money) {
        this.cardId = cardId;
        this.money = money;
    }

    public String getCardId() {
        return cardId;
    }

    public void setCardId(String cardId) {
        this.cardId = cardId;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    // 小明和小红同时过来的
    public void drawMoney(double money) {
        // 先搞清楚是谁来取钱
        String name = Thread.currentThread().getName();
        // 判断余额是否足够
        synchronized (this) {
            if (this.money >= money){
                System.out.println(name + "来取钱" + money + "成功");
                this.money -= money;
                System.out.println(name + "来取钱后，余额剩余：" + this.money);
            }else {
                System.out.println(name + "来取钱，余额不足");
            }
        }
    }
}

 ThreadTest类

public class ThreadTest {
    public static void main(String[] args) {
        // 创建一个账户对象，代表两个人的共享账户
        Account acc = new Account("ICBC-100",100000);
        // 创建两个线程，分别代表小明，小红，再去同一个账户对象中取钱10万
        new DrawThread(acc,"小明").start();
        new DrawThread(acc,"小红").start();

        Account acc1 = new Account("ICBC-200",100000);
        new DrawThread(acc,"小黑").start();
        new DrawThread(acc,"小白").start();
    }
}

方式二：同步方法

• 作用：把访问共享资源的核心方法给上锁，以次保证线程安全。

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

同步方法底层原理

• 同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。
• 如果方法是实例方法：同步方法默认使用this作为锁对象。
• 如果方法是静态方法：同步方法默认使用类名.class作为锁对象。

是同步代码块好还是同步方法好一点？ 

• 范围上：同步代码块锁的范围更小，同步方法锁的范围更大。
• 可读性：同步方法更好。

方式三：Lock锁

• Lock锁是JDK5开始提供的一个新的锁定操作，通过它可以创建出锁对象进行加锁和解锁，更灵活、更方便、更强大。
• Lock是接口，不能直接实例化，可以采用它的实现类ReentrantLock来构建Lock锁对象。

构造器	说明
public ReentrantLock（）	获得Lock锁的实现类对象

Lock的常用方法

方法名称	说明
void lock（）	获得锁
void unlock（）	释放锁

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

public class Account {
    private String cardId; //卡号
    private double money; //余额
    // 创建了一个锁对象
    private final Lock lk = new ReentrantLock();

    public Account() {
    }

    public Account(String cardId, double money) {
        this.cardId = cardId;
        this.money = money;
    }

    public String getCardId() {
        return cardId;
    }

    public void setCardId(String cardId) {
        this.cardId = cardId;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    // 小明和小红同时过来的
    public void drawMoney(double money) {
        // 先搞清楚是谁来取钱
        String name = Thread.currentThread().getName();
        lk.lock(); //加锁
        try {
            // 判断余额是否足够
            if (this.money >= money){
                System.out.println(name + "来取钱" + money + "成功");
                this.money -= money;
                System.out.println(name + "来取钱后，余额剩余：" + this.money);
            }else {
                System.out.println(name + "来取钱，余额不足");
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lk.unlock(); //解锁
        }
    }
}