欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Java多线程 线程同步与死锁

程序员文章站 2023-11-26 23:36:04
 java多线程 线程同步与死锁 1.线程同步 多线程引发的安全问题 一个非常经典的案例,银行取钱的问题。假如你有一张银行卡,里面有5000块钱,然后你去银...

 java多线程 线程同步与死锁

1.线程同步

多线程引发的安全问题

一个非常经典的案例,银行取钱的问题。假如你有一张银行卡,里面有5000块钱,然后你去银行取款2000块钱。正在你取钱的时候,取款机正要从你的5000余额中减去2000的时候,你的老婆正巧也在用银行卡对应的存折取钱,由于取款机还没有把你的2000块钱扣除,银行查到存折里的余额还剩5000块钱,准备减去2000。这时,有趣的事情发生了,你和你的老婆从同一个账户共取走了4000元,但是账户最后还剩下3000元。

使用代码模拟下取款过程:

public class threadtest {

  public static void main(string[] args) {
    // 创建一个账户,里面有存款5000元
    account account = new account(5000);
    // 模拟取钱过程
    getmoney getmoney = new getmoney(account);
    new thread(getmoney, "你").start();
    new thread(getmoney, "你老婆").start();
  }
}

class getmoney implements runnable {

  private account account;

  public getmoney(account account) {
    super();
    this.account = account;
  }

  @override
  public void run() {
    system.out.println(thread.currentthread().getname() + "账户现在有"
        + account.getmoney() + "元");
    // 使效果更明显,休眠10ms
    try {
      thread.sleep(10);
    } catch (interruptedexception e) {
      e.printstacktrace();
    }
    int money = account.getmoney() - 2000;
    account.setmoney(money);
    system.out.println(thread.currentthread().getname() + "取了2000元,账户现在有"
        + account.getmoney() + "元");
  }

}

class account {
  private int money;

  public account(int money) {
    super();
    this.money = money;
  }

  public int getmoney() {
    return money;
  }

  public void setmoney(int money) {
    this.money = money;
  }
}

看下打印信息:

你账户现在有5000元
你老婆账户现在有5000元
你取了2000元,账户现在有3000元
你老婆取了2000元,账户现在有3000元

同步锁

从上面的案例可以看出,当多个线程同时访问同一个数据时,很容易出现问题。为了避免这种情况出现,我们要保证线程同步互斥,就是指并发执行的多个线程,在同一时间内只允许一个线程访问共享数据。
java中可以使用synchronized关键字来取得一个对象的同步锁。

// object可以为任何对象,表示当前线程取得该对象的锁。
synchronized (object) {
}

修改一下上面的案例,在run方法中加入同步锁:

@override
public void run() {
  synchronized (this) {
    system.out.println(thread.currentthread().getname() + "账户现在有"
        + account.getmoney() + "元");
    // 使效果更明显,休眠10ms
    try {
      thread.sleep(10);
    } catch (interruptedexception e) {
      e.printstacktrace();
    }
    int money = account.getmoney() - 2000;
    account.setmoney(money);
    system.out.println(thread.currentthread().getname()
        + "取了2000元,账户现在有" + account.getmoney() + "元");
  }
}

看下打印信息:

你账户现在有5000元
你取了2000元,账户现在有3000元
你老婆账户现在有3000元
你老婆取了2000元,账户现在有1000元

当你取钱的时候,取款机锁定了你的账户,不允许其他人对账户进行操作,当你取完钱后,取款机释放了你的账户,你的老婆才可以取钱。

2.死锁

同步锁虽好,但也要科学使用,不然就会发生死锁,何为死锁,就是多个线程同时被阻塞,它们中的一个或者全部都在等待某个资源被释放。

举个栗子,两个人面对面过独木桥,甲和乙都已经在桥上走了一段距离,即占用了桥的资源,甲如果想通过独木桥的话,乙必须退出桥面让出桥的资源,让甲通过,但是乙不服,为什么让我先退出去,我还想先过去呢,于是就僵持不下,导致谁也过不了桥,这就是死锁。

下面用一段简单的代码来模拟死锁:

public class deadlocktest {

  public static void main(string[] args) {
    string str1 = new string("资源1");
    string str2 = new string("资源2");

    new thread(new lock(str1, str2), "线程1").start();
    new thread(new lock(str2, str1), "线程2").start();
  }
}

class lock implements runnable {

  private string str1;
  private string str2;

  public lock(string str1, string str2) {
    super();
    this.str1 = str1;
    this.str2 = str2;
  }

  @override
  public void run() {
    try {
      system.out.println(thread.currentthread().getname() + "运行");
      synchronized (str1) {
        system.out.println(thread.currentthread().getname() + "锁住"
            + str1);
        thread.sleep(1000);
        synchronized (str2) {
          // 执行不到这里
          system.out.println(thread.currentthread().getname()
              + "锁住" + str2);
        }
      }
    } catch (exception e) {
      e.printstacktrace();
    }
  }
}

看下打印信息:

线程1运行
线程2运行
线程1锁住资源1
线程2锁住资源2

第一个线程锁住了资源1(甲占有桥的一部分资源),第二个线程锁住了资源2(乙占有桥的一部分资源),线程1企图锁住资源2(甲让乙退出桥面,乙不从),进入阻塞,线程2企图锁住资源1(乙让甲退出桥面,甲不从),进入阻塞,死锁了。

死锁的产生是有规律可循的,只有同时满足以下四个条件,死锁才会产生。

1.互斥条件:一个资源每次只能被一个进程使用。独木桥每次只能通过一个人。

2.请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放。乙不退出桥面,甲也不退出桥面。

3.不剥夺条件: 进程已获得的资源,在未使用完之前,不能强行剥夺。甲不能强制乙退出桥面,乙也不能强制甲退出桥面。

4.循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。如果乙不退出桥面,甲不能通过,甲不退出桥面,乙不能通过。

知道了死锁产生的必要条件,在开发中就很容易避免死锁问题了。

感谢阅读,希望能帮助到大家,谢谢大家对本站的支持!