cpp用三个线程分别循环打印123456...

可以使用互斥锁和条件变量来实现。具体实现如下：

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>

using namespace std;

mutex mtx;
condition_variable cv;
int count = 1;

void print(int id) {
unique_lock<mutex> lock(mtx);
while (count <= 10) {
if (count % 3 == id) {
cout << count << " ";
count++;
cv.notify_all();
} else {
cv.wait(lock);
}
}
}

int main() {
thread t1(print, );
thread t2(print, 1);
thread t3(print, 2);

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

return ;
}

相关问题

C++实现建立三个线程A、B、C，A线程打印10次字母A，B线程打印10次字母B,C线程打印10次字母C，但是要求三个线程同时运行，并且实现交替打印，即按照ABCABCABC的顺序打印。

下面是一个基于C++11的实现，使用了互斥锁和条件变量来实现线程的同步和互斥。

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>

std::mutex mtx;
std::condition_variable cv;
int count = 0;
const int kMaxCount = 30;

void print(char ch, int num) {
    for (int i = 0; i < num; ++i) {
        std::unique_lock<std::mutex> lock(mtx);
        while (count % 3 != ch - 'A') {
            cv.wait(lock);
        }
        std::cout << ch;
        ++count;
        cv.notify_all();
    }
}

int main() {
    std::thread threadA(print, 'A', 10);
    std::thread threadB(print, 'B', 10);
    std::thread threadC(print, 'C', 10);
    threadA.join();
    threadB.join();
    threadC.join();
    std::cout << std::endl;
    return 0;
}

其中，`print`函数接收两个参数，一个是要打印的字符，另一个是打印的次数。在函数内部，我们使用`std::unique_lock<std::mutex>`来获取互斥锁，并使用`while`循环和`std::condition_variable`来实现线程的等待和唤醒。具体地，当目前正在执行的线程不是需要打印的线程时，我们调用`cv.wait(lock)`来释放互斥锁并等待唤醒。一旦被唤醒，我们再次获取互斥锁并打印字符，同时递增`count`计数器，并通过`cv.notify_all()`来唤醒其他线程。

在`main`函数中，我们创建三个线程并分别传入不同的字符和打印次数，然后等待三个线程执行完毕后输出换行符。如果一切正常，程序应该输出：`ABCABCABCABCABCABCABCABCABCABC`。

C++不适用锁实现建立三个线程A、B、C，A线程打印10次字母A，B线程打印10次字母B,C线程打印10次字母C，但是要求三个线程同时运行，并且实现交替打印，即按照ABCABCABC的顺序打印。

这里提供一种基于原子变量和条件变量的解法，避免了使用锁。

#include <iostream>
#include <thread>
#include <atomic>
#include <condition_variable>

std::atomic<int> count(0);
const int kMaxCount = 30;
std::condition_variable cv;
std::mutex cv_mtx;

void print(char ch, int num) {
    for (int i = 0; i < num; ++i) {
        while (count % 3 != ch - 'A') {
            std::unique_lock<std::mutex> lock(cv_mtx);
            cv.wait(lock);
        }
        std::cout << ch;
        ++count;
        cv.notify_all();
    }
}

int main() {
    std::thread threadA(print, 'A', 10);
    std::thread threadB(print, 'B', 10);
    std::thread threadC(print, 'C', 10);
    threadA.join();
    threadB.join();
    threadC.join();
    std::cout << std::endl;
    return 0;
}

在这个解法中，我们使用了一个`std::atomic<int>`类型的变量`count`来记录当前应该打印哪个字符。同时，我们使用了一个`std::condition_variable`类型的变量`cv`和一个`std::mutex`类型的变量`cv_mtx`来实现线程的等待和唤醒。

在`print`函数内部，我们使用了一个`while`循环来判断是否轮到当前线程打印字符。如果不是，就等待唤醒。如果是，就打印字符并递增`count`，然后通过`cv.notify_all()`来唤醒其他线程。

在`main`函数中，我们创建三个线程并分别传入不同的字符和打印次数，然后等待三个线程执行完毕后输出换行符。如果一切正常，程序应该输出：`ABCABCABCABCABCABCABCABCABCABC`。

注意，这种解法使用了原子变量和条件变量，可以避免使用锁。但是，它可能会带来额外的开销和复杂性，具体取决于系统的实现。在实际应用中，需要根据具体情况进行选择。