在Linux中使用C++進行并發編程，你可以使用多種方法。以下是一些常見的并發編程技術：
POSIX Threads (pthreads):
POSIX Threads是一個標準的線程庫，它提供了創建和管理線程的API。在C++中，你可以使用<pthread.h>頭文件中的函數來創建線程、等待線程結束、傳遞參數等。
#include <pthread.h>
#include <iostream>
void* thread_function(void* arg) {
std::cout << "Thread is running" << std::endl;
return nullptr;
}
int main() {
pthread_t thread_id;
if (pthread_create(&thread_id, nullptr, thread_function, nullptr) != 0) {
std::cerr << "Error creating thread" << std::endl;
return 1;
}
pthread_join(thread_id, nullptr);
return 0;
}
C++11 標準庫線程:
C++11引入了標準庫線程支持，它提供了一個更高級別的抽象來處理線程。你可以使用<thread>頭文件中的std::thread類來創建和管理線程。
#include <thread>
#include <iostream>
void thread_function() {
std::cout << "Thread is running" << std::endl;
}
int main() {
std::thread t(thread_function);
t.join();
return 0;
}
異步編程:
C++11還引入了<future>和<async>頭文件，它們提供了異步編程的能力。你可以使用std::async來啟動一個異步任務，并通過std::future來獲取結果。
#include <future>
#include <iostream>
int async_function() {
// Simulate a long-running task
std::this_thread::sleep_for(std::chrono::seconds(1));
return 42;
}
int main() {
std::future<int> result = std::async(std::launch::async, async_function);
std::cout << "Waiting for the result..." << std::endl;
int value = result.get(); // This will block until the result is ready
std::cout << "The result is " << value << std::endl;
return 0;
}
互斥鎖和條件變量:
當多個線程需要訪問共享資源時，你需要使用互斥鎖（std::mutex）來保護這些資源。條件變量（std::condition_variable）可以用來同步線程間的操作。
#include <thread>
#include <mutex>
#include <condition_variable>
#include <iostream>
std::mutex mtx;
std::condition_variable cv;
bool ready = false;
void print_id(int id) {
std::unique_lock<std::mutex> lck(mtx);
while (!ready) {
cv.wait(lck);
}
std::cout << "Thread " << id << std::endl;
}
void go() {
std::unique_lock<std::mutex> lck(mtx);
ready = true;
cv.notify_all();
}
int main() {
std::thread threads[10];
// Spawn 10 threads:
for (int i = 0; i < 10; ++i)
threads[i] = std::thread(print_id, i);
std::cout << "10 threads ready to race...\n";
go(); // go!
for (auto &th : threads) th.join();
return 0;
}
原子操作:
C++11還提供了原子操作的支持，可以在不使用鎖的情況下安全地更新共享變量。你可以使用<atomic>頭文件中的原子類型和函數。
#include <atomic>
#include <thread>
#include <iostream>
std::atomic<int> counter(0);
void increment_counter() {
for (int i = 0; i < 1000; ++i) {
++counter; // This is thread-safe
}
}
int main() {
std::thread t1(increment_counter);
std::thread t2(increment_counter);
t1.join();
t2.join();
std::cout << "Counter: " << counter << std::endl;
return 0;
}
這些是Linux下C++并發編程的一些基本方法。在實際應用中，你可能需要結合使用這些技術來實現復雜的并發模式。記得在多線程編程中處理好同步和數據競爭問題，以確保程序的正確性和性能。
