我们正在使用 ScheduledExecutorService.scheduleAtFixedRate 每 100 毫秒执行一次 I/O 任务。 (实际的 I/O 操作是由第三方库执行的，我们不知道里面到底发生了什么。)

有时跟上 100 毫秒的间隔会出现一些问题，我们会退回到 500 毫秒。由于是 I/O，我们并不感到惊讶，但我们观察到一个奇怪的行为:

如果特定线程运行，我们将匹配 100 毫秒。 如果此线程未运行，我们将回退到 500 毫秒。

特定线程的运行方法如下所示:

while(active){
  try {
    Thread.sleep(delay);
  } catch (InterruptedException e) {
    Thread.currentThread().interrupt();
    break;
  }
//some more stuff
}

基本上，当我们使用 5 毫秒这样的短延迟时，我们会在库中获得更好的性能。当我们使用更长的延迟(例如 1000 毫秒)时，性能会明显变差。

它似乎也是特定于平台的，因为我们无法重现该问题(Java 8、Windows 10)。

我们所知道的是，它肯定是短的 sleep() 调用导致了改进，因为我们可以通过运行一个以短时间间隔 hibernate 的虚拟线程来解决这个问题。

任何解释都有助于理解正在发生的事情:-)

---编辑

更有趣的是:如果我们只为较短的 hibernate 间隔添加一个而不是两个新线程，它会增加一点性能。不像第一个线程那么重要，但仍然像 20%。

---编辑2

我们可以在其中观察行为的系统: 英特尔凌动 E3845 Windows 10

我们无法重现的系统: 英特尔 i7-5820K Windows 10

我们无法查找源代码，但该库似乎是单线程运行的(没有创建新线程)并创建一个 Socket 连接。

最佳答案

这可能是一个多线程可见性问题(如果不知道涉及的源/库就很难说)。

该示例基于线程 how-to-demonstrate-java-multithreading-visibility-problems 中的代码.

执行下面的代码会导致无限执行线程t。

public class Test extends Thread {

    boolean keepRunning = true;

    public static void main(String[] args) throws InterruptedException {
        Test t = new Test();
        t.start();
        Thread.sleep(1000);
        t.keepRunning = false;
        System.out.println(System.currentTimeMillis() + ": keepRunning is false");
    }

    public void run() {
        int i = 0;
        while (keepRunning) {
            i++;
        }
        System.out.println("iterations: " + i);
    }
}

原因是线程 t 保持它自己的本地状态 keepRunning 并且永远不会得到更新的状态。

如果将run方法修改为

public void run() {
    int i = 0;
    while (keepRunning) {
        i++;
        System.out.println(i);
    }
    System.out.println("iterations: " + i);
}

它完成例如

...
111955
111956
iterations: 111956
1582797899956: keepRunning is false

问:这个额外的 println 语句如何改变行为？ A: System.out 是一个PrintStream 并且println 方法实现为

public void println(boolean x) {
    synchronized (this) {
        print(x);
        newLine();
    }
}

synchronized block 导致线程本地状态和主内存之间的同步。

当您改用 Thread.sleep(delay) 时，会发生类似的效果。

public void run() {
    int i = 0;
    while (keepRunning) {
        i++;
        try {
            Thread.sleep(5);
        } catch(InterruptedException e) {
            System.out.println("interrupted");
            Thread.currentThread().interrupt();
        }
    }
    System.out.println("iterations: " + i);
}

示例输出

1582798987660: keepRunning is false
iterations: 197

您可以尝试将 Thread.sleep(delay) 替换为 System.out.println() 语句，看看这是否会产生类似的效果。那么它很可能与上面的例子有关。

• 关于 SO Questions about thread+loop not working without print statement 的相关问题的链接集合
• 关于 memory barriers 的一般文章
• 有关 Java 内存模型的更多信息可以在 JSR 133 FAQ 中找到。

edit 要强制线程 t 获取更新状态，可以将变量 keepRunning 声明为 volatile。

公共(public)类测试扩展线程{

volatile boolean keepRunning = true;

public static void main(String[] args) throws InterruptedException {
    Test t = new Test();
    t.start();
    Thread.sleep(1000);
    t.keepRunning = false;
    System.out.println(System.currentTimeMillis() + ": keepRunning is false");
}

public void run() {
    int i = 0;
    while (keepRunning) {
        i++;
    }
    System.out.println("iterations: " + i);
}

示例输出

iterations: 1726941412
1582799612746: keepRunning is false

关于java - 为什么虚拟线程(仅在短时间内 hibernate )会提高另一个线程的性能？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/56458397/