Java多线程之线程同步（解决线程安全问题）

前言必读

读者手册（必读）_云边的快乐猫的博客-CSDN博客

  一、概念讲解

1.什么是线程安全？

保证多个线程同时对某一对象或资源操作时不会出现问题

2.出现线程安全的原因？

（1）存在多线程并发

（2）同时访问共享资源

（3）存在修改共享资源  

3.出现线程安全的例子（不安全）

例子是模拟两个人（两个线程）同时去取同一个账户里面的钱操作。 

操作的线程类

package bao;
public class Test {
    public static void main(String[] args) {
        //二、创建线程
        // 1.new账户对象
        Account acc = new Account(10000);//账户里面有10000块钱
        //2.创建两个线程对象，小白，小红
        new MyThread(acc,"小白").start();//匿名形式调用线程，更简单
        new MyThread(acc,"小红").start();//匿名形式调用线程，更简单
    }
}
//三、创建线程类
//1.创建线程对象
class MyThread extends Thread{
    //3.接收处理的账户对象
    private Account acc;
    public MyThread(Account acc,String name){
        super(name);
        this.acc=acc;
    }
    //2.重写run方法
    @Override
    public void run() {
        super.run();
        //4.两个人取钱的操作
        acc.Mymoney(10000);//报红了就alt+回车键就自动在账户类里面生成了取钱的操作

    }
}

被操作的账户类 

package bao;
//一、创建一个账户类，来进行存取钱操作
public class Account {
    //1.创建账户余额变量
    private double money;//账户的余额
    //2.生成set和get方法

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
    //3.生成有参和无参构造器

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

    public Account() {
    }
    //四、核心逻辑代码：通过另一个类生成的，需要修改括号里面生成的参数
    public void Mymoney(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+"来取钱，余额不足！");
        }
    }
}

运行结果：

小红来取钱成功了，吐出：10000.0
小白来取钱成功了，吐出：10000.0
小白取钱后剩余-10000.0
小红取钱后剩余0.0 

总结：账户里面的钱为-10000，明显不合理。要去解决这个线程安全的问题 

4.解决线程安全的方法？

解决线程安全的办法就是线程同步 （通过加锁的方式，锁是可以跨方法的）有三种方式👇

二、3种解决方式 

方式一：同步代码块

（1）作用：把出现线程安全问题的核心代码块进行上锁

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

（3）区别：同步代码块锁的范围更小（优点：效率好一点）----类似锁厕所坑位

（4）规范要求：实例方法用this作为锁对象。静态方法字节码（类名.class）对象作为锁对象

（5）步骤：选中核心代码块（逻辑代码）--ctrl+alt+t----选中第9个synchronized----然后在生成的括号里面加上this就好了（如果要锁更具体的，就把this换为更具体的共享资源账户）

（6）例子（代码来源于上面3账户类出现安全问题的核心代码）

运行结果： 

小红来取钱成功了，吐出：10000.0
小红取钱后剩余0.0
小白来取钱，余额不足！

方式二：同步方法（开发中用的比较多）

（1）作用和原理和上面同步代码块的是一样的

（2）区别：同步方法锁的是整个方法，范围更大（编写简便，开发中用的比较多） ----类似锁厕所

（3）规范要求：实例方法用this作为锁对象。静态方法字节码（类名.class）对象作为锁对象

（4）步骤：在核心代码快的方法修饰符后面加上synchronized就好了

（5）例子（代码来源于上面3账户类出现安全问题的核心代码）

 运行结果： 

小白来取钱成功了，吐出：10000.0
小白取钱后剩余0.0
小红来取钱，余额不足！

方式三：Lock锁

（1）为了解决出现死锁的问题，中间代码块如果出现了问题，也可以及时解开这个锁

（2）步骤：

1.在核心代码块的类里面添加一个Lock锁对象---private final Lock lock = new ReentrantLock();

 2.在核心代码块添加上面添加一个上锁-------lock.lock();

3.把核心代码块进行全部选中ctrl+alt+t快捷键选中try/catch/finally，把解锁----lock.unlock();

放在finally里面就好了        

 运行结果： 

小红来取钱成功了，吐出：10000.0
小红取钱后剩余0.0
小白来取钱，余额不足！ 

旁白：这个锁的作用就是为了防止线程不同步进行同一个资源操作出现错误的。上锁的方式围绕着核心逻辑代码块去进行上锁解锁。通过快捷键可以很快的完成了。具体使用哪一个根据情景来使用，第二种对比第一种使用的比较多。步骤跟着一步步来就好了。