无锁生产者与消费者模型实例-线程

无锁的话就是要两个线程不能同时访问一个变量。那么这样就干脆用两个任务链表，如果在读队列里面的任务处理完成，同时写队列里面又有任务了，就交换两个队列，交换任务队列的动作由主线程来实现。基于这种思想代码如下：

#include "public.h"
#include <list>
using namespace std;

list<int>* queueMain;
list<int>* queueThread;
int fdThread;
int fdMain;
int threadRunning = 1;

void* thread_func(void*ptr)
{
    while(1)
    {
        char nouse_buf;
        // 告诉主线程，我即将休眠
        write(fdThread, &nouse_buf, 1);
        // 阻塞调用
        read(fdThread, &nouse_buf, 1);

        // 开始工作
        while(queueThread->size() > 0)
        {
            int task = queueThread->front();
            queueThread->pop_front();
            printf("task is %d\n", task);
        }
    }
}

int main()
{
    // 定义两个消息队列用于交换
    list<int> queue1;
    list<int> queue2;    

    queueMain = &queue1;
    queueThread = &queue2;

    // 使用socketpair用于两个线程的通信和同步
    int fd[2];
    socketpair(AF_UNIX, SOCK_STREAM, 0, fd);
    fdThread = fd[0];
    fdMain = fd[1];

    // 创建消费者线程
    pthread_t tid;
    pthread_create(&tid, NULL, thread_func, NULL);
    char nousebuf;


    // 使用多路转换器，同时检测标准输入和子线程通知文件描述符
    while(1)
    {
        fd_set set;
        FD_ZERO(&set);
        FD_SET(fdMain, &set);
        FD_SET(STDIN_FILENO, &set);

        int ret = select(fdMain+1, &set, NULL, NULL, NULL);
        if(ret > 0)
        {
            // 如果检测到标准输入有信息，读取标准输入
            if(FD_ISSET(STDIN_FILENO, &set))
            {
                char buf[1024];
                fgets(buf, sizeof(buf), stdin);
                int task = atoi(buf);
                queueMain->push_back(task);

                if(threadRunning == 0)
                {
                    write(fdMain, &nousebuf, 1);
                    threadRunning = 1;
                }
            }
            // 如果子线程有通知，将子线程设置为休眠状态
            if(FD_ISSET(fdMain, &set))
            {
                // 说明子线程休眠了
                // 首先把socket中的数据取出，如果不取出，那么下一次的select调用不会阻塞
                // 会通知主线程，fdMain有数据
                read(fdMain, &nousebuf, 1);

                if(queueMain->size() > 0)
                {
                    // 交换两个消息队列
                    list<int>* tmp = queueThread;
                    queueThread = queueMain;
                    queueMain = tmp;

                    // 唤醒子线程
                    write(fdMain, &nousebuf, 1);
                }
                else
                {
                    // 子线程休眠了
                    threadRunning = 0;
                }
            }
        }
    }

}