在Linux環境下使用C++進行并發編程，主要依賴于POSIX線程庫（pthread）和C++11引入的線程庫。以下是一些基本的步驟和示例代碼，幫助你開始使用C++進行并發編程。
大多數Linux發行版默認已經安裝了pthread庫。如果沒有安裝，可以使用包管理器進行安裝。例如，在Ubuntu上可以使用以下命令：
sudo apt-get install libpthread-stubs0-dev
#include <iostream>
#include <pthread.h>
void* thread_function(void* arg) {
std::cout << "Thread is running" << std::endl;
return nullptr;
}
int main() {
pthread_t thread_id;
int result = pthread_create(&thread_id, nullptr, thread_function, nullptr);
if (result != 0) {
std::cerr << "Failed to create thread" << std::endl;
return 1;
}
pthread_join(thread_id, nullptr);
std::cout << "Thread has finished" << std::endl;
return 0;
}
C++11引入了標準線程庫，提供了更現代和類型安全的接口。
#include <iostream>
#include <thread>
void thread_function() {
std::cout << "Thread is running" << std::endl;
}
int main() {
std::thread t(thread_function);
if (!t.joinable()) {
std::cerr << "Failed to create thread" << std::endl;
return 1;
}
t.join();
std::cout << "Thread has finished" << std::endl;
return 0;
}
互斥鎖用于保護共享數據，防止多個線程同時訪問。
#include <iostream>
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* increment_counter(void* arg) {
for (int i = 0; i < 100000; ++i) {
pthread_mutex_lock(&mutex);
// Critical section
int* counter = static_cast<int*>(arg);
++(*counter);
pthread_mutex_unlock(&mutex);
}
return nullptr;
}
int main() {
int counter = 0;
pthread_t threads[10];
for (int i = 0; i < 10; ++i) {
pthread_create(&threads[i], nullptr, increment_counter, &counter);
}
for (int i = 0; i < 10; ++i) {
pthread_join(threads[i], nullptr);
}
std::cout << "Counter value: " << counter << std::endl;
return 0;
}
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mtx;
void increment_counter(int& counter) {
for (int i = 0; i < 100000; ++i) {
std::lock_guard<std::mutex> lock(mtx);
// Critical section
++counter;
}
}
int main() {
int counter = 0;
std::thread threads[10];
for (int i = 0; i < 10; ++i) {
threads[i] = std::thread(increment_counter, std::ref(counter));
}
for (auto& t : threads) {
t.join();
}
std::cout << "Counter value: " << counter << std::endl;
return 0;
}
條件變量用于線程間的同步，允許一個線程等待某個條件成立。
#include <iostream>
#include <pthread.h>
#include <unistd.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
bool ready = false;
void* wait_for_signal(void* arg) {
pthread_mutex_lock(&mutex);
while (!ready) {
pthread_cond_wait(&cond, &mutex);
}
std::cout << "Signal received" << std::endl;
pthread_mutex_unlock(&mutex);
return nullptr;
}
void send_signal() {
sleep(2); // Simulate some work
pthread_mutex_lock(&mutex);
ready = true;
pthread_cond_signal(&cond);
pthread_mutex_unlock(&mutex);
}
int main() {
pthread_t thread;
pthread_create(&thread, nullptr, wait_for_signal, nullptr);
send_signal();
pthread_join(thread, nullptr);
return 0;
}
#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
std::mutex mtx;
std::condition_variable cv;
bool ready = false;
void wait_for_signal() {
std::unique_lock<std::mutex> lock(mtx);
cv.wait(lock, []{ return ready; });
std::cout << "Signal received" << std::endl;
}
void send_signal() {
std::this_thread::sleep_for(std::chrono::seconds(2)); // Simulate some work
std::lock_guard<std::mutex> lock(mtx);
ready = true;
cv.notify_one();
}
int main() {
std::thread thread(wait_for_signal);
send_signal();
thread.join();
return 0;
}
線程池是一種管理線程的機制，可以提高性能和資源利用率。
#include <iostream>
#include <vector>
#include <thread>
#include <queue>
#include <functional>
#include <mutex>
#include <condition_variable>
#include <future>
class ThreadPool {
public:
ThreadPool(size_t threads) : stop(false) {
for (size_t i = 0; i < threads; ++i) {
workers.emplace_back([this] {
while (true) {
std::function<void()> task;
{
std::unique_lock<std::mutex> lock(this->queue_mutex);
this->condition.wait(lock, [this] { return this->stop || !this->tasks.empty(); });
if (this->stop && this->tasks.empty()) {
return;
}
task = std::move(this->tasks.front());
this->tasks.pop();
}
task();
}
});
}
}
template<class F, class... Args>
auto enqueue(F&& f, Args&&... args) -> std::future<typename std::result_of<F(Args...)>::type> {
using return_type = typename std::result_of<F(Args...)>::type;
auto task = std::make_shared<std::packaged_task<return_type()>>(
std::bind(std::forward<F>(f), std::forward<Args>(args)...)
);
std::future<return_type> res = task->get_future();
{
std::unique_lock<std::mutex> lock(queue_mutex);
if (stop) {
throw std::runtime_error("enqueue on stopped ThreadPool");
}
tasks.emplace([task]() { (*task)(); });
}
condition.notify_one();
return res;
}
~ThreadPool() {
{
std::unique_lock<std::mutex> lock(queue_mutex);
stop = true;
}
condition.notify_all();
for (std::thread& worker : workers) {
worker.join();
}
}
private:
std::vector<std::thread> workers;
std::queue<std::function<void()>> tasks;
std::mutex queue_mutex;
std::condition_variable condition;
bool stop;
};
int main() {
ThreadPool pool(4);
auto result = pool.enqueue([](int answer) { return answer; }, 42);
std::cout << "Result: " << result.get() << std::endl;
return 0;
}
通過這些示例代碼，你可以開始在Linux環境下使用C++進行并發編程。根據具體需求，你可以進一步擴展和優化這些代碼。
