Java信号量导致多线程死锁

Question

在使用信号量时，我应该注意多线程问题吗？在我的测试之后，似乎有一段时间信号灯#release not cause acquire wake up，即使有足够的许可证。

底部是我的测试代码。

1. 带有2个许可证的信号灯
2. Thread3和Thread2先向上
3. 线程3获取许可，等待锁，锁将由线程1通知
4. 线程2获取许可，等待锁1，锁1将由线程3通知
5. 线程1启动，线程1和线程2先睡眠30ms启动
6. 线程1通知锁定，获取2个许可
7. 线程3唤醒，通知锁1，睡眠（1）睡眠1毫秒对于线程2，先获取许可证，然后释放许可证
8. 线程2唤醒，获取许可证，然后释放一个许可证，再释放另一个许可证

它将在随机迭代时导致死锁，并输出一些类似这样的日志。

in 3, a = 2
in 2 ,a = 2
in in 2 lock 1, a = 0
in 1 , a = 0
acquire and release 3
in in 2 locked, a = 0
out 3 ,a  = 0
in 1 locked, a = 0
acquire and release 2
out 2
out 1 ,a = 2
--------------------------------------------------------------  0
in 2 ,a = 2
in 3, a = 1
in 1 , a = 0
in in 2 lock 1, a = 0
acquire and release 3
out 3 ,a  = 1 
//deadlock here

在线程3信号量释放许可后，不会导致线程2唤醒，然后线程1和线程3永远等待获取

Bleow是我的测试代码

import java.util.concurrent.Semaphore;

/**
 * Created by rqg on 6/10/17.
 */
public class WaitTest {


    public static void main(String[] args) throws InterruptedException {
        Semaphore semaphore = new Semaphore(2);

        final Object lock = new Object();
        final Object lock1 = new Object();
//        testSemaphore(semaphore, lock, lock1);

        for (int i = 0; i < 10000; i++) {
            testSemaphore(semaphore, lock, lock1);
            System.out.println("---------------------------------------------------------------------------------  " + i);
        }
    }

    private static void testSemaphore(Semaphore semaphore, Object lock, Object lock1) throws InterruptedException {
        Thread t1 = new Thread() {
            @Override
            public void run() {
                try {
                    Thread.sleep(30);

                    synchronized (lock) {
                        lock.notify();
                    }
                    System.out.println("in 1 , a = " + semaphore.availablePermits());
                    semaphore.acquire(2);
                    System.out.println("in 1 locked, a = " + semaphore.availablePermits());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                semaphore.release(2);

                System.out.println("out 1 ,a = " + semaphore.availablePermits());
            }
        };


        Thread t2 = new Thread() {
            @Override
            public void run() {
                try {

                    System.out.println("in 2 ,a = " + semaphore.availablePermits());
                    semaphore.acquire();

                    synchronized (lock1) {
                        lock1.wait();
                    }

                    System.out.println("in in 2 lock 1, a = " + semaphore.availablePermits());
                    semaphore.acquire();
                    System.out.println("in in 2 locked, a = " + semaphore.availablePermits());
                    semaphore.release();

                    semaphore.release();

                    System.out.println("acquire and release 2");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println("out 2");
            }
        };

        Thread t3 = new Thread() {
            @Override
            public void run() {
                try {
                    System.out.println("in 3, a = " + semaphore.availablePermits());
                    semaphore.acquire();

                    synchronized (lock) {
                        lock.wait();
                    }

                    synchronized (lock1) {
                        lock1.notify();
                    }
                    sleep(1);

                    semaphore.release();

                    System.out.println("acquire and release 3");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println("out 3 ,a  = " + semaphore.availablePermits());

            }
        };

        t1.start();
        t2.start();
        t3.start();


        t1.join();
        t2.join();
        t3.join();
    }
}

这是死锁发生时我的脚印

Answer 1

你是赖特，死锁发生了，因为释放没有发出驻车线程的信号。我发现了一些报告的错误http://bugs.java.com/view_bug.do?bug_id=7011859

Answer 2

java.util.concurrent.locks.AbstractQueuedSynsynizer被Semaphore用来做一些同步工作。它具有FIFO属性，这会导致问题。

我有2个许可证，在thread-3发布一个许可证后，只有一个许可证可用，根据SemaphoreFIFO获取顺序，如果Mythread-3获取（2）发生在thread-2获取（1）之前，thread-3将永远阻塞。

我将信号量与fair=false一起使用，内部将初始化非空同步，它扩展了AbstractQueuedSynchronizer。

下面的代码导致信号量总是流FIFO获取顺序。

/**
 *java.util.concurrent.locks.AbstractQueuedSynchronizer#doAcquireSharedInterruptibly
*/
private void doAcquireSharedInterruptibly(int arg)
    throws InterruptedException {
    final Node node = addWaiter(Node.SHARED);
    boolean failed = true;
    try {
        for (;;) {
            final Node p = node.predecessor();
            if (p == head) {
                int r = tryAcquireShared(arg);
                if (r >= 0) {
                    setHeadAndPropagate(node, r);
                    p.next = null; // help GC
                    failed = false;
                    return;
                }
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

Answer 3

Semaphore只保留许可证的数量。来自Semaphore文档：

从概念上讲，信号量维护一组许可。每个{@link获取}在必要时阻塞，直到许可可用，然后获取它。每个{@link#释放}都会添加一个许可，可能会释放阻塞的获取者。但是，没有使用实际的许可对象；{@code Semaphore}只是保留可用数量的计数并相应地执行操作。

我的意思是程序应该关心同步。

信号量通常用于限制可以访问某些（物理或逻辑）资源的线程数