C 在简单多线程程序中实现基本信号量

请帮助同步 我必须使这个程序以顺序的方式使用 线程内（ex）线程1执行和线程2执行等 但是它应该只使用信号量来实现。我输入了wait（），Signal（） 函数的作用类似于信号量（但不起作用）

您只需要看到pthread_连接和thread_工作部分 （该程序的主要目的是：生成20个线程并将其与信号量同步）

#包括
#包括
#包括
#包括
#定义num_线程20
char-str[11]；
无效*螺纹工程（无效*tid）//螺纹加工主体
void生成_str（int n）//创建随机字符串
void stru排序（void）//将生成的字符串排序为alpabet方式
作废检查\排序（作废）//检查“排序是否正确”
无效打印时间（struct timespec*myclock）//打印线程工作的时间间隔
无效打印时间程序（struct timespec*myclock）；
无效等待（void）//我在这两个函数中加入了信号量
无效信号（void）//但它不起作用
int S=1；
内部主（空）
{
pthread_t tid[num_thread]；
int rc；
int t；
结构timespec myclock[4]；
srand（时间（空））；
clock_gettime（clock_REALTIME和myclock[2]）；
对于（t=0；t，下面是一个如何使用信号量（Linux/Cygwin pthreads）让线程一个接一个地执行的工作示例：

#包括
#包括
#包括
#包括
#包括
#定义NUM_线程5
/*全局线程退出控制标志*/
易失性uint32\u t g\u ExitFlag=0；
/*全局线程执行控制信号量*/
sem_t g_sem；
/*线程函数*/
void*ThreadFunc（void*pContext）
{
uint32_t tid=（uint32_t）pContext；
/*主线程环*/
而（g_ExitFlag==0）
{
/*等待信号量发出信号*/
sem_wait（&g_sem）；
printf（“线程%d正在运行。\n”，tid）；
}
printf（“线程%d正在退出。\n”，tid）；
返回NULL；
}
int main（int argc，char*argv[]）
{
uint32_t i=0；
pthread_t th；
/*抑制警告*/
（无效）argc；
（无效）argv；
/*初始化信号量*/
sem_init（&g_-sem，0,0）；
/*创建并分离多个线程*/
对于（i=0；i

将这种功能集成到程序中应该很简单。
S需要声明为volatile。如果代码缩进正确，我更可能阅读您的代码。非常抱歉；这是第一次在这里询问……很难输入代码；；-将线程转换为非常慢的顺序代码。同样，您无法实现在不使用C11中的stdatomic.h的情况下正确输入您自己的信号量。即使这样，您也只能实现同步旋转，而不能实现正确的休眠。因此，我建议使用pthreads库提供的标准信号量。
#include <stdio.h>
#include <pthread.h>
#include <time.h>
#include <stdlib.h>
#define num_thread 20

char str[11];
void *thread_work(void *tid);   //Main body of Thread working
void generate_str(int n);       //Create random character string
void str_sort(void);            //Sorting the generated string into alpabet manner
void check_sort(void);          //Check about "Is the sorting is right"
void print_time(struct timespec *myclock);  //print the time interval of thread work
void print_time_program(struct timespec *myclock);
void wait(void);           //I put in these two function to be act like semaphore
void Signal(void);         //But it does't work
int S=1;

int main(void)
{
  pthread_t tid[num_thread];
  int rc; 
  int t;
  struct timespec myclock[4];
  srand(time(NULL));
  clock_gettime(CLOCK_REALTIME, &myclock[2]);
  for(t=0; t<num_thread; t++)
      pthread_create(&tid[t], NULL, thread_work, (void *)&t);

  for(t=0; t<num_thread; t++)
      pthread_join(tid[t], NULL);


  clock_gettime(CLOCK_REALTIME, &myclock[3]);
  print_time_program(myclock);
  return 0;
}

void *thread_work(void *t)
{
  do
  {
      wait();           //Entry Section

      //CRITICAL SECTION START

              struct timespec myclock[2];
      clock_gettime(CLOCK_REALTIME, &myclock[0]);   
      int n = *((int *)t);
      printf("########## Thread #%d starting ########## \n", n);
      generate_str(n);
      str_sort();
      check_sort();
      printf("########## Thread #%d exiting  ##########\n", n);
      clock_gettime(CLOCK_REALTIME, &myclock[1]);
      print_time(myclock);

              //CRITICAL SECTION END

      Signal();
      pthread_exit(NULL);
  }while (1);               

}

void str_sort(void)
{
  int temp;
  int i, j;

  for(i=0; i<9; i++)
      for(j=0; j<9-i; j++)
      {
          if(str[j]>str[j+1])
          {
                  temp=str[j];
              str[j]=str[j+1];
              str[j+1]=temp;
          }
      }
  printf("Sorted string      : %s  ", str);
}

void generate_str(int n)
{
      int i;
  int num;
  srand(n);
  for(i=0; i<10; i++)
  {
      num = (97+rand()%26);
      str[i]=num;
  }

  str[10]='\0';
  printf("Initialized string : %s \n", str);
}

void check_sort(void)
{
  int i;
  int count=0;
  for(i=0; i<9; i++)
  {
      if(str[i]>str[i+1])
          count++;
  }
  if(count != 0)
      printf("[X] FALSE \n");
  else
      printf("[O] TRUE \n");
  }

void print_time(struct timespec *myclock)
{
  long delay, temp, temp_n, sec;
  sec = myclock[0].tv_sec % 60;
  printf("Thread Starting Time : %ld.%ld second\n", sec, myclock[0].tv_nsec);
  sec = myclock[1].tv_sec % 60;
  printf("Thread Exiting Time  : %ld.%ld second\n", sec, myclock[1].tv_nsec);

  if (myclock[1].tv_nsec >= myclock[0].tv_nsec) 
  { 
      temp = myclock[1].tv_sec - myclock[0].tv_sec; 
      temp_n = myclock[1].tv_nsec - myclock[0].tv_nsec; 
      delay = 1000000000 * temp + temp_n; 
  }
  else 
  { 
      temp = myclock[1].tv_sec - myclock[0].tv_sec - 1; 
      temp_n = 1000000000 + myclock[1].tv_nsec - myclock[0].tv_nsec; 
      delay = 1000000000 * temp + temp_n; 
  }  

  printf("Thread Working Time  : %ld nano second", delay);
  delay = delay / 1000000;
  printf("(%ld ms)\n\n\n", delay);
  return ;
}

void print_time_program(struct timespec *myclock)
{
  long delay, temp, temp_n, sec;
  sec = myclock[2].tv_sec % 60;
  printf("Program Starting Time : %ld.%ld second\n", sec, myclock[2].tv_nsec);
  sec = myclock[3].tv_sec % 60;
  printf("Program Exiting Time  : %ld.%ld second\n", sec, myclock[3].tv_nsec);

  if (myclock[3].tv_nsec >= myclock[2].tv_nsec) 
  { 
      temp = myclock[3].tv_sec - myclock[2].tv_sec; 
      temp_n = myclock[3].tv_nsec - myclock[2].tv_nsec; 
      delay = 1000000000 * temp + temp_n; 
  }
  else 
  { 
      temp = myclock[3].tv_sec - myclock[2].tv_sec - 1; 
      temp_n = 1000000000 + myclock[3].tv_nsec - myclock[2].tv_nsec; 
      delay = 1000000000 * temp + temp_n; 
  } 

  printf("Program Total Working Time : %ld nano second", delay);
  delay = delay / 1000000;
  printf("(%ld ms)\n\n\n", delay);
  return ;
}

void wait(void)
{
  while( S <= 0);
  S--;
}

void Signal(void)
{
  S++;
}

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

#define NUM_THREADS 5

/* global thread exit control flag */
volatile uint32_t g_ExitFlag = 0;

/* global thread execution control semaphore */
sem_t g_Sem;

/* the thread function */
void *ThreadFunc(void *pContext)
{
    uint32_t tid = (uint32_t)pContext;

    /* main thread loop */
    while (g_ExitFlag == 0)
    {
        /* wait for semaphore to be signalled */
        sem_wait(&g_Sem);
        printf("Thread %d running.\n", tid);
    }

    printf("Thread %d exiting.\n", tid);

    return NULL;
}

int main(int argc, char *argv[])
{
    uint32_t i = 0;
    pthread_t th;

    /* suppress warnings */
    (void)argc;
    (void)argv;

    /* initialize the semaphore */
    sem_init(&g_Sem, 0, 0);

    /* create and detach several threads */
    for (i = 0; i < NUM_THREADS; ++i)
    {
        pthread_create(&th, NULL, ThreadFunc, (void *)i);
        pthread_detach(th);
    }

    /* run each thread four times and exit */
    for (i = 0; i < (NUM_THREADS * 4); ++i)
    {
        if (i == 15)
        {
            g_ExitFlag = 1;
        }

        /* release a thread to execute */
        sem_post(&g_Sem);
        sleep(1);
    }

    return 0;
}