线程安全问题的基本入门

2301_76933484

已于 2023-09-13 23:56:33 修改

阅读量21

点赞数

文章标签：学习 java 前端

于 2023-09-13 21:38:23 首次发布

本文链接：https://blog.csdn.net/2301_76933484/article/details/132865129

版权

一、概述

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

二、案例

下面通过一个取钱的案例给大家演示一下。

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

线程安全问题的代码演示

1、先定义一个共享的账户类。

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

    public Account() {
    }

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

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

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

2、再定义一个是取钱的线程类。

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

3、最后，再写一个测试类，在测试类中创建两个线程对象。

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

4、运行程序，执行效果如下。

你会发现两个人都取了10万块钱，余额为-10万了。

5、问题解析。

如下图所示，小明和小红假设都是一个线程，本类每个线程都应该执行完三步操作，才算是完成的取钱的操作。但是真实执行过程可能是下面这样子的。

① 小红线程只执行了判断余额是否足够（条件为true），然后CPU的执行权就被小红线程抢走了。

② 小红线程也执行了判断了余额是否足够（条件也是true）, 然后CPU执行权又被小明线程抢走了。

③ 小明线程由于刚才已经判断余额是否足够了，直接执行第2步，吐出了10万元钱，此时共享账户月为0。然后CPU执行权又被小红线程抢走。

④ 小红线程由于刚刚也已经判断余额是否足够了，直接执行第2步，吐出了10万元钱，此时共享账户月为-10万。

你会发现，在这个取钱案例中，两个人把共享账户的钱都取了10万，但问题是只有10万块钱啊！！！

以上取钱案例中的问题，就是线程安全问题的一种体现！

三、线程同步方案

为了解决前面的线程安全问题，我们可以使用线程同步思想。为了解决前面的线程安全问题，我们可以使用线程同步思想。同步最常见的方案就是加锁，意思是每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动释放锁，然后其他线程才能再加锁进来。

等小红线程执行完了，把余额改为0，出去了就会释放锁。这时小明线程就可以加锁进来执行，如下图所示。

采用加锁的方案，就可以解决前面两个线程都取10万块钱的问题。怎么加锁呢？Java提供了三种方案。

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

线程同步方案1：同步代码块

//帐户类
public class Account {
    //目标：掌握使用线程同步方案1：同步代码块！！！

    //卡号
    private String cardId;
    //余额
    private double money;

    public Account() {
    }

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

    /*锁对象：必须是一个唯一的对象（同一个地址）
    synchronized(锁对象){
        //...访问共享数据的代码...
    }*/

    //定义一个取钱的方法
    //小明、小红同时过来取钱的
    public void drawMoney(double money) {
        //方式一：同步代码块

        //0.类级别，极不推荐！！！！！因为整个银行都会生效了，小明取钱，银行其他所有用户都取不了钱了！！
        //synchronized (Account.class)
        //1.对象级别（Account的对象）
        synchronized (this){
            //先搞清楚是谁来取钱？
            String name = Thread.currentThread().getName();

            //1.判断余额是否足够
            if (this.money >= money) {
                System.out.println(name + "来取钱" + money + "成功！");
                this.money -= money;
                System.out.println(name + "来取钱后，余额剩余：" + this.money);
            } else {
                System.out.println(name + "来取钱：余额不足~~");
            }
        }

    }

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

线程同步方案2：同步方法

//帐户类
public class Account {
    //目标：掌握使用线程同步方案2：同步方法！！！

    //卡号
    private String cardId;
    //余额
    private double money;

    public Account() {
    }

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

    //定义一个取钱的方法
    //小明、小红同时过来取钱的
    //方式二：同步方法
    public synchronized void drawMoney(double money) {
        //先搞清楚是谁来取钱？
        String name = Thread.currentThread().getName();

        //1.判断余额是否足够
        if (this.money >= money) {
            System.out.println(name + "来取钱" + money + "成功！");
            this.money -= money;
            System.out.println(name + "来取钱后，余额剩余：" + this.money);
        } else {
            System.out.println(name + "来取钱：余额不足~~");
        }
    }

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

线程同步方案3：Lock锁

//帐户类
public class Account {
    //目标：掌握使用线程同步方案3：Lock锁！！！

    //方式三：需要创建一个Lock接口的实现类对象（这个对象就是锁对象）
    private final Lock lk = new ReentrantLock();

    //卡号
    private String cardId;
    //余额
    private double money;

    public Account() {
    }

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

    //定义一个取钱的方法
    //小明、小红同时过来取钱的
    public void drawMoney(double money) {
        //先搞清楚是谁来取钱？
        String name = Thread.currentThread().getName();

        try {
            //加锁
            lk.lock();
            //1.判断余额是否足够
            if (this.money >= money) {
                System.out.println(name + "来取钱" + money + "成功！");
                this.money -= money;
                System.out.println(name + "来取钱后，余额剩余：" + this.money);
            } else {
                System.out.println(name + "来取钱：余额不足~~");
            }
        } finally {
            //解锁
            lk.unlock();
        }

    }

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

public class ThreadTest1 {
    public static void main(String[] args) throws InterruptedException {
        //1.创建一个账号对象，代表两个人的共享账户
        Account acc = new Account("ICBC-110", 100000);

        //2.创建两个线程，分别代表小明、小红，再去同一个账号对象中去取钱10万
        //方式一：获取到DrawThread对象，再调用start()方法开启线程
        DrawThread t1 = new DrawThread(acc, "小明");
        t1.start(); //小明
        DrawThread t2 = new DrawThread(acc, "小红");
        t2.start(); //小红
    }
}

public class ThreadTest2 {
    public static void main(String[] args) {
        //1.创建一个账号对象，代表两个人的共享账户
        Account acc = new Account("ICBC-110", 100000);

        //2.创建两个线程，分别代表小明、小红，再去同一个账号对象中去取钱10万
        //方式二：直接调用start()方法开启线程
        new DrawThread(acc, "小明").start();
        new DrawThread(acc, "小红").start();
    }
}

运行程序结果，观察是否还有线程安全问题。

到此，三种常用的解决线程安全问题的办法，我们就学习完了！