使用线程同时访问Java同步块？

Question

两个线程如何同时访问同步块？也就是说，如何让一个线程为另一个线程提供执行同步块的机会，甚至在该线程完成同一同步块的执行之前？

Answer 1

请参阅 wait(), notify() 和 notifyAll()。

编辑：对您问题的编辑不正确。 sleep() 方法不释放监视器。

例如：

private static final Object lock = new Object();

public static void main(String[] args) {
    ExecutorService executorService = Executors.newFixedThreadPool(2);
    executorService.execute(new One());
    executorService.execute(new Two());
}

static class One implements Runnable {
    @Override
    public void run() {
        synchronized (lock) {
            System.out.println("(One) I own the lock");
            System.out.println("(One) Giving up the lock and waiting");
            try {
                lock.wait();
            } catch (InterruptedException e) {
                System.err.println("(One) I shouldn't have been interrupted");
            }
            System.out.println("(One) I have the lock back now");
        }
    }
}

static class Two implements Runnable {
    @Override
    public void run() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            System.err.println("(Two) I shouldn't have been interrupted");
        }
        synchronized (lock) {
            System.out.println("(Two) Now I own the lock (Two)");
            System.out.println("(Two) Giving up the lock using notify()");
            lock.notify();
        }
    }
}

Answer 2

听起来您可能需要考虑使用多个同步块，特别是如果一个线程正在执行阻塞操作，从而阻塞另一个想要执行块中其他操作的线程。

Answer 3

同步块是（根据定义）一次只能由一个线程访问的代码块。
如果您希望另一个线程进入此块，而另一个线程当前也在处理它，则确实会使同步块方案毫无用处。

您可能想将同步块拆分为许多其他块。

Answer 4

我可以查看是否有一个线程在监视器对象上调用 wait() 的唯一方法。然后它将释放监视器并等待通知，而其他线程可以执行同步块。然后其他线程必须调用notify()/notifyAll()，以便第一个线程取回监视器并继续。

Answer 5

线程可以使用lock.wait() 释放其监视器。然后另一个线程可以拿起监视器并进入同步块。

示例：

public class MultipleThreadsInSynchronizedBlock {
    public static void main(String... args) {
        final Object lock = new Object();
        Runnable runnable = new Runnable() {
            public void run() {
                synchronized (lock) {
                    System.out.println("Before wait");
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                    }
                    System.out.println("After wait");
                }
            }
        };
        new Thread(runnable).start();
        new Thread(runnable).start();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
        }

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

这会打印：

Before wait
Before wait
After wait
After wait

但是，允许互斥块以非原子方式运行并不是“黑客”。如果您要使用像这样的非常低级的同步原语，您需要知道您在做什么。