线程安全问题（同步）

线程安全问题

多个线程同时操作同一个共享资源的时候可能出现线程安全

线程安全问题的解决（线程同步）

线程同步的方式有三种：

1. 同步代码块
2. 同步方法
3. lock显示锁

同步代码块

作用：把出现线程安全问题的核心代码给上锁，每次只能一个线程进入执行完毕以后自动 解锁，其他线程才可以进来执行

格式：

​ synchronized(锁对象){

//访问共享资源的核心代码

}

锁对象：理论上可以是任意的“唯一”对象即可

原则上：锁对象建议使用共享资源。

1. ​ 在实例方法中建议用this作为锁对象。此时this正好是共享资源
2. ​ 在静态方法中建议用类名.class 字节码作为锁对象

提示：锁 锁的范围越精准性能越好

例子（小红和小明同时去取统一账户下的money）

账户类

// 账户类
public class Account {
    private double money ; // 余额
    private String cardId ;
    public Account(){

    }
    public Account(double money, String cardId) {
        this.money = money;
        this.cardId = cardId;
    }
    // 小明、小红执行到此
    public void drawMoney(double money) {
        // 1.先拿到是谁来取钱：取当前线程对象的名称
        String name = Thread.currentThread().getName();
        // 小明、小红
        // this == 当前共享账户acc
        // 2.判断余额是否足够
        synchronized (this){
            if(this.money >= money){
                // 3.余额足够
                System.out.println(name+"来取钱，吐出："+money);
                // 4.更新余额
                this.money -= money;
                // 5.输出结果
                System.out.println(name+"来取钱"+money+"成功，取钱后剩余："+this.money);
            }else{
                // 6.余额不足
                System.out.println(name+"来取钱，余额不足，剩余"+this.money);
            }
        }
    }

    public double getMoney() {
        return money;
    }

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

    public String getCardId() {
        return cardId;
    }

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


}

取钱的线程类

/**
    取钱的线程类
 */
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(10000);
    }
}

测试类

/**
    目标：线程同步_同步代码块

    线程同步的作用：就是为了解决线程安全问题的方案。

    线程同步解决线程安全问题的核心思想：
            让多个线程实现先后依次访问共享资源，这样就解决了安全问题。

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

    线程同步的方式有三种：
        （1）同步代码块。
        （2）同步方法。
        （3）lock显示锁。

    a.同步代码块。
         作用：把出现线程安全问题的核心代码给上锁，每次只能一个线程进入
              执行完毕以后自动解锁，其他线程才可以进来执行。

         格式：
              synchronized(锁对象){
                    // 访问共享资源的核心代码
              }
              锁对象：理论上可以是任意的“唯一”对象即可。
              原则上：锁对象建议使用共享资源。
                    -- 在实例方法中建议用this作为锁对象。此时this正好是共享资源！必须代码高度面向对象
                    -- 在静态方法中建议用类名.class字节码作为锁对象。

 */
public class ThreadSafe {
    public static void main(String[] args) {
        // 入口类：
        // 1.创建一个共享的账户对象（共享资源），账户对象必须只创建一个。
        Account acc = new Account(10000, "ICBC-110");

        // 2.创建2个线程对象代表：小明和小红。
        Thread xiaoMing = new DrawThread(acc,"小明");
        xiaoMing.start();

        Thread xiaoRed = new DrawThread(acc,"小红");
        xiaoRed.start();
    }
}

同步方法

作用：把出现线程安全问题的核心方法给锁起来

每次只能一个线程进入访问，其他线程必须在方法外面等待

用法：直接给方法加上一个修饰符 synchronized

原理;同步方法的原理和同步代码块的底层原理其实是完全一样的，只是同步方法是把整个方法的代码都锁起来了。

同步方法其实底层也是有锁对象的：

1. 如果方法是实例方法：同步方法默认用this作为的锁对象
2. 如果方法时静态方法：同步方法默认用类名.class作为的锁对象

// 小明、小红执行到此
public synchronized void drawMoney(double money) {
    // 1.先拿到是谁来取钱：取当前线程对象的名称
    String name = Thread.currentThread().getName();
    // 2.判断余额是否足够
    if(this.money >= money){
        // 3.余额足够
        System.out.println(name+"来取钱，吐出："+money);
        // 4.更新余额
        this.money -= money;
        // 5.输出结果
        System.out.println(name+"来取钱"+money+"成功，取钱后剩余："+this.money);
    }else{
        // 6.余额不足
        System.out.println(name+"来取钱，余额不足，剩余"+this.money);
    }
}

Lock锁

Lock锁也称同步锁，加锁与释放锁方法化了，如下：
- public void lock():加同步锁。
- public void unlock():释放同步锁。

// 账户类
public class Account {
    private double money ; // 余额
    private String cardId ;
    // 创建一把锁对象:因为账户对象对于小明小红是唯一的，所以这里的锁对象对于小明小红也是唯一的
    private final Lock lock = new ReentrantLock();
    public Account(){

    }
    public Account(double money, String cardId) {
        this.money = money;
        this.cardId = cardId;
    }
    // 小明、小红执行到此
    public void drawMoney(double money) {
        // 1.先拿到是谁来取钱：取当前线程对象的名称
        String name = Thread.currentThread().getName();
        lock.lock(); // 上锁~!
        try{
            if(this.money >= money){
                // 3.余额足够
                System.out.println(name+"来取钱，吐出："+money);
                // 4.更新余额
                this.money -= money;
                // 5.输出结果
                System.out.println(name+"来取钱"+money+"成功，取钱后剩余："+this.money);
            }else{
                // 6.余额不足
                System.out.println(name+"来取钱，余额不足，剩余"+this.money);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock(); // 解锁~!
        }

    }

    public double getMoney() {
        return money;
    }

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

    public String getCardId() {
        return cardId;
    }

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


}

1. 创建一个锁对象
2. 到共享资源代码阶段 上锁
3. 共享资源使用完成就 释放锁

总结：

• 线程安全，性能差
• 线程不安全性能好。加入开发中不会存在多线程安全问题，建议使用线程不安全的设计
• StringBuilder 线程不安全
• StringBuffer线程安全（淘汰了）