Java并发编程实战:第十章读书笔记

最新推荐文章于 2022-10-01 19:26:36 发布

lcn_2017

最新推荐文章于 2022-10-01 19:26:36 发布

阅读量361

点赞数

分类专栏：读书笔记文章标签： Java 并发编程

本文链接：https://blog.csdn.net/lcn_2017/article/details/82355604

版权

读书笔记专栏收录该内容

12 篇文章 1 订阅

订阅专栏

第十章避免活跃性危险

摘要: 本章主要介绍了许多可能造成活跃性降低的情况以及相关的危险操作。

10.1 死锁

说道死锁最典型的问题就是哲学家就餐的问题，如果五个哲学家就餐桌上有五支筷子，那么当五个哲学家同时拿起左手边的筷子时，他们就会一直持有一支筷子而等待另外的筷子从而造成死锁，在没有外界介入的情况下他们就将永久的等待下去。

那么除了上述典型的问题还有什么情况有可能导致死锁呢？

锁顺序死锁

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

    public void leftRight() {
        synchronized (left) {
            synchronized (right) {
                doSomething();
            }
        }
    }

    public void rightLeft() {
        synchronized (right) {
            synchronized (left) {
                doSomethingElse();
            }
        }
    }

    void doSomething() {
    }

    void doSomethingElse() {
    }
}

这样简单的代码会因为方法A和方法B的加锁顺序不同而导致死锁。当线程A锁住A的同时线程B锁住B 那么双方都在等待对方持有的资源而不释放自己手中的资源从而导致死锁。

动态锁顺序死锁

    public static void transferMoney(Account fromAccount,
                                     Account toAccount,
                                     DollarAmount amount)
            throws InsufficientFundsException {
        synchronized (fromAccount) {
            synchronized (toAccount) {
                if (fromAccount.getBalance().compareTo(amount) < 0)
                    throw new InsufficientFundsException();
                else {
                    fromAccount.debit(amount);
                    toAccount.credit(amount);
                }
            }
        }
    }

虽然不存在方法A、B的相互调用但是假设线程A和线程B在进行X转账给Y，Y转账给X的任务是就有可能发生死锁。

协作对象死锁

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

        public synchronized void setLocation(Point location) {
            this.location = location;
            if (location.equals(destination))
                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);
        }

        public synchronized Image getImage() {
            Image image = new Image();
            for (Taxi t : taxis)
                image.drawMarker(t.getLocation());
            return image;
        }
    }

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

对象Taxi和对象Dispatcher彼此并不知道会争夺锁。