4

我的问题与这个问题有关，它已经有了答案：

是的，在线程调用/的操作和由此提交的可运行的 EDT 上的操作之间存在发生之前的关系。invokeLaterinvokeAndWait

我的问题有点笼统：是否甚至可以实现一个方法，invokeAndWait例如 ，使其正常工作，但不强加发生前的关系？通过正常工作的方法，我的意思是：

  • 提交Runnable的保证只执行一次。
  • 提交Runnable在特定线程上执行。
  • 该方法一直等到提交的执行Runnable完成。
  • 该方法保证在提交的执行Runnable完成后返回。

对我来说，如果不强加发生之前的关系，似乎没有办法实现这一点，还是我错了？如果是这样，请包含一个示例实现，以证明这一点。

4

1 回答 1

2

这里最困难的要求是：

提交Runnable的保证只执行一次。

使用非volatile（普通）字段将工作任务从提交者转移到执行者不会创建发生之前的 关系，但也不能保证执行者完全或在有限的时间内看到任务。编译器将能够优化对该字段的分配，或者在运行时执行器线程可能只从其缓存而不是主内存中读取值。

因此，对于使用 Java 8 或更低版本的代码，我会说答案是“不，这种invokeAndWait方法是不可能的”（可能使用本机代码除外）。

但是，Java 9 添加了内存模式Opaque。JEP 193（添加了此功能）的作者 Doug Lea 的“使用 JDK 9 内存顺序模式”页面非常详细地描述了这一点。最重要的是，不透明模式比不透明模式弱，但仍提供以下保证：volatile

  • 进步。写入最终是可见的。
    [...]
    例如，在某些变量 x 的唯一修改是让一个线程以不透明（或更强）模式写入的结构中X.setOpaque(this, 1)，任何其他线程旋转while(X.getOpaque(this)!=1){}最终将终止。
    [...]
    请注意，此保证不适用于普通模式，其中自旋循环可能（并且通常会）无限循环 [...]

在设计这种invokeAndWait没有发生之前关系的方法时，您还必须考虑在启动线程之前的动作发生在该线程中的第一个动作之前（JLS §17.4.4）。所以必须在构造动作之前启动工作线程。

此外，必须考虑“final字段语义”（JLS §17.15.1 ）。当调用者以 lambda 表达式的形式invokeAndWait创建Runnable时，该 lambda 对变量的捕获具有（据我理解）隐式final字段语义。

如果是这样，请包含一个示例实现，以证明这一点。

由于硬件和时间依赖，使用示例证明或反驳线程安全或发生之前的关系是困难的，如果不是不可能的话。然而，像jcstress这样的工具可以帮助解决这个问题。

下面是一个（简化的）潜在实现，用于invokeAndWait没有发生之前的关系。请注意，我对 Java 内存模型并不完全熟悉，因此代码中可能存在错误。

import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;

class OpaqueExecutor {
  // For simplicity assume there will every only be a single work task
  // So pending task being replaced by other task is not an issue
  private final AtomicReference<Runnable> nextTask = new AtomicReference<>();

  public OpaqueExecutor() {
    Thread worker = new Thread(() -> {
      while (true) {
        // Use getOpaque() to no create happens-before relationship
        Runnable task = nextTask.getOpaque();
        if (task == null) {
          // For efficiency indicate to the JVM that this is busy-waiting
          Thread.onSpinWait();
        } else {
          // Clear pending task; memory mode here does not matter because we only want
          // to guarantee that this thread does not see task again
          nextTask.setPlain(null);
          task.run();
        }
      }
    }, "Worker thread");
    worker.setDaemon(true);
    worker.start();
  }

  public void invokeLater(Runnable runnable) {
    // For simplicity assume that there is no existing pending task which could be
    // replaced by this
    // Use setOpaque(...) to not create happens-before relationship
    nextTask.setOpaque(runnable);
  }

  private static class Task implements Runnable {
    private final AtomicBoolean isFinished = new AtomicBoolean(false);
    // Must NOT be final to prevent happens-before relationship from
    // final field semantics
    private Runnable runnable;

    public Task(Runnable runnable) {
      this.runnable = runnable;
    }

    public void run() {
      try {
        runnable.run();
      } finally {
        // Use setOpaque(...) to not create happens-before relationship
        isFinished.setOpaque(true);
      }
    }

    public void join() {
      // Use getOpaque() to no create happens-before relationship
      while (!isFinished.getOpaque()) {
        // For efficiency indicate to the JVM that this is busy-waiting
        Thread.onSpinWait();
      }
    }
  }

  public void invokeAndWait(Runnable runnable) {
    Task task = new Task(runnable);
    invokeLater(task);
    task.join();
  }

  public static void main(String... args) {
    // Create executor as first step to not create happens-before relationship
    // for Thread.start()
    OpaqueExecutor executor = new OpaqueExecutor();

    final int expectedValue = 123;
    final int expectedNewValue = 456;

    class MyTask implements Runnable {
      // Must NOT be final to prevent happens-before relationship from
      // final field semantics
      int value;

      public MyTask(int value) {
        this.value = value;
      }

      public void run() {
        int valueL = value;
        if (valueL == expectedValue) {
          System.out.println("Found expected value");
        } else {
          System.out.println("Unexpected value: " + valueL);
        }

        value = expectedNewValue;
      }
    }

    MyTask task = new MyTask(expectedValue);
    executor.invokeAndWait(task);

    int newValue = task.value;
    if (newValue == expectedNewValue) {
      System.out.println("Found expected new value");
    } else {
      System.out.println("Unexpected new value: " + newValue);
    }
  }
}
于 2020-10-31T23:08:37.427 回答