多线程之死锁就是这么简单

时间 2019-11-10

标签多线程死锁就是简单栏目 Java 繁體版

原文原文链接

前言

只有光头才能变强

回顾前面：html

本篇主要是讲解死锁，这是我在多线程的最后一篇了。主要将多线程的基础过一遍，之后有机会再继续深刻！java

死锁是在多线程中也是比较重要的知识点了！编程

那么接下来就开始吧，若是文章有错误的地方请你们多多包涵，不吝在评论区指正哦~c#

声明：本文使用JDK1.8

1、死锁讲解

在Java中使用多线程，就会有可能致使死锁问题。死锁会让对应产生死锁的线程卡住，再也不程序往下执行。咱们只能经过停止并重启的方式来让程序从新执行。微信

这是咱们很是不肯意看到的一种现象，咱们要尽量避免死锁的状况发生！

形成死锁的缘由能够归纳成三句话：多线程

当前线程拥有其余线程须要的资源
当前线程等待其余线程已拥有的资源
都不放弃本身拥有的资源

1.1锁顺序死锁

首先咱们来看一下最简单的死锁(锁顺序死锁)是怎么样发生的：并发

public class LeftRightDeadlock {
    private final Object left = new Object();
    private final Object right = new Object();

    public void leftRight() {
        // 获得left锁
        synchronized (left) {
            // 获得right锁
            synchronized (right) {
                doSomething();
            }
        }
    }

    public void rightLeft() {
        // 获得right锁
        synchronized (right) {
            // 获得left锁
            synchronized (left) {
                doSomethingElse();
            }
        }
    }
}

咱们的线程是交错执行的，那么就颇有可能出现如下的状况：ide

线程A调用leftRight()方法，获得left锁
同时线程B调用rightLeft()方法，获得right锁
线程A和线程B都继续执行，此时线程A须要right锁才能继续往下执行。此时线程B须要left锁才能继续往下执行。
可是：线程A的left锁并无释放，线程B的right锁也没有释放。
因此他们都只能等待，而这种等待是无期限的-->永久等待-->死锁

1.2动态锁顺序死锁

咱们看一下下面的例子，你认为会发生死锁吗？工具

// 转帐
    public static void transferMoney(Account fromAccount,
                                     Account toAccount,
                                     DollarAmount amount)
            throws InsufficientFundsException {

        // 锁定汇帐帐户
        synchronized (fromAccount) {
            // 锁定来帐帐户
            synchronized (toAccount) {

                // 判余额是否大于0
                if (fromAccount.getBalance().compareTo(amount) < 0) {
                    throw new InsufficientFundsException();
                } else {

                    // 汇帐帐户减钱
                    fromAccount.debit(amount);

                    // 来帐帐户增钱
                    toAccount.credit(amount);
                }
            }
        }
    }

上面的代码看起来是没有问题的：锁定两个帐户来判断余额是否充足才进行转帐！oop

可是，一样有可能会发生死锁：

若是两个线程同时调用transferMoney()
线程A从X帐户向Y帐户转帐
线程B从帐户Y向帐户X转帐
那么就会发生死锁。

A:transferMoney(myAccount,yourAccount,10);


B:transferMoney(yourAccount,myAccount,20);

1.3协做对象之间发生死锁

咱们来看一下下面的例子：

public class CooperatingDeadlock {
    // Warning: deadlock-prone!
    class Taxi {
        @GuardedBy("this") private Point location, destination;
        private final Dispatcher dispatcher;

        public Taxi(Dispatcher dispatcher) {
            this.dispatcher = dispatcher;
        }

        public synchronized Point getLocation() {
            return location;
        }

        // setLocation 须要Taxi内置锁
        public synchronized void setLocation(Point location) {
            this.location = location;
            if (location.equals(destination))
                // 调用notifyAvailable()须要Dispatcher内置锁
                dispatcher.notifyAvailable(this);
        }

        public synchronized Point getDestination() {
            return destination;
        }

        public synchronized void setDestination(Point destination) {
            this.destination = destination;
        }
    }

    class Dispatcher {
        @GuardedBy("this") private final Set<Taxi> taxis;
        @GuardedBy("this") private final Set<Taxi> availableTaxis;

        public Dispatcher() {
            taxis = new HashSet<Taxi>();
            availableTaxis = new HashSet<Taxi>();
        }

        public synchronized void notifyAvailable(Taxi taxi) {
            availableTaxis.add(taxi);
        }

        // 调用getImage()须要Dispatcher内置锁
        public synchronized Image getImage() {
            Image image = new Image();
            for (Taxi t : taxis)
                // 调用getLocation()须要Taxi内置锁
                image.drawMarker(t.getLocation());
            return image;
        }
    }

    class Image {
        public void drawMarker(Point p) {
        }
    }
}

上面的getImage()和setLocation(Point location)都须要获取两个锁的

而且在操做途中是没有释放锁的

这就是隐式获取两个锁(对象之间协做)..

这种方式也很容易就形成死锁.....

2、避免死锁的方法

避免死锁能够归纳成三种方法：

固定加锁的顺序(针对锁顺序死锁)
开放调用(针对对象之间协做形成的死锁)
使用定时锁-->tryLock()
- 若是等待获取锁时间超时，则抛出异常而不是一直等待！

2.1固定锁顺序避免死锁

上面transferMoney()发生死锁的缘由是由于加锁顺序不一致而出现的~

正如书上所说的：若是全部线程以固定的顺序来得到锁，那么程序中就不会出现锁顺序死锁问题！

那么上面的例子咱们就能够改造成这样子：

public class InduceLockOrder {

    // 额外的锁、避免两个对象hash值相等的状况(即便不多)
    private static final Object tieLock = new Object();

    public void transferMoney(final Account fromAcct,
                              final Account toAcct,
                              final DollarAmount amount)
            throws InsufficientFundsException {
        class Helper {
            public void transfer() throws InsufficientFundsException {
                if (fromAcct.getBalance().compareTo(amount) < 0)
                    throw new InsufficientFundsException();
                else {
                    fromAcct.debit(amount);
                    toAcct.credit(amount);
                }
            }
        }
        // 获得锁的hash值
        int fromHash = System.identityHashCode(fromAcct);
        int toHash = System.identityHashCode(toAcct);

        // 根据hash值来上锁
        if (fromHash < toHash) {
            synchronized (fromAcct) {
                synchronized (toAcct) {
                    new Helper().transfer();
                }
            }

        } else if (fromHash > toHash) {// 根据hash值来上锁
            synchronized (toAcct) {
                synchronized (fromAcct) {
                    new Helper().transfer();
                }
            }
        } else {// 额外的锁、避免两个对象hash值相等的状况(即便不多)
            synchronized (tieLock) {
                synchronized (fromAcct) {
                    synchronized (toAcct) {
                        new Helper().transfer();
                    }
                }
            }
        }
    }
}

获得对应的hash值来固定加锁的顺序，这样咱们就不会发生死锁的问题了！

2.2开放调用避免死锁

在协做对象之间发生死锁的例子中，主要是由于在调用某个方法时就须要持有锁，而且在方法内部也调用了其余带锁的方法！

若是在调用某个方法时不须要持有锁，那么这种调用被称为开放调用！

咱们能够这样来改造：

同步代码块最好仅被用于保护那些涉及共享状态的操做！

class CooperatingNoDeadlock {
    @ThreadSafe
    class Taxi {
        @GuardedBy("this") private Point location, destination;
        private final Dispatcher dispatcher;

        public Taxi(Dispatcher dispatcher) {
            this.dispatcher = dispatcher;
        }

        public synchronized Point getLocation() {
            return location;
        }

        public synchronized void setLocation(Point location) {
            boolean reachedDestination;

            // 加Taxi内置锁
            synchronized (this) {
                this.location = location;
                reachedDestination = location.equals(destination);
            }
            // 执行同步代码块后完毕，释放锁



            if (reachedDestination)
                // 加Dispatcher内置锁
                dispatcher.notifyAvailable(this);
        }

        public synchronized Point getDestination() {
            return destination;
        }

        public synchronized void setDestination(Point destination) {
            this.destination = destination;
        }
    }

    @ThreadSafe
    class Dispatcher {
        @GuardedBy("this") private final Set<Taxi> taxis;
        @GuardedBy("this") private final Set<Taxi> availableTaxis;

        public Dispatcher() {
            taxis = new HashSet<Taxi>();
            availableTaxis = new HashSet<Taxi>();
        }

        public synchronized void notifyAvailable(Taxi taxi) {
            availableTaxis.add(taxi);
        }

        public Image getImage() {
            Set<Taxi> copy;

            // Dispatcher内置锁
            synchronized (this) {
                copy = new HashSet<Taxi>(taxis);
            }
            // 执行同步代码块后完毕，释放锁

            Image image = new Image();
            for (Taxi t : copy)
                // 加Taix内置锁
                image.drawMarker(t.getLocation());
            return image;
        }
    }

    class Image {
        public void drawMarker(Point p) {
        }
    }

}

使用开放调用是很是好的一种方式，应该尽可能使用它~