C++多线程实现静态队列进队、key随机匹配队列值

队列

template <class T>
class MyQueue
{
private:
    int front;
    int rear;
    int maxSize;
    T *array;

public:
    MyQueue(void)
    {
        front = 0;
        rear = 0;
        maxSize = 500;
        array = new T[maxSize];
    }

    ~MyQueue(void)
    {
        delete[] array; /*析构函数释放用户自己分配内存空间并且释放了array指针指向的全部内存空间*/
    }

    int getFront(void)
    {
        return this->front;
    }

    int getRear(void)
    {
        return this->rear;
    }

    T *getArray(void)
    {
        return this->array;
    }

    int getSize(void)
    {
        return this->maxSize;
    }

    //初始化队列满以后，队列进行覆盖式插入元素
    void push(T obj)
    {
        try
        {
            if (isFull())
            {
                front = (front + 1) % maxSize;
            }
            array[rear] = obj;
            rear = (rear + 1) % maxSize;

            EnterCriticalSection(&cs);
            printf("当前:rear=%d,front=%d,obj=%d的小黄人入队\n", rear, front, obj);
            LeaveCriticalSection(&cs);
            //Sleep(10);

        }
        catch (const std::exception &e)
        {
            std::cerr << e.what() << '\n';
        }
    }

    //从对头取元素
    T pop()
    {
        if (!isEmpty())
        {
            try
            {
                T t = array[front];
                front = (front + 1) % maxSize;
                return t;
            }
            catch (const std::exception &e)
            {
                std::cerr << e.what() << '\n';
            }
        }
        return 0;
    }

    //循环队列是否为满
    bool isFull()
    {
        if ((rear + 1) % maxSize == front) //循环队列,队满条件:front==(rear+1)%maxSize
            return true;
        else
            return false;
    }

    //循环队列是否为空
    bool isEmpty()
    {
        if (front == rear)
            return true;
        else
            return false;
    }

    //获取队列当前大小
    int size()
    {
        if (rear > front)
            return rear - front;
        else
            return rear + maxSize + 1 - front;
    }
};

匹配类

template <class T>
class MatchP
{
private:
public:
    MatchP() {}
    ~MatchP(void)
    {
        EnterCriticalSection(&cs);         
        printf("销毁 mp\n");
        LeaveCriticalSection(&cs);

    };

    T doMatch(int key, MyQueue<T> *queue)
    {
        try
        {
            int curFront = queue->getFront();
            int curRear = queue->getRear();
            if (queue->isFull())
            {
                for (int i = 0; i <= curRear; i++)
                {
                    if (queue->getArray()[i] == key)
                    {
                        EnterCriticalSection(&cs);
                        printf("找到 key=%d\n", key);
                        LeaveCriticalSection(&cs);
                        return queue->getArray()[i];
                    }
                }
                for (int i = curFront; i < queue->getSize(); i++)
                {
                    if (queue->getArray()[i] == key)
                    {
                        EnterCriticalSection(&cs);
                        printf("找到 key=%d\n", key);
                        LeaveCriticalSection(&cs);
                        return queue->getArray()[i];
                    }
                }
                EnterCriticalSection(&cs);
                printf("未找到 key=%d\n", key);
                LeaveCriticalSection(&cs);
            }
            else
            {
                for (int i = curFront; i < curRear; i++)
                {
                    if (queue->getArray()[i] == key)
                    {
                        EnterCriticalSection(&cs);
                        printf("找到 key=%d\n", key);
                        LeaveCriticalSection(&cs);
                        return queue->getArray()[i];
                    }
                }
                EnterCriticalSection(&cs);
                printf("未找到 key=%d\n", key);
                LeaveCriticalSection(&cs);
            }
        }
        catch (const std::exception &e)
        {
            std::cerr << e.what() << '\n';
        }
        return 0;
    }
};

入队线程

void *queueLine(void *args)
{
    MyQueue<int> *queue = ((MyQueue<int> *)args);
    int i = 1;
    while (i < 2000)
    {
        queue->push(i);
        i++;
    }
}

匹配线程

void *matchQueue(void *args)
{
    MyQueue<int> *queue = ((MyQueue<int> *)args);
    EnterCriticalSection(&cs);
    printf("接受queue：头：%d,尾：%d\n\n",queue->getFront(),queue->getRear());
    printf("线程2开始\n\n");
    LeaveCriticalSection(&cs);
    int count1 = 0,count2 = 0;
    int j = 1;
    while (j < 2000)
    {
        if (j % 25 == 0)
        {
            MatchP<int> *mp = new MatchP<int>();
            int t = mp->doMatch(j, queue);
            if (t)
            {
                EnterCriticalSection(&cs);
                printf("找到 key=%d\n", j);
                LeaveCriticalSection(&cs);
                count2++;//匹配成功计数
            }
            else
            {
                EnterCriticalSection(&cs);
                printf("未找到 key=%d\n", j);
                LeaveCriticalSection(&cs);
            }

            delete mp;
            count1++;
        }
        j++;
    }
    //delete queue;
    EnterCriticalSection(&cs);
    printf("总共匹配数据:%d\n", count1);
    printf("匹配成功数据:%d\n", count2);
    LeaveCriticalSection(&cs);
}

多线程测试

void test_thread(void)
{
    InitializeCriticalSection(&cs);//临界区初始化
    clock_t startTime, stopTime;
    startTime = clock();
    MyQueue<int> *queue = new MyQueue<int>();
    
    pthread_t tids[2]; //线程id
    int ret = pthread_create(&tids[0], NULL, queueLine, (void *)queue);
    if (ret != 0) //创建线程成功返回0
    {
        cout << "pthread_create error:error_code=" << ret << endl;
    }

    ret = pthread_create(&tids[1], NULL, matchQueue, (void *)queue); //传入到参数必须强转为void*类型，即无类型指针，&i表示取i的地址，即指向i的指针
    if (ret != 0)                                                    //创建线程成功返回0
    {
        cout << "pthread_create error:error_code=" << ret << endl;
    }
    pthread_join(tids[0],NULL);
    pthread_join(tids[1],NULL);

    stopTime = clock();
    printf("共计耗时:%f\n ",(double)(stopTime - startTime) / CLOCKS_PER_SEC);
    while(1);
    pthread_exit(NULL); //等待各个线程退出后，进程才结束，否则进程强制结束，线程处于未终止的状态
    
}