C++|四种方法解决三线程按顺序轮流打印ABC的问题:互斥锁和条件变量、原子操作、信号量

基于Pthreads线程库的实现

cpp 复制代码
g++ your_program.cpp -lpthread

编译时确保链接了Pthreads库.

cpp 复制代码
#include <pthread.h>
#include <iostream>
#include <unistd.h>

// 全局变量,用于控制打印顺序
int turn = 0;
// 定义互斥锁和条件变量
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

void* printA(void* arg) {
    for (int i = 0; i < 10; i++) {
        pthread_mutex_lock(&lock);
        while (turn != 0) {
            pthread_cond_wait(&cond, &lock);
        }
        std::cout << "A ";
        turn = 1;
        pthread_cond_broadcast(&cond);
        pthread_mutex_unlock(&lock);
    }
    return NULL;
}

void* printB(void* arg) {
    for (int i = 0; i < 10; i++) {
        pthread_mutex_lock(&lock);
        while (turn != 1) {
            pthread_cond_wait(&cond, &lock);
        }
        std::cout << "B ";
        turn = 2;
        pthread_cond_broadcast(&cond);
        pthread_mutex_unlock(&lock);
    }
    return NULL;
}

void* printC(void* arg) {
    for (int i = 0; i < 10; i++) {
        pthread_mutex_lock(&lock);
        while (turn != 2) {
            pthread_cond_wait(&cond, &lock);
        }
        std::cout << "C ";
        turn = 0;
        pthread_cond_broadcast(&cond);
        pthread_mutex_unlock(&lock);
    }
    return NULL;
}

int main() {
    pthread_t t1, t2, t3;

    pthread_create(&t1, NULL, printA, NULL);
    pthread_create(&t2, NULL, printB, NULL);
    pthread_create(&t3, NULL, printC, NULL);

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);

    pthread_mutex_destroy(&lock);
    pthread_cond_destroy(&cond);

    return 0;
}

互斥锁和条件变量

cpp 复制代码
#include <iostream>
#include <vector>
#include <thread>
#include <mutex>
using namespace std;

class PrintABC {
public:
    PrintABC(int count) : count_(count) { }

    void printA () {
        for (int i = 0; i < count_; ++i) {
            std::unique_lock<std::mutex> lock(mtx_);
            //等待turn_变为0
            cv_.wait(lock, [this]() { return turn_ == 0; });
            std::cout << "a" << endl;
            //设置下一个轮次为1,并通知等待的线程
            turn_ = 1;
            cv_.notify_all();
        }
    }
    void printB () {
        for (int i = 0; i < count_; ++i) {
            std::unique_lock<std::mutex> lock(mtx_);
            //等待turn_变为0
            cv_.wait(lock, [this]() { return turn_ == 1; });
            std::cout << "b" << endl;
            //设置下一个轮次为1,并通知等待的线程
            turn_ = 2;
            cv_.notify_all();
        }
    }
    void printC () {
        for (int i = 0; i < count_; ++i) {
            std::unique_lock<std::mutex> lock(mtx_);
            //等待turn_变为0
            cv_.wait(lock, [this]() { return turn_ == 2; });
            std::cout << "c" << endl;
            //设置下一个轮次为1,并通知等待的线程
            turn_ = 0;
            cv_.notify_all();

        }
    }
private:
    std::mutex mtx_;
    std::condition_variable cv_;
    int turn_ = 0;  //控制打印顺序,0代表打印a,1代表打印b,2代表打印c,
    int count_; //打印次数
};

int main () {
    int printCount = 10; //设定打印次数
    PrintABC printABC(printCount);

    std::thread t1(&PrintABC::printA, &printABC);
    std::thread t2(&PrintABC::printB, &printABC);
    std::thread t3(&PrintABC::printC, &printABC);

    t1.join();
    t2.join();
    t3.join();

    return 0;
}

原子变量

无锁实现控制打印顺序,但会占用更多的CPU资源,因为线程在等待时处于忙等(busy-waiting)状态。

cpp 复制代码
#include <iostream>
#include <thread>
#include <atomic>

volatile std::atomic<int> turn(0);

void printA(int count) {
    for (int i = 0; i < count; ++i) {
        while(turn != 0); // 忙等
        std::cout << "a";
        turn = 1;
    }
}

void printB(int count) {
    for (int i = 0; i < count; ++i) {
        while(turn != 1); // 忙等
        std::cout << "b";
        turn = 2;
    }
}

void printC(int count) {
    for (int i = 0; i < count; ++i) {
        while(turn != 2); // 忙等
        std::cout << "c";
        turn = 0;
    }
}

int main() {
    int count = 10;
    std::thread a(printA, count);
    std::thread b(printB, count);
    std::thread c(printC, count);

    a.join();
    b.join();
    c.join();

    std::cout << "\n";
    return 0;
}

信号量

C++20之后引入的库,才使得C++语言级别的信号量实现,

编译的时候记得加一个-std=c++20

cpp 复制代码
#include <iostream>
#include <thread>
#include <semaphore>

std::counting_semaphore semA(1); // 初始计数为1,A可以立即打印
std::counting_semaphore semB(0); // 初始计数为0,B需要等待A释放
std::counting_semaphore semC(0); // 初始计数为0,C需要等待B释放

void printA(int count) {
    for (int i = 0; i < count; ++i) {
        semA.acquire();
        std::cout << "a" << std::endl;
        semB.release();
    }
}

void printB(int count) {
    for (int i = 0; i < count; ++i) {
        semB.acquire();
        std::cout << "b" << std::endl;
        semC.release();
    }
}

void printC(int count) {
    for (int i = 0; i < count; ++i) {
        semC.acquire();
        std::cout << "c" << std::endl;
        semA.release();
    }
}

int main() {
    int count = 10; // 每个线程打印10次
    std::thread a(printA, count);
    std::thread b(printB, count);
    std::thread c(printC, count);

    a.join();
    b.join();
    c.join();

    std::cout << "\n";
    return 0;
}
相关推荐
jingling55510 分钟前
面试版-前端开发核心知识
开发语言·前端·javascript·vue.js·面试·前端框架
oioihoii21 分钟前
C++11 forward_list 从基础到精通:原理、实践与性能优化
c++·性能优化·list
m0_6873998429 分钟前
写一个Ununtu C++ 程序,调用ffmpeg API, 来判断一个数字电影的视频文件mxf 是不是Jpeg2000?
开发语言·c++·ffmpeg
爱上语文39 分钟前
Redis基础(5):Redis的Java客户端
java·开发语言·数据库·redis·后端
A~taoker1 小时前
taoker的项目维护(ng服务器)
java·开发语言
萧曵 丶1 小时前
Rust 中的返回类型
开发语言·后端·rust
hi星尘1 小时前
深度解析:Java内部类与外部类的交互机制
java·开发语言·交互
看到我,请让我去学习1 小时前
Qt编程-qml操作(js,c++,canvas)
开发语言·qt
橘子编程1 小时前
Python-Word文档、PPT、PDF以及Pillow处理图像详解
开发语言·python
Ronin3052 小时前
【C++】类型转换
开发语言·c++