Multi Threading #

TypeScript, seperti JavaScript, berjalan di lingkungan single-threaded secara default. Ini berarti bahwa kode dieksekusi dalam satu thread, dan operasi yang memakan waktu lama seperti I/O, pengolahan data yang intensif, atau panggilan jaringan dilakukan secara asinkron untuk mencegah pemblokiran eksekusi kode lainnya. Namun, JavaScript dan TypeScript menyediakan beberapa mekanisme untuk menangani pekerjaan yang membutuhkan paralelisme atau pengolahan data secara bersamaan, meskipun tidak mendukung multithreading sejati seperti di beberapa bahasa lain (misalnya, Java atau C++).

Web Workers #

Web Workers adalah salah satu cara untuk menjalankan kode JavaScript di thread yang terpisah dari thread utama (main thread) di browser. Dengan Web Workers, Anda dapat menjalankan tugas berat di latar belakang tanpa membekukan atau memperlambat antarmuka pengguna.

Cara Menggunakan Web Workers di TypeScript:

• Membuat Worker: Anda perlu menulis skrip worker yang akan dijalankan di thread terpisah. Worker ini biasanya ditulis dalam file .js atau .ts terpisah.

  worker.ts:

  // worker.ts
  self.addEventListener('message', (event) => {
      const result = event.data * 2; // Proses sederhana
      self.postMessage(result);      // Kirim hasil kembali ke main thread
  });
  

• Menggunakan Worker di Main Thread: Di file utama, Anda bisa membuat instance dari Worker, mengirim pesan ke worker, dan menangani pesan yang dikirim oleh worker.

  main.ts:

  const worker = new Worker(new URL('./worker.ts', import.meta.url));
  
  worker.addEventListener('message', (event) => {
      console.log('Received from worker:', event.data);
  });
  
  worker.postMessage(10); // Kirim data ke worker
  

• Komunikasi antara Main Thread dan Worker: Komunikasi dilakukan melalui pesan menggunakan metode postMessage dan event message. Ini memungkinkan pengiriman data bolak-balik antara main thread dan worker.

Catatan:

• Web Workers tidak memiliki akses langsung ke DOM, window, atau beberapa API browser lainnya.
• Web Workers digunakan untuk tugas berat yang memerlukan komputasi, seperti pengolahan data yang intensif, tanpa membekukan antarmuka pengguna.

Worker Threads di Node.js #

Di lingkungan Node.js, ada modul worker_threads yang menyediakan kemampuan untuk menjalankan JavaScript di beberapa thread yang berbeda.

Menggunakan Worker Threads di Node.js:

• Membuat Worker:

  worker.js:

  import { parentPort } from 'worker_threads';
  
  parentPort?.on('message', (data) => {
      const result = data * 2;
      parentPort?.postMessage(result);
  });
  

• Menggunakan Worker di Main Thread:

  main.js:

  import { Worker } from 'worker_threads';
  
  const worker = new Worker('./worker.js');
  
  worker.on('message', (result) => {
      console.log('Result from worker:', result);
  });
  
  worker.postMessage(10);
  

Catatan:

• Worker Threads di Node.js memungkinkan paralelisme yang lebih efektif dibandingkan dengan model event loop tradisional.
• Pekerjaan yang memakan waktu lama, seperti pemrosesan data besar atau penghitungan yang kompleks, dapat ditangani di worker thread untuk mencegah pemblokiran event loop utama.

Async/Await dan Event Loop #

Meskipun bukan multithreading sejati, penggunaan async/await di TypeScript (dan JavaScript) memungkinkan penulisan kode asinkron yang lebih bersih dan lebih mudah dibaca. Operasi asinkron dikelola oleh event loop, yang memungkinkan kode non-blokir dieksekusi secara efisien.

Contoh Penggunaan Async/Await:

async function fetchData(url: string): Promise<void> {
    try {
        const response = await fetch(url);
        const data = await response.json();
        console.log(data);
    } catch (error) {
        console.error('Error fetching data:', error);
    }
}

fetchData('https://api.example.com/data');

• async: Menandakan bahwa fungsi tersebut mengandung operasi asinkron.
• await: Digunakan untuk menunggu penyelesaian dari operasi asinkron sebelum melanjutkan eksekusi.

Libraries untuk Paralelisme #

Ada beberapa pustaka yang bisa membantu dalam mengelola paralelisme atau pekerjaan yang membutuhkan banyak thread secara lebih efisien, seperti workerpool atau threads.js.

Contoh Menggunakan workerpool:

import * as workerpool from 'workerpool';

const pool = workerpool.pool();

async function run() {
    const result = await pool.exec((n: number) => n * 2, [10]);
    console.log(result); // Output: 20
    pool.terminate(); // Menghentikan semua worker
}

run();

• workerpool memudahkan pembagian tugas berat di beberapa worker, baik di Node.js maupun di browser.

Kesimpulan #

Meskipun TypeScript, seperti JavaScript, berjalan di atas lingkungan single-threaded, ada beberapa cara untuk melakukan pekerjaan secara paralel atau di thread terpisah, seperti menggunakan Web Workers di browser, Worker Threads di Node.js, atau bahkan dengan menggunakan pustaka pihak ketiga yang memfasilitasi pembagian kerja di beberapa thread. Ini memberikan fleksibilitas dalam menangani pekerjaan yang berat dan memastikan aplikasi tetap responsif dan efisien.