C++ Lanjutan | #8 Multithreading (C++11 ke atas)

Multithreading di C++ (C++11 ke atas)

Multithreading adalah teknik penting dalam pemrograman modern yang memungkinkan program untuk menjalankan beberapa tugas secara bersamaan. Pada C++11 ke atas, dukungan multithreading diintegrasikan melalui kelas std::thread dan berbagai mekanisme sinkronisasi seperti mutex dan lock. Artikel ini akan membahas konsep dasar thread, cara menggunakannya di C++, dan bagaimana menangani sinkronisasi antar thread.

Konsep Dasar Thread

Thread adalah unit eksekusi terkecil dalam program. Pada dasarnya, multithreading memungkinkan beberapa bagian dari program berjalan secara paralel. Ini sangat berguna dalam aplikasi yang membutuhkan performa tinggi atau ketika beberapa tugas bisa dilakukan secara independen satu sama lain.

Namun, penggunaan thread juga dapat memunculkan masalah seperti race conditions (dua atau lebih thread mencoba mengakses dan memodifikasi data yang sama secara bersamaan), sehingga sinkronisasi diperlukan.

Penggunaan std::thread di C++

Pada C++11 dan versi yang lebih baru, std::thread digunakan untuk membuat dan mengelola thread. Berikut adalah contoh dasar penggunaan std::thread:

#include <iostream>
#include <thread>

void printMessage(const std::string& message) {
    std::cout << message << std::endl;
}

int main() {
    // Membuat thread baru
    std::thread t1(printMessage, "Hello from thread 1");
    std::thread t2(printMessage, "Hello from thread 2");

    // Menunggu kedua thread selesai
    t1.join();
    t2.join();

    return 0;
}

Pada contoh di atas, kita membuat dua thread, t1 dan t2, yang menjalankan fungsi printMessage secara bersamaan. Fungsi join() digunakan untuk menunggu hingga kedua thread selesai sebelum program melanjutkan eksekusi.

Sinkronisasi dengan std::mutex dan std::lock_guard

Saat bekerja dengan multithreading, masalah race conditions dapat terjadi ketika beberapa thread mengakses data bersama (shared data) secara bersamaan. Untuk menghindari hal ini, C++ menyediakan std::mutex untuk sinkronisasi. mutex (mutual exclusion) memastikan bahwa hanya satu thread yang bisa mengakses kode kritis (critical section) pada satu waktu.

Berikut adalah contoh penggunaan std::mutex:

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;

void printMessage(const std::string& message) {
    // Mengunci sebelum mengakses shared data
    mtx.lock();
    std::cout << message << std::endl;
    // Membuka kembali lock
    mtx.unlock();
}

int main() {
    std::thread t1(printMessage, "Hello from thread 1");
    std::thread t2(printMessage, "Hello from thread 2");

    t1.join();
    t2.join();

    return 0;
}

Pada contoh ini, mtx.lock() digunakan untuk mengunci thread saat mengakses std::cout, dan mtx.unlock() untuk membukanya setelah selesai. Namun, cara ini berisiko menyebabkan deadlock jika thread tidak berhasil membuka kunci. Untuk menghindari hal tersebut, kita bisa menggunakan std::lock_guard, yang secara otomatis mengunci dan membuka mutex:

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;

void printMessage(const std::string& message) {
    std::lock_guard<std::mutex> lock(mtx); // Mengunci secara otomatis
    std::cout << message << std::endl;
}

int main() {
    std::thread t1(printMessage, "Hello from thread 1");
    std::thread t2(printMessage, "Hello from thread 2");

    t1.join();
    t2.join();

    return 0;
}

std::lock_guard akan memastikan bahwa mutex dikunci ketika masuk ke dalam blok kode dan dibuka secara otomatis ketika keluar dari blok, bahkan jika terjadi exception.

Kesimpulan

Multithreading di C++ memungkinkan kita menjalankan beberapa tugas secara bersamaan, yang sangat bermanfaat untuk meningkatkan performa program. Dengan menggunakan std::thread, kita bisa membuat dan mengelola thread dengan mudah. Namun, dalam proses ini, sinkronisasi sangat penting untuk mencegah race conditions. Penggunaan std::mutex dan std::lock_guard memastikan bahwa thread yang berjalan secara paralel tidak saling mengganggu dalam mengakses data bersama.