logger.info("message");

Thread.ofVirtual().start(() -> File.WriteAllBytes("file1"));

·>logger.info("message");
·>

·>Thread.ofVirtual().start(() -> File.WriteAllBytes("file1"));
·>

await foreach (Task<int> t in Task.WhenEach(downloadTasks))
    {
        total += await t;
    }

·>

·>Никак. Зачем их создавать? Просто запускаешь поток, и всё.

·> Ты об этом уже писал, и я тебе уже про это отвечал. Хинт: Java 25.

Если поток сталкивается с блокирующим вызовом, он продолжает выполняться нормально, если он является платформенным потоком. Однако, если это виртуальный поток (и, следовательно, временно смонтированный на несущем потоке), то среда выполнения просто диспетчеризирует операцию ввода-вывода, а затем завершает работу, отсоединяя виртуальный поток от носителя.

Помните, что в Java 15 и более поздних версиях ввод/вывод выполняется неблокирующим образом, согласно JEP 353 и JEP 373. Поэтому носитель теперь может свободно монтировать другой виртуальный поток и продолжать выполнение, пока блокирующий ввод/вывод из первого виртуального потока выполняется в фоновом режиме.

Планировщик на уровне ВМ не будет перепланировать заблокированный виртуальный поток до тех пор, пока операция ввода-вывода не будет завершена и не появятся данные для получения.

На сегодняшний день большинство распространенных операций блокировки были адаптированы для поддержки виртуальных потоков. Однако некоторые операции, такие как Object.wait(), пока не поддерживаются и, наоборот, захватывают несущий поток . В этом случае пул потоков реагирует временным увеличением числа потоков платформы в пуле, чтобы компенсировать захваченный поток.

S>некоторые операции, такие как Object.wait(), пока не поддерживаются

На сегодняшний день большинство распространенных операций блокировки были адаптированы для поддержки виртуальных потоков.

await Task.Yield();

static ProductPayload fetchProduct(long id) throws Exception {
    ThreadFactory named = Thread.ofVirtual().name("prod-%d", 1).factory();

    try (var scope = StructuredTaskScope.open(
        StructuredTaskScope.Joiner.<Object>allSuccessfulOrThrow(),
        cfg -> cfg.withTimeout(Duration.ofSeconds(1))
            .withThreadFactory(named))) {

      StructuredTaskScope.Subtask<Product> core = scope.fork(() -> coreApi(id));
      StructuredTaskScope.Subtask<Stock> stock = scope.fork(() -> stockApi(id));
      StructuredTaskScope.Subtask<Price> price = scope.fork(() -> priceApi(id));

      scope.join(); // throws on first failure / timeout
      return new ProductPayload(core.get(), stock.get(), price.get());
    }
  }

  void main() throws Exception {
    ProductPayload productPayload = fetchProduct(1L);
    System.out.println(productPayload);
  }

S>>await Task.Yield();
S>>

S>static ProductPayload fetchProduct(long id) throws Exception {
S>  void main() throws Exception {

Product coreApi(long id) {
  var d1 = readFromFile(id);
  var d2 = queryDb(id, d1);
  lock();
  var d3 = downloadFromRestApi(id, d2, d1);
  unlock();
  return new Product(d3, d1);
}

private static readonly AsyncLock _lock = new AsyncLock();
Task<Product> coreApi(long id) {
  var d1 = readFromFile(id); // возвращает Task не дожидаемся результата
  var d2 = queryDb(id, d1);  // возвращает Task не дожидаемся результата
  using (await _lock.LockAsync())
 {
  var d3 = await downloadFromRestApi(id, d2, d1); // внутри downloadFromRestApi дожидаемся выполнения d2 и d1
  return new Product(d3, await d1);
}
}

Product coreApi(long id) {
  var d1 = readFromFile(id);
  var d2 = queryDb(id, d1 + 42);
  synchronized(lock) {
    var d3 = downloadFromRestApi(id, d2, d1);
    return new Product(d3, d1);
  }
}

async Product coreApi(long id,  CancellationToken token = default) {
  var d1 = await readFromFile(id, token);
  var d2 = await queryDb(id, d1 + 42, token);  // используем резульат d1.
  using (await _lock.LockAsync(token))
  {
    var d3 = await downloadFromRestApi(id, d2, d1, token);
    return new Product(d3, await d1);
  }
}