操作系统实验3－线程间的双向消息通信

        线程间的双向消息通信

       我们知道，信号量的值初始化为0时可作为同步控制，值为1时可作为互斥控制。在消息通信中，这里假设有两个线程A,B，那双向通信就需要两个信号量来同步消息。

        在实验中，我们定义两个同步信号量： semaphore sem1 = {0,NULL};   semaphore sem2 = {0,NULL}; 

                             其中，sem1用于A向B发送消息和B向A接收消息，sem2用于B向A发送消息和A向B接收消息。

      现在，我们来修改一下模拟两个线程执行内容的函数：

    线程1：

void f1()       /* 1#线程  */
{
    long i, j, k;
    char a[NTEXT];
    int len = 0;
    i = 0;
    while(++i)
    {
        if(i == 5) break;
        printf("f1 sending!\n");
        send("f2", "f1 send message to f2", 21);
        v(&sem1);   // 发送消息后，sem1的value+1使得线程2被主动唤醒执行

        p(&sem2);  // 要接收消息，先检查sem2的value-1是否>=0,小于0的话将阻塞该线程直到有消息发送过来被主动唤醒
        len = receive("f2", a);
        printf("f1 received %d: %s\n\n", len, a);
    }
}

线程2同理：

void f2()           /* 2#线程  */
{
    int i, j, k;
    int len = 0;
    char a[NTEXT];

    i = 0;
    while(++i)
    {
        if(i == 5) break;
        p(&sem1);  // 要接收消息，先检查sem1的value-1是否>=0,小于0的话将阻塞该线程直到有消息发送过来被主动唤醒
        len = receive("f1", a);
        printf("f2 received %d: %s\n\n", len, a);

        printf("f2 sending!\n");
        send("f1", "f2 send message to f1", 21);
        v(&sem2);  // 发送消息后，sem2的value+1使得线程1被主动唤醒执行
    }
}

和之前两次实验一样，这里我们也要更改线程的调度函数，我这里是基于优先级调度而非时间片切换调度，注意要初始化默认的优先级值。

代码如下：

int Find()
{
    int i = 0, index = 0, maxpri = 0;

    for(i = 1; i < NTCB; i++)
    {
        if(tcb[i].state != FINISHED && tcb[i].state != BLOCKED
                && maxpri < tcb[i].value)
        {
            maxpri = tcb[i].value;
            index = i;
        }
    }

    return index;
}

在代码中，还有一些小细节需要修改，比如receive()函数：

int receive(char *sender, char *a)
{
    struct buffer *buff;
    int i;
    int size = 0;
    disable();

    for(i = 0; i < NTCB; i++)
        if(strcmp(sender, tcb[i].name) == 0)
            break;

    if(i == NTCB)
    {
        printf("error:sender not exist!\n");
        enable();
        return size;
    }

    if(tcb[current].mq == NULL)
    {
        p(&tcb[current].sm);
        return size;
    }

    p(&tcb[current].mutex);   /* 当前线程的消息缓冲队列资源的互斥操作*/
    buff = tcb[current].mq;
    tcb[current].mq = tcb[current].mq->next;

    for(i = 0; i < buff->size; i++, a++) /* 输出所接受的内容  */
        (*a) = buff->text[i];
    *a = '\0';
    size = buff->size;
    v(&tcb[current].mutex);  /* 当前线程的消息缓冲队列资源的互斥操作 */
    p(&mutexfb);
    buff->sender = -1;
    buff->size = 0;
    strcpy(buff->text, "");
    buff->next = NULL;
    putbuf(buff);
    v(&mutexfb);

    v(&sfb);
    p(&tcb[current].sm);
    return size;
//	v(&test);     /* 对应于p(&Tcb[current].sm)  */
}

到此，我们看一下运行结果：

大家最关心的是最后代码了，好的，这就贴上：

#include <stdlib.h>
#include <dos.h>
#include <stdio.h>

#define GET_INDOS 0x34        /* 34H 系统功能调用    */
#define GET_CRIT_ERR 0x5d06    /* 5D06H号系统功能调用 */

#define BLANK -1
#define FINISHED 0       /*     终止    */
#define RUNNING 1        /*   执行  */
#define READY 2          /*   就绪  */
#define BLOCKED 3        /*   阻塞  */
#define NTCB 3       /* 系统线程的最大数 */

#define TL 10           /* 时间片大小  */
#define NBUF 2        /* 消息缓冲区数目 */
#define NTEXT 50             /* 文本输出大小  */


char far* intdos_ptr = 0;
char far* crit_err_ptr = 0;
int timecount = 0;
int current = -1;

typedef unsigned int UINT16;

typedef struct/* 信号量 */
{
    int value;
    struct TCB* wq;
} semaphore;

semaphore mutexfb = {1, NULL};
semaphore sfb = {2, NULL};

semaphore sem1 = {0, NULL};
semaphore sem2 = {0, NULL};


struct buffer/* 消息缓冲区  */
{
    int sender;       /*消息发送者的标识数 */
    int size;         /* 消息长度<=NTEXT 个字节   */
    char text[NTEXT];           /* 消息正文   */
    struct buffer* next;      /* 指向下一个消息缓冲区的指针 */
} *freebuf;


struct TCB            /* 线程控制块  */
{
    unsigned char* stack;          /* 堆栈的起始地址  */
    unsigned ss;
    unsigned sp;            /* 堆栈段址和堆栈指针 */
    char state;             /* 进程状态   */
    char name[10];          /* 线程的外部标识符  */
    int value;             /*优先级*/
    struct TCB* next;       /* 指向控制快指针  */
    struct buffer* mq;      /* 消息缓冲队列首指针  */
    semaphore mutex;        /* 互斥信号量   */
    semaphore sm;           /* 消息缓冲队列计数信号量*/
} tcb[NTCB];

struct int_regs           /* 堆栈现场保护和恢复结构体 */
{
    unsigned BP, DI, SI, DS, ES, DX, CX, BX, AX, IP, CS, Flags, off, seg;
};

typedef int(far* codeptr)(void);

void interrupt(*old_int8)(void);


int DosBusy(void);
void InitIndos(void);
void InitTcb();
void interrupt new_int8(void);
void interrupt swtch();
void send(char *receiver, char *a, int size);
int receive(char *sender, char *a);
void p(semaphore *sem);
void v(semaphore *sem);

int Create(char* name, codeptr code, int stacklen, int prio); /* 创建线程 */
void Destroy(int i);

void f1()       /* 1#线程  */
{
    long i, j, k;
    char a[NTEXT];
    int len = 0;
    i = 0;
    while(++i)
    {
        if(i == 5) break;
        printf("f1 sending!\n");
        send("f2", "f1 send message to f2", 21);
        v(&sem1);

        p(&sem2);
        len = receive("f2", a);
        printf("f1 received %d: %s\n\n", len, a);
    }
}

void f2()           /* 2#线程  */
{
    int i, j, k;
    int len = 0;
    char a[NTEXT];

    i = 0;
    while(++i)
    {
        if(i == 5) break;
        p(&sem1);
        len = receive("f1", a);
        printf("f2 received %d: %s\n\n", len, a);

        printf("f2 sending!\n");
        send("f1", "f2 send message to f1", 21);
        v(&sem2);
    }
}


void InitInDos()      /* 取得INDOS标志和严重错误标志地址 */
{
    union REGS regs;
    struct SREGS segregs;

    regs.h.ah = GET_INDOS;    /* 使用34H号系统功能调用 */
    intdosx(&regs, &regs, &segregs);

    intdos_ptr = MK_FP(segregs.es, regs.x.bx);
    if(_osmajor < 3)
        crit_err_ptr = intdos_ptr + 1;  /* 严重错误在INDOS后一字节处 */
    else if(_osmajor == 3 && _osminor == 0)
        crit_err_ptr = intdos_ptr - 1;  /* 严重错误在INDOS前一字节处 */
    else
    {
        regs.x.ax = GET_CRIT_ERR;
        intdosx(&regs, &regs, &segregs);
        crit_err_ptr = MK_FP(segregs.ds, regs.x.si);
    }
}

int DosBusy(void)            /* 判断DOS是否忙 */
{
    if(intdos_ptr && crit_err_ptr)
        return(*intdos_ptr || *crit_err_ptr); /* DOS忙,返回严重错误标志 */
    else
        return(-1);         /* DOS不忙 */
}

void InitTcb()           /* 初始化线程 */
{
    int i;

    for(i = 0; i < NTCB; i++)
    {
        tcb[i].state = BLANK;     /* 初始状态标志   */
        tcb[i].mq = NULL;
        tcb[i].mutex.value = 1;
        tcb[i].mutex.wq = NULL;
        tcb[i].sm.value = 0;
        tcb[i].sm.wq = NULL;
    }
}

void Destroy(int i)
{
    if(tcb[i].state == RUNNING)
    {
        disable();
        tcb[i].state = FINISHED;
        //strcpy(tcb[i].name,NULL);
        free(tcb[i].stack);
        tcb[i].ss = 0;
        tcb[i].sp = 0;
        enable();
    }

// return;
}

void over()
{
    Destroy(current);
    swtch();
}


int Create(char *name, codeptr code, int stacklen, int value)
{
    int i;
    char *p;
    struct int_regs *pt;
    unsigned int *pp;

    for(i = 1; i < NTCB; i++)
    {
        if(tcb[i].state == BLANK || tcb[i].state == FINISHED)
            break;
    }
    if(i == NTCB)
        return -1;

    tcb[i].value = value;
    strcpy(tcb[i].name, name);
    tcb[i].stack = (p = (unsigned char*)malloc(stacklen));
    memset(tcb[i].stack, 0xff, stacklen);
    p = p + stacklen;

    *(p - 1) = (FP_SEG(over) & 0xff00) >> 8;
    *(p - 2) = FP_SEG(over) & 0x00ff;

    *(p - 3) = (FP_OFF(over) & 0xff00) >> 8;
    *(p - 4) = FP_OFF(over) & 0x00ff;

    *(p - 5) = 0x02;
    *(p - 6) = 0x00;

    *(p - 7) = (FP_SEG(code) & 0xff00) >> 8;
    *(p - 8) = FP_SEG(code) & 0x00ff;

    *(p - 9) = (FP_OFF(code) & 0xff00) >> 8;
    *(p - 10) = FP_OFF(code) & 0x00ff;

    *(p - 19) = (_ES & 0xff00) >> 8;
    *(p - 20) = _ES & 0x00ff;

    *(p - 21) = (_DS & 0xff00) >> 8;
    *(p - 22) = _DS & 0x00ff;

    tcb[i].sp = FP_OFF((UINT16 *)(p - 28));
    tcb[i].ss = FP_SEG((UINT16 *)(p - 28));


    tcb[i].state = READY;

    return i;
}


void tcb_state()        /* 线程状态信息 */
{
    int i;

    for(i = 0; i < NTCB; i++)
        if(tcb[i].state != BLANK)
        {
            switch(tcb[i].state)
            {
            case FINISHED:
                printf("\ntcb[%d] is FINISHED\n", i);
                break;

            case RUNNING:
                printf("tcb[%d] is RUNNING\n", i);
                break;
            case READY:
                printf("tcb[%d] is READY\n", i);
                break;
            case BLOCKED:
                printf("tcb[%d] is BLOCKED\n", i);

                break;
            }
        }
}

int all_finished()
{
    int i;

    for(i = 1; i < NTCB; i++)
        if(tcb[i].state == RUNNING || tcb[i].state == BLOCKED || tcb[i].state == READY)
            return 0;

    return 1;
}

int Find()
{
    int i = 0, index = 0, maxpri = 0;

    for(i = 1; i < NTCB; i++)
    {
        if(tcb[i].state != FINISHED && tcb[i].state != BLOCKED
                && maxpri < tcb[i].value)
        {
            maxpri = tcb[i].value;
            index = i;
        }
    }

    return index;
}


void interrupt new_int8(void)       /* CPU 调度*/
{
    int i;

    (*old_int8)();      /* 指向原来时钟中断处理过程入口的中断处理函数指针 */
    timecount++;

    if(timecount == TL)      /* 时间片是否到? */
    {
        if(!DosBusy())     /* DOS是否忙? */
        {
            disable();

            tcb[current].ss = _SS;   /* 保存现场 */
            tcb[current].sp = _SP;

            if(tcb[current].state == RUNNING)
                tcb[current].state = READY;

            i = Find();
            if(i < 0)
                return;

            _SS = tcb[i].ss;
            _SP = tcb[i].sp;
            tcb[i].state = RUNNING;
            current = i;
            timecount = 0;    /* 重新计时 */

            enable();
        }
        else
            return;
    }
    else
        return;
}

void interrupt swtch()            /* 其他原因CPU调度  */
{
    int i;

    if(tcb[current].state != FINISHED
            && current != 0 && tcb[current].state != BLOCKED) /* 当前线程还没结束 */
        return;

    i = Find();
    if(i < 0)
        return;

    disable();
    tcb[current].ss = _SS;
    tcb[current].sp = _SP;

    if(tcb[current].state == RUNNING)
        tcb[current].state = READY;    /* 放入就绪队列中 */

    _SS = tcb[i].ss;
    _SP = tcb[i].sp;      /* 保存现场 */

    tcb[i].state = RUNNING;
    current = i;
    enable();
}

struct buffer*Initbuf(void)
{
    struct buffer *p, *pt, *pt2;
    int i;

    pt2 = pt = (struct buffer*)malloc(sizeof(struct buffer));
    pt->sender = -1;
    pt->size = 0;
    strcmp(pt->text, "");
    pt->next = NULL;

    for(i = 0; i < NBUF - 1; i++)
    {
        p = (struct buffer*)malloc(sizeof(struct buffer));
        p->sender = -1;
        p->size = 0;
        p->text[NTEXT] = '\0';
        p->next = NULL;
        pt2->next = p;
        pt2 = p;
    }

    return pt;
}

struct buffer* getbuf(void)  /* 从空闲消息缓冲队列队头上取下一缓冲区 */

{
    struct buffer *buf;

    buf = freebuf;      /* 取得缓冲队列的缓冲区*/
    freebuf = freebuf->next;

    return(buf);        /* 返回指向该缓冲区的指针 */
}

void putbuf(struct buffer *pt)
{
    struct buffer *p = freebuf;

    while(p->next)
        p = p->next;

    p->next = pt;
    pt->next = NULL;
}

void block(struct TCB **p)         /* 阻塞原语 */
{
    struct TCB *pp;

    tcb[current].state = BLOCKED;

    if((*p) == NULL)
        *p = &tcb[current];  /* 阻塞队列空,直接放入 */
    else
    {
        pp = *p;
        while(pp->next)
            pp = pp->next;       /* 找到阻塞队列最后一个节点 */

        pp->next = &tcb[current];    /* 放入阻塞队列 */
    }
    tcb[current].next = NULL;
    swtch();       /* 重新进行CPU调度 */
}

void wakeup_first(struct TCB **p)    /* 唤醒队首线程 */
{
    struct TCB *pl;

    if((*p) == NULL)
        return;

    pl = (*p);
    (*p) = (*p)->next;   /* 得到阻塞队列队首线程 */
    pl->state = READY;      /* 修为就绪状态 */
    pl->next = NULL;
    swtch();
}

void p(semaphore *sem)
{
    struct TCB **qp;

    disable();
    sem->value = sem->value - 1;

    if(sem->value < 0)
    {
        qp = &(sem->wq);
        block(qp);
    }
    enable();
}

void v(semaphore*sem)
{
    struct TCB **qp;

    disable();
    qp = &(sem->wq);
    sem->value = sem->value + 1;

    if(sem->value >= 0)
        wakeup_first(qp);

    enable();
}

void insert(struct buffer **mq, struct buffer *buff)
{
    /* 将buff所指的缓冲区插到*mq所指的缓冲队列末尾*/
    struct buffer *temp;

    if(buff == NULL)
        return;       /* buff为空 */

    buff->next = NULL;
    if(*mq == NULL)   /* *mq为空 则直接插入*/
        *mq = buff;
    else
    {
        temp = *mq;
        while(temp->next)      /* 找到队尾 */
            temp = temp->next;

        temp->next = buff;
    }
}

void send(char *receiver, char *a, int size)
{
    /* 将地址a开始的size个字节发送给外部标识符为receiver的线程 */
    struct buffer *buff;
    int i, id = -1;

    disable();
    for(i = 0; i < NTCB; i++) /* 找receiver相对应的线程号*/
    {
        if(strcmp(receiver, tcb[i].name) == 0)
        {
            id = i;
            break;
        }
    }

    if(id == -1)  /* 没找到 */
    {
        printf("Error:Receiver not exist!\n");
        enable();
        return;
    }

    p(&sfb);     /* 空闲缓冲队列数量的互斥操作   */
    p(&mutexfb);     /* 空闲缓冲队列资源的互斥操作   */
    buff = getbuf();  /* 获得一缓冲区 */
    v(&mutexfb);

    buff->sender = current;
    buff->size = size;
    buff->next = NULL;

    for(i = 0; i < buff->size; i++, a++) /* 写入缓冲队列   */
        buff->text[i] = *a;

    p(&tcb[id].mutex);     /* 相应线程的消息缓冲队列互斥操作   */
    insert(&(tcb[id].mq), buff); /* buff所指的缓冲区插到相应线程的消息缓冲队列末尾 */
    v(&tcb[id].mutex);
    v(&tcb[id].sm);  /* 对应于p(&sfb),线程的消息缓冲队列数量的互斥操作   */
    enable();
}

int receive(char *sender, char *a)
{
    struct buffer *buff;
    int i;
    int size = 0;
    disable();

    for(i = 0; i < NTCB; i++)
        if(strcmp(sender, tcb[i].name) == 0)
            break;

    if(i == NTCB)
    {
        printf("error:sender not exist!\n");
        enable();
        return size;
    }

    if(tcb[current].mq == NULL)
    {
        p(&tcb[current].sm);
        return size;
    }

    p(&tcb[current].mutex);   /* 当前线程的消息缓冲队列资源的互斥操作*/
    buff = tcb[current].mq;
    tcb[current].mq = tcb[current].mq->next;

    for(i = 0; i < buff->size; i++, a++) /* 输出所接受的内容  */
        (*a) = buff->text[i];
    *a = '\0';
    size = buff->size;
    v(&tcb[current].mutex);  /* 当前线程的消息缓冲队列资源的互斥操作 */
    p(&mutexfb);
    buff->sender = -1;
    buff->size = 0;
    strcpy(buff->text, "");
    buff->next = NULL;
    putbuf(buff);
    v(&mutexfb);

    v(&sfb);
    p(&tcb[current].sm);
    return size;
//	v(&test);     /* 对应于p(&Tcb[current].sm)  */
}

void main()
{
    long i, j, k;

    InitInDos();
    InitTcb();

    freebuf = Initbuf();
    old_int8 = getvect(8);

    strcpy(tcb[0].name, "main");
    tcb[0].state = RUNNING;
    tcb[0].value = 0;
    current = 0;

    Create("f1", (codeptr)f1, 1024, 5);
    Create("f2", (codeptr)f2, 1024, 6);

    tcb_state();
    setvect(8, new_int8);
// swtch();

    while(!all_finished());

    tcb[0].name[0] = '\0';
    tcb[0].state = FINISHED;
    setvect(8, old_int8);

    tcb_state();

    printf("\n Muli_task system teminated \n");
}