Day08_02目标：线程同步

目标：线程同步

线程同步的作用：

就是为了解决线程安全问题的方案。

线程同步解决线程安全问题的核心思想：

​ 让多个线程实现先后依次访问共享资源，这样就解决了安全问题。
线程同步的做法：
​ 是把共享资源进行上锁，每次只能一个线程进入访问完毕以后，其他线程才能进来。

线程同步的方式有三种：

​ （1）同步代码块。
​ （2）同步方法。
​ （3）lock显示锁。

a.同步代码块。
作用：把出现线程安全问题的核心代码给上锁，每次只能一个线程进入
执行完毕以后，其他线程才可以进来执行。
格式：
synchronized(锁对象){
// 访问共享资源的核心代码
}
锁对象：理论上可以是任意的“唯一”对象即可。
原则上：锁对象建议使用共享资源。
– 在实例方法中建议用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();
    }
}

取钱的线程类

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

账户类

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();
        synchronized (this){
            // 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);
            }
        }
    }

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

b.同步方法
作用：把出现线程安全问题的核心方法给锁起来，
每次只能一个线程进入访问，其他线程必须在外面等待。
用法：直接给方法加上一个修饰符 synchronized.
原理: 同步方法的原理和同步代码块的底层原理其实是完全一样的，只是
同步方法是把整个方法的代码都锁起来的。
同步方法其实底层也是有锁对象的：
如果方法是实例方法：同步方法默认用this作为的锁对象。
如果方法是静态方法：同步方法默认用类名.class作为的锁对象。

账户类

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

    }
    public Account(double money, String cardId) {
        this.money = money;
        this.cardId = cardId;
    }
    // 小明、小红执行到此
    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);
        }
    }

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

c.lock显示锁。
java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,
同步代码块/同步方法具有的功能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();
        // 2.判断余额是否足够
        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;
    }
}

总结：
线程安全性能差。
线程不安全性能好。假如开发中不会存在多线程安全问题，建议使用线程不安全的设计。