问题引入–模拟银行取钱
关于线程安全问题,借用经典的银行取钱问题引入,除去验证登陆等步骤,只考虑取钱过程.
- 用户输入取款金额
- 系统判断余额是否大于取款金额
- 如果余额大于取款金额,则取款成功;如果小于取款金额则取款失败
我们模拟以上流程,采用两个线程同时操作一个账户来模拟并发取钱问题
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方法可以看见程序并没有执行下去,而是进入相互等待状态
扫一扫
608
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
