进程通信实例

版权声明：博主的博客不值钱随便转载但要注明出处 https://blog.csdn.net/easylovecsdn/article/details/82943082

有待修改，先放上代码供参考。

代码：

#include <bits/stdc++.h>

using namespace std;

const int maxn = 105;

typedef int semaphore;   //信号量类型

char *buf;

/*缓冲区数据结构*/
typedef struct message_buffer {
    char sender;
    int Size;
    char *text;
    struct message_buffer *next;
}message_buffer;

/*进程控制块数据结构*/
typedef struct processcontrol_block {
    message_buffer *mq;
    semaphore mutex;     //互斥信号量
    semaphore sm;        //资源信号量
}PCB;

/*管程*/
typedef struct process {
    char name;
    PCB pcb;

    void send(process &receiver, message_buffer **message);  //发送
    void receive(message_buffer *mb);                        //接收
    void print();                                            //打印出接收到的信息

    process() {}

    process(char nam) {
        name = nam;
        pcb.mq = NULL;
        pcb.mutex = 1;
        pcb.sm = 0;
    }

}process;

process *P[2];

/*将消息插入消息缓冲区*/
void Insert(message_buffer **mq, message_buffer *message)
{

    if (!(*mq)) {
        *mq = message;
        cout << "OK1" << endl;
        (*mq)->next = NULL;
    }
    else {
        message_buffer *p = (*mq);
        while (p->next) p = p->next;
        cout << "OK2" << endl;
        p->next = message;
    }
}

/*释放消息缓冲区*/
void release(message_buffer *mq)
{
    if (!mq) return ;

    message_buffer *temp = NULL;

    while (mq) {
        delete [] mq->text;
        temp = mq;
        mq = mq->next;
        delete temp;
    }
}

/*上锁*/
void wait(int &S)
{
    if (S <= 0) {
        cout << "waiting..." << endl;
        while (S <= 0) ;
    }

    S--;
}

/*解锁*/
void signal(int &S)
{
    S++;
}

/*进程消息发送（至缓冲区）*/
void process::send(process &receiver, message_buffer **message)
{
    *message = new message_buffer;          //开辟缓冲池

    (*message)->sender = this->name;


    (*message)->Size = maxn;


    (*message)->text = new char [(*message)->Size];



    strcpy((*message)->text, buf);

    (*message)->next = NULL;

    wait(this->pcb.mutex);

    Insert(&(receiver.pcb.mq), *message);


    signal(this->pcb.mutex);
    signal(this->pcb.sm);
}

/*进程消息接收（从缓冲区）*/
void process::receive(message_buffer *mb)
{

    int flag = mb->sender == 'A' ? 0 : 1;

    wait(P[flag]->pcb.sm);
    wait(P[flag]->pcb.mutex);

    //Insert(&(this->pcb.mq), mb);

    signal(P[flag]->pcb.mutex);

    //release(mb);  //释放消息缓冲区
}

void process::print()
{
    message_buffer *head = this->pcb.mq;
    while (head) {
        cout << head->text << endl; ;
        head = head->next;
    }
    cout << endl;
}

void Make_message(char *mg)
{
    strcpy(buf, mg);
}

void init()
{
    buf = new char [maxn];
}

int main()
{
    init();

    message_buffer *mb = NULL;    //产生一个消息缓冲区

    process p1('A');
    process p2('B');

    P[0] = &p1;
    P[1] = &p2;

    Make_message("我是A进程，现在向你发送一条信息\0");


    p1.send(p2, &mb);

    p2.receive(mb);
    p2.print();

    Make_message("我是B进程，现在向你发送一条信息\0");
    p2.send(p1, &mb);
    p1.receive(mb);
    p1.print();

	return 0;
}

运行结果初步：