Java线程安全

问题引入–模拟银行取钱

关于线程安全问题,借用经典的银行取钱问题引入,除去验证登陆等步骤,只考虑取钱过程.

• 用户输入取款金额
• 系统判断余额是否大于取款金额
• 如果余额大于取款金额,则取款成功;如果小于取款金额则取款失败

我们模拟以上流程,采用两个线程同时操作一个账户来模拟并发取钱问题
1.定义账户

public class Account {

    private int account;
    private String name;

    public Account(String name,int account){
        this.account=account;
        this.name=name;
    }

    public int getAccount() {
        return account;
    }

    public void setAccount(int account) {
        this.account = account;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

2.取钱线程

public class DrawMoneyThread extends Thread{

    private Account account;
    private int drawMoney;

    public DrawMoneyThread(Account account,String threadname,int drawMoney){
        super(threadname);
        this.account=account;
        this.drawMoney=drawMoney;
    }

    @Override
    public void run() {
        if(account.getAccount()>=drawMoney){
//            try {
//                Thread.sleep(1);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
            account.setAccount(account.getAccount()-drawMoney);
            System.out.println(getName()+"取款成功! "+"取出 "+drawMoney+",余额"+account.getAccount());
        }else {
            System.out.println(getName()+"取款失败! "+"余额"+account.getAccount());
        }
    }
}

3.测试并发取钱

public class TestThread {

    public static void main(String []args){
        Account account=new Account("Eric",600);
        DrawMoneyThread A=new DrawMoneyThread(account,"A",600);
        A.start();
        DrawMoneyThread B=new DrawMoneyThread(account,"B",600);
        B.start();
    }
}

输出结果

A取款成功! 取出 600,余额0
B取款失败! 余额0

这样看来貌似并没有什么错误,完全正确;这只是因为Run里的代码太少,运行太快,没有出现同时访问account的情况!

接下来我们去掉DrawMoneyThread里的注释,让Run执行起来后sleep(1),切换执行其他线程
输出结果(要多运行几遍,情况可能我的不一样,但是结果应该是有问题的)

A取款成功! 取出 600,余额0
B取款成功! 取出 600,余额-600

这里就出现了问题,我们的逻辑里不允许账户有负余额,然而这里我们却得到了负余额;这是因为账户A在判断到可以取出钱时,还没来得及取出钱时就切换到了线程B,线程B判断也可以从账户中取出钱,这时A,B都获得了从账户中取钱的权利;A,B都取了钱,账户自然就成为-600了;问题本质是线程A中对变量account还未使用完毕时,线程B又把变量account拿去进行了使用,这就是所谓的线程安全问题.

同步代码块

为了解决这个问题,Java的多线程引入了同步监视器,使用同步监视器的通用方法就是同步代码块

        synchronized (obj){
            ......//此处代码就是同步代码块
        }

synchronized后面的obj就是同步监视器

• 线程开始执行同步代码块之前必须先获得对同步监视器的锁定
• 任何时刻只能有一条线程可以获得对同步监视器的锁定,当同步代码块执行结束后,该线程自然是释放了对同步监视器的锁定
• 同步监视器为了防止多线程并发访问共享资源,因此通常使用共享资源作为同步监视器

修改取钱线程,将account作为同步监视器

public class DrawMoneyThread extends Thread{

    private Account account;
    private int drawMoney;

    public DrawMoneyThread(Account account,String threadname,int drawMoney){
        super(threadname);
        this.account=account;
        this.drawMoney=drawMoney;
    }

    @Override
    public void run() {
        synchronized (account) {//加锁
            if (account.getAccount() >= drawMoney) {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                account.setAccount(account.getAccount() - drawMoney);
                System.out.println(getName() + "取款成功! " + "取出 " + drawMoney + ",余额" + account.getAccount());
            } else {
                System.out.println(getName() + "取款失败! " + "余额" + account.getAccount());
            }
        }//同步代码块结束,释放锁
    }
}

在run里进行取钱操作时,对account进行加锁,别的线程就不能使用account,这样就限制了同时使用account的线程只有一个,从而实现了对account这个共享资源的保护.

同步方法

同步方法就是使用synchronized修饰某个方法,该方法称为同步方法.对于同步方法,无须显示指定同步监视器,同步方法的监视器是this,也就是该对象本身.这样使得某个方法同时只有一个线程可以访问,使得该方法线程安全.

接下来我们修改account让其提供一个取钱的同步方法(这样更符合面向对象)

public class Account {

    private int account;
    private String name;

    public Account(String name,int account){
        this.account=account;
        this.name=name;
    }

    public synchronized void drawMoney(String personname,int money){
        if(account>=money){
            account=account-money;
            System.out.println(personname+"取钱成功!"+" 取出"+money+",剩余"+account);
        }else {
            System.out.println(personname+"取钱失败!"+" 账户余额"+account+",想要取出"+money);
        }
    }
}

修改取钱线程

public class DrawMoneyThread extends Thread{

    private Account account;
    private int drawMoney;

    public DrawMoneyThread(Account account,String threadname,int drawMoney){
        super(threadname);
        this.account=account;
        this.drawMoney=drawMoney;
    }

    @Override
    public void run() {
        account.drawMoney(getName(),drawMoney);
    }
}

测试类不变,进行测试,输出结果

A取钱成功! 取出600,剩余0
B取钱失败! 账户余额0,想要取出600

注意可变线类的程安全是以牺牲运行效率为代价的,因此仅对那些需要同步的方法进行同步就可以了.

释放同步监视器的锁定

释放

• 出现error,未捕获的exception,break,return等使得跳出同步代码块情况
• 当线程执行同步代码块或同步方法时,程序执行了同步监视器对象的wait()方法,则当前线程停止,并释放同步监视器.

不会释放的情况

• 当线程执行同步代码块或同步方法时,程序调用Ｔhread().sleep,Thread.yield()方法来暂停当前线程
• 当线程执行同步代码块或同步方法时,其他线程调用了该线程的suspend方法将该线程挂起

同步锁(Lock)

从JDK1.5以后java引入另一种线程同步的机制:它通过显示定义同步锁对象来实现同步,同步锁使用Lock充当
由于Lock下也有很多内容,不在这里详述,对account进行修改,演示大概如何使用Lock

public class Account {

    private int account;
    private String name;
    private final ReentrantLock lock=new ReentrantLock();

    public Account(String name,int account){
        this.account=account;
        this.name=name;
    }

    public void drawMoney(String personname,int money){
        lock.lock();//对同步锁加锁
        try {
            if(account>=money){
                account=account-money;
                System.out.println(personname+"取钱成功!"+" 取出"+money+",剩余"+account);
            }else {
                System.out.println(personname+"取钱失败!"+" 账户余额"+account+",想要取出"+money);
            }
        }finally {
            lock.unlock();//释放锁
        }
    }
}

死锁

由于互相等待同步监视器的释放导致都不能执行的情况成为死锁
写个例子来演示一下

public class A {
    public synchronized void first(B b){
        System.out.println("当前线程:"+Thread.currentThread().getName()+" 进入了A的first方法");
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("当前线程:"+Thread.currentThread().getName()+" 企图调用B实例的last方法");
        b.last();

    }

    public synchronized void last(){
        System.out.println("进入了A的last方法");
    }
}

public class B {
    public synchronized void first(A a){
        System.out.println("当前线程:"+Thread.currentThread().getName()+" 进入了B的first方法");
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("当前线程:"+Thread.currentThread().getName()+" 企图调用A实例的last方法");
        a.last();

    }

    public synchronized void last(){
        System.out.println("进入了A的last方法");
    }
}

public class DeadLock extends Thread {
    A a=new A();
    B b=new B();

    public void init(){
        Thread.currentThread().setName("主线程");
        a.first(b);
        System.out.println("进入了主线程之后");
    }

    @Override
    public void run() {
        Thread.currentThread().setName("副线程");
        b.first(a);
        System.out.println("进入了副线程之后");
    }

    public static void main(String []args){
        DeadLock deadLock=new DeadLock();
        deadLock.start();
        deadLock.init();
    }
}

运行结果:

当前线程:主线程 进入了A的first方法
当前线程:副线程 进入了B的first方法
当前线程:主线程 企图调用B实例的last方法
当前线程:副线程 企图调用A实例的last方法

可以看见程序并没有执行下去,而是进入相互等待状态