设计一个有N个进程并发的进程调度程序，用代码展示出来

下面是一个基于优先级调度算法的进程调度程序的示例代码，可以支持N个进程的并发执行。

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

#define MAX_PROCESS_NUM 10

typedef struct PCB {
    int pid;
    int priority;
    int state; // 0: ready, 1: running, 2: blocked, 3: finished
} PCB;

PCB process_list[MAX_PROCESS_NUM];
int process_num = 0;

pthread_mutex_t mutex;

void init_processes() {
    process_list[0].pid = 1;
    process_list[0].priority = 10;
    process_list[0].state = 0;

    process_list[1].pid = 2;
    process_list[1].priority = 5;
    process_list[1].state = 0;

    process_list[2].pid = 3;
    process_list[2].priority = 7;
    process_list[2].state = 0;

    process_list[3].pid = 4;
    process_list[3].priority = 3;
    process_list[3].state = 0;

    process_num = 4;
}

int get_highest_priority_process_index() {
    int highest_priority = -1;
    int highest_priority_index = -1;

    for (int i = 0; i < process_num; i++) {
        if (process_list[i].state == 0 && process_list[i].priority > highest_priority) {
            highest_priority = process_list[i].priority;
            highest_priority_index = i;
        }
    }

    return highest_priority_index;
}

void* process_thread(void* arg) {
    int process_index = *((int*) arg);

    while (1) {
        pthread_mutex_lock(&mutex);

        process_list[process_index].state = 1; // running
        printf("Process %d is running...\n", process_list[process_index].pid);
        usleep(50000); // simulate process execution time

        process_list[process_index].state = 0; // ready
        printf("Process %d is finished.\n", process_list[process_index].pid);

        int next_process_index = get_highest_priority_process_index();
        if (next_process_index == -1) {
            printf("All processes are finished.\n");
            pthread_mutex_unlock(&mutex);
            break;
        }

        pthread_mutex_unlock(&mutex);

        usleep(10000); // simulate context switch time

        process_index = next_process_index;
    }

    return NULL;
}

int main() {
    init_processes();

    pthread_t threads[process_num];
    int args[process_num];

    pthread_mutex_init(&mutex, NULL);

    for (int i = 0; i < process_num; i++) {
        args[i] = i;
        pthread_create(&threads[i], NULL, process_thread, &args[i]);
    }

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

    pthread_mutex_destroy(&mutex);

    return 0;
}

该程序使用了pthread库来创建N个进程线程，并使用互斥锁来保证多线程之间的同步。在进程线程中，按照优先级调度算法选择就绪进程并运行，直到所有进程都完成执行为止。