在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++进行并发编程。根据具体需求，你可以进一步扩展和优化这些代码。
