操作系统-线程死锁是不是cpu资源一定会居高不下

Question

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(); 
  } 
}

Answer 1

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

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

"Thread-1" prio=6 tid=0x0000000009184800 nid=0xd64 waiting for monitor entry [0x000000000b2ef000]
java.lang.Thread.State: BLOCKED (on object monitor)
at AnotherDeadLock$2.run(AnotherDeadLock.java:35)
- waiting to lock <0x00000000ecdc2020> (a java.lang.String)
- locked <0x00000000ecdc1fc8> (a java.lang.String)

Locked ownable synchronizers:
- None

"Thread-0" prio=6 tid=0x0000000009184000 nid=0x1618 waiting for monitor entry [0x000000000b0ff000]
java.lang.Thread.State: BLOCKED (on object monitor)
at AnotherDeadLock$1.run(AnotherDeadLock.java:17)
- waiting to lock <0x00000000ecdc1fc8> (a java.lang.String)
- locked <0x00000000ecdc2020> (a java.lang.String)

Locked ownable synchronizers:
- None

死锁线程不占cpu:

Answer 2

这取决于锁的实现，通常锁有两种实现：

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

while (locked);

这种锁，称为自旋锁。比如pthread_spin_lock。
拿不到锁的时候，放弃CPU，休眠，离开运行队列，这种情况不会消耗CPU。

while (locked) sleep(1);

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

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

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

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

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

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

Answer 3

你好，楼主，我认为不是。

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