操作系统实验三——生产者，消费者

矫情吗；* 2022-05-23 04:45 179阅读 0赞

**实验任务**  
生产者/消费者模型为依据，在Windows环境下创建一个控制台进程，在该进程中创建n个线程模拟生产者和消费者，实现进程(线程)的同步与互斥。

--------------------

**基础知识：**  
[CreateMutex的用法（详见官方文档）][CreateMutex]

HANDLE CreateMutex(
    
    LPSECURITY_ATTRIBUTES lpMutexAttributes, // 指向安全属性的指针
    
    BOOL bInitialOwner, // 初始化互斥对象的所有者
    
    LPCTSTR lpName // 指向互斥对象名的指针
    
    );

1.  CreateMutex只是创建了一把锁, 这把锁你用来锁门还是锁抽屉都由你自己决定。
2.  lpName是指定这把锁的名字. 你要不给这把锁取个名字都可以. 只是有了相同的名字, 在跨进程加锁的时候, 就可以得到同一把锁。

//加锁  
WaitForSingleObject(hMutex, INFINITE);

//解锁  
ReleaseMutex(hMutex);

--------------------

[CreateSemaphore和ReleaseSemaphore函数][CreateSemaphore_ReleaseSemaphore]

HANDLE WINAPI CreateSemaphore( 
      _In_opt_  LPSECURITY_ATTRIBUTES lpSemaphoreAttributes 
      _In_      LONG lInitialCount, 
      _In_      LONG lMaximumCount, 
      _In_opt_  LPCTSTR lpName 
    );

第一个参数：安全属性，如果为NULL则是默认安全属性  
第二个参数：信号量的初始值，要>=0且<=第三个参数  
第三个参数：信号量的最大值  
第四个参数：信号量的名称  
返回值：指向信号量的句柄，如果创建的信号量和已有的信号量重名，那么返回已经存在的信号量句柄

ReleaseSemaphore(
        __in      HANDLE hSemaphore,
        __in      LONG lReleaseCount,
        __out_opt LPLONG lpPreviousCount
        );

hSemaphore是要释放的信号量名字。  
lReleaseCount是增加的计数。  
lpPreviousCount是增加前的数值返回。

使用方法：  
1、创建一个信号量：CreateSemaphore；  
2、打开一个已经存在的信号量：OpenSemaphore；  
3、获得信号量的一个占有权：WaitForSingleObject、WaitForMultipleObjects 等一类等待的函数……（可能造成阻塞）；  
4、释放信号量的占有权：ReleaseSemaphore；  
5、关闭信号量：CloseHandle；

信号量的使用规则：  
1. 如果当前资源计数大于0，那么信号量处于触发状态；  
2. 如果当前资源计数等于0，那么信号量处于未触发状态；那么系统会让调用线程进入等待状态。  
CreateSemaphore(NULL,0,1,NULL); 当第二个参数为0时，调用线程就会进入等待状态  
3. 系统绝对不会让当前资源计数变为负数；  
4. 当前资源计数绝对不会大于最大资源计数。  
5.

--------------------

[创建线程CreateThread函数][CreateThread]  
默认的线程函数必须具有如下原型DWORD WINAPI ThreadProc(LPVOID LpParameter);  
调用API:CreateThread可以创建一个新进程

HANDLE WINAPI CreateThread(  
         LPSECURITY_ATTRIBUTES lpThreadAttributes,  
         SIZE_T dwStackSize,  
         LPTHREAD_START_ROUTINE lpStartAddress,  
         LPVOID lpParameter,  
         DWORD dwCreationFlags,  
         LPDWORD lpThreadId  
        );

lpThreadAttributes：其中安全属性参数指定的是创建新进程内核对象的安全属性，不是线程访问字符串(Token)的属性  
dwStackSize用于指定线程初始时的栈大小，通常传入0即可，此时系统会使用一个合适的大小  
lpStartAddress就是新进程入口函数的地址  
lpParameter就是传入线程入口的参数，这个参数完全由调用者使用，系统只是简单的将这个参数  
传递给线程函数，并不做别的任何处理  
dwCreationFlags指出创建线程的方式，如果是0，表示线程一被创建就被立即执行，如果是CREATE\_SUSPENDED,表示线程一被创建先暂停，并不执行，在XP以上的系统中此参数还可以结合一个STACK\_SIZE\_PARAM\_IS\_A\_RESERVATION  
用于指出设置dwStackSize起始只是为线程栈保留的虚拟地址空间的大小，并不需要实际提交那么多物理页面  
如果没有指定这个标志位，那么dwStackSize也是实际提交内存的大小值  
lpThreadId则用于得到线程唯一的标识符

--------------------

**Windows环境下代码**

#include<iostream>
    #include<cstdlib>
    #include<ctime>
    #include<windows.h>
    using namespace std;
    
    const int BUFFER_SIZE=10;
    int buffer[BUFFER_SIZE];
    int front,rear;
    bool full;
    HANDLE Mutex;
    HANDLE Full;
    HANDLE Empty;
    
    void showBuffer(){
        cout<<"buffer: ";
        if(front!=rear||full){
            int i=front;
            do{
                cout<<buffer[i]<<" ";
                i=(i+1)%BUFFER_SIZE;
            }while(i!=rear);
        }else
            cout<<"empty";
        cout<<"\n*******************************"<<endl;
    }
    
    int insert_item(int item){
        int condition = -1;
        WaitForSingleObject(Empty,INFINITE);
        WaitForSingleObject(Mutex,INFINITE);
    
        if(!full){
            buffer[rear]= item;
            rear=(rear+1)%BUFFER_SIZE;
            if(rear==front)full=true;
            condition=0;
            cout<<"producer produced "<<item<<endl;
            showBuffer();
        }
    
        ReleaseMutex(Mutex);
        ReleaseSemaphore(Full,1,NULL);
        return condition;
    }
    
    int remove_item(int item){
        int condition = -1;
        WaitForSingleObject(Full,INFINITE); //获得信号量的一个占有权 
        WaitForSingleObject(Mutex,INFINITE);//加锁 
        if(front!=rear||full){
            item=buffer[front];
            front=(front+1)%BUFFER_SIZE;
            full=false;
            condition=0;
    
            cout<<"consumer comsumed "<<item<<endl;
            showBuffer();
        }
        ReleaseMutex(Mutex); //解锁 
        ReleaseSemaphore(Empty,1,NULL); // 释放信号量的一个占有权 
        return condition;
    }
    
    DWORD WINAPI producer(void *param){
        srand((unsigned)time(0));
    
        for(int i=0;;++i){
            Sleep((rand()%50)+2000);
            insert_item(rand()%BUFFER_SIZE);
        }
    };
    DWORD WINAPI consumer(void *param){
        srand((unsigned)time(0));
        for(int j=0;;j++){
            Sleep((rand()%100)+2500);
            remove_item(rand()%BUFFER_SIZE);
        }
    };
    
    int main(int argc, char *argv[]){
        front=0;
        rear=0;
        full=false;
    
        Mutex=CreateMutex(NULL,FALSE,NULL);
        Full=CreateSemaphore(NULL,0,5,NULL); //创建一个信号量 
        Empty=CreateSemaphore(NULL,5,5,NULL);
        CreateThread(NULL,0,producer,NULL,0,NULL);
        CreateThread(NULL,0,consumer,NULL,0,NULL);
    
        Sleep(400000);
        return 0;
    }

[CreateMutex]: https://msdn.microsoft.com/en-us/library/windows/desktop/ms682411%28v=vs.85%29.aspx
[CreateSemaphore_ReleaseSemaphore]: https://msdn.microsoft.com/en-us/library/windows/desktop/ms682438%28v=vs.85%29.aspx
[CreateThread]: https://msdn.microsoft.com/en-us/library/windows/desktop/ms682453%28v=vs.85%29.aspx