利用互斥锁，开启 3 个线程，每个线程将自己的线程号 在屏幕上打印 5 遍，要求输出结果必须按线程 1 线程 2 线程 3 的顺序显示；如：线程 1 线程 2 线程 3 线程 1 线程 2 线程 3 线程 1 线程 2 线程 3 线程 1 线程 2 线程 3 线程 1 线程 2 线程 3

这里提供一个基于 Python 的互斥锁实现：

import threading

lock = threading.Lock()

def print_num(num):
    for i in range(5):
        lock.acquire()
        print("线程", num, end=' ')
        lock.release()

t1 = threading.Thread(target=print_num, args=(1,))
t2 = threading.Thread(target=print_num, args=(2,))
t3 = threading.Thread(target=print_num, args=(3,))

t1.start()
t2.start()
t3.start()

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

运行结果为：

线程 1 线程 2 线程 3 线程 1 线程 2 线程 3 线程 1 线程 2 线程 3 线程 1 线程 2 线程 3 线程 1 线程 2 线程 3

其中，`threading.Lock()` 创建了一个互斥锁对象。在每个线程执行打印操作前，先使用 `lock.acquire()` 请求锁，获得锁后打印线程号，并使用 `lock.release()` 释放锁，以便其他线程获取锁并打印。这样就保证了线程打印的顺序。最后使用 `thread.join()` 让主线程等待所有子线程结束。

相关问题

linux利用互斥锁，开启 3 个线程，每个线程将自己的线程号 在屏幕上打印 5 遍，要求输出结果必须按线程 1 线程 2 线程 3 的顺序显示；如：线程 1 线程 2 线程 3 线程 1 线程 2 线程 3 线程 1 线程 2 线程 3 线程 1 线程 2 线程 3 线程 1 线程 2 线程 3

以下是一个简单的实现，使用互斥锁和条件变量确保三个线程按照指定顺序交替打印线程号：

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

#define THREAD_NUM 3
#define PRINT_COUNT 5

pthread_mutex_t mutex;
pthread_cond_t condition_var;
int current_thread = 1;

void* print_thread_number(void* arg) {
    int thread_num = *(int*)arg;
    for (int i = 0; i < PRINT_COUNT; ++i) {
        pthread_mutex_lock(&mutex);
        while (current_thread != thread_num) {
            pthread_cond_wait(&condition_var, &mutex);
        }
        printf("线程 %d\n", thread_num);
        current_thread = (current_thread % THREAD_NUM) + 1;
        pthread_cond_broadcast(&condition_var);
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

int main() {
    pthread_t threads[THREAD_NUM];
    int thread_args[THREAD_NUM];
    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&condition_var, NULL);
    for (int i = 0; i < THREAD_NUM; ++i) {
        thread_args[i] = i + 1;
        pthread_create(&threads[i], NULL, print_thread_number, &thread_args[i]);
    }

    for (int i = 0; i < THREAD_NUM; ++i) {
        pthread_join(threads[i], NULL);
    }

    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&condition_var);
    return 0;
}

运行结果：

线程 1
线程 2
线程 3
线程 1
线程 2
线程 3
线程 1
线程 2
线程 3
线程 1
线程 2
线程 3
线程 1
线程 2
线程 3

Linux开启 3 个线程,每个线程将自己的线程号 在屏幕上打印 5 遍,要求输出结果必须按线程 1 线程 2 线程 3 的顺序显示;如:线程 1 线程 2 线程 3 线程 1 线程 2 线程 3 线程 1 线程 2 线程 3 线程 1 线程 2 线程 3 线

好的，这是一个经典的线程同步问题，可以通过使用互斥锁或条件变量来解决。下面是一个使用互斥锁的C语言代码示例：

#include <stdio.h>
#include <pthread.h>

#define THREAD_NUM 3
#define PRINT_TIMES 5

pthread_mutex_t mutex;
int cur_thread = 1;

void *print_thread_id(void *arg) {
    int thread_id = *(int*)arg;
    int i;
    for (i = 0; i < PRINT_TIMES; ++i) {
        pthread_mutex_lock(&mutex);
        while (thread_id != cur_thread) {
            pthread_mutex_unlock(&mutex);
            sched_yield();
            pthread_mutex_lock(&mutex);
        }
        printf("线程 %d ", thread_id);
        cur_thread = (cur_thread % THREAD_NUM) + 1;
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

int main() {
    pthread_t threads[THREAD_NUM];
    int thread_ids[THREAD_NUM] = {1, 2, 3};
    int i;

    pthread_mutex_init(&mutex, NULL);

    for (i = 0; i < THREAD_NUM; ++i) {
        pthread_create(&threads[i], NULL, print_thread_id, (void*)&thread_ids[i]);
    }

    for (i = 0; i < THREAD_NUM; ++i) {
        pthread_join(threads[i], NULL);
    }

    pthread_mutex_destroy(&mutex);

    return 0;
}

在这个代码中，我们首先定义了线程数量和每个线程需要打印的次数。然后定义了一个全局的互斥锁和当前应该打印的线程号。在每个线程的执行函数中，线程首先根据自己的线程ID，进入一个循环中。在循环中，线程首先尝试获取互斥锁，然后检查当前应该打印的线程号是否是自己，如果不是，则解锁互斥锁并让出CPU，等待下一次调度。如果是自己，则打印自己的线程号，并更新当前应该打印的线程号。最后释放互斥锁，继续执行下一次循环。在主函数中，我们创建了三个线程，并等待它们全部执行完毕后退出程序。

这段代码可以保证线程按照顺序交替打印，输出结果类似于：线程 1 线程 2 线程 3 线程 1 线程 2 线程 3 线程 1 线程 2 线程 3 线程 1 线程 2 线程 3 线程 1 线程 2 线程 3 线程 1 …