C 在Linux2中调度两个线程打印数字模式

我想使用两个线程

T1

和

T2

打印数字。T1应打印数字，如

1,2,3,4,5

，然后T2应打印

6,7,8,9,10

，再次

T1

应开始，然后

T2

应跟随。它应该从

1…100打印。我有两个问题

如何使用线程和一个全局变量完成任务
如何在linux中按所需顺序调度线程
如何在linux中按所需顺序调度线程

您需要使用锁定原语（如互斥体或条件变量）来影响线程的调度顺序。或者你必须让你的线程在订单上独立工作

如何使用线程和一个全局变量完成任务

如果只允许使用一个变量，则不能使用互斥（互斥将是第二个变量）。因此，您必须做的第一件事是声明您的原子变量。否则，编译器可能会优化代码，使一个线程看不到另一个线程所做的更改。对于您想要的简单代码，它将通过在寄存器上缓存变量来实现。使用
std:：atomic\u int
。您可能会找到使用
volatile int
的建议，但现在
std:：atomic_int
是一种更直接的方法来指定所需内容

你不能使用互斥锁，所以你不能让你的线程等待。它们将不断运行并浪费CPU。但这似乎适合这项任务。因此，您需要编写一个自旋锁。线程将在循环中等待，不断检查值。如果
值%10<5
，则第一个线程中断循环并执行递增，否则第二个线程执行该作业

因为这个问题看起来像是一个家庭作业，我在这里没有展示任何代码示例，所以您需要自己编写它们

如何在linux中按所需顺序调度线程

您需要使用锁定原语（如互斥体或条件变量）来影响线程的调度顺序。或者你必须让你的线程在订单上独立工作

如何使用线程和一个全局变量完成任务

如果只允许使用一个变量，则不能使用互斥（互斥将是第二个变量）。因此，您必须做的第一件事是声明您的原子变量。否则，编译器可能会优化代码，使一个线程看不到另一个线程所做的更改。对于您想要的简单代码，它将通过在寄存器上缓存变量来实现。使用
std:：atomic\u int
。您可能会找到使用
volatile int
的建议，但现在
std:：atomic_int
是一种更直接的方法来指定所需内容

你不能使用互斥锁，所以你不能让你的线程等待。它们将不断运行并浪费CPU。但这似乎适合这项任务。因此，您需要编写一个自旋锁。线程将在循环中等待，不断检查值。如果
值%10<5
，则第一个线程中断循环并执行递增，否则第二个线程执行该作业

因为这个问题看起来像是一个家庭作业，我在这里没有展示任何代码示例，所以您需要自己编写它们

如何使用线程和一个全局变量完成任务

如果您使用的是
Linux
，则可以使用
POSIX
库在
C
编程语言中进行线程处理。该库是
。然而，作为一种替代方案，一个非常可移植且相对非侵入性的库，在
gcc
和
g++
上得到了很好的支持，并且（使用旧版本）在MSVC上得到了很好的支持

不是标准C和C++，OpenMP本身是标准。
如何在linux中按所需顺序调度线程
要实现所需的打印操作，您需要有一个全局变量，该变量可以由您的两个线程访问。两个线程轮流访问全局变量
变量
并执行操作（
增量
和
打印
）。但是，要实现
所需的顺序
，您需要有一个
互斥锁
。互斥是一种互斥信号量，是一种特殊的信号量变体，一次只允许一个锁存器。当您有一个资源实例（
全局变量，在您的例子中为
）并且该资源由两个线程共享时，可以使用它。锁定互斥锁后的线程可以独占访问资源实例，并且在完成其操作后，线程应该为其他线程释放互斥锁

您可以从中的
中的线程和互斥开始

解决您的问题的一个可能的方法是下面给出这个程序。然而，我建议你自己去尝试，然后看看我的解决方案

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

pthread_mutex_t lock;
int variable=0;

#define ONE_TIME_INC 5
#define MAX 100

void *thread1(void *arg)
{
 while (1) {
    pthread_mutex_lock(&lock);
    printf("Thread1: \n");
    int i;
    for (i=0; i<ONE_TIME_INC; i++) {
        if (variable >= MAX)
            goto RETURN;
        printf("\t\t%d\n", ++variable);
    }   
    printf("Thread1: Sleeping\n");
    pthread_mutex_unlock(&lock);
    usleep(1000);
}
RETURN:
pthread_mutex_unlock(&lock);
return NULL;
}

void *thread2(void *arg)
{
while (1) {
    pthread_mutex_lock(&lock);
    printf("Thread2: \n");
    int i;
    for (i=0; i<ONE_TIME_INC; i++) {
        if (variable >= MAX)
            goto RETURN;
        printf("%d\n", ++variable);
    }   
    printf("Thread2: Sleeping\n");
    pthread_mutex_unlock(&lock);
    usleep(1000);
}
RETURN:
pthread_mutex_unlock(&lock);
return NULL;

}

int main()
{

if (pthread_mutex_init(&lock, NULL) != 0) {
    printf("\n mutex init failed\n");
    return 1;
}

pthread_t pthread1, pthread2;
if (pthread_create(&pthread1, NULL, thread1, NULL))
    return -1;
if (pthread_create(&pthread2, NULL, thread2, NULL))
    return -1;

pthread_join(pthread1, NULL);
pthread_join(pthread2, NULL);

pthread_mutex_destroy(&lock);

return 0;
}

#包括
#包括
#包括
pthread_mutex_t lock；
int变量=0；
#定义一次性公司5
#定义最大值100
void*thread1（void*arg）
{
而(1){
pthread_mutex_lock（&lock）；
printf（“Thread1:\n”）；
int i；
对于（i=0；i=MAX）
转到返回；
printf（“\t\t%d\n”++变量）；
}   
printf（“Thread1:Sleeping\n”）；
pthread_mutex_unlock（&lock）；
usleep（1000）；
}
返回：
pthread_mutex_unlock（&lock）；
返回NULL；
}
void*thread2（void*arg）
{
而(1){
pthread_mutex_lock（&lock）；
printf（“Thread2:\n”）；
int i；
对于（i=0；i=MAX）
转到返回；
printf（“%d\n”++变量）；
}   
printf（“Thread2:Sleeping\n”）；
pthread_mutex_unlock（&lock）；
usleep（1000）；
}
返回：
pthread_mutex_unlock（&lock）；
返回NULL；
}
int main（）
{
if（pthread\u mutex\u init（&lock，NULL）！=0）{
printf（“\n互斥初始化失败\n”）；
返回1；
}
pthread_t pthread 1，pthread 2；
if（pthread_create（&pthread1，NULL，thread1，NULL））
返回-1；
if（pthread_create（&pthread2，NULL，thread2，NULL））
返回-1；
pthread_join（p
int counter=1;
pthread_mutex_t mutex; //needs to be initialised

void incrementGlobal() {
    for(int i=0;i<5;i++){
        counter++;
        printf("%i\n",counter);
    }
 }

pthread_mutex_lock(&mutex);
incrementGlobal();
pthread_mutex_unlock(&mutex);

int num_thread=2;
int current_thread_id=0;
pthread_cond_t cond; //needs to be initialised

int local_thread_id; // the ID of the thread
while(true) {
    phread_mutex_lock(&mutex);
    while (current_thread_id != local_thread_id) {
        pthread_cond_wait(&cond, &mutex);
    }
    incrementGlobal();
    current_thread_id = (current_thread_id+1) % num_threads; 
    pthread_cond_broadcast(&cond);
    pthread_mutex_unlock(&mutex);
}