精华内容
下载资源
问答
  • public class DeadLockSample {public static void main(String[] args) {DeadLock d1 = new DeadLock(true);DeadLock d2 = new DeadLock...}}class Lock {/*** 死锁定义 所谓死锁是指两个或两个以上的线程在执...

    public class DeadLockSample {

    public static void main(String[] args) {

    DeadLock d1 = new DeadLock(true);

    DeadLock d2 = new DeadLock(false);

    d1.start();

    d2.start();

    }

    }

    class Lock {

    /**

    * 死锁定义 所谓死锁是指两个或两个以上的线程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去。

    * 死锁发生时的条件: *

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

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

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

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

    * 先看生活中的一个实例,两个人面对面过独木桥,甲和乙都已经在桥上走了一段距离,即占用了桥的资源,甲如果想通过独木桥的话,

    * 乙必须退出桥面让出桥的资源,让甲通过,但是乙不服,为什么让我先退出去,我还想先过去呢,于是就僵持不下,导致谁也过不了桥,这就是死锁。

    *

    * 在计算机系统中也存在类似的情况。例如,某计算机系统中只有一台打印机和一台输入 设备,进程P1正占用输入设备,

    * 同时又提出使用打印机的请求,但此时打印机正被进程P2 所占用,而P2在未释放打印机之前,

    * 又提出请求使用正被P1占用着的输入设备。这样两个进程相互无休止地等待下去,均无法继续执行,此时两个进程陷入死锁状态。

    * 下面代码将产生死锁

    */

    static Object obja = new Object();

    static Object objb = new Object();

    }

    class DeadLock extends Thread {

    private boolean flag;

    DeadLock(boolean flag) {

    this.flag = flag;

    }

    @Override

    public void run() {

    if (flag) {

    synchronized (Lock.obja) {

    System.out.println("if obja");

    synchronized (Lock.objb) {

    System.out.println("if objb");

    }

    }

    } else {

    synchronized (Lock.objb) {

    System.out.println("else objb");

    synchronized (Lock.obja) {

    System.out.println("else obja");

    }

    }

    }

    }

    }

    展开全文
  • Java死锁分析

    2021-05-13 17:58:14
    死锁是多进程环境下的一种假死现象,即产生死锁的进程都处于等待状态。只要满足了下面四个必要条件,就有可能产生死锁:互斥条件:进程对所分配到的资源不允许其他进程进行访问,若其他进程访问该资源,只能等待,...

    死锁是多进程环境下的一种假死现象,即产生死锁的进程都处于等待状态。只要满足了下面四个必要条件,就有可能产生死锁:

    互斥条件:进程对所分配到的资源不允许其他进程进行访问,若其他进程访问该资源,只能等待,直至占有该资源的进程使用完成后释放该资源

    请求和保持条件:进程获得一定的资源之后,又对其他资源发出请求,但是该资源可能被其他进程占有,此事请求阻塞,但又对自己获得的资源保持不放

    不可剥夺条件:是指进程已获得的资源,在未完成使用之前,不可被剥夺,只能在使用完后自己释放

    环路等待条件:是指进程发生死锁后,必然存在一个进程–资源之间的环形链

    一旦产生了死锁,程序将不再往下执行。那么应该怎么分析程序是否产生了死锁呢?本节来介绍一种使用Java Dump分析死锁的方法。

    1.包含死锁的程序

    下面是一段包含死锁的程序:DeadLock.java

    public class DeadLock {

    final Object lockA = new Object();

    final Object lockB = new Object();

    public static void main(String[] args) {

    DeadLock demo = new DeadLock();

    demo.startLock();

    }

    public void startLock(){

    ThreadA a= new ThreadA(lockA,lockB);

    ThreadB b= new ThreadB(lockA,lockB);

    //start threads

    a.start();

    b.start();

    }

    }

    class ThreadA extends Thread{

    private Object lockA = null;

    private Object lockB = null;

    public ThreadA(Object a, Object b){

    this.lockA = a;

    this.lockB = b;

    }

    public void run() {

    synchronized (lockA) {

    System.out.println("*** Thread A: ***: Lock A" );

    try {

    sleep(3000);

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    synchronized (lockB) {

    System.out.println("*** Thread A: ***: Lock B" );

    }

    }

    System.out.println("*** Thread A: ***: Finished" );

    }

    }

    class ThreadB extends Thread{

    private Object lockA = null;

    private Object lockB = null;

    public ThreadB(Object a, Object b){

    this.lockA = a;

    this.lockB = b;

    }

    public void run() {

    synchronized (lockB) {

    System.out.println("*** Thread B: ***: Lock B" );

    try {

    sleep(3000);

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    synchronized (lockA) {

    System.out.println("*** Thread B: ***: Lock A" );

    }

    }

    System.out.println("*** Thread B: ***: Finished" );

    }

    }

    说明:以上代码中,有两个共享资源lockA和lockB,同时启动两个线程a和b,其中线程a先申请资源lockA,然后睡3秒,再去申请资源lockB;线程b先申请资源lockB,然后也睡3秒,再去申请资源lockA。当线程a启动并申请到资源lockA然后睡3秒时,这时线程b启动并申请到资源lockB也睡3秒;等线程a睡醒后去申请资源lockB,发现资源lockB被其他线程占用,所以线程a就开始等待;等线程b睡醒后去申请资源lockA,发现资源lockA也被其他线程占用,然后线程b也开始等待。如此这般,a和b就进入了循环等待的死锁状态。

    2.使用JDK的Thread Dump工具分析死锁

    这里介绍一种在Windows和Linux下,使用JDK提供的Thread Dump工具分析死锁的办法。

    1.Windows下使用Thread Dump分析死锁

    (1)编译并执行DeadLock.java程序

    409e8eeb2e0c

    image

    (2)按Ctrl + Break(或者fn + b)分析死锁

    409e8eeb2e0c

    image

    409e8eeb2e0c

    image

    2.Linux下使用Thread Dump分析死锁

    (1)编译并执行DeadLock.java程序

    409e8eeb2e0c

    image

    (2)使用kill -3 PID分析死锁

    新打开一个终端,查看jps进程号,使用kill -3 PID杀死死锁进程:

    409e8eeb2e0c

    image

    原来的终端窗口会显示检测到的死锁信息:

    409e8eeb2e0c

    image

    死锁分析是一门非常重要的技术手段。使用Thread Dump工具可以方便的检测出程序是否包含死锁。

    本节介绍了Java中使用Thread Dump工具分析死锁的详细过程。祝你玩的愉快!

    展开全文
  • Java 死锁及解决方法

    2021-02-27 14:41:24
    import java.util.Date;import java.util.concurrent.Semaphore;import java.util.concurrent.TimeUnit;public class UnLockTest {public static String obj1 = "obj1";public static final Semaphore a1 = new Sema...

    import java.util.Date;

    import java.util.concurrent.Semaphore;

    import java.util.concurrent.TimeUnit;

    public class UnLockTest {

    public static String obj1 = "obj1";

    public static final Semaphore a1 = new Semaphore(1);

    public static String obj2 = "obj2";

    public static final Semaphore a2 = new Semaphore(1);

    public static void main(String[] args) {

    LockAa la = new LockAa();

    new Thread(la).start();

    LockBb lb = new LockBb();

    new Thread(lb).start();

    }

    }

    class LockAa implements Runnable {

    public void run() {

    try {

    System.out.println(new Date().toString() + " LockA 开始执行");

    while (true) {

    if (UnLockTest.a1.tryAcquire(1, TimeUnit.SECONDS)) {

    System.out.println(new Date().toString() + " LockA 锁住 obj1");

    if (UnLockTest.a2.tryAcquire(1, TimeUnit.SECONDS)) {

    System.out.println(new Date().toString() + " LockA 锁住 obj2");

    Thread.sleep(60 * 1000); // do something

    }else{

    System.out.println(new Date().toString() + "LockA 锁 obj2 失败");

    }

    }else{

    System.out.println(new Date().toString() + "LockA 锁 obj1 失败");

    }

    UnLockTest.a1.release(); // 释放

    UnLockTest.a2.release();

    Thread.sleep(1000); // 马上进行尝试,现实情况下do something是不确定的

    }

    } catch (Exception e) {

    e.printStackTrace();

    }

    }

    }

    class LockBb implements Runnable {

    public void run() {

    try {

    System.out.println(new Date().toString() + " LockB 开始执行");

    while (true) {

    if (UnLockTest.a2.tryAcquire(1, TimeUnit.SECONDS)) {

    System.out.println(new Date().toString() + " LockB 锁住 obj2");

    if (UnLockTest.a1.tryAcquire(1, TimeUnit.SECONDS)) {

    System.out.println(new Date().toString() + " LockB 锁住 obj1");

    Thread.sleep(60 * 1000); // do something

    }else{

    System.out.println(new Date().toString() + "LockB 锁 obj1 失败");

    }

    }else{

    System.out.println(new Date().toString() + "LockB 锁 obj2 失败");

    }

    UnLockTest.a1.release(); // 释放

    UnLockTest.a2.release();

    Thread.sleep(10 * 1000); // 这里只是为了演示,所以tryAcquire只用1秒,而且B要给A让出能执行的时间,否则两个永远是死锁

    }

    } catch (Exception e) {

    e.printStackTrace();

    }

    }

    }

    运行结果:

    Tue May 05 10:59:13 CST 2015 LockA 开始执行

    Tue May 05 10:59:13 CST 2015 LockB 开始执行

    Tue May 05 10:59:13 CST 2015 LockB 锁住 obj2

    Tue May 05 10:59:13 CST 2015 LockA 锁住 obj1

    Tue May 05 10:59:14 CST 2015LockB 锁 obj1 失败

    Tue May 05 10:59:14 CST 2015LockA 锁 obj2 失败

    Tue May 05 10:59:15 CST 2015 LockA 锁住 obj1

    Tue May 05 10:59:15 CST 2015 LockA 锁住 obj2

    采用lock锁 使用trylock 获取锁,并使用unlock释放锁 采用flag控制循环的结束

    import java.util.Date;

    import java.util.concurrent.TimeUnit;

    import java.util.concurrent.locks.ReentrantLock;

    /**

    * @description 采用lock 锁 使用trylock 获取锁,并使用unlock释放锁 采用flag控制循环的结束

    **/

    public class LockTest3 {

    public static ReentrantLock lock1 = new ReentrantLock();

    public static ReentrantLock lock2 = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {

    Thread t1 = new Thread(new LockA(),"线程A");

    Thread t2 = new Thread(new LockB(),"线程B");

    t1.start();

    t2.start();

    Thread.sleep(5000);

    System.out.println("主线程结束");

    }

    static class LockA implements Runnable{

    boolean fa = true;

    @Override

    public void run() {

    System.out.println("线程A开始执行"+new Date());

    try {

    while (fa){

    if (LockTest3.lock1.tryLock(1,TimeUnit.SECONDS)){

    System.out.println("线程A锁住lock1"+new Date());

    if (LockTest3.lock2.tryLock(1,TimeUnit.SECONDS)){

    System.out.println("线程A锁住lock2"+new Date());

    fa =false;

    }else {

    System.out.println("线程A锁住lock2 失败"+new Date());

    }

    }else {

    System.out.println("线程A锁住lock1 失败"+new Date());

    }

    /* lock1.unlock();

    lock2.unlock();*/

    System.out.println("当前线程"+Thread.currentThread().getName());

    if (lock1.isHeldByCurrentThread()){

    lock1.unlock();

    System.out.println("线程A释放lock1");

    }

    if (lock2.isHeldByCurrentThread()){

    lock2.unlock();

    System.out.println("线程A释放lock2");

    }

    Thread.sleep(2000);

    }

    System.out.println("线程A结束=============");

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    }

    }

    static class LockB implements Runnable{

    boolean fb = true;

    @Override

    public void run() {

    System.out.println("线程B开始执行"+new Date());

    try {

    while (fb){

    if (LockTest3.lock2.tryLock(1,TimeUnit.SECONDS)){

    System.out.println("线程B锁住lock2"+new Date());

    if (LockTest3.lock1.tryLock(1,TimeUnit.SECONDS)){

    System.out.println("线程B锁住lock1"+new Date());

    fb=false;

    }else {

    System.out.println("线程B锁住lock1 失败"+new Date());

    }

    }else {

    System.out.println("线程B锁住lock2 失败"+new Date());

    }

    /* lock1.unlock();

    lock2.unlock();*/

    System.out.println("当前线程"+Thread.currentThread().getName());

    if (lock1.isHeldByCurrentThread()){

    lock1.unlock();

    System.out.println("线程B释放lock1");

    }

    if (lock2.isHeldByCurrentThread()){

    lock2.unlock();

    System.out.println("线程B释放lock2");

    }

    Thread.sleep(2000);

    }

    System.out.println("线程结束B=============");

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    }

    }

    }

    输出结果

    线程A开始执行Wed Dec 25 11:23:27 CST 2019

    线程A锁住lock1Wed Dec 25 11:23:27 CST 2019

    线程A锁住lock2Wed Dec 25 11:23:27 CST 2019

    当前线程线程A

    线程A释放lock1

    线程A释放lock2

    线程B开始执行Wed Dec 25 11:23:27 CST 2019

    线程B锁住lock2Wed Dec 25 11:23:27 CST 2019

    线程B锁住lock1Wed Dec 25 11:23:27 CST 2019

    当前线程线程B

    线程B释放lock1

    线程B释放lock2

    线程A结束=============

    线程结束B=============

    主线程结束

    展开全文
  • java死锁

    千次阅读 2021-06-14 18:48:43
    public class Test { public static void main(String[] args) { Makeup g1=new Makeup(0,"灰姑凉"); Makeup g2=new Makeup(1,"白雪公主"); g1.start(); g2.start(); } } ...class Mak...

    怎样会产生死锁

     

    某一个同步块用时拥有"两个以上对象的锁"时,就可能会发生"死锁"的问题

     

    死锁避免方法()

     

    产生死锁的四个必要条件:

    1.互斥条件:一个资源每次只能被一个进程使用
    2.请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放
    3.不剥夺条件:进程已获得的资源,在没使用完之前,不能强行剥夺
    4.循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系
    public class Test {
        public static void main(String[] args) {
            Makeup g1=new Makeup(0,"灰姑凉");
            Makeup g2=new Makeup(1,"白雪公主");
    
            g1.start();
            g2.start();
    
        }
    }
    
    //口红
    class Lipstick{
    
    }
    
    //镜子
    class Mirror{
    
    }
    
    class Makeup extends Thread{
        //需要的资源只有一份,用static来保证只有一份
        static Lipstick lipstick=new Lipstick();
        static Mirror mirror=new Mirror();
    
        int choice;//选择
        String girlName;//使用化妆品的人
    
        Makeup(int choice,String girlName){
            this.choice=choice;
            this.girlName=girlName;
        }
    
        @Override
        public void run() {
            try {
                makeup();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        //化妆,互相持有对象的锁,就是需要拿到对方的资源
        private void makeup() throws InterruptedException {
            if(choice==0){
                synchronized (lipstick){//获取口红的锁
                    System.out.println(this.girlName+": 获取口红的锁");
                    Thread.sleep(1000);
                    /*System.out.println("注意:会产生死锁,放在外面则不会");
                    synchronized (mirror){//一秒种后想获得镜子
                        System.out.println(this.girlName+": 获取镜子的锁");
                    }*/
                }
                synchronized (mirror){//一秒种后想获得镜子
                    System.out.println(this.girlName+": 获取镜子的锁");
                }
            }else{
                synchronized (mirror){//获取口红的锁
                    System.out.println(this.girlName+": 获取镜子的锁");
                    Thread.sleep(2000);
                    /*System.out.println("注意:会产生死锁,放在外面则不会");
                    synchronized (lipstick){//一秒种后想获得镜子
                        System.out.println(this.girlName+": 获取口红的锁");
                    }*/
                }
                synchronized (lipstick){//一秒种后想获得镜子
                    System.out.println(this.girlName+": 获取口红的锁");
                }
            }
        }
    }

     

    展开全文
  • java死锁排查

    2021-03-15 03:22:32
    废话不多说,直接看下面死锁代码,这是一个典型的死锁,线程1拿到A锁获取B锁,线程2拿到B锁获取A锁public class DeadLockTest{private static Object A = new Object(), B = new Object();public static void main...
  • Java 死锁以及如何避免?

    千次阅读 2021-03-04 07:10:15
    Java中产生死锁的原因以及如何避免:1. Java中导致死锁的原因Java死锁最简单的情况是,一个线程T1持有锁L1并且申请获得锁L2,而另一个线程T2持有锁L2并且申请获得锁L1,因为默认的锁申请操作都是阻塞的,所以线程...
  • java死锁原因和解决

    2021-07-23 11:25:19
    死锁 简单点来说,两个或两个以上的线程情景下,线程A持有锁资源A,但是还想要资源B,于是请求B锁,线程B持有锁资源B,但是还想要资源A,于是请求A锁。两者互不释放锁,又想获得对方资源。 死锁条件 1、请求保持 2...
  • Java死锁示例及检测

    2021-02-28 14:11:14
    死锁是指多个线程在等待不可能被释放的锁,导致程序无法继续运行,下面用一个例子来说明。线程A持有lock1,在等待lock2,线程B持有lock2,在等待lock1,这样就发生了死锁。首先看一个类DealThread,这个类含有互斥锁...
  • Java死锁范例ThreadDeadlock.java在上面的程序中同步线程正完成Runnable的接口,它工作的是两个对象,这两个对象向对方寻求死锁而且都在使用同步阻塞。在主函数中,我使用了三个为同步线程运行的线程,而且...
  • Java死锁的简单例子

    2021-04-17 10:08:04
    Java死锁的简单例子两个线程互相占有对方需要的资源而不释放,便形成了死锁。代码如下:Program.java/*** 程序类* @author michael**/public class Program implements Runnable {//两个静态的资源public static ...
  • java死锁程序

    2021-02-28 17:17:57
    (1)死锁案例/*** 一个简单的死锁类* main方法中启动两个线程,分别调用methodA和methodB方法* methodA方法首先获取到a对象的锁,睡眠1秒钟* 此时methodB方法执行获取到b对象的锁,睡眠1秒* 此时methodA需要去获取b...
  • 进程死锁及解决办法一、要点提示(1) 掌握死锁的概念和产生死锁的根本原因。(2) 理解产生死锁的必要条件–以下四个条件同时具备:互斥条件、不可抢占条件、占有且申请条件、循环等待条件。(3) 记住解决死锁的一般方法...
  • Java死锁的理解

    2021-03-09 08:08:09
    我们有时候操作数据库的时候会遇到死锁,那么什么使死锁呢?它的一个比较官方的定义就是:死锁是指两个或两个以上的进程在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞的现象,若无外力作用,它们都将...
  • 1 死锁是什么死锁是指两个线程之间相互等待对方资源,但同时又互不相让,都想自己先执行2 Java中的死锁具体例子使用synchronized 关键子作为锁,并且两个线程之间同时对同一个synchronized关键子修饰的对象锁进行...
  • java死锁示例代码

    2021-03-15 11:31:12
    public class DeadLock {public static String obj1 = "obj1";public static String obj2 = "obj2";public static void main(String[] args) {Thread thread1 = new Thread(new Lock1());Thread thread2 = new Threa...
  • 死锁原因Java发生死锁的根本原因是:在申请锁时发生了交叉闭环申请。即线程在获得了锁A并且没有释放的情况下去申请锁B,这时,另一个线程已经获得了锁B,在释放锁B之前又要先获得锁A,因此闭环发生,陷入死锁循环。...
  • java死锁分析

    2021-02-28 15:58:16
    Java死锁分析(*)JDK: 提供强大诊断工具:Thread Dump ----> 文本信息(*)windows: ctrl+break /(fn+B) 打印锁信息linux: kill -3 pid ----> 命令:jps 打印锁信息Java stack information for the...
  • Java死锁问题

    2021-01-18 23:59:54
    Java死锁问题 可以参考哲学家就餐问题,了解死锁的基本特点 死锁产生原因及解决方式想了解的自行百度,这里不再赘述,注意的是解决一个原因就能解决死锁 下面通过Java代码模拟哲学家就餐问题中死锁的产生 package test...
  • Java死锁

    2021-09-02 10:39:00
    Java死锁 出现死锁的情况 当第一个线程拥有A对象锁标记,并等待B对象锁标记,第二个线程拥有B对象锁标记,并等待A对象锁标记,产生死锁 一个线程可以拥有多个对象锁标记,当线程阻塞的时候,不会释放已经拥有的锁...
  • Java死锁代码演示死锁的概念知识储备对象锁:Java一切皆对象,每个类都有一个class文件。由class文件可以new出对象,我们简单认识 下java对象,对象有个对象头信息,也就是这个对象概述,其中一条信息就是对象锁,也...
  • Java 死锁

    2021-04-18 02:48:07
    请模拟写出一段 Java 死锁的核心代码?如何避免死锁?答:死锁其实就是陷入互相等待谁都无法执行的一种状态,譬如有 A 和 B 两个线程,A 持有 LockA 锁且在等待 LockB 锁,而 B 持有锁 LockB 且在等待 LockA 锁,...
  • java死锁简介

    2021-07-27 09:42:23
    此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程。即某一个同步块同时拥有“两个以上对象的锁”时,就可能会发生"死锁"的问题。 示例: public class TestDeadLock { public static...
  • 死锁的概念知识储备对象锁:Java一切皆对象,每个类都有一个class文件。由class文件可以new出对象,我们简单认识 下java对象,对象有个对象头信息,也就是这个对象概述,其中一条信息就是对象锁,也就是我们当前对象...
  • java死锁检测

    2021-02-24 20:33:08
    * @Description: java死锁测试 * 进程id查看命令:jsp 找到对应的进程id * 通过jstack 进程id 输出死锁信息 * * 如何定位死循环导致的其他线程阻塞等待: * linux下top命令查看cpu使用率较高的java进程,进而...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 155,660
精华内容 62,264
关键字:

java死锁

java 订阅