C 信号灯工作不正常

我一直在尝试编写一个程序，其中我使用线程和信号量模拟最短的第一个作业算法。当主线程告诉他这样做时，每个线程都负责打印其id。主线程（main）将控制这些作业何时在屏幕上打印。下面是我想到的，但我似乎做错了什么，我还没弄明白。我设法让它相应地打印出作业，但10个作业中总是有2个遗漏。文件格式是“id（char）arrival（int）burst（int）”。因此，我在这里迫切需要帮助，因为我已经尝试了许多事情，并且总是以数小时的相同情况结束

#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#include <stdlib.h>
#define MAX 10

sem_t childs[MAX];
sem_t master;

int jobdone = 0;

typedef struct job
{
  int burst, arrival, wait_time, turn_around, executed, done;
  char id;
} JOB;

JOB jobs[MAX];

void ShortestFirstJob()
{

  int i, j;
  char id;
  int burst, arrival, wait_time, turn_around, done;
  for (i = 0; i < MAX; i++)
  {
    for (j = 0; j < MAX - 1; j++)
    {
      if (jobs[j].arrival > jobs[j + 1].arrival)
      {
        id = jobs[j].id;
        done = jobs[j].done;
        burst = jobs[j].burst;
        arrival = jobs[j].arrival;
        wait_time = jobs[j].wait_time;
        turn_around = jobs[j].turn_around;
        jobs[j].id = jobs[j + 1].id;
        jobs[j].burst = jobs[j + 1].burst;
        jobs[j].wait_time = jobs[j + 1].wait_time;
        jobs[j].arrival = jobs[j + 1].arrival;
        jobs[j].turn_around = jobs[j + 1].turn_around;
        jobs[j].done = jobs[j + 1].done;
        jobs[j + 1].id = id;
        jobs[j + 1].burst = burst;
        jobs[j + 1].arrival = arrival;
        jobs[j + 1].wait_time = wait_time;
        jobs[j + 1].turn_around = turn_around;
        jobs[j + 1].done = done;

      }
    }
  }
  printf("SORT \n");
  for (j = 0; j < MAX; j++)
  {
    printf("%c %d %d\n", jobs[j].id, jobs[j].arrival, jobs[j].burst);
  }

}

void* PrintJob(void *params)
{

  char id = *((char*) params);

  int i, j, k;
  for (i = 0; i < MAX; i++)
  {
    if (id == jobs[i].id)
      break;
  }

  for (k = 0; k < jobs[i].burst; k++)
  {

    sem_wait(&childs[i]);
    printf("%c", id);
    fflush(stdout);
    jobs[i].executed += 1;

    for (j = 0; j < MAX; j++)
    {
      if ((i != j) && (jobs[j].arrival > 0))
      {
        jobs[j].arrival -= 1;
        jobs[j].wait_time += 1;
      }
    }

    sem_post(&master);
  }

  jobs[i].done = 1;
  jobdone++;

}
int main()
{

  pthread_t threadIds[MAX];
  char threadsIdx;
  int result;
  int i = 0;
  int j;
  int index[MAX];

  FILE* fp = fopen("joblist1.txt", "r");

  for (j = 0; j < MAX; j++)
  {
    sem_init(&childs[j], 0, 0);
  }
  sem_init(&master, 0, 1);

  char id;
  int arrival, burst;
  while (fscanf(fp, "%c %d %d\n", &id, &arrival, &burst) != EOF)
  {

    jobs[i].id = id;
    jobs[i].arrival = arrival;
    jobs[i].burst = burst;
    jobs[i].wait_time = 0;
    jobs[i].turn_around = 0;
    jobs[i].executed = 0;
    jobs[i].done = 0;

    i++;
  }

  for (j = 0; j < MAX; j++)
  {
    printf("%c %d %d\n", jobs[j].id, jobs[j].arrival, jobs[j].burst);
  }

  ShortestFirstJob();

  for (i = 0; i < MAX; i++)
  {

    if (pthread_create(&threadIds[i], NULL, PrintJob, &jobs[i].id) != 0)
    {
      perror("thread create");
      exit(1);
    }
  }

  int k, c = 0;
  int min = 0;
  int in = 0;
  int value, flag = 0;
  while (jobdone < MAX)
  {

    k = 0;
    c = 0;

    sem_wait(&master);
    for (j = 0; j < MAX; j++)
    {
      if ((jobs[j].arrival == 0) && (jobs[j].done != 1))
      {
        index[k++] = j;
        c++;

      }
    }

    if (c == 1)
    {

      sem_post(&childs[index[0]]);

    }
    else if (c > 1)
    {

      min = jobs[index[0]].burst;
      for (j = 1; j < k; j++)
      {
        if (jobs[index[j]].burst <= min)
        {
          min = jobs[index[j]].burst;
          in = index[j];

        }
      }

      sem_post(&childs[in]);

    }

  }

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

  return 0;

}

#包括
#包括
#包括
#包括
#定义最大值10
sem_t childs[MAX]；
硕士研究生；
int jobdone=0；
类型定义结构作业
{
int突发、到达、等待时间、掉头、执行、完成；
字符id；
}工作；
工作岗位[最大值]；
void ShortestFirstJob（）
{
int i，j；
字符id；
int突发，到达，等待时间，掉头，完成；
对于（i=0；i作业[j+1].到达）
{
id=jobs[j].id；
完成=作业[j]。完成；
突发=作业[j]。突发；
到达=作业[j]。到达；
等待时间=作业[j]。等待时间；
掉头=工作[j]。掉头；
jobs[j].id=jobs[j+1].id；
作业[j]。突发=作业[j+1]。突发；
作业[j]。等待时间=作业[j+1]。等待时间；
作业[j]。到达=作业[j+1]。到达；
作业[j]。掉头=作业[j+1]。掉头；
作业[j]。完成=作业[j+1]。完成；
作业[j+1].id=id；
作业[j+1]。突发=突发；
作业[j+1]。到达=到达；
作业[j+1]。等待时间=等待时间；
作业[j+1]。掉头=掉头；
作业[j+1]。完成=完成；
}
}
}
printf（“SORT\n”）；
对于（j=0；j0））
{
作业[j].到达-=1；
作业[j].等待时间+=1；
}
}
高级管理人员职位（硕士）；
}
作业[i].done=1；
jobdone++；
}
int main（）
{
pthread_t threadIds[MAX]；
char-threadsIdx；
int结果；
int i=0；
int j；
整数指数[MAX]；
文件*fp=fopen（“joblist1.txt”、“r”）；
对于（j=0；j1），则为else
{
min=作业[索引[0]]。突发；
对于（j=1；jif（jobs[index[j]].burst我不太理解你的一些计算，但我发现了两个问题

首先，在函数
PrintJob（）
中，应该在发布主信号量之前设置
jobs[i].done=1；
，因为主线程计算
jobs[i].done
来决定它将唤醒哪个线程

因此
PrintJob（）
函数的正确代码应该是：

void* PrintJob(void *params) {

  char id = *((char*) params);

  int i, j, k;
  for (i = 0; i < MAX; i++) {
    if (id == jobs[i].id) break;
  }

  for (k = 0; k < jobs[i].burst; k++) {
    sem_wait(&childs[i]);
    printf("%c", id);
    fflush(stdout);
    jobs[i].executed += 1;

    for (j = 0; j < MAX; j++)
    {
      if ((i != j) && (jobs[j].arrival > 0))
      {
        jobs[j].arrival -= 1;
        jobs[j].wait_time += 1;
      }
    }

    /////////////////////////////
    // Here:
    if(k == (jobs[i].burst - 1))
      jobs[i].done = 1;
      jobdone++;
    }
    /////////////////////////////

    sem_post(&master);
  }
}

else if (c > 1) {

  min = jobs[index[0]].burst;

  // Here:
  in = index[0];

  for (j = 1; j < k; j++)
  {
    if (jobs[index[j]].burst <= min)
    {
      min = jobs[index[j]].burst;
      in = index[j];
    }
  }

  sem_post(&childs[in]);

}