Multithreaded application (thread pool, singleton mode)

Thread pool

A bunch of threads handle tasks , It is mainly aimed at scenarios that need to be handled by a large number of tasks , Using multiple execution streams can improve processing efficiency

If a task arrives, create a thread to handle it, which has great disadvantages :

• cost : Total time = Thread creation time + Task processing time + Thread destruction time , If the task processing time is short , Then a lot of time is consumed by thread creation and destruction
• risk : If a large number of threads come in , The system may collapse under peak pressure

thought : Thread pool is actually a pile of created threads and a task queue , When a task comes, it is thrown into the thread pool , Allocate a thread to process

There is a maximum number of threads and task nodes in the thread pool , Avoid resource consumption .

Realization :

typedef void (*handler_t)(int data);

class ThreadTask{
    private:
        int _data;// Data to process 
        handler_t _handler;// Functions that process data 
    public:
        ThreadTask() {}
        ThreadTask(int data, handler_t handler):_data(data),
            _handler(handler){}
        void Run(){
            _handler(_data);
        }
};

class BlockQueue
{
    private:
        std::queue<ThreadTask> _queue;
        int _capacity;
        pthread_mutex_t _mutex;
        pthread_cond_t _cond_pro;
        pthread_cond_t _cond_con;
    public:
        BlockQueue(int maxq = MAXQ):_capacity(maxq){
            pthread_mutex_init(&_mutex, NULL);
            pthread_cond_init(&_cond_pro, NULL);
            pthread_cond_init(&_cond_con, NULL);
        }
        ~BlockQueue() {
            pthread_mutex_destroy(&_mutex);
            pthread_cond_destroy(&_cond_pro);
            pthread_cond_destroy(&_cond_con);
        }
        bool Push(const ThreadTask &data){
            pthread_mutex_lock(&_mutex);
            while(_queue.size() == _capacity) {
                pthread_cond_wait(&_cond_pro, &_mutex);
            }
            _queue.push(data);
            pthread_mutex_unlock(&_mutex);
            pthread_cond_signal(&_cond_con);
            return true;
        }
        bool Pop(ThreadTask *data) {
            pthread_mutex_lock(&_mutex);
            while(_queue.empty() == true) {
                pthread_cond_wait(&_cond_con, &_mutex);
            }
            *data = _queue.front();
            _queue.pop();
            pthread_mutex_unlock(&_mutex);
            pthread_cond_signal(&_cond_pro);
            return true;
        }
};


class Threadpool{
    private:
        int _max_thread;// Maximum number of threads 
        int _max_queue;// The maximum number of nodes in the task queue 
        BlockQueue _queue;
    public:
        Threadpool(int max_thr=MAX_THREAD, int max_q=MAXQ):
            _max_thread(max_thr),
            _max_queue(max_q), _queue(max_q){
            pthread_t tid;
            int ret;
            for (int i = 0; i < max_thr; i++) {
                ret = pthread_create(&tid, NULL, thr_entry, this);
                if (ret != 0) {
                    printf("thread create error\n");
                    exit(-1);
                }
                pthread_detach(tid);
            }
        }
        static void *thr_entry(void *arg){
            Threadpool *pool = (Threadpool*)arg;
            while(1) {
                ThreadTask task;
                pool->_queue.Pop(&task);
                task.Run();
            }
        }
        bool TaskPush(const ThreadTask &task) {
            _queue.Push(task);
        }
};

The singleton pattern

Aimed at the scene : A class can only instantiate one object , Provide an access interface , In other words, a resource can only have one copy in memory

Purpose : To save memory ; Prevent data ambiguity ;

Concrete realization

Hungry and lazy mode

All hungry resources are loaded in advance and initialized , Use it directly when you use it ( Space for time )

• Constructor privatization , Cannot instantiate object outside class
• Instantiate globally unique objects within classes , Resources are shared separately , Pre run initialization , The initialization process does not consider thread safety issues

lazy : Load when resources are used ( It's used a lot )

• Constructor private
• Lock the access interface to protect the resource initialization loading process
• Second test , Prevent lock conflicts , Increase of efficiency
• Prevent the compiler from over Optimizing , Use volatile Modify pointer member variables

// Starving model 
class Singleton
{
   public:
        static Singleton* GetInstance()
        {
            return &_instance;
        }
    private:
        Singleton(){};
        Singleton(Singleton const&);
        static Singleton _instance;// Global unique object 
};

// The sluggard model 
class Singleton
{
public:
     volatile static Singleton* GetInstance()
    {
        if (_instance == nullptr)
        {
            m_mutex.lock();
            if (_instance == nullptr)
            {
                _instance = new Singleton();
            }
            m_mutex.unlock();
        }
        return _instance;
    }
private:
    Singleton() {};// Constructor private 
    volatile static Singleton* _instance;// Singleton object pointer 
    static mutex m_mutex;// The mutex 
};