qt 中使用pthread

qt有自己的线程实现方式，但有时候我们由于某些原因，会用到pthread来实现多线程。

我把自己看到过的pthread使用方法记下来。如果你有更好的方法，或觉得此方法有什么缺点，请在评论区指出。

这个类去掉了一些冗余代码，编译时可能出现小错误。

 

CRecvJson.cpp

#include "ReceiveJson.h"
#include<sys/time.h>
#include<unistd.h>

void sleep_ms(unsigned int secs)
{
    struct timeval tval;
    tval.tv_sec = secs / 1000;
    tval.tv_usec = (secs * 1000) % 1000000;
    select(0, NULL, NULL, NULL, &tval);
}

unsigned long TimeElapseUs(timeval& start, timeval& end)
{
    unsigned long un1 = 1000000*(end.tv_sec - start.tv_sec);
    unsigned long un2 = (end.tv_usec - start.tv_usec);
    unsigned long diff = un1 + un2;

    return diff;
}

CReceiveJson::CReceiveJson(void)
{
}


CReceiveJson::~CReceiveJson(void)
{
}

void CReceiveJson::PushJsonData(char* pRecv, int nRecvLen)
{
    char* pRecvData = new char[nRecvLen + 1];
    memset(pRecvData, 0, nRecvLen + 1);
    memcpy(pRecvData, pRecv, nRecvLen);

    m_lock.Lock();    
    m_dequeJson.push_front(pRecvData);
    m_lock.UnLock();
}

void CReceiveJson::InitRecvThd()
{
    m_bRecvRunning = true;
    int nRet = pthread_create(&m_recvThdId, NULL, RecieveThd, this);
    if(nRet == 0)
    {

    }
}

void CReceiveJson::UnInitParaseThd()
{
    m_bRecvRunning = false;
}

void *CReceiveJson::RecieveThd(void* lParam)
{
    CReceiveJson* pThis = (CReceiveJson*)lParam;
    pThis->DoRecieve();

    return NULL;
}

void CReceiveJson::DoRecieve()
{
    while(m_bRecvRunning)
    {
        if (m_dequeJson.size() > 0)
        {
            m_lock.Lock();
            char* pRecieve = m_dequeJson.back();

            PopJsonData();
            m_lock.UnLock();
        }

        sleep_ms(ThdSleepTime);
    }

    pthread_detach(m_recvThdId);
}

void CReceiveJson::PopJsonData()
{
    char* p = m_dequeJson.back();
    delete[] p;
    p = NULL;
    m_dequeJson.pop_back();
}

 

CRecvJson.h

#pragma once
#include "TLock.h"
#include <deque>
#include<map>
#include<pthread.h>
#include<string>

using namespace std;

class CReceiveJson
{
public:
    CReceiveJson(void);
    ~CReceiveJson(void);
public:
    void PushJsonData(char* pRecv, int nRecvLen);
    void UnInitParaseThd();
    static void* RecieveThd(void* lParam);
    void InitRecvThd();
private:
    TLock m_lock;
    deque<char*> m_dequeJson;
    bool m_bRecvRunning;
    pthread_t m_recvThdId;


    void DoRecieve();
    void PopJsonData();

    //bool IsHeartBeatTimeOut( struct lws* wsi, map<lws*, timeval>& mapHb );
};

 

TLock.h

/**
* @file
* @brief 对锁的封装
* @Author
* @date
*/
#ifndef __SIROTLOCK_H__
#define __SIROTLOCK_H__
#pragma once

#if 0
#include <windows.h>

#define  T_MUTEX                CRITICAL_SECTION //利用临界区实现的锁变量
#define  T_MUTEX_INIT(m)        InitializeCriticalSection(m)
#define  T_MUTEX_LOCK(m)        EnterCriticalSection(m)
#define  T_MUTEX_UNLOCK(m)        LeaveCriticalSection(m)
#define  T_MUTEX_DESTORY(m)        DeleteCriticalSection(m)

#else    
#include<pthread.h>
#define  T_MUTEX                pthread_mutex_t
#define  T_MUTEX_INIT(m)        pthread_mutex_init(m,NULL)
#define  T_MUTEX_LOCK(m)        pthread_mutex_lock(m)
#define  T_MUTEX_UNLOCK(m)        pthread_mutex_unlock(m)
#define  T_MUTEX_DESTORY(m)        pthread_mutex_destroy(m)

#endif


class  TLock
{
public:
    TLock(void)
    {
        T_MUTEX_INIT(&m_Lock);
    }

    ~TLock(void)
    {
        T_MUTEX_DESTORY(&m_Lock);
    }

public:
    void Lock() { T_MUTEX_LOCK(&m_Lock); }
    void UnLock() { T_MUTEX_UNLOCK(&m_Lock); }
private:
    T_MUTEX    m_Lock;
};

#endif