线程池+时间片轮转法调度+连续内存管理+内存调度

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <semaphore.h>
#include <unistd.h>
#include <time.h>
#include <sys/types.h>
#include <pthread.h>
#define bool int
#define true 1
#define false 0
#define THREAD_MAXN 100//线程数
#define RUNTIME_SUB 1//每次运行线程减去的运行时间
#define RUN_TIME 100//线程运行时间
#define TASK_NUM 10000//任务数
//-----结构体定义
typedef struct TCB//存储线程信息
{
    int thread_id;//线程编号
    int arriveTime;//线程到达时间
    int runTime;//持续时间
    int finishTime;//完成时间
    int wholeTime;//周转时间
    double weightWholeTime;//带权周转时间
    bool Finished;//线程是否完成
    struct TCB* next;//使用链式存储方式
}TCB;
struct TCB_counterpart
{
    struct TCB *father;
    struct TCB_counterpart *next;
};
struct task
{
    void *(*task_func)(void *param);
    void *param;
    struct task *next;
};
struct tcb_queue//TCB队列定义
{
    struct TCB* tcbQueue[THREAD_MAXN+1];//TCB指针数组
    int r, f;
};
struct thread_pool//线程池结构体
{
    pthread_mutex_t tcb_lock;//互斥锁
    int fDestroyed;//线程池是否被销毁
    pthread_t* threadid;//存储线程标识符指针
    struct TCB* nowRunThread;//指向当前正在运行的线程     
    int nFinish;//完成线程数
    sem_t sem[THREAD_MAXN+1];//用于控制线程的信号量
    struct tcb_queue rrQueue;//轮转队列
    struct tcb_queue showQueue;//用于辅助打印的队列
    struct TCB_counterpart *nowPullQueue;
    struct task *task_queue;//任务队列
    int task_num;
    struct TCB* tcb;//存储TCB
};
//-----全局变量定义
static struct thread_pool* pool = NULL;//全局变量pool，指向线程池
int nowTime = -1;//当前已走过的时间
//-----函数声明
void TCB_bubble();//给TCB排序
void add_task (void *(*task_func)(void *param));
void task_init();
void show_rr();//打印轮转队列
void show_tcb();//打印所有线程的信息
void pool_init();//初始化线程池
void* thread_run_func(void* param);//线程里运行的函数
void round_robin();//时间片轮转算法的调度函数
int pool_destroy();//销毁线程池
void* task_run();
void pull_thread();
void enqueue(struct tcb_queue  *q, struct TCB* tcb);
struct TCB* dequeue(struct tcb_queue *q);
struct TCB* get_front(struct tcb_queue *q);
bool empty(struct tcb_queue *q);
struct TCB_counterpart* create_TCB_counterpart();
void insert_counterpart(struct TCB *tcb);
//main
int main()
{
    pool_init();
    TCB_bubble();
    show_tcb();
    task_init();
    round_robin();
    sleep(3);
    pool_destroy();
    return 0;
}
//函数定义
void TCB_bubble()//给TCB排序,按arriveTime升序排列
{
    TCB* ptemp = NULL;
    for (int i = 0; i < THREAD_MAXN+1; ++i)
    {
        ptemp = pool->tcb;
        int f = 0;
        while (ptemp && ptemp->next)
        {
            if (ptemp->arriveTime > ptemp->next->arriveTime)
            {//交换两个节点
                f = 1;
                TCB* p_next = ptemp->next->next;
                TCB* p_pre = ptemp;//后面ptemp = ptemp->next，当前ptemp相当于pre
                TCB* p_pre_pre = pool->tcb;//pre的pre
                if (p_pre_pre == p_pre)//说明ptemp是头结点
                {
                    p_pre_pre = NULL;
                }
                else//否则找到pre_pre所在位置
                {
                    while (p_pre_pre && p_pre_pre->next != p_pre)
                    {
                        p_pre_pre = p_pre_pre->next;
                    }
                }
                //交换结点
                ptemp = ptemp->next;
                ptemp->next = p_pre;
                p_pre->next = p_next;
                if (p_pre_pre)
                {
                    p_pre_pre->next = ptemp;
                }
                else
                {
                    pool->tcb = ptemp;
                }
            }
            ptemp = ptemp->next;
        }
        if(f == 0) return;
    }
}
void show_rr()//打印轮转队列
{
    if (empty(&(pool->rrQueue)))
    {
        printf("目前还没有线程在队列中
");
    }
    else
    {
        printf("目前轮转队列为：
");
    }
    while (!empty(&(pool->rrQueue)))
    {
        enqueue(&(pool->showQueue), get_front(&(pool->rrQueue)));
        printf("%d ", dequeue(&(pool->rrQueue))->thread_id);
    }
    while (!empty(&(pool->showQueue)))//将队列放回
    {
        enqueue(&(pool->rrQueue), dequeue(&(pool->showQueue)));
    }
    printf("
");
}
void show_tcb()//打印所有线程的信息
{
    TCB* ptemp = pool->tcb;
    printf("打印所有线程的信息：
");
    while (ptemp)
    {
        printf("线程%d：到达时间：%d，剩余时间：%d
", ptemp->thread_id, ptemp->arriveTime, ptemp->runTime);
        ptemp = ptemp->next;
    }
    printf("
");
}
void pool_init()//初始化线程池
{
    pool = (struct thread_pool*)malloc(sizeof(struct thread_pool));
    pthread_mutex_init(&(pool->tcb_lock), NULL);//初始为未锁住状态
    pool->fDestroyed = 0;//线程池是否被销毁
    pool->nFinish = 0;
    pool->task_num = 0;
    pool->nowRunThread = NULL;//指向当前正在运行的线程 
    pool->rrQueue.f = pool->rrQueue.r = 0;//轮转队列
    pool->showQueue.r = pool->showQueue.r = 0;//用于辅助打印的队列
    pool->task_queue = NULL;
    pool->nowPullQueue = NULL;
    pool->tcb = NULL;
    //创建并初始化TCB
    TCB* ptemp = pool->tcb;
    srand(time(0));
    for (int i = 0; i < THREAD_MAXN; ++i)
    {
        TCB* s = (TCB*)malloc(sizeof(TCB));
        // s->arriveTime = rand()%9;
        s->arriveTime = 0;
        s->runTime = RUN_TIME;
        s->thread_id = i;//编号令为0
        s->Finished = false;
        s->next = NULL;
        //尾插入
        if (!pool->tcb)//第一个节点
        {
            pool->tcb = s;
        }
        else
        {
            ptemp = pool->tcb;
            while (ptemp && ptemp->next)
            {
                ptemp = ptemp->next;
            }
            ptemp->next = s;
        }
    }
    //初始化信号量
    ptemp = pool->tcb;
    int i = 0;
    while (ptemp)
    {
        int i = ptemp->thread_id;
        sem_init(&(pool->sem[i]), 0, 0);
        ptemp = ptemp->next;
    }
    //创建线程
    ptemp = pool->tcb;
    pool->threadid = (pthread_t*)malloc(sizeof(pthread_t) * (THREAD_MAXN+1));
    while (ptemp)
    {
        //把ptemp作为参数传入thread_run_func()
        int t;
        t = pthread_create(&(pool->threadid[ptemp->thread_id]), 
            NULL, thread_run_func, ptemp);
        if (!t)//线程创建成功
        {
            printf("线程%d创建成功!
", ptemp->thread_id);
        }
        else
        {
            printf("线程创建失败!
");
        }
        ptemp = ptemp->next;
    }
    printf("线程池pool初始化完成！
");
}
void* thread_run_func(void* param)//线程里运行的函数
{
    TCB* ptemp = (TCB*)param;
    while (ptemp->runTime > 0)
    {
        sem_wait(&(pool->sem[ptemp->thread_id]));//唤醒
        pthread_mutex_lock(&(pool->tcb_lock));//上互斥锁
        if (pool->fDestroyed)
        {
            pthread_mutex_unlock(&(pool->tcb_lock));
            printf ("线程%d退出
", ptemp->thread_id);
            pthread_exit (NULL);
        }
        ptemp->runTime -= RUNTIME_SUB;
        if(ptemp->runTime > 0) enqueue(&(pool->rrQueue), ptemp);
        printf("线程%d（剩余时间%d->%d）", ptemp->thread_id, ptemp->runTime + RUNTIME_SUB, ptemp->runTime < 0 ? 0 : ptemp->runTime);
        //线程操作
        struct task *pTask = pool->task_queue;
        if(pool->task_queue)
        {
            pool->task_queue = pool->task_queue->next;
            --pool->task_num;
        }
        else
        {
            pthread_mutex_unlock(&(pool->tcb_lock));
            printf("任务为空
");
            break;
        }
        (*(pTask->task_func))(pTask->param);
        free(pTask);
        pTask = NULL;
        pthread_mutex_unlock(&(pool->tcb_lock));
        sleep(1);
    }
    pthread_exit(NULL);
}
void round_robin()//时间片轮转算法的调度函数
{
    TCB* ptemp = pool->tcb;
    while (1)
    {
        ++nowTime;
        pthread_mutex_lock(&(pool->tcb_lock));
        if (pool->nFinish == THREAD_MAXN)//所有线程完成
            break;
        while (ptemp && ptemp->arriveTime == nowTime)
        {
            printf("当前时间为%d, 线程%d进入轮转队列，运行时间：%d
",nowTime, ptemp->thread_id, ptemp->runTime);
            enqueue(&(pool->rrQueue), ptemp);
            ptemp=ptemp->next;
        }
        printf("
");
        show_rr();
        pull_thread();
        pthread_mutex_unlock(&(pool->tcb_lock));
        sleep(10);
        if(!pool->task_queue)break;
    }
}
int pool_destroy()//销毁线程池
{
    if (pool->fDestroyed)//防止重复销毁
        return -1;
    pool->fDestroyed = 1;
    TCB* ptemp = pool->tcb;
    while (ptemp)
    {
        pthread_join(pool->threadid[ptemp->thread_id], NULL);
        printf("线程%d已结束
", ptemp->thread_id);
        ptemp = ptemp->next;
    }
    struct task *ptask = pool->task_queue;
    while (pool->task_queue)
    {
        ptask = pool->task_queue;
        pool->task_queue = pool->task_queue->next;
        free(ptask);
    }
    free(ptemp);
    free(pool->threadid);
    pthread_mutex_destroy(&(pool->tcb_lock));
    free(pool);
    pool = NULL;
    printf("线程池pool已被销毁！
");
    return 0;
}
void* task_run()
{
    printf("正在执行任务
");
    sleep(1);
    return;
}
void add_task(void *(*task_func)(void *param))
{
    pthread_mutex_lock(&(pool->tcb_lock));
    struct task *newtask = (struct task*) malloc (sizeof (struct task));
    newtask->task_func = task_run;//要执行的函数
    newtask->next = NULL;
    struct task *pTask = pool->task_queue;
    if (pTask)
    {
        while (pTask && pTask->next)
            pTask = pTask->next;
        pTask->next = newtask;
    }
    else
    {
        pool->task_queue = newtask;
    }
    ++pool->task_num;
    pthread_mutex_unlock(&(pool->tcb_lock));
    return;
}
void task_init()
{
    for(int i = 0; i < TASK_NUM; ++i)   
        add_task(task_run);     
}
void pull_thread()
{
    struct TCB *ptemp1 = NULL;
    struct TCB *ptemp2 = NULL;
    struct TCB *ptemp3 = NULL;
    if(pool->nowPullQueue)
    {
        struct nowPullQueue *ppull = pool->nowPullQueue;
        while(pool->nowPullQueue)
        {
            ppull = pool->nowPullQueue;
            pool->nowPullQueue = pool->nowPullQueue->next;
            free(ppull); 
        }
        pool->nowPullQueue = NULL;
    }
    printf("当前时间为：%d，轮转的线程为：",nowTime);
    if(!empty(&(pool->rrQueue)))
    {
        ptemp1 = dequeue(&(pool->rrQueue));
        sem_post(&(pool->sem[ptemp1->thread_id]));
        insert_counterpart(ptemp1);
        sleep(2);
        if(!empty(&(pool->rrQueue)))
        {
            ptemp2 = dequeue(&(pool->rrQueue));
            sem_post(&(pool->sem[ptemp2->thread_id]));
            insert_counterpart(ptemp2);
            sleep(2);
            if(!empty(&(pool->rrQueue)))
            {
                ptemp3 = dequeue(&(pool->rrQueue));
                sem_post(&(pool->sem[ptemp3->thread_id]));
                insert_counterpart(ptemp3);
                sleep(2);
            }
        }
    }
    printf("
");
}
void enqueue(struct tcb_queue  *q, struct TCB* tcb)
{
    q->r = (q->r + 1) % (THREAD_MAXN+1);
    q->tcbQueue[q->r] = tcb;
}
struct TCB* dequeue(struct tcb_queue *q)
{
    q->f = (q->f + 1) % (THREAD_MAXN+1);
    return q->tcbQueue[q->f];
}
struct TCB* get_front(struct tcb_queue *q)
{
    return q->tcbQueue[(q->f + 1) % (THREAD_MAXN+1)];
}
bool empty(struct tcb_queue *q)
{
    return q->r == q->f;
}
struct TCB_counterpart* create_TCB_counterpart()
{
    struct TCB_counterpart *s = (struct TCB_counterpart*)malloc(sizeof(struct TCB_counterpart));
    s->next = NULL;
    s->father = NULL;
    return s;
}
void insert_counterpart(struct TCB *tcb)
{
    if(!pool->nowPullQueue)
    {
        pool->nowPullQueue = create_TCB_counterpart();
        pool->nowPullQueue->father = tcb;
    }
    else
    {
        struct TCB_counterpart *ptemp = pool->nowPullQueue;
        while(ptemp && ptemp->next)
        {
            ptemp = ptemp->next;
        }
        ptemp->next = create_TCB_counterpart();
        ptemp->next->father = tcb;
    }
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <semaphore.h>
#include <unistd.h>
#include <time.h>
#include <sys/types.h>
#include <pthread.h>
#define bool int
#define true 1
#define false 0
#define rerange BF_rerange//选择内存分配方法
#define schedule fifo//选择调度方法
#define THREAD_MAXN 2//线程数
#define RUNTIME_SUB 1//每次运行线程减去的运行时间
#define INIT_FREE_BLOCK_NUM 8//内存块初始数量
#define INIT_FREE_BLOCK_SIZE 10//内存块初始大小
#define FREE_MAXN 80//最大空闲块数量
#define RUN_TIME 10000//线程运行时间
#define STU_NUM 10000//学生数量
//-----结构体定义
typedef struct TCB//存储线程信息
{
    int thread_id;//线程编号
    int arriveTime;//线程到达时间
    int runTime;//持续时间
    int finishTime;//完成时间
    int wholeTime;//周转时间
    double weightWholeTime;//带权周转时间
    bool Finished;//线程是否完成
    struct TCB* next;//使用链式存储方式
}TCB;
struct task
{
    void *(*task_func) (void *param);
    void *param;
    struct task *next;
};
struct tcb_queue//TCB队列定义
{
    struct TCB* tcbQueue[THREAD_MAXN+1];//TCB指针数组
    int r, f;
};
struct thread_pool//线程池结构体
{
    pthread_mutex_t tcb_lock;//互斥锁
    int fDestroyed;//线程池是否被销毁
    pthread_t* threadid;//存储线程标识符指针
    struct TCB* nowRunThread;//指向当前正在运行的线程     
    int nFinish;//完成线程数
    sem_t sem[THREAD_MAXN+1];//用于控制线程的信号量
    struct tcb_queue rrQueue;//轮转队列
    struct tcb_queue showQueue;//用于辅助打印的队列
    struct task *task_queue;//任务队列
    int task_num;
    struct TCB* tcb;//存储TCB
};
struct free_block//空闲块结构体
{
    int start;//起始位置
    int size;
    struct free_block* next;
};
struct busy_block//被分配的内存块
{
    int id;//编号
    int start;
    int size;
    char* data;//根据需要动态分配
    struct busy_block* next;
};
struct student//储存学生信息
{
    char number[9];
    char name[76];
    int name_size;
};
//-----全局变量定义
static struct thread_pool* pool = NULL;//全局变量pool，指向线程池
int nowTime;//当前已走过的时间
int busy_cnt = -1;//分配块编号计数器
int nFree = 0;//空闲块数量
int nBusy = 0;//已分配块数量
int nameCnt = 0;//名字存储计数器
int numCnt = 0;//学号存储计数器
int ScheduleCnt = 0;//调度次数
struct free_block* free_queue = NULL;//储存空闲块的链表
struct busy_block* busy_queue = NULL;//储存已分配块的链表
struct student student_info[STU_NUM];
//-----函数声明
void TCB_bubble();//给TCB排序
void add_task (void *(*task_func)(void *param));
void show_rr();//打印轮转队列
void show_tcb();//打印所有线程的信息
void pool_init();//初始化线程池
void* thread_run_func(void* param);//线程里运行的函数
void round_robin();//时间片轮转算法的调度函数
int pool_destroy();//销毁线程池
void init_free();//初始化空闲块
struct free_block* create_free(int start, int size, struct free_block* next);//创建一个空闲块
struct busy_block* create_busy(int start, int size, struct busy_block* next, char* data);//创建一个已分配块
struct free_block* merge_free(struct free_block* f);//合并所有能够合并的空闲内存块
void init_student();//初始化学生的学号，姓名，采用随机生成的方法
void insert_busy(struct busy_block* pBusy);//尾插法插入一个分配块到链表busy_queue中
void insert_free(struct free_block* pFree);//尾插法插入一个空闲块到链表free_queue中
void delete_free(struct free_block* pFree, int size);//删除一个空闲块中被占用的部分，保留剩余部分
void fifo_delete_busy();//fifo算法中删除分配块
void lifo_delete_busy();//lifo算法中删除分配块
void show_free();//显示空闲块链表   
void show_busy();//显示分配块链表
void free_bubble(int choice);//choice1:start升序，choice2：size升序，choice3：size降序
void FF_rerange();//按不同内存分配方法的规则排序
void BF_rerange();
void WF_rerange();
void *store_info(void* param);//param: 1存学号，2存姓名
void merge_in();//合并空闲内存块函数的入口
void fifo();//fifo算法调出分配块
void lifo();//lifo算法调出分配块
void enqueue(struct tcb_queue  *q, struct TCB* tcb);
struct TCB* dequeue(struct tcb_queue *q);
struct TCB* get_front(struct tcb_queue *q);
bool empty(struct tcb_queue *q);
//main
int main()
{
    init_student();
    init_free();
    pool_init();
    TCB_bubble();
    show_tcb();
    for(int i = 0; i < 2*STU_NUM; ++i) add_task(store_info);
    round_robin();
    sleep(3);
    pool_destroy();
    return 0;
}
//函数定义
void TCB_bubble()//给TCB排序,按arriveTime升序排列
{
    TCB* ptemp = NULL;
    for (int i = 0; i < THREAD_MAXN+1; ++i)
    {
        ptemp = pool->tcb;
        int f = 0;
        while (ptemp && ptemp->next)
        {
            if (ptemp->arriveTime > ptemp->next->arriveTime)
            {//交换两个节点
                f = 1;
                TCB* p_next = ptemp->next->next;
                TCB* p_pre = ptemp;//后面ptemp = ptemp->next，当前ptemp相当于pre
                TCB* p_pre_pre = pool->tcb;//pre的pre
                if (p_pre_pre == p_pre)//说明ptemp是头结点
                {
                    p_pre_pre = NULL;
                }
                else//否则找到pre_pre所在位置
                {
                    while (p_pre_pre && p_pre_pre->next != p_pre)
                    {
                        p_pre_pre = p_pre_pre->next;
                    }
                }
                //交换结点
                ptemp = ptemp->next;
                ptemp->next = p_pre;
                p_pre->next = p_next;
                if (p_pre_pre)
                {
                    p_pre_pre->next = ptemp;
                }
                else
                {
                    pool->tcb = ptemp;
                }
            }
            ptemp = ptemp->next;
        }
        if(f == 0) return;
    }
}
void show_rr()//打印轮转队列
{
    printf("当前时间为：%d
", nowTime);
    if (pool->rrQueue.f == pool->rrQueue.r)
    {
        printf("目前还没有线程到达
");
    }
    else
    {
        printf("目前轮转队列为：
");
    }
    while (!empty(&(pool->rrQueue)))
    {
        enqueue(&(pool->showQueue), get_front(&(pool->rrQueue)));
        printf("%d ", dequeue(&(pool->rrQueue))->thread_id);
    }
    while (!empty(&(pool->showQueue)))//将队列放回
    {
        enqueue(&(pool->rrQueue), dequeue(&(pool->showQueue)));
    }
    printf("

");
}
void show_tcb()//打印所有线程的信息
{
    TCB* ptemp = pool->tcb;
    printf("打印所有线程的信息：
");
    while (ptemp)
    {
        printf("线程%d：到达时间：%d，剩余时间：%d
", ptemp->thread_id, ptemp->arriveTime, ptemp->runTime);
        ptemp = ptemp->next;
    }
    printf("
");
}
void pool_init()//初始化线程池
{
    pool = (struct thread_pool*)malloc(sizeof(struct thread_pool));
    pthread_mutex_init(&(pool->tcb_lock), NULL);//初始为未锁住状态
    pool->fDestroyed = 0;//线程池是否被销毁
    pool->nFinish = 0;
    pool->task_num = 0;
    pool->nowRunThread = NULL;//指向当前正在运行的线程 
    pool->rrQueue.f = pool->rrQueue.r = 0;//轮转队列
    pool->showQueue.r = pool->showQueue.r = 0;//用于辅助打印的队列
    pool->task_queue = NULL;
    pool->tcb = NULL;
    //创建并初始化TCB
    TCB* ptemp = pool->tcb;
    srand(time(0));
    for (int i = 0; i < THREAD_MAXN; ++i)
    {
        TCB* s = (TCB*)malloc(sizeof(TCB));
        // s->arriveTime = rand()%9;
        s->arriveTime = 0;
        s->runTime = RUN_TIME;
        s->thread_id = i;//编号令为0
        s->Finished = false;
        s->next = NULL;
        //尾插入
        if (!pool->tcb)//第一个节点
        {
            pool->tcb = s;
        }
        else
        {
            ptemp = pool->tcb;
            while (ptemp && ptemp->next)
            {
                ptemp = ptemp->next;
            }
            ptemp->next = s;
        }
    }
    //初始化信号量
    ptemp = pool->tcb;
    int i = 0;
    while (ptemp)
    {
        int i = ptemp->thread_id;
        sem_init(&(pool->sem[i]), 0, 0);
        ptemp = ptemp->next;
    }
    //创建线程
    ptemp = pool->tcb;
    pool->threadid = (pthread_t*)malloc(sizeof(pthread_t) * (THREAD_MAXN+1));
    while (ptemp)
    {
        //把ptemp作为参数传入thread_run_func()
        int t;
        t = pthread_create(&(pool->threadid[ptemp->thread_id]), 
            NULL, thread_run_func, ptemp);
        if (!t)//线程创建成功
        {
            printf("线程%d创建成功!
", ptemp->thread_id);
        }
        else
        {
            printf("线程创建失败!
");
        }
        ptemp = ptemp->next;
    }
    printf("线程池pool初始化完成！
");
}
void* thread_run_func(void* param)//线程里运行的函数
{
    TCB* ptemp = (TCB*)param;
    int i = 0;
    while (ptemp->runTime > 0)
    {
        sem_wait(&(pool->sem[ptemp->thread_id]));//唤醒
        pthread_mutex_lock(&(pool->tcb_lock));//上互斥锁
        if (pool->fDestroyed)
        {
            pthread_mutex_unlock(&(pool->tcb_lock));
            printf ("线程%d退出
", ptemp->thread_id);
            pthread_exit (NULL);
        }
        ptemp->runTime -= RUNTIME_SUB;
        //线程操作
        printf("当前线程：%d号
", ptemp->thread_id);
        struct task *pTask = pool->task_queue;
        if(pool->task_queue)
        {
            pool->task_queue = pool->task_queue->next;
            --pool->task_num;
        }
        else
        {
            pthread_mutex_unlock(&(pool->tcb_lock));
            printf("任务为空
");
            break;
        }
        if (ptemp->thread_id == 0)i = 1;//number
        else i = 2;
            (*(pTask->task_func))(&i);
        
        free(pTask);
        pTask = NULL;
        //线程操作  
        if (ptemp->runTime <= 0)//线程已经完成
        {
            ++pool->nFinish;
            ptemp->Finished = true;
            //出队
            dequeue(&(pool->rrQueue));
        }
        else
        {//还未完成
            //出队
            dequeue(&(pool->rrQueue));
            //入队
            enqueue(&(pool->rrQueue), ptemp);
        }
        pthread_mutex_unlock(&(pool->tcb_lock));
        sleep(1);
    }
    pthread_exit(NULL);
}
void round_robin()//时间片轮转算法的调度函数
{
    TCB* ptemp = pool->tcb;
    while (1)
    {
        //sleep(1);
        pthread_mutex_lock(&(pool->tcb_lock));
        if (pool->nFinish == THREAD_MAXN)//所有线程完成
            break;
        while (ptemp && ptemp->arriveTime == nowTime)
        {
            enqueue(&(pool->rrQueue), ptemp);
            ptemp = ptemp->next;
        }
        if (pool->rrQueue.f != pool->rrQueue.r)
        {
            pool->nowRunThread = get_front(&(pool->rrQueue));
            sem_post(&(pool->sem[pool->nowRunThread->thread_id]));
        }
        ++nowTime;
        pthread_mutex_unlock(&(pool->tcb_lock));
        sleep(1);
    }
}
int pool_destroy()//销毁线程池
{
    if (pool->fDestroyed)//防止重复销毁
        return -1;
    pool->fDestroyed = 1;
    TCB* ptemp = pool->tcb;
    while (ptemp)
    {
        pthread_join(pool->threadid[ptemp->thread_id], NULL);
        printf("线程%d已结束
", ptemp->thread_id);
        ptemp = ptemp->next;
    }
    free(ptemp);
    free(pool->threadid);
    pthread_mutex_destroy(&(pool->tcb_lock));
    free(pool);
    pool = NULL;
    printf("线程池pool已被销毁！
");
    return 0;
}

//----------------------------------------------------------------------------------

void init_free()
{
    int start_address = 0;
    struct free_block* ptemp = NULL;
    for (int i = 0; i < INIT_FREE_BLOCK_NUM; ++i)
    {
        struct free_block* s = create_free(start_address, INIT_FREE_BLOCK_SIZE, NULL);
        printf("已创建起始地址为%d，大小为%d的空闲块！
", s->start, s->size);
        ++nFree;
        if (!free_queue)
        {
            free_queue = s;
        }
        else
        {
            ptemp = free_queue;
            while (ptemp && ptemp->next)
            {
                ptemp = ptemp->next;
            }
            ptemp->next = s;
        }
        start_address += INIT_FREE_BLOCK_SIZE;
    }
    printf("空闲内存块初始化完成！
");
    show_free();
}
struct free_block* create_free(int start, int size, struct free_block* next)
{
    struct free_block* s = (struct free_block*)malloc(sizeof(struct free_block));
    s->start = start;
    s->size = size;
    s->next = next;
    return s;
}
struct busy_block* create_busy(int start, int size, struct busy_block* next, char* data)
{
    struct busy_block* s = (struct busy_block*)malloc(sizeof(struct busy_block));
    s->start = start;
    s->id = ++busy_cnt;
    s->next = NULL;
    s->size = size;
    s->data = (char*)malloc(sizeof(char) * size);
    for (int i = 0; i < size; ++i)
    {
        s->data[i] = data[i];
    }
    return s;
}
void init_student()
{
    srand(time(0));
    for (int i = 0; i < STU_NUM; ++i)
    {
        strcpy(student_info[i].number, "18");
        for(int j=2; j<8; ++j)
        {
            student_info[i].number[j] = (char)('0'+(rand()%10));
        }
        student_info[i].number[8] = '';
        student_info[i].name_size = 4 + (rand() % 70);//拼音长度：4~20
        for (int j = 0; j < student_info[i].name_size; ++j)
        {
            student_info[i].name[j] = (char)('a' + rand()%26);
        }
        student_info[i].name[student_info[i].name_size] = '';
        printf("编号：%d，姓名：%s，姓名大小：%d，学号：%s
", i, student_info[i].name, student_info[i].name_size, student_info[i].number);
    }
    printf("学生信息初始化完成！
");
}
void free_bubble(int choice)
{
    struct free_block* ptemp = NULL;
    if (free_queue)
        for (int i = 0; i < FREE_MAXN; ++i)
        {
            int fReturn = 0;
            ptemp = free_queue;
            while (ptemp && ptemp->next)
            {
                if ((ptemp->start > ptemp->next->start && choice == 1) || /*FF*/
                    (ptemp->size > ptemp->next->size && choice == 2) || /*BF*/
                    (ptemp->size < ptemp->next->size && choice == 3) ) /*WF*/ 
                {//交换两个节点
                    fReturn = 1;
                    struct free_block* p_next = ptemp->next->next;
                    struct free_block* p_pre = ptemp;
                    struct free_block* p_pre_pre = free_queue;
                    if (p_pre_pre == p_pre)
                    {
                        p_pre_pre = NULL;
                    }
                    else
                    {
                        while (p_pre_pre && p_pre_pre->next != p_pre)
                        {
                            p_pre_pre = p_pre_pre->next;
                        }
                    }
                    ptemp = ptemp->next;
                    ptemp->next = p_pre;
                    p_pre->next = p_next;
                    if (p_pre_pre)
                    {
                        p_pre_pre->next = ptemp;
                    }
                    else
                    {
                        free_queue = ptemp;
                    }
                }
                ptemp = ptemp->next;
            }
            if(fReturn == 0)//排序已完成
            {
                return;
            }
        }
}
void insert_busy(struct busy_block* pBusy)
{
    if (!busy_queue)
    {
        busy_queue = pBusy;
    }
    else
    {
        struct busy_block* ptemp = busy_queue;
        while (ptemp && ptemp->next)
        {
            ptemp = ptemp->next;
        }
        ptemp->next = pBusy;
    }
    ++nBusy;
    printf("完成插入分配块——开始地址：%d，大小：%d
", pBusy->start, pBusy->size);
    return;
}
void insert_free(struct free_block* pFree)
{
    if (!free_queue)
    {
        free_queue = pFree;
    }
    else
    {
        struct free_block* ptemp = free_queue;
        while (ptemp && ptemp->next)
        {
            ptemp = ptemp->next;
        }
        ptemp->next = pFree;
    }
    ++nFree;
    printf("完成插入空闲块——开始地址：%d，大小：%d
", pFree->start, pFree->size);
    return;
}
void delete_free(struct free_block* pFree, int size)
{
    if (!free_queue)return;
    struct free_block* ptemp = free_queue;
    struct free_block* pre = NULL;
    while (ptemp)
    {
        if (ptemp == pFree)
        {
            if (pre)
            {
                if (pFree->size == size)//无剩余
                {
                    --nFree;
                    pre->next = ptemp->next;
                }
                else
                {
                    pre->next = create_free(pFree->start + size, pFree->size - size, ptemp->next);
                }
            }
            else
            {
                if (pFree->size == size)
                {
                    free_queue = ptemp->next;
                }
                else
                {
                    free_queue = create_free(pFree->start + size, pFree->size - size, ptemp->next);
                }
            }
            free(ptemp);
            ptemp = NULL;
            break;
        }
        pre = ptemp;
        ptemp = ptemp->next;
    }
    return;
}
void fifo_delete_busy()
{
    if (busy_queue)
    {
        struct busy_block* ptemp = busy_queue;
        busy_queue = busy_queue->next;
        free(ptemp);
        ptemp = NULL;
        --nBusy;
    }
    else
    {
        printf("无分配块
");
    }
}
void lifo_delete_busy()
{
    if (busy_queue)
    {
        struct busy_block* ptemp = busy_queue;
        struct busy_block* pre = NULL;
        while (ptemp && ptemp->next)
        {
            pre = ptemp;
            ptemp = ptemp->next;
        }
        if (!pre)
        {
            busy_queue = NULL;
        }
        else
        {
            pre->next = NULL;
        }
        free(ptemp);
        ptemp = NULL;
        --nBusy;
    }
    else
    {
        printf("无分配块
");
    }
    return;
}
void show_free()
{
    if (free_queue)
    {
        struct free_block* ptemp = free_queue;
        printf("显示空闲块：
");
        while (ptemp)
        {
            printf("————开始：%d，大小：%d
", ptemp->start, ptemp->size);
            ptemp = ptemp->next;
        }
        printf("
");
    }
    else
    {
        printf("当前无空闲块
");
    }
    return;
}
void show_busy()
{
    if (busy_queue)
    {
        struct busy_block* ptemp = busy_queue;
        printf("显示已分配块：
");
        while (ptemp)
        {
            printf("—————————序号:%d，开始：%d，大小：%d，数据：", ptemp->id, ptemp->start, ptemp->size);
            for (int i = 0; i < ptemp->size; ++i)
            {
                printf("%c", ptemp->data[i]);
            }
            printf("
");
            ptemp = ptemp->next;
        }
        printf("
");
    }
    else
    {
        printf("当前无分配块
");
    }
    return;
}
void merge_in()
{
    free_bubble(1);
    free_queue = merge_free(free_queue);
    printf("紧缩完成
");
    return;
}
struct free_block* merge_free(struct free_block* f)
{
    if (f && f->next)
    {
        f->next = merge_free(f->next);
        if (f->next && (f->start + f->size == f->next->start))
        {
            struct free_block* p = f->next;
            f->next = p->next;
            f->size += p->size;
            free(p);
            p = NULL;
        }
    }
    return f;
}
void fifo()
{
    if (busy_queue)
    {
        printf("+++++++++++++++++++++被调出的信息:序号：%d，开始地址：%d，大小：%d, 数据:", 
            busy_queue->id, busy_queue->start, busy_queue->size);
        for (int k = 0; k < busy_queue->size; ++k)
        {
            printf("%c", busy_queue->data[k]);
        }
        printf("
");
        printf("+++++++++++++++++++++调度次数：%d
", ++ScheduleCnt);
        struct free_block* pFree = create_free(busy_queue->start, busy_queue->size, NULL);
        insert_free(pFree);
        fifo_delete_busy();
    }
    else
    {
        printf("无分配块，无法调出
");
    }
    return;
}
void lifo()
{
    if (busy_queue)
    {
        struct busy_block* ptemp = busy_queue;
        while (ptemp && ptemp->next)
        {
            ptemp = ptemp->next;
        }
        printf("+++++++++++++++++++++被调出的信息:序号：%d，开始地址：%d，大小：%d, 数据:", 
            ptemp->id, ptemp->start, ptemp->size);
        for (int k = 0; k < ptemp->size; ++k)
        {
            printf("%c", ptemp->data[k]);
        }
        printf("
");
        printf("+++++++++++++++++++++调度次数：%d
", ++ScheduleCnt);
        struct free_block* pFree = create_free(ptemp->start, ptemp->size, NULL);
        insert_free(pFree);
        lifo_delete_busy();
    }
    else
    {
        printf("无分配块，无法调出
");
    }
    return;
}
void FF_rerange()
{
    merge_in();
    return;
}
void BF_rerange()
{
    merge_in();
    free_bubble(2);
    return;
}
void WF_rerange()
{
    merge_in();
    free_bubble(3);
    return;
}
void *store_info(void* param)
{
    int choice = *((int*)param);
    struct free_block* pFree = free_queue;
    struct busy_block* pBusy = busy_queue;    
    int subscript = choice == 1 ? numCnt : nameCnt;
    char *data = choice == 1 ? student_info[subscript].number : student_info[subscript].name;
    int size = choice == 1 ? 8 : student_info[subscript].name_size;
    printf("将要放入内存的信息：");
    for (int c = 0; c < size; ++c)
    {
        printf("%c", data[c]);
    }
    printf("，大小：%d
", size);
    printf("将所有空闲内存块紧缩
");
    rerange();
    show_free();
    int fEnough = 0;//内存大小是否足够
    while (!fEnough)
    {
        if (pFree && pFree->size >= size)
        {
            fEnough = 1;
            if(choice == 1) ++numCnt;
            else ++nameCnt;
            pBusy = create_busy(pFree->start, size, NULL, data);
            printf("正在存储的信息：开始地址:%d, 大小:%d
", pFree->start, size);
            delete_free(pFree, size);
            insert_busy(pBusy);
            show_busy();
            break;
        }
        else
        {
            if (pFree)
            {
                printf("当前指向空闲内存大小不够，跳到下一块空闲内存
");
                pFree = pFree->next;
            }
            else
            {
                printf("没有足够大小的空闲内存可用，开始调度：
");
                schedule();
                printf("将所有空闲内存块紧缩并排序
");
                rerange();
                show_free();
                pFree = free_queue;
            }
        }
    }
    sleep(1);
}
void add_task (void *(*task_func)(void *param))
{
    struct task *newtask = (struct task*) malloc (sizeof (struct task));
    pthread_mutex_lock(&(pool->tcb_lock));
    newtask->task_func = store_info;//要执行的函数
    newtask->next = NULL;
    struct task *pTask = pool->task_queue;
    if (pTask)
    {
        while (pTask && pTask->next)
            pTask = pTask->next;
        pTask->next = newtask;
    }
    else
    {
        pool->task_queue = newtask;
    }
    ++pool->task_num;
    pthread_mutex_unlock(&(pool->tcb_lock));
    return;
}
void enqueue(struct tcb_queue  *q, struct TCB* tcb)
{
    q->r = (q->r + 1) % (THREAD_MAXN+1);
    q->tcbQueue[q->r] = tcb;
}
struct TCB* dequeue(struct tcb_queue *q)
{
    q->f = (q->f + 1) % (THREAD_MAXN+1);
    return q->tcbQueue[q->f];
}
struct TCB* get_front(struct tcb_queue *q)
{
    return q->tcbQueue[(q->f + 1) % (THREAD_MAXN+1)];
}
bool empty(struct tcb_queue *q)
{
    return q->r == q->f;
}