为什么这个并发的 Java 代码经常失败？答案

【问题标题】：Why does this concurrent Java code often fail?为什么这个并发的 Java 代码经常失败？
【发布时间】：2021-05-04 00:28:41
【问题描述】：

//Initially, I wanted to compare synchronized with Lock
public class SynchronizedVSLock {
    static final Lock lock = new ReentrantLock();
    static final int loopTime = 10;
    static final int numOfThread = 6;
    static final Random random = new Random();
    static final Semaphore runningThreadsNum = new Semaphore(numOfThread);
    public static void main(String[] args) throws InterruptedException {
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < numOfThread - 1; i++) {
            new Thread(new Test1()).start();
        }
        new Thread(new Test1()).join();
        runningThreadsNum.acquire(numOfThread);
        long endTime = System.currentTimeMillis();
        System.out.println(endTime - startTime);
    }

    static class Test1 implements Runnable {
        @Override
        public void run() {
            try {
                runningThreadsNum.acquire();
            } catch (InterruptedException e) {
                throw new RuntimeException();
            }
            for (int i = 0; i < SynchronizedVSLock.loopTime; i++) {
                SynchronizedVSLock.lock.lock();
                System.out.println(SynchronizedVSLock.random.nextDouble());
                SynchronizedVSLock.lock.unlock();
            }
            runningThreadsNum.release();
        }
    }

    static class Test2 implements Runnable {
        @Override
        public void run() {
            try {
                runningThreadsNum.acquire();
            } catch (InterruptedException e) {
                throw new RuntimeException();
            }
            for (int i = 0; i < SynchronizedVSLock.loopTime; i++) {
                synchronized (SynchronizedVSLock.lock) {
                    System.out.println(SynchronizedVSLock.random.nextDouble());
                }
            }
            runningThreadsNum.release();
        }
    }
}

总体思路是创建多个线程并发执行输出随机数的任务，分别使用lock和synchronized两种同步机制。最后将程序运行时间作为指标输出。使用信号量确保主线程在所有子线程完成之前不会获得最终经过的时间但是我发现很多时候主线程在其他子线程运行之前就拿到了所有的权限，然后打印出一个很小的运行时间，也就一两毫秒，不知道怎么回事。

【问题讨论】：

标签： java multithreading concurrency semaphore java.util.concurrent

【解决方案1】：

您正在加入一个您没有开始的线程，而不是等待您在循环中启动的任何线程：

for (int i = 0; i < numOfThread - 1; i++) {
   new Thread(new Test1()).start();
}
new Thread(new Test1()).join();

在未启动的线程上调用join() 会立即返回。这意味着您的初始线程可以在第一个 Test1 线程开始执行之前获得信号量的所有 6 个许可，这意味着它只会打印时间并退出。

您应该考虑在此处使用CountDownLatch 而不是信号量，因为这是它的教科书用例。

【讨论】：

【解决方案2】：

您使用 main 所需的所有许可初始化信号量，以继续在线 runningThreadsNum.acquire(numOfThread)。

static final Semaphore runningThreadsNum = new Semaphore(0); // should be zero

【讨论】：

请注意，要将信号量用作同步锁存器，您还需要删除每个工作线程中的 acquire() 并只保留它们 release()，这样主线程的 acquire() 就会在第六个线程释放后解除阻塞。
是的，我没看到。无论如何，最好使用您提到的 CountDownLatch。