Java多线程二-线程安全

1、线程安全问题

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

2、实例：取钱的线程安全问题

2.1、场景

小明和小红是夫妻，他们有个共同账户，余额是十万元，如果两人同时取钱并且各自取十万元，可能会出现什么问题？

2.2、模拟取钱案例

分析：

1、需要提供一个账户类，接着创建一个账户对象代表2个人的共享账户。

2、需要定义一个线程类（用于创建两个线程，分别代表小明和小红）。

3、创建2个线程，传入同一个账户对象给2个线程处理。

4、启动两个线程，同时去同一个账户对象中取钱10万元。

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


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

    public Account() {
    }

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

    public void drawMoney(double i){
        //判断谁来取钱
        String name = Thread.currentThread().getName();
        //判断余额是否足够
        if (this.money>=i){
            System.out.println(name+"来取钱:"+i+"成功");
            this.money -= i;
            System.out.println(name+"来取钱后，"+"余额剩余："+this.money);
        }else{
            System.out.println(name+"来取钱:余额不足");
        }
    }

    public String getCargId() {
        return cargId;
    }

    public void setCargId(String cargId) {
        this.cargId = cargId;
    }

    public double getMoney() {
        return money;
    }

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

public class DrawThread extends Thread{
    private Account account;
    public DrawThread(Account a,String name) {
        super(name);
        this.account = a;
    }
    @Override
    public void run() {
        //super.run();
        //取钱
        account.drawMoney(1000000);
    }
}

//执行结果
小红来取钱:1000000.0成功
小明来取钱:1000000.0成功
小红来取钱后，余额剩余：0.0
小明来取钱后，余额剩余：-1000000.0

2.3、解决办法：线程同步

2.3.1、线程同步的思想

小明和小红都使用了取钱线程，两个线程同时执行了，就出现了都取成功，余额出现了负数。

2.3.2、线程同步的常见方案

加锁：每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动解锁，然后其他线程才能再加锁进来。

加锁的三种方式：1、同步代码块；2、同步方法；3、Lock锁

2.3.3、同步代码块

作用：把访问共享资源的核心代码给上锁，以此保证线程安全。

synchronized(同步锁){

访问共享资源的核心代码

}

原理：每次只允许一个线程加锁后进入，执行完毕后自动解锁，其他线程才可以进来执行，执行过程还是加锁再解锁

ps:对于当前同时执行的线程来说，同步锁必须是同一把（同一个对象），否则会出现bug。

 //将主业务设置为同步代码块
        synchronized ("同步锁") {
            if (this.money>=i){
                System.out.println(name+"来取钱:"+i+"成功");
                this.money -= i;
                System.out.println(name+"来取钱后，"+"余额剩余："+this.money);
            }else{
                System.out.println(name+"来取钱:余额不足");
            }
        }
//执行结果
小明来取钱:1000000.0成功
小明来取钱后，余额剩余：0.0
小红来取钱:余额不足

如果有其他人来取钱

Account acc1 = new Account("ICBC-112",1000000);
new DrawThread(acc1,"小黑").start();//小黑
new DrawThread(acc1,"小白").start();//小白

此时就会出现这情况

小白来取钱:1000000.0成功
小白来取钱后，余额剩余：0.0
小红来取钱:1000000.0成功
小红来取钱后，余额剩余：0.0
小黑来取钱:余额不足
小明来取钱:余额不足

解决办法就是将synchronized里面的参数改为this

 //this代表共享资源
        synchronized (this) {
            if (this.money>=i){
                System.out.println(name+"来取钱:"+i+"成功");
                this.money -= i;
                System.out.println(name+"来取钱后，"+"余额剩余："+this.money);
            }else{
                System.out.println(name+"来取钱:余额不足");
            }
        }

执行结果

小黑来取钱:1000000.0成功
小黑来取钱后，余额剩余：0.0
小明来取钱:1000000.0成功
小白来取钱:余额不足
小明来取钱后，余额剩余：0.0
小红来取钱:余额不足

扩展：静态方法

当静态方法使用同步锁的时候，可以直接使用类名来作为参数

public static void test(){
        synchronized (Account.class){
        }
    }

PS：使用规范：

建议使用共享资源做为锁对象，对于实力方法建议使用this作为锁对象。
对于静态方法建议使用字节码（类名.class）对象作为锁对象。

2.3.4、同步方法

作用：把访问共享资源的核心方法给上锁，以此来保证线程安全

修饰符 synchronized 返回值类型方法名称（形参列表）｛

操作共享资源的代码

｝

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

 //同步方法，内部包含this
    public synchronized void drawMoney(double i){
        //判断谁来取钱
        String name = Thread.currentThread().getName();
        //判断余额是否足够
        if (this.money>=i){
            System.out.println(name+"来取钱:"+i+"成功");
            this.money -= i;
            System.out.println(name+"来取钱后，"+"余额剩余："+this.money);
        }else{
            System.out.println(name+"来取钱:余额不足");
        }
    }
//执行结果
小红来取钱:1000000.0成功
小红来取钱后，余额剩余：0.0
小明来取钱:余额不足

同步方法底层原理：

同步方法其实底层也是有隐士锁对象的，只是锁的范围是整个方法代码。
如果方法是实例方法：同步方法默认用this作为的锁对象。
如果方法是静态方法：同步方法默认用类名.class作为的锁对象。

2.3.5、同步代码块与同步方法比较

范围上：同步代码块锁的范围更小，同步方法锁的范围更大，锁的范围越小，性能越好。
可读性：同步方法更好

2.3.6、Lock锁

是JDK5开始提供的一个新的锁定操作，通过它可以创建出锁对象进行加锁和解锁，更灵活、更方便、更强大。
是接口，不能直接实例化，可以采用他的实现类ReentrantLock来构建Lock锁对象。

//创建一个锁对象
private Lock lock = new ReentrantLock();

         //加锁
        lock.lock();
        //判断余额是否足够
        if (this.money>=i){
            System.out.println(name+"来取钱:"+i+"成功");
            this.money -= i;
            System.out.println(name+"来取钱后，"+"余额剩余："+this.money);
        }else{
            System.out.println(name+"来取钱:余额不足");
        }
        //解锁
        lock.unlock();
//执行结果
小明来取钱:1000000.0成功
小明来取钱后，余额剩余：0.0
小红来取钱:余额不足

ps:注意

创建的时候增加final,保证不可修改：private final Lock lock = new ReentrantLock();

解锁最好放在finally中：

//加锁
        lock.lock();
        //判断余额是否足够
        try {
            if (this.money>=i){
                System.out.println(name+"来取钱:"+i+"成功");
                this.money -= i;
                System.out.println(name+"来取钱后，"+"余额剩余："+this.money);
            }else{
                System.out.println(name+"来取钱:余额不足");
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            //解锁
            lock.unlock();
        }

这样的好处就是，如果出现错误，还能继续执行

构造器	说明
public ReentrantLock()	获得Lock锁的实现类对象
常用方法
方法名称	说明
void lock()	获得锁
void unlocak()	释放锁

2.4、线程通信

当多个线程共同操作共享资源时，线程间通过某种方式互相告知自己的状态，以相互协调，并避免无效的资源争夺。

2.4.1、常见模型

生产者负责生产数据。
消费者线程负责消费生产者生产的数据。
注意：生产者生产完数据应该等待自己，通知消费者消费；消费者消费完数据也应该等待自己，通知生产者生产。

2.4.2、案例

Object类的等待和唤醒方法：

方法名称	说明
void wait()	让当前线程等待并释放所占锁，直到令一个线程调用notify()方法或notifyAll()方法
void notify()	唤醒正在等待的单个线程
void notifyAll()	唤醒正在等待的所有线程

注意：上述方法应该使用当前同步锁对象进行调用

public class ThreadTest {
    public static void main(String[] args) {
        Desk desk = new Desk();
        //创建三个生产者线程
        new Thread(() ->{
            desk.put();
        },"生产者1").start();


        new Thread(() ->{
            desk.put();
        },"生产者2").start();

        new Thread(() ->{
            desk.put();
        },"生产者3").start();

        //创建两个消费者线程
        new Thread(() ->{
            while (true) {
                desk.get();
            }
        },"消费者1").start();

        new Thread(() ->{
            while (true) {
                desk.get();
            }
        },"消费者2").start();
    }
}

public class Desk {
    private List<String> list = new ArrayList<>();

    //放1个包子的方法
    //三个生产者
    public synchronized void put() {
        String name = Thread.currentThread().getName();
        //判断是否有包子
        try {
            if (list.size() == 0){
                list.add(name + "做的肉包子");
                System.out.println(name + "做了一个肉包子");
                Thread.sleep(2000);

                //唤醒别人，等待自己
                //先唤醒，再等待
                this.notifyAll();
                this.wait();

            }else{
                //其他生产者进来，发现有包子，不做了
                //唤醒别人，等待自己
                //先唤醒，再等待
                this.notifyAll();
                this.wait();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    //取一个包子的方法
    //两个消费者
    public synchronized void get() {
        String name = Thread.currentThread().getName();
        try {
            if (list.size() == 1){
                //有包子，吃掉
                System.out.println(name + "吃了:"+list.get(0));
                //清空list
                list.clear();
                Thread.sleep(1000);
                //唤醒别人，等待自己
                //先唤醒，再等待
                this.notifyAll();
                this.wait();
            }else{
                //没有包子
                //唤醒别人，等待自己
                //先唤醒，再等待
                this.notifyAll();
                this.wait();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

执行结果

生产者1做了一个肉包子
消费者2吃了:生产者1做的肉包子
生产者3做了一个肉包子
消费者1吃了:生产者3做的肉包子