线程安全和解决的办法

一、线程安全

线程安全问题出现的原因：

1.存在多个线程同时运行

2.访问同一个共享资源

3.存在修改共享资源

案例： 银行取款

?

?直接上代码：模拟银行取款的线程安全问题

1.先创建一个账户类（Account）

public class Account {
    private String cardId;
    private double money;

    //小红和小明同时过来
    public void drawMoney(double money){
        //先判断谁来取钱
        String name = Thread.currentThread().getName();
        //判断余额是否充足
        if (this.money >= money){
            System.out.println(name + "来取钱，取钱成功！");
            this.money -= money;
            System.out.println(name + "来取钱后，账户余额" + this.money);
        }else{
            System.out.println(name + "来取钱，余额不足！");
        }
    }
    public String getCardId() {
        return cardId;
    }

    public double getMomey() {
        return money;
    }

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

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

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

    public Account() {
    }
}

2.创建一个任务类（DrawThread）

public class DrawTread extends Thread{

    private Account acc;

    public DrawTread(Account acc, String name) {
        super(name);
        this.acc = acc;
    }

    @Override
    public void run() {
        //取钱（小明，小红）
        acc.drawMoney(100000.00);
    }
}

3.测试（ThreadTest）

public class ThreadTest {
    //模拟线程安全问题
    public static void main(String[] args) {
        //银行账里有10万元，小明和小红同事来取钱（取10万）
        Account acc = new Account("ZMSN-110",100000.00);
        new DrawTread(acc,"小红").start();
        new DrawTread(acc,"小明").start();
    }
}

最后的结果：

小明来取钱，取钱成功！
小红来取钱，取钱成功！
小明来取钱后，账户余额0.0
小红来取钱后，账户余额-100000.0

从这里就可以看出出现了线程安全问题。上面的代码具体的讲解就不再过多赘述，主要是了解线程安全问题是怎么产生的。

二、解决线程安全的办法

线程同步：解决线程安全问题

线程同步的思想：让多个线程先后依次访问公共资源，从而解决问题

?常见方案： 加锁：每次只允许一个线程加锁，加锁后才能访问，访问完毕后自动解锁，然后将其他线程再加锁进来

加锁的方案有三种。下面来介绍三中方案：

方法一：同步代码块

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

synchronized(同步锁){

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

}?

同步锁使用的注意事项：对于当前同时执行的线程来说，同步锁必须是同一把（同一个对象），否则会出bug

实例方法建议用? this? 作为锁对象 ；静态方法建议用? 类名.class? 作为锁对象。

以上面的案例为解决对象：

    public static void Test() {
         synchronized (Account.class){
             //静态方法推荐使用  类名.class  来上锁
        }
   }
//小红和小明同时过来
    public void drawMoney(double money){
        //先判断谁来取钱
        String name = Thread.currentThread().getName();
        //判断余额是否充足
        //this正好代表共享资源，这里最好不要用字符串，因为字符串在常量池中只有一份，会锁住其他的人，比如小明一家来取钱会锁住小黑一家人
        //synchronized ("字符串") {}最好不要用
        synchronized (this) {
            if (this.money >= money){
                System.out.println(name + "来取钱，取钱成功！");
                this.money -= money;
                System.out.println(name + "来取钱后，账户余额" + this.money);
            }else{
                System.out.println(name + "来取钱，余额不足！");
            }
        }
    }

上面如果用字符串，则会锁住小黑一家人，当小明一家人正在取钱时，小黑一家人是不能取钱的，会出现问题的，建议用this

  public static void main(String[] args) {
        //银行账里有10万元，小明和小红同事来取钱（取10万）
        Account acc = new Account("ZMSN-110",100000.00);
        new DrawTread(acc,"小红").start();
        new DrawTread(acc,"小明").start();

        //另一家人
      //  Account acc1 = new Account("ZMSN-111",100000.00);
        //new DrawTread(acc1,"小黑").start();
       // new DrawTread(acc1,"小白").start();
}

方法二：同步方法

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

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

共享资源的代码?

}

底层原理：含有隐似的锁对象，只是锁的范围是整个方法的代码

同步方法和同步代码块的优缺点：

范围上：同步代码块锁的范围更小，同步方法锁的范围更大 *

可读性：同步方法更好

//小红和小明同时过来
    public synchronized void drawMoney(double money){
        //加一个synchronized 即可
            
}

方法三：Lock锁

Lock是接口，所以要找他的实现类ReentrantLock来创建对象

private finall Lock l = new ReentrantLock();（这里建议用finally修饰）

解锁的代码放在try-catch-finally的finally{}中。

 public class Account {
    private String cardId;
    private double money;

    private finall Lock l = new ReentrantLock();

    //小红和小明同时过来
    public void drawMoney(double money){
        //先判断谁来取钱
        String name = Thread.currentThread().getName();
        l.lock();加锁
        //判断余额是否充足
            if (this.money >= money){
                System.out.println(name + "来取钱，取钱成功！");
                this.money -= money;
                System.out.println(name + "来取钱后，账户余额" + this.money);
            }else{
                System.out.println(name + "来取钱，余额不足！");
            }
        l.unlock();解锁
       
    }

三种方式的运行结果：

小红来取钱，取钱成功！
小红来取钱后，账户余额0.0
小明来取钱，余额不足！

成功解决问题！