C++11引入了標準庫中的多線程支持，包括std::thread類和各種同步機制

• 互斥鎖std::mutex ： 互斥鎖用于保護共享資源，確保同一時間只有一個線程能夠訪問該資源，以防止數據競爭。

• 條件變量std::condition_variable ： 條件變量用于線程之間的通信，允許一個或多個線程等待某個條件（或者事件）的發生，而另一個線程則可以通知這些等待的線程該條件已經滿足。

• 原子操作std::atomic ： 原子操作用于無鎖編程，提供對基本數據類型的原子讀寫操作，防止數據競爭而無需顯式的鎖機制。

• 信號量（Semaphore）：用于控制對共享資源的訪問，可以實現多個線程之間的同步和互斥。

• 讀寫鎖（Reader-Writer Lock）：用于實現讀寫線程對共享數據的訪問控制，允許多個讀線程同時進行讀操作，但只允許一個寫線程進行寫操作。

• 屏障（Barrier）：用于保證多個線程在某個點上同步，只有當所有線程都達到屏障點時才能繼續執行。

• 事件（Event）：用于實現線程間的通信和同步，一個線程等待某個事件的發生，而另一個線程觸發該事件。

• 互斥量遞歸鎖（Recursive Mutex）：與互斥鎖類似，但允許同一個線程多次獲得同一個鎖，避免死鎖。

• 讀寫互斥量（Read-Write Mutex）：類似于讀寫鎖，但使用互斥量來實現，可以更靈活地控制讀寫線程對共享數據的訪問。

創建和管理線程

#include <iostream>
#include <thread>void printMessage(const std::string& message) {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;
}

使用互斥鎖進行同步

#include <iostream>
#include <thread>
#include <mutex>std::mutex mtx;void printMessage(const std::string& message) {std::lock_guard<std::mutex> lock(mtx);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;
}

使用條件變量進行線程間通信

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>std::mutex mtx;
std::condition_variable cv;
bool ready = false;void printMessage() {std::unique_lock<std::mutex> lock(mtx);cv.wait(lock, []{ return ready; });std::cout << "Hello from thread!" << std::endl;
}int main() {std::thread t(printMessage);{std::lock_guard<std::mutex> lock(mtx);ready = true;}cv.notify_one();t.join();return 0;
}

信號量（Semaphore）：

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <chrono>
#include <semaphore.h>sem_t semaphore;void worker() {sem_wait(&semaphore); // 等待信號量std::cout << "執行任務" << std::endl;
}int main() {sem_init(&semaphore, 0, 0); // 初始化信號量為0std::thread t(worker);// 模擬一些操作std::this_thread::sleep_for(std::chrono::seconds(2));sem_post(&semaphore); // 發送信號量t.join();sem_destroy(&semaphore);return 0;
}

讀寫鎖（Reader-Writer Lock）：

#include

#include <thread>
#include <shared_mutex>std::shared_mutex rwMutex;
int data = 0;void reader() {std::shared_lock<std::shared_mutex> lock(rwMutex);std::cout << "讀取數據：" << data << std::endl;
}void writer() {std::unique_lock<std::shared_mutex> lock(rwMutex);data++;std::cout << "寫入數據：" << data << std::endl;
}int main() {std::thread readerThread1(reader);std::thread readerThread2(reader);std::thread writerThread(writer);readerThread1.join();readerThread2.join();writerThread.join();return 0;
}

屏障（Barrier）：

#include <iostream>
#include <thread>
#include <barrier>std::barrier myBarrier(3); // 創建一個屏障，需要三個線程都到達后才能繼續執行void worker() {// 模擬一些操作std::this_thread::sleep_for(std::chrono::seconds(1));std::cout << "執行任務" << std::endl;myBarrier.arrive_and_wait(); // 到達屏障并等待std::cout << "任務完成" << std::endl;
}int main() {std::thread t1(worker);std::thread t2(worker);std::thread t3(worker);t1.join();t2.join();t3.join();return 0;
}

事件（Event）

事件可以用于實現線程間的通信和同步，一個線程等待某個事件的發生，而另一個線程觸發該事件。

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>std::mutex mtx;
std::condition_variable cv;
bool eventOccurred = false;void waitForEvent() {std::unique_lock<std::mutex> lock(mtx);while (!eventOccurred) {cv.wait(lock);}std::cout << "事件已發生，執行任務" << std::endl;
}void triggerEvent() {{std::lock_guard<std::mutex> lock(mtx);eventOccurred = true;}cv.notify_one();std::cout << "事件已觸發" << std::endl;
}int main() {std::thread t1(waitForEvent);std::this_thread::sleep_for(std::chrono::seconds(2));std::thread t2(triggerEvent);t1.join();t2.join();return 0;
}

互斥量遞歸鎖（Recursive Mutex）

互斥量遞歸鎖允許同一個線程多次獲得同一個鎖，避免了死鎖。

#include <iostream>
#include <thread>
#include <mutex>std::recursive_mutex mtx;void recursiveFunction(int depth) {std::lock_guard<std::recursive_mutex> lock(mtx);if (depth > 0) {std::cout << "遞歸深度：" << depth << std::endl;recursiveFunction(depth - 1);}
}int main() {recursiveFunction(3);return 0;
}

讀寫互斥量（Read-Write Mutex）

讀寫互斥量使用互斥量來實現，可以更靈活地控制讀寫線程對共享數據的訪問。

#include <iostream>
#include <thread>
#include <mutex>std::mutex readMutex;
std::mutex writeMutex;
int data = 0;void reader() {std::lock_guard<std::mutex> lock(readMutex);std::cout << "讀取數據：" << data << std::endl;
}void writer() {std::lock_guard<std::mutex> lock(writeMutex);data++;std::cout << "寫入數據：" << data << std::endl;
}int main() {std::thread readerThread1(reader);std::thread readerThread2(reader);std::thread writerThread(writer);readerThread1.join();readerThread2.join();writerThread.join();return 0;
}