探索 JVM 虚拟线程机制中的固定

哈喽！大家好，很高兴又见面了，我是golang学习网的一名作者，今天由我给大家带来一篇《探索 JVM 虚拟线程机制中的固定》，本文主要会讲到等等知识点，希望大家一起学习进步，也欢迎大家关注、点赞、收藏、转发! 下面就一起来看看吧！

java 的虚拟线程提供了传统操作系统线程的轻量级替代方案，可实现高效的并发管理。但了解他们的行为对于获得最佳表现至关重要。这篇博文深入探讨了固定（一种可能影响虚拟线程执行的场景），并探讨了监控和解决该问题的技术。

虚拟线程：一种轻量级并发方法

java 的虚拟线程是运行在底层操作系统线程（载体线程）之上的托管实体。与创建大量操作系统线程相比，它们提供了一种更有效的处理并发的方法，因为它们产生的开销较低。 jvm 动态地将虚拟线程映射到载体线程，从而实现更好的资源利用率。

• 由 jvm 管理：与操作系统直接管理的操作系统线程不同，虚拟线程是由 java 虚拟机 (jvm) 创建和调度的。这允许在 jvm 环境中进行更细粒度的控制和优化。

• 减少开销：与操作系统线程相比，创建和管理虚拟线程所产生的开销显着降低。这是因为 jvm 可以利用较少数量的底层操作系统线程，有效地管理更大的虚拟线程池。

• 与现有代码的兼容性：虚拟线程旨在与现有 java 代码无缝集成。它们可以与传统操作系统线程一起使用，并在 executor 和 executorservice 等熟悉的结构中工作，用于管理并发。

下图展示了虚拟线程和平台线程的关系：

固定：当虚拟线程卡住时

当虚拟线程与其载体线程绑定时，就会发生固定。这本质上意味着虚拟线程在处于固定状态时不能被抢占（切换到另一个承载线程）。以下是触发固定的常见场景：

• 同步块和方法：在同步块或方法中执行代码会导致固定。这可确保对共享资源的独占访问，防止数据损坏问题。

代码示例：

import java.util.concurrent.executorservice;
import java.util.concurrent.executors;

public class main {

  public static void main(string[] args) throws interruptedexception {

    final counter counter = new counter();

    runnable task = () -> {
      for (int i = 0; i < 1000; i++) {
        counter.increment();
      }
    };

    thread thread1 = new thread(task);
    thread thread2 = new thread(task);

    thread1.start();
    thread2.start();

    thread1.join();
    thread2.join();

    system.out.println("final counter value: " + counter.getcount());
  }
}

class counter {

  private int count = 0;

  public synchronized void increment() {
    count++;
  }

  public synchronized int getcount() {
    return count;
  }
}

在此示例中，当虚拟线程进入同步块时，它会固定到其承载线程，但这并不总是正确的。仅java的synchronized关键字不足以导致虚拟线程中的线程固定。为了发生线程固定，同步块内必须有一个阻塞点，该阻塞点会导致虚拟线程触发暂停，并最终不允许从其承载线程卸载。线程固定可能会导致性能下降，因为它会抵消使用轻量级/虚拟线程的好处。

每当虚拟线程遇到阻塞点时，其状态就会转换为 parking。这种状态转换是通过调用 virtualthread.park() 方法来指示的：

// jdk core code
void park() {
  assert thread.currentthread() == this;
  // complete immediately if parking permit available or interrupted
  if (getandsetparkpermit(false) || interrupted)
    return;
  // park the thread
  setstate(parking);
  try {
    if (!yieldcontinuation()) {
      // park on the carrier thread when pinned
      parkoncarrierthread(false, 0);
    }
  } finally {
    assert (thread.currentthread() == this) && (state() == running);
  }
}

让我们看一个代码示例来说明这个概念：

import java.util.concurrent.executorservice;
import java.util.concurrent.executors;

public class main {

  public static void main(string[] args) {

    counter counter = new counter();

    runnable task = () -> {
      for (int i = 0; i < 100; i++) {
        counter.increment();
      }
    };

    thread thread1 = thread.ofvirtual().start(task);
    thread thread2 = thread.ofvirtual().start(task);

    try {
      thread1.join();
      thread2.join();
    } catch (interruptedexception e) {
      throw new runtimeexception(e);
    }

    system.out.println("final counter value: " + counter.getcount());
  }
}

class counter {

  private int count = 0;

  public void increment() {
    synchronized (this) {
      try {
        thread.sleep(100); // this simulates a blocking call within the synchronized block
      } catch (interruptedexception e) {
        e.printstacktrace();
      }
      count++;
    }
  }

  public synchronized int getcount() {
    return count;
  }
}

• 本机方法/外部函数：运行本机方法或外部函数也可能导致固定。在这些操作期间，jvm 可能无法有效管理虚拟线程的状态。

使用 -djdk.tracepinnedthreads=full 监视固定

-djdk.tracepinnedthreads=full 标志是一个 jvm 启动参数，提供有关虚拟线程固定的详细跟踪信息。启用后，它会记录以下事件：

• 固定涉及的虚拟线程id
• 虚拟线程固定的承载线程id
• 堆栈跟踪指示导致固定的代码部分

仅在调试会话期间明智地使用此标志，因为它会带来性能开销。

1. 编译我们的演示代码：
   

   javac main.java
   

2. 使用 -djdk.tracepinnedthreads=full 标志启动编译的代码：
   

   java -djdk.tracepinnedthreads=full main
   

3. 观察控制台中的输出，其中显示了有关虚拟线程固定的详细信息：
   

   thread[#29,forkjoinpool-1-worker-1,5,carrierthreads]
   java.base/java.lang.virtualthread$vthreadcontinuation.onpinned(virtualthread.java:183)
   java.base/jdk.internal.vm.continuation.onpinned0(continuation.java:393)
   java.base/java.lang.virtualthread.parknanos(virtualthread.java:621)
   java.base/java.lang.virtualthread.sleepnanos(virtualthread.java:791)
   java.base/java.lang.thread.sleep(thread.java:507)
   counter.increment(main.java:38) <== monitors:1
   main.lambda$main\$0(main.java:13)
   java.base/java.lang.virtualthread.run(virtualthread.java:309)
   
   final counter value: 200
   

使用可重入锁修复固定

固定是一种不良情况，它会影响虚拟线程的性能。可重入锁是抵消固定的有效工具。以下是如何使用可重入锁来缓解固定情况：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantLock;

public class Main {

  public static void main(String[] args) {

    Counter counter = new Counter();

    Runnable task = () -> {
      for (int i = 0; i < 100; i++) {
        counter.increment();
      }
    };

    Thread thread1 = Thread.ofVirtual().start(task);
    Thread thread2 = Thread.ofVirtual().start(task);

    try {
      thread1.join();
      thread2.join();
    } catch (InterruptedException e) {
      throw new RuntimeException(e);
    }

    System.out.println("Final counter value: " + counter.getCount());
  }
}

class Counter {

  private int count = 0;
  private final ReentrantLock lock = new ReentrantLock();

  public void increment() {
    lock.lock();
    try {
      Thread.sleep(100); // This simulates a blocking call
      count++;
    } catch (InterruptedException e) {
      e.printStackTrace();
    } finally {
      lock.unlock();
    }
  }

  public int getCount() {
    return count;
  }
}

在更新的示例中，我们使用 reentrantlock 而不是同步块。线程可以获取锁并在完成操作后立即释放它，与可能持有锁更长时间的同步块相比，可能会减少锁定的持续时间。

综上所述

java 的虚拟线程是该语言的发展和功能的见证。它们为传统操作系统线程提供了一种全新的、轻量级的替代方案，为高效的并发管理提供了一座桥梁。花时间深入挖掘并理解线程固定等关键概念可以让开发人员掌握如何充分利用这些轻量级线程的潜力。这些知识不仅帮助开发人员为利用即将推出的功能做好准备，还使他们能够在当前项目中更有效地解决复杂的并发控制问题。

以上就是《探索 JVM 虚拟线程机制中的固定》的详细内容，更多关于的资料请关注golang学习网公众号！