系统编程（3）

• 使用链表实现进出排队系统

// 练习：模拟银行的排队系统

#include 
#include "link_queue.h"
#include 
#include 
#include 

#define MAX_CLIENT_COUNT 100

// 全局队列：用于存放用户ID的链式队列
link_queue_t *queue;
// 互斥锁：用于保障生产者线程和消费者线程互斥访问用户队列
pthread_mutex_t mutex;
// 用户数信号量：用于表示当前可用的用户个数
sem_t client_sem;
// 空余排队数信号量：用于表示当前队列中能够继续插入的用户个数
sem_t free_space_sem;

// 生产者线程：用于模拟用户的产生
void *producer_thread(void *arg);

// 消费者线程：用于模拟银行柜台的动作
void *consumer_thread(void *arg);

int main(int argc, char *argv[])
{
    pthread_t producer_id;
    pthread_t consumer_id;

    // 初始化全局用户队列
    queue = create_empty_link_queue();
    // 初始化互斥锁
    pthread_mutex_init(&mutex, NULL);
    // 初始化相关信号量
    sem_init(&client_sem, 0, 0);
    sem_init(&free_space_sem, 0, MAX_CLIENT_COUNT);
    
    // create threads
    pthread_create(&producer_id, NULL, producer_thread, NULL);
    pthread_create(&consumer_id, NULL, consumer_thread, NULL);
    
    // join threads 
    pthread_join(producer_id, NULL);
    pthread_join(consumer_id, NULL);

    sem_destroy(&client_sem);
    sem_destroy(&free_space_sem);

    return 0;
}

// 生产者线程：用于模拟用户的产生
void *producer_thread(void *arg)
{
    int client_no = 0;
    
    while(1)
    {
        // 1.获取 产生用户的资格(即让空余位置-1)
        sem_wait(&free_space_sem);
        
        // 2.模拟产生用户ID
        client_no = rand()%1000+1;
        
        // 3.以互斥的方式向用户队列中插入用户ID信息
        pthread_mutex_lock(&mutex);
        insert_to_link_queue(queue, client_no);
        pthread_mutex_unlock(&mutex);
        
        // 4.模拟打印用户入队信息
        printf("client %d is in...queue length : %d\n", client_no, length_of_link_queue(queue));
        
        // 5.可用用户数目+1
        sem_post(&client_sem);
        
        // 6.模拟用户的到达时间间隔
        sleep(1);
    }
}

// 消费者线程：用于模拟银行柜台的动作
void *consumer_thread(void *arg)
{
    int client_no = 0;
    
    while(1)
    {
        // 1.申请可用用户资源(即对可用用户数-1)
        sem_wait(&client_sem);
        
        // 2.以互斥的方式从全局用户队列中获取用户ID
        pthread_mutex_lock(&mutex);
        delete_from_link_queue(queue, &client_no);
        pthread_mutex_unlock(&mutex);
        
        // 3.模拟银行柜台的操作
        printf("client %d is out...\n", client_no);  
        
        // 3.队列空余资源数+1
        sem_post(&free_space_sem);
        
        // 4.模拟柜台操作的时间间隔
        sleep(rand()%5+1);
    }
}

// 变式练习：
// 1.参考上述代码，实现单生产者多消费者问题
// 2.参考上述代码，实现多生产者多消费者问题

• 链表的函数的声明

#ifndef __SQ_QUEUE_H__
#define __SQ_QUEUE_H__

// 定义链式队列中元素的实际类型的别名
// 注意：队列中可以存放任意类型的数据
typedef int datatype_t;

// 定义链式队列中结点的类型及其别名
typedef struct _queue_node
{   
    datatype_t data;
    struct _queue_node *next;    
}queue_node_t;

// 定义存放链式队列队首和队尾指针的结构类型及其别名
typedef struct _link_queue
{
    queue_node_t *front;
    queue_node_t *rear;
}link_queue_t;

// 创建一个空的链式队列
link_queue_t *create_empty_link_queue(void);

// 判断链式队列是否为空，为空返回1，否则，0
int is_empty_of_link_queue(link_queue_t *queue);

// 求链式队列中元素的个数即队列长度
int length_of_link_queue(link_queue_t *queue);

// 入队操作(即在队尾插入数据结点)
int insert_to_link_queue(link_queue_t *queue, 
            datatype_t x);

// 出队操作(即在对头删除数据结点)
int delete_from_link_queue(link_queue_t *queue, 
            datatype_t *px);

// 清空链式队列
void clear_link_queue(link_queue_t *queue);

// 销毁链式队列
void destroy_link_queue(link_queue_t *queue);

// 遍历打印链式队列中的数据
void print_data_info_of_link_queue(link_queue_t *queue);

#endif

• 对于链表头文件各种操作具体功能的实现

#include "link_queue.h"
#include 
#include 

// 创建链式队列
link_queue_t *create_empty_link_queue(void)
{
    // 为包含队首和队尾指针的结点动态申请空间
    link_queue_t *queue = (link_queue_t *)malloc(sizeof(link_queue_t));
    // 队首指针和队尾指针均指向头结点
    queue->front = queue->rear = (queue_node_t *)malloc(sizeof(queue_node_t));
    queue->front->next = NULL;
    
    return queue;
}

// 判断链式队列是否为空，为空返回1，否则0
int is_empty_of_link_queue(link_queue_t *queue)
{
    return queue->front == queue->rear;
    // return queue->front->next == NULL;
}

// 求链式队列的数据元素个数即队列长度
int length_of_link_queue(link_queue_t *queue)
{
    int len = 0;
    queue_node_t *p = queue->front;
    
    while(p->next != NULL)
    {
        len++;
        p = p->next;
    }
    
    return len;
}

// 入队操作，成功，返回0，失败-1
int insert_to_link_queue(link_queue_t *queue, 
            datatype_t x)
{
    // 队列不存在，插入失败返回
    if(queue == NULL)
        return -1;
    
    // 1.为插入的数据申请结点空间
    queue_node_t *p = (queue_node_t *)malloc(sizeof(queue_node_t));
    p->data = x;
    
    // 2.插入到队尾指针的后一个位置
    p->next = queue->rear->next;
    queue->rear->next = p;
    
    // 3.更新队尾指针
    queue->rear = queue->rear->next;
    
    return 0;
}

// 出队操作，成功，返回0；失败，-1
int delete_from_link_queue(link_queue_t *queue, 
            datatype_t *px)
{
    // 如果队列不存在或队列为空，出队失败
    if(queue == NULL || is_empty_of_link_queue(queue))
        return -1;
    
    // 1.定位出队的数据结点的位置
    queue_node_t *p = queue->front->next;
    // 2.将该结点从链式队列中移除
    queue->front->next = p->next;
    // 3.如果需要，将待出队元素的值传出
    if(px != NULL)
        *px = p->data;
    // 4.释放结点空间
    free(p);
    
    // 注意：如果出队之后，队列为空，重定位尾指针的位置
    if(queue->front->next == NULL)
        queue->rear = queue->front;
    
    return 0;
}

// 清空链式队列
void clear_link_queue(link_queue_t *queue)
{
    queue_node_t *p = NULL;

    // 循环的采用头删法删除链式队列的数据结点直到队列为空
    while(!is_empty_of_link_queue(queue))
    {
        p = queue->front->next;
        queue->front->next = p->next;
        free(p);
    }
}

// 销毁链式队列
void destroy_link_queue(link_queue_t *queue)
{
    // 清空链式队列
    clear_link_queue(queue);
    // 释放链式队列头结点空间
    free(queue->front);
    // 释放队首和队尾指针结点空间
    free(queue);
}

// 根据实际datatype_t类型打印数据
static void print_data(datatype_t x)
{
    printf("%d ", x);
}

// 遍历打印链式队列的数据结点
void print_data_info_of_link_queue(link_queue_t *queue)
{
    queue_node_t *p = queue->front;
    
    printf("linkqueue : ");
    while(p->next != NULL)
    {
        p = p->next;
        print_data(p->data);    
    }    
    printf("\n");
}