浅谈死锁原理

int64 发布于2019-06-25 18:12 / 2536人阅读

摘要：死锁通常发生在多个线程同时但以不同的顺序请求同一组锁的时候。现在和对象被两个不同的线程锁住了。更复杂的死锁死锁可能不止包含个线程，这让检测死锁变得更加困难。

死锁是两个或更多线程阻塞着等待其它处于死锁状态的线程所持有的锁。死锁通常发生在多个线程同时但以不同的顺序请求同一组锁的时候。

例如，如果线程1锁住了A，然后尝试对B进行加锁，同时线程2已经锁住了B，接着尝试对A进行加锁，这时死锁就发生了。线程1永远得不到B，线程2也永远得不到A，并且它们永远也不会知道发生了这样的事情。为了得到彼此的对象（A和B），它们将永远阻塞下去。这种情况就是一个死锁。

该情况如下：

Thread 1  locks A, waits for B
Thread 2  locks B, waits for A

这里有一个TreeNode类的例子，它调用了不同实例的synchronized方法：

public class TreeNode {
    TreeNode parent   = null;  
    List children = new ArrayList();

    public synchronized void addChild(TreeNode child){
        if(!this.children.contains(child)) {
            this.children.add(child);
            child.setParentOnly(this);
        }
    }

    public synchronized void addChildOnly(TreeNode child){
        if(!this.children.contains(child){
            this.children.add(child);
        }
    }

    public synchronized void setParent(TreeNode parent){
        this.parent = parent;
        parent.addChildOnly(this);
    }

    public synchronized void setParentOnly(TreeNode parent){
        this.parent = parent;
    }
}

如果线程1调用parent.addChild(child)方法的同时有另外一个线程2调用child.setParent(parent)方法，两个线程中的parent表示的是同一个对象，child亦然，此时就会发生死锁。下面的伪代码说明了这个过程：

Thread 1: parent.addChild(child); //locks parent
          --> child.setParentOnly(parent);

Thread 2: child.setParent(parent); //locks child
          --> parent.addChildOnly()

首先线程1调用parent.addChild(child)。因为addChild()是同步的，所以线程1会对parent对象加锁以不让其它线程访问该对象。

然后线程2调用child.setParent(parent)。因为setParent()是同步的，所以线程2会对child对象加锁以不让其它线程访问该对象。

现在child和parent对象被两个不同的线程锁住了。接下来线程1尝试调用child.setParentOnly()方法，但是由于child对象现在被线程2锁住的，所以该调用会被阻塞。线程2也尝试调用parent.addChildOnly()，但是由于parent对象现在被线程1锁住，导致线程2也阻塞在该方法处。现在两个线程都被阻塞并等待着获取另外一个线程所持有的锁。

注意：像上文描述的，这两个线程需要同时调用parent.addChild(child)和child.setParent(parent)方法，并且是同一个parent对象和同一个child对象，才有可能发生死锁。上面的代码可能运行一段时间才会出现死锁。

这些线程需要同时获得锁。举个例子，如果线程1稍微领先线程2，然后成功地锁住了A和B两个对象，那么线程2就会在尝试对B加锁的时候被阻塞，这样死锁就不会发生。因为线程调度通常是不可预测的，因此没有一个办法可以准确预测什么时候死锁会发生，仅仅是可能会发生。

更复杂的死锁

死锁可能不止包含2个线程，这让检测死锁变得更加困难。下面是4个线程发生死锁的例子：

Thread 1  locks A, waits for B
Thread 2  locks B, waits for C
Thread 3  locks C, waits for D
Thread 4  locks D, waits for A

线程1等待线程2，线程2等待线程3，线程3等待线程4，线程4等待线程1。

数据库的死锁

更加复杂的死锁场景发生在数据库事务中。一个数据库事务可能由多条SQL更新请求组成。当在一个事务中更新一条记录，这条记录就会被锁住避免其他事务的更新请求，直到第一个事务结束。同一个事务中每一个更新请求都可能会锁住一些记录。

当多个事务同时需要对一些相同的记录做更新操作时，就很有可能发生死锁，例如：

Transaction 1, request 1, locks record 1 for update
Transaction 2, request 1, locks record 2 for update
Transaction 1, request 2, tries to lock record 2 for update.
Transaction 2, request 2, tries to lock record 1 for update.

因为锁发生在不同的请求中，并且对于一个事务来说不可能提前知道所有它需要的锁，因此很难检测和避免数据库事务中的死锁。

原文 Deadlock
译者申章
校对丁一
via ifeve.com

GPU云服务器云服务器设计浅谈浅谈javascript 浅谈sdwan解决方案浅谈正则表达式

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/17436.html

浅谈Java中锁的问题

摘要：之前我们简单的讨论了一下关于中的同步还有一些锁优化的问题，今天我们就来简单的聊一聊关于中的死锁问题。这里显示两个线程的状态现在是处于阻塞状态，然后都在等待锁的获取，我们再继续往下看。之前我们简单的讨论了一下关于Java中的同步还有一些锁优化的问题，今天我们就来简单的聊一聊关于Java中的死锁问题。这个问题我们在开发的时候，或多或少都能遇到，对业务逻辑没有正确的梳理，又或者是在多线程...

fox_soyoung 2019-08-19 10:57 评论0 收藏0
Java并发核心浅谈

摘要：耐心看完的你或多或少会有收获并发的核心就是包，而的核心是抽象队列同步器，简称，一些锁啊信号量啊循环屏障啊都是基于。耐心看完的你或多或少会有收获！ Java并发的核心就是 java.util.concurrent 包，而 j.u.c 的核心是AbstractQueuedSynchronizer抽象队列同步器，简称 AQS，一些锁啊！信号量啊！循环屏障啊！都是基于AQS。而 AQS 又是...

cppowboy 2019-08-16 18:04 评论0 收藏0
浅谈Java并发编程系列（八）—— LockSupport原理剖析

摘要：此对象在线程受阻塞时被记录，以允许监视工具和诊断工具确定线程受阻塞的原因。阻塞当前线程，最长不超过纳秒，返回条件在的基础上增加了超时返回。唤醒线程唤醒处于阻塞状态的线程。 LockSupport 用法简介 LockSupport 和 CAS 是Java并发包中很多并发工具控制机制的基础，它们底层其实都是依赖Unsafe实现。 LockSupport是用来创建锁和其他同步类的基本线程阻塞...

jeyhan 2019-08-14 17:36 评论0 收藏0
浅谈java中的并发控制

摘要：并发需要解决的问题功能性问题线程同步面临两个问题，想象下有两个线程在协作工作完成某项任务。锁可用于规定一个临界区，同一时间临界区内仅能由一个线程访问。并发的数据结构线程安全的容器，如等。并发指在宏观上的同一时间内同时执行多个任务。为了满足这一需求，现代的操作系统都抽象出线程的概念，供上层应用使用。这篇博文不打算详细展开分析，而是对java并发中的概念和工具做一个梳理。沿着并发模...

Gilbertat 2019-08-16 12:39 评论0 收藏0