java synchronized修饰的方法中调用sleep竟然产生这样的输出?!
 package com.imooc.bank;

//银行类
public class Bank {
    private String account;
    private int balance;

    public Bank(String account, int balance) {
        this.account = account;
        this.balance = balance;
    }

    public String getAccount() {
        return account;
    }

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

    public int getBalance() {
        return balance;
    }

    public void setBalance(int balance) {
        this.balance = balance;
    }

    @Override
    public String toString() {
        return "Bank [账号:"+account+", 余额:"+balance+"]";
    }

    //存款
    public synchronized void saveAccount() {
        int balance = getBalance();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        balance += 100;
        setBalance(balance);

        System.out.println("存款后的账户余额为:"+balance);
    }

    //取款
    public void drawAccount() {
            int balance = getBalance();

            balance -= 200;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            setBalance(balance);

            System.out.println("取款后的账户余额为:"+balance);

    }



}
 package com.imooc.bank;
 //取款线程

public class DrawAccount implements Runnable{

    private Bank bank;

    public DrawAccount(Bank bank) {
        this.bank = bank;
    }

    @Override
    public void run() {
        bank.drawAccount();
    }


}
 package com.imooc.bank;
//存款线程
public class SaveAccount implements Runnable{

    private Bank bank;

    public SaveAccount(Bank bank) {
        this.bank = bank;
    }

    @Override
    public void run() {
        bank.saveAccount();

    }


}

 package com.imooc.bank;
//测试类
public class Test {

    public static void main(String[] args) {
        Bank bank = new Bank("1001", 1000);

        SaveAccount sa = new SaveAccount(bank);
        DrawAccount da = new DrawAccount(bank);

        Thread save = new Thread(sa);
        Thread draw = new Thread(da);

        save.start();
        draw.start();

        try {
            save.join();
            draw.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //加join是为了让下面这条语句最后输出
        System.out.println(bank);

    }

}

为啥会产生这样的输出?
取款后的账户余额为:800
存款后的账户余额为:1100
Bank [账号:1001, 余额:1100]

如果我把saveAccount方法也用synchronized修饰的话就会正常输出。
存款后的账户余额为:1100
取款后的账户余额为:900
Bank [账号:1001, 余额:900]

是sleep的原因导致调用这个public synchronized void saveAccount() 方法的线程被阻塞, 然后被别的线程占用了cpu吗?
不是说synchronized修饰的方法调用过程中不会被别的线程打断吗?
求大神解答!!

4个回答

不是不会被打断,而是多个线程同时调用同一个方法,才会同步,别的线程调用别的代码,不会。

sinat_34927324
sjk1996 你好, 那我两个线程都加synchronized时, 为啥结果就总是对的?
大约 2 年之前 回复

这是很明显的线程安全问题,因为加减操作是非原子操作,所以多线程中不加锁的话会出现脏读的情况,其实你加不加sleep这种问题都会出现,加了sleep
只会比较容易出现而已

这个应该和cpu处理有关系,两个线程同时开启,让他们两个同时进行开始,看他们两个谁运气好。就像抢火车票一样,有的能抢到,有的抢不到。这只是打个比方,希望你能理解。

由结果分析就能看出来了啊!
第一步首先你先save.start();然后再开启线程draw.start();并不是一起开的线程,程序顺序执行的是
第二步那么我们为什么会得出"取款后的账户余额为:800 存款后的账户余额为:1100"这个结果呢?
* 结果显示我们的程序首先运行的是取款操作,然后执行的才是存款操作.
* 那么我们就可以得出结论,是因为存款操作加锁导致进入程序变慢,
* 也就是说,存款线程首先要先获取锁,而取款线程可以直接运行取款操作没有任何阻碍
第三步那么为什么结果余额会是800 和 1100呢?
* 这是因为开启线程进入run方法拿到的是同一个bank对象此时进入到save和draw我还是画图给你看好了图片说明

zhuofai_
zhuofai_ 回复sinat_34927324: 就是这种问题比较简单了,如果还是不清楚的话可以.....发邮件好了2287233405@qq.com加微信也行哈哈
大约 2 年之前 回复
zhuofai_
zhuofai_ 回复sinat_34927324: 如果两个都加的话就不需要这么分析了,因为synchronized加的是同一个锁this,所以当开启save线程时会阻塞draw线程,并不会造成balance读取相同值的问题
大约 2 年之前 回复
sinat_34927324
sjk1996 感谢你详细的解答, 那我两个线程都加synchronized时, 为啥结果就总是对的?
大约 2 年之前 回复
zhuofai_
zhuofai_ 回复zforler: ...线程运行是和代码无关,但是线程先start不就首先开始吗?
大约 2 年之前 回复
zforler
单调的黑白灰 别瞎说,线程的运行跟代码的顺序无关
大约 2 年之前 回复
Csdn user default icon
上传中...
上传图片
插入图片
抄袭、复制答案,以达到刷声望分或其他目的的行为,在CSDN问答是严格禁止的,一经发现立刻封号。是时候展现真正的技术了!
立即提问
相关内容推荐