Как вам Thread?
 

Мне потребовалось многопоточный цикл. И кажется нашел решение и он прекрасно работает.

Терь можно создать много цикл с разным интервалом.
Но хотел услышать от людей =)

Класс Thread (Сырое конечно)

abstract class Thread {
  private running: boolean = false;

  static sleep(time: number = 1000) {
    return new Promise((resolve) => {
      setTimeout(resolve, time);
    });
  }

  start() {
    if (this.running) return;
    this.running = true
    this.run()
  }

  stop() {
    this.running = false
  }

  get isRunning() {
    return this.running;
  }

  abstract async run(): Promise<void>;
}

Пример рабочий код:

class Game extends Thread {
  async run() {
    while (this.isRunning) {
      console.log('Game Update')
      await Thread.sleep(1000) // 1 sec
    }
  }
}

class Test extends Thread {
  async run() {
    while (this.isRunning) {
      console.log('Test Update')
      await Thread.sleep(5000) // 5 sec
    }
  }
}

new Game().start()
new Test().start()
console.log('run')

Почему "многопоточный"?
Все работает в одном потоке.
И представьте, что там не console.log, а действительно тяжелая работа, которая занимает больше, чем время указанное в Thread.sleep

voraa, нода в multithreading не научилась?

И что это дает
Ну допустим в run будет запускаться Worker.
По идее по смыслу
new Game().start()
должен запускать новый Worker каждую секунду
Напишем так

new Game().start()
let n = 2**40
while (n--) {
let l = 2**40
while (l--);
};

Через сколько запустится второй Worker?
Даже если тело цикла выполняется в отдельном потоке, сам цикл то работает в одном потоке.

По сути это обертка над setInterval. Делает тоже самое, только более многословно.
Я ничуть не против, если кому то нравится использовать классы везде.
Но зачем называть это многопоточным?

Ну если не нравится класс то замена функция

function sleep(time = 1000) {
  return new Promise((resolve) => {
    setTimeout(resolve, time);
  });
}

function createThread(run: (isRunning: () => boolean, sleep?: (time: number) => Promise<unknown>) => Promise<unknown>) {
  let running = false

  const stop = () => {
    running = false
  }

  const start = () => {
    if (running) return;
    running = true
    run(() => running, sleep)
  }

  return { start, stop }
}

По сути даже это не очень верно.
После вызова stop мгновенной остановки не произойдет. Все равно после этого выполнится последний заданный timeout.
clearInterval прервет выполнение сразу.