关于java之中死锁会不会占用系统资源

RT代码如下:

 

public class AnotherDeadLock { 

  public static void main(String[] args) { 

    final Object resource1 = "resource1"; 

    final Object resource2 = "resource2"; 

    // t1 tries to lock resource1 then resource2 

    Thread t1 = new Thread() { 

      public void run() { 

        // Lock resource 1 

        synchronized (resource1) { 

          System.out.println("Thread 1: locked resource 1"); 

          try { 

            Thread.sleep(50); 

          } catch (InterruptedException e) { 

          } 

 

          synchronized (resource2) { 

            System.out.println("Thread 1: locked resource 2"); 

          } 

        } 

      } 

    }; 

 

    // t2 tries to lock resource2 then resource1 

    Thread t2 = new Thread() { 

      public void run() { 

        synchronized (resource2) { 

          System.out.println("Thread 2: locked resource 2"); 

 

          try { 

            Thread.sleep(50); 

          } catch (InterruptedException e) { 

          } 

 

          synchronized (resource1) { 

            System.out.println("Thread 2: locked resource 1"); 

          } 

        } 

      } 

    }; 

 

    // If all goes as planned, deadlock will occur, 

 

    // and the program will never exit. 

    t1.start(); 

    t2.start(); 

  } 

}

 

各位可以自己试一试,有点儿疑惑(因为老师上课讲的是死锁会引发系统资源居高不下),

然后在德问社区中发帖求助,有大神回答如下:

源:http://www.dewen.org/q/13297/%E7%BA%BF%E7%A8%8B%E6%AD%BB%E9%94%81%E6%98%AF%E4%B8%8D%E6%98%AFcpu%E8%B5%84%E6%BA%90%E4%B8%80%E5%AE%9A%E4%BC%9A%E5%B1%85%E9%AB%98%E4%B8%8D%E4%B8%8B#24104

 

这取决于锁的实现,通常锁有两种实现:

  1. 拿不到锁的时候,忙等待,反复探测锁状态,直到拿到锁,进入临界区。这种情况会消耗CPU。

    1. while(locked);

    这种锁,称为自旋锁。比如pthread_spin_lock。

  2. 拿不到锁的时候,放弃CPU,休眠,离开运行队列,这种情况不会消耗CPU。

    1. while(locked) sleep(1);

    这种锁,称为休眠锁。pthread_mutex就是这种锁。也是最常用的锁。
    当然通常不会直接使用sleep实现,因为sleep会导致 释放锁后,等锁的线程不能及时醒来干活儿。一般会借助系统调用,比如linux上会使用futex,这个调用可以让等锁线程休眠直到被释放锁的线程唤醒 它。等锁线程会执行FUTEX_WAIT休眠, 而unlock的线程会执行FUTEX_WAKE唤醒休眠的等锁线程。

    1. if(locked) futex(FUTEX_WAIT...);

很显然由于自旋锁不会放弃CPU,没有调度开销(进出运行队列),性能要好于休眠锁,只是等锁的时候CPU是100%,所以适用于临界区比较短的场景。

facebook的folly库,实现了一种混合的锁,先自旋一定的次数,然后执行sleep放弃cpu。可以避免异常情况下,持锁进程长时间不释放导致的CPU开销问题。

关于锁的更多的探讨,可以参考我的一篇博文《多核环境下锁优化方法分析

java的synchronized应该是休眠锁。所以不占CPU。

 

 

另外打大神:

恰恰相反, 死锁的线程基本上不占用cpu. 你试一下自己的程序就知道了.

更新
因为你用java来举例, 而根据经验, java死锁的时候, cpu很低(不考虑有别的线程占用cpu的情况).
sun java1.7 x64:
死锁的线程:

  1. "Thread-1" prio=6 tid=0x0000000009184800 nid=0xd64 waiting for monitor entry [0x000000000b2ef000]
  2.    java.lang.Thread.State: BLOCKED (on object monitor)
  3.     at AnotherDeadLock$2.run(AnotherDeadLock.java:35)
  4.     - waiting to lock<0x00000000ecdc2020>(a java.lang.String)
  5.     - locked <0x00000000ecdc1fc8>(a java.lang.String)
  6.    Locked ownable synchronizers:
  7.     -None
  8. "Thread-0" prio=6 tid=0x0000000009184000 nid=0x1618 waiting for monitor entry [0x000000000b0ff000]
  9.    java.lang.Thread.State: BLOCKED (on object monitor)
  10.     at AnotherDeadLock$1.run(AnotherDeadLock.java:17)
  11.     - waiting to lock<0x00000000ecdc1fc8>(a java.lang.String)
  12.     - locked <0x00000000ecdc2020>(a java.lang.String)
  13.    Locked ownable synchronizers:
  14.     -None

死锁线程不占cpu:

 

 

大神回答:

进程的死锁是由两个以上的进程并发互斥访问临界资源时,发生相互等待造成的,进入死锁后,除了已经使用的资源外,并未有使用包括内存,CPU时间片等计算机资源。这是操作系统常识。

看来老师上课讲的不全是对的了

你可能感兴趣的:(java)