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