Java_线程安全

发布时间:2024年01月12日

一、多线程常用方法

在这里插入图片描述

下面我们演示一下getName()setName(String name)currentThread()sleep(long time)这些方法的使用效果。

public class MyThread extends Thread{
    public MyThread(String name){
        super(name); //1.执行父类Thread(String name)构造器,为当前线程设置名字了
    }
    @Override
    public void run() {
        //2.currentThread() 哪个线程执行它,它就会得到哪个线程对象。
        Thread t = Thread.currentThread();
        for (int i = 1; i <= 3; i++) {
            //3.getName() 获取线程名称
            System.out.println(t.getName() + "输出:" + i);
        }
    }
}

再测试类中,创建线程对象,并启动线程

public class ThreadTest1 {
    public static void main(String[] args) {
        Thread t1 = new MyThread();
        t1.setName(String name) //设置线程名称;
        t1.start();
        System.out.println(t1.getName());  //Thread-0
 
        Thread t2 = new MyThread("2号线程");
        // t2.setName("2号线程");
        t2.start();
        System.out.println(t2.getName()); // Thread-1
 
        // 主线程对象的名字
        // 哪个线程执行它,它就会得到哪个线程对象。
        Thread m = Thread.currentThread();
        m.setName("最牛的线程");
        System.out.println(m.getName()); // main
 
        for (int i = 1; i <= 5; i++) {
            System.out.println(m.getName() + "线程输出:" + i);
        }
    }
}

执行上面代码,效果如下图所示,我们发现每一条线程都有自己了名字了。
在这里插入图片描述

最后再演示一下join这个方法是什么效果。

join的作用就是让当前调用该方法的线程先执行完

public class ThreadTest2 {
    public static void main(String[] args) throws Exception {
        // join方法作用:让当前调用这个方法的线程先执行完。
        Thread t1 = new MyThread("1号线程");
        t1.start();
        t1.join();
 
        Thread t2 = new MyThread("2号线程");
        t2.start();
        t2.join();
 
        Thread t3 = new MyThread("3号线程");
        t3.start();
        t3.join();
    }
}

执行效果是1号线程先执行完,再执行2号线程;2号线程执行完,再执行3号线程;3号线程执行完就结束了。
在这里插入图片描述

我们再尝试,把join()方法去掉,再看执行效果。此时你会发现2号线程没有执行完1号线程就执行了 (效果是多次运行才出现的,根据个人电脑而异,可能有同学半天也出现不了也是正常的)
在这里插入图片描述

二、线程安全问题

各位小伙伴,前面我们已经学习了如何创建线程,以及线程的常用方法。接下来,我们要学习一个在实际开发过程中,使用线程时最重要的一个问题,叫线程安全问题。

2.1 线程安全问题概述

  • 首先,什么是线程安全问题呢?

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

下面通过一个取钱的案例给同学们演示一下。案例需求如下

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

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

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

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

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

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

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

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

2.2 线程安全问题的代码演示

先定义一个共享的账户类

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

在定义一个是取钱的线程类

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 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(); // 小红
    }
}

运行程序,执行效果如下。你会发现两个人都取了10万块钱,余额为-10万了。
在这里插入图片描述

2.3 线程同步方案

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

在这里插入图片描述

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

在这里插入图片描述
在这里插入图片描述

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

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

2.4 同步代码块

在这里插入图片描述

同步代码块。它的作用就是把访问共享数据的代码锁起来,以此保证线程安全。

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

使用同步代码块,来解决前面代码里面的线程安全问题。我们只需要修改DrawThread类中的代码即可。

// 小明 小红线程同时过来的
public void drawMoney(double money) {
    // 先搞清楚是谁来取钱?
    String name = Thread.currentThread().getName();
    // 1、判断余额是否足够
    // this正好代表共享资源!
    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 + "来取钱:余额不足~");
        }
    }
}

此时再运行测试类,观察是否会出现不合理的情况。
在这里插入图片描述

最后,再给同学们说一下锁对象如何选择的问题

1.建议把共享资源作为锁对象, 不要将随便无关的对象当做锁对象
2.对于实例方法,建议使用this作为锁对象
3.对于静态方法,建议把类的字节码(类名.class)当做锁对象

在这里插入图片描述
双引号给出的对象,存储在常量区,只有一份,对于多线程来说就是同一个对象,对于小明,小红一家;小黑小白一家都是同一个对象,所以当小明,小红一家取钱时,小黑小白一家就只能干等着,显然是不正确的。原因就是常量锁🔒对象,锁的范围太大了。
在这里插入图片描述

2.5 同步方法

接下来,学习同步方法解决线程安全问题。其实同步方法,就是把整个方法给锁住,一个线程调用这个方法,另一个线程调用的时候就执行不了,只有等上一个线程调用结束,下一个线程调用才能继续执行。

// 同步方法
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 + "来取钱:余额不足~");
    }
}

改完之后,再次运行测试类,观察是否会出现不合理的情况。

接着,再问同学们一个问题,同步方法有没有锁对象?锁对象是谁?

同步方法也是有锁对象,只不过这个锁对象没有显示的写出来而已。
    1.对于实例方法,锁对象其实是this(也就是方法的调用者)
    2.对于静态方法,锁对象时类的字节码对象(类名.class

最终,总结一下同步代码块和同步方法有什么区别?

1.不存在哪个好与不好,只是一个锁住的范围大,一个范围小
2.同步方法是将方法中所有的代码锁住
3.同步代码块是将方法中的部分代码锁住

在这里插入图片描述

2.6 Lock锁

接下来,再来学习一种,线程安全问题的解决办法,叫做Lock锁。
在这里插入图片描述
在这里插入图片描述

Lock锁是JDK5版本专门提供的一种锁对象,通过这个锁对象的方法来达到加锁,和释放锁的目的,使用起来更加灵活。格式如下

1.首先在成员变量位子,需要创建一个Lock接口的实现类对象(这个对象就是锁对象)
    private final Lock lk = new ReentrantLock();
2.在需要上锁的地方加入下面的代码
     lk.lock(); // 加锁
     //...中间是被锁住的代码...
     lk.unlock(); // 解锁

使用Lock锁改写前面DrawThread中取钱的方法,代码如下

// 创建了一个锁对象
private final Lock lk = new ReentrantLock();
 
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 + "来取钱:余额不足~");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lk.unlock(); // 解锁
        }
    }
}

运行程序结果,观察是否有线程安全问题。到此三种解决线程安全问题的办法就学习完了。

文章来源:https://blog.csdn.net/qq_48083892/article/details/135546338
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。