实现简单多线程程序的基本信号量

Question

请帮助同步我必须使这个程序执行顺序的方式使用在线程(ex) thread1和thread2执行，等等但是它应该只使用信号量来实现。我输入wait()和Signal()函数的行为像信号量(但不工作)

您只需要查看pthread_join和thread_work部分(这个程序的主要目的:创建20个线程并使用信号量同步它们)

#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]='';
  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 secondn", sec, myclock[0].tv_nsec);
  sec = myclock[1].tv_sec % 60;
  printf("Thread Exiting Time  : %ld.%ld secondn", 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)nnn", 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 secondn", sec, myclock[2].tv_nsec);
  sec = myclock[3].tv_sec % 60;
  printf("Program Exiting Time  : %ld.%ld secondn", 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)nnn", delay);
  return ;
}
void wait(void)
{
  while( S <= 0);
  S--;
}
void Signal(void)
{
  S++;
}

Answer 1

下面是一个使用信号量(Linux/Cygwin pthreads)使线程一个接一个执行的工作示例:

#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;
}

将这种功能集成到程序中应该是很简单的。