经典进程同步问题生产者——消费者问题

最新推荐文章于 2024-07-11 21:05:35 发布

xiaoleiacm

最新推荐文章于 2024-07-11 21:05:35 发布

阅读量2.1k

点赞数

分类专栏：操作系统文章标签：线程安全对象操作系统多线程内存泄露

本文链接：https://blog.youkuaiyun.com/xiaoleiacmer/article/details/13017605

版权

操作系统专栏收录该内容

4 篇文章

订阅专栏

本文探讨了经典进程同步问题——生产者消费者问题，重点关注如何使用Windows API来解决这个问题，并强调了使用CreateThread可能导致的内存泄露问题。建议使用-_beginThread和_endThread组合以避免C标准库冲突，并确保正确关闭线程。此外，还介绍了信号灯（Semaphore）的概念及其在限制资源访问数量中的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

“生产者消费者”问题是经典的进程同步问题，它是在同一块儿进程地址内不同线程对于资源的利用时避免死锁的问题。

总结了一下网上的windows api函数的用法：

///
用户模式 对事件进行初始化操作
HANDLE CreateEvent(
　　LPSECURITY_ATTRIBUTES lpEventAttributes, // 安全属性
　　BOOL bManualReset, // 复位方式
　　BOOL bInitialState, // 初始状态
　　LPCTSTR lpName // 对象名称
　　);
///
用户模式 信号灯
CreateSemaphore函数负责创建信号灯
HANDLE CreateSemaphore(
    LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,    //安全属性
    LONG lInitialCount,                             //初始化计数个数
    LONG lMaximumCount,                             //计数器最大个数
    LPCWSTR lpName                                  //命名
    );

ReleaseSemaphore函数增加信号灯的计数器
BOOL ReleaseSemaphore(           
    HANDLE hSemaphore,         //信号灯句柄
    LONG lReleaseCount,        //本次操作增加的计数
    LPLONG lpPreviousCount     //记录以前的计数
    );
HANDLE CreateThread(
    LPSECURITY_ATTRIBUTES lpThreadAttributes, //线程安全属性
    DWORD dwStackSize, // 堆栈大小
    LPTHREAD_START_ROUTINE lpStartAddress, // 线程函数
    LPVOID lpParameter, //线程参数
    DWORD dwCreationFlags, // 线程创建属性
    LPDWORD lpThreadId // 线程ID
);
///
用户模式 互斥体
初始化互斥体
HANDLE CreateMutex(
LPSECURITY_ATTRIBUTES lpMutexAttributes, //安全属性
BOOL bInitialOwner,                       //是否被占有
LPCTSTR lpName                            //命名
);
//可以看出，当CreateSemaphore 的lInitialCount与lMaximumCount 都置为1的时候，CreateSemaphor相当于CreateMutex；

同时CreateThread 在使用不当的情况下会造成内存泄露，原因是在C标准库中的全局变量会引起冲突，通常用_beginThread来创建线程，再用_endThread来结束线程{此时用c的标准库}，所以应该避免在c标准库中使用createthread，用CreateThread 创建线程、并用CloseHandle来关闭这个线程！！！！！！！！

信号灯一般用来限制可以同时存取一共同区域的数目，它的用法是:
先用CreateSemaphore初始化最大数和当前数

当前数为0时，信号灯为nonsingled状态，也就是说这时用WaitForSingleObject时会等待直到当前数大于0（或超时），如果不为0时，用WaitForSingleObject就马上返回并把当前数减一;

增加当前数，用ReleaseSemaphore.

例子:
http://msdn2.microsoft.com/en-us/library/ms686946.aspx

一个信号量只能置一次初值，以后只能对之进行p操作或v操作。

code:

//#define DWORD unsigned long
#include <windows.h>
#include <iostream>
using namespace std;
const unsigned short SIZE_OF_BUFFER = 10; //缓冲区长度
unsigned short ProductID = 0; //产品号
unsigned short ConsumeID = 0; //将被消耗的产品号
unsigned short in = 0; //产品进缓冲区时的缓冲区下标
unsigned short out = 0; //产品出缓冲区时的缓冲区下标
int g_buffer[SIZE_OF_BUFFER]; //缓冲区是个循环队列
bool g_continue = true; //控制程序结束
HANDLE g_hMutex; //用于线程间的互斥
HANDLE g_hFullSemaphore; //当缓冲区满时迫使生产者等待
HANDLE g_hEmptySemaphore; //当缓冲区空时迫使消费者等待
DWORD WINAPI Producer(LPVOID); //生产者线程
DWORD WINAPI Consumer(LPVOID); //消费者线程
int main()
{
//创建各个互斥信号
    g_hMutex = CreateMutex(NULL,FALSE,NULL);
    g_hFullSemaphore = CreateSemaphore(NULL,SIZE_OF_BUFFER-1,SIZE_OF_BUFFER-1,NULL);
    g_hEmptySemaphore = CreateSemaphore(NULL,0,SIZE_OF_BUFFER-1,NULL);
    //疑问：在这里如何声明信号量的，full 不是应该开始时置1么 empty开始的时候置0么 


//调整下面的数值，可以发现，当生产者个数多于消费者个数时，
//生产速度快，生产者经常等待消费者；反之，消费者经常等待
    const unsigned short PRODUCERS_COUNT = 4; //生产者的个数
    const unsigned short CONSUMERS_COUNT = 1; //消费者的个数
//总的线程数
    const unsigned short THREADS_COUNT = PRODUCERS_COUNT+CONSUMERS_COUNT;

    HANDLE hThreads[THREADS_COUNT]; //各线程的handle
    DWORD producerID[PRODUCERS_COUNT]; //生产者线程的标识符
    DWORD consumerID[CONSUMERS_COUNT]; //消费者线程的标识符
//创建生产者线程
    for (int i=0;i<PRODUCERS_COUNT;++i)
    {
        hThreads[i]=CreateThread(NULL,0,Producer,NULL,0,&producerID[i]);

        if (hThreads[i]==NULL)
            return -1;
    }
//创建消费者线程
    for (int i=0;i<CONSUMERS_COUNT;++i)
    {
        hThreads[PRODUCERS_COUNT+i]=CreateThread(NULL,0,Consumer,NULL,0,&consumerID[i]);

        if (hThreads[i]==NULL) return -1;
    }
    //cout<<111<<endl;
    while (g_continue)
    {
        if (getchar()) //按回车后终止程序运行
        {
            g_continue = false;
        }
    }
    return 0;
}
//生产一个产品。简单模拟了一下，仅输出新产品的ID号
void Produce()
{
    std::cerr << "Producing " << ++ProductID << " ... ";
    std::cerr << "Succeed" << std::endl;
}
//把新生产的产品放入缓冲区
void Append()
{
    std::cerr << "Appending a product ... ";
    g_buffer[in] = ProductID;
    in = (in+1)%SIZE_OF_BUFFER;
    std::cerr << "Succeed" << std::endl;
//输出缓冲区当前的状态
    for (int i=0;i<SIZE_OF_BUFFER;++i)
    {
        std::cout << i <<": " << g_buffer[i];
        if (i==in) std::cout << " <-- 生产";
        if (i==out) std::cout << " <-- 消费";
        std::cout << std::endl;
    }
}
//从缓冲区中取出一个产品
void Take()
{
    std::cerr << "Taking a product ... ";
    ConsumeID = g_buffer[out];
    out = (out+1)%SIZE_OF_BUFFER;
    std::cerr << "Succeed" << std::endl;
//输出缓冲区当前的状态
    for (int i=0;i<SIZE_OF_BUFFER;++i)
    {
        cout << i <<": " << g_buffer[i];
        if (i==in) cout << " <-- 生产";
        if (i==out) cout << " <-- 消费";
        cout<<endl;
    }
}
//消耗一个产品
void Consume()
{
    std::cerr << "Consuming " << ConsumeID << " ... ";
    std::cerr << "Succeed" << std::endl;
}
//生产者
DWORD WINAPI Producer(LPVOID lpPara)
{
    while (g_continue)
    {
        WaitForSingleObject(g_hFullSemaphore,INFINITE);
        WaitForSingleObject(g_hMutex,INFINITE);
        Produce();
        Append();
        Sleep(1500);
        ReleaseMutex(g_hMutex);
        ReleaseSemaphore(g_hEmptySemaphore,1,NULL);
    }
    return 0;
}
//消费者
DWORD WINAPI Consumer(LPVOID lpPara)
{
    while (g_continue)
    {
        WaitForSingleObject(g_hEmptySemaphore,INFINITE);
        WaitForSingleObject(g_hMutex,INFINITE);
        Take();
        Consume();
        Sleep(1500);
        ReleaseMutex(g_hMutex);
        ReleaseSemaphore(g_hFullSemaphore,1,NULL);
    }
    return 0;
}

cerr比cout更快！！！！！！！