《Linux从练气到飞升》No.31 多线程编程实践与线程安全技术

main:main.cc
  g++ -o $@ $^ -lpthread
.PHONY:clean
clean:
  rm -f main

#pragma
#include<iostream>
#include<math.h>
#include<unistd.h>
#include<stdlib.h>
#include<pthread.h>
#include<queue>
#define NUM 5
class Task
{
private:
    int _b;
public:
    Task(){}
    Task(int b)
        :_b(b)
    {}
    ~Task(){}
    void run(){
        std::cout<<"I am "<<pthread_self()<<" Task run ... bace:"<<\
            _b<<" ^2 = "<<pow(_b,2)<<std::endl;
    }
};
class Thread_Pool
{
private:
    std::queue<Task*> q;
    int _max_num;//线程总数
    pthread_mutex_t lock;
    pthread_cond_t cond;//只能让消费者操作
    void LockQueue(){
        pthread_mutex_lock(&lock);
    }
    void UnLockQueue(){
        pthread_mutex_unlock(&lock);
    }
    bool IsEmpty(){
        return q.size()==0;
    }
    bool IsFull(){
        return q.size()==_max_num;
    }
    void ThreadWait()
    {
        pthread_cond_wait(&cond,&lock);
    }
    void ThreadWakeUp()
    {
        pthread_cond_signal(&cond);
    }
public:
    Thread_Pool(int max_num = NUM)
        :_max_num(max_num)
    {}
    void Get(Task& out)//取数据
    {
        Task*t=q.front();
        q.pop();
        out=*t;
    }
    void Put(Task& in){//放置数据
        LockQueue();
        q.push(&in);
        UnLockQueue();
        ThreadWakeUp();
    }
    static void* Routine(void* arg){
        while(1){
            Thread_Pool* tp = (Thread_Pool*)arg;
            while(tp->IsEmpty()){
                tp->LockQueue();//静态成员方法不能访问非静态成员方法，所以传(void*)this过去
                tp->ThreadWait();//为空挂起等待
            }
            Task t;
            tp->Get(t);
            tp->UnLockQueue();
            t.run();
        }
    }
    void ThreadPoolInit(){
        pthread_mutex_init(&lock,NULL);
        pthread_cond_init(&cond,NULL);
        int i=0;
        pthread_t t;
        for(i=0;i<_max_num;++i){
            pthread_create(&t,NULL,Routine,(void*)this);  
        }
    }
    ~Thread_Pool(){
        pthread_mutex_destroy(&lock);
        pthread_cond_destroy(&cond);
    }
};

#include"Thread_Pool.h"
using namespace std;
int main(){
    Thread_Pool *tp = new Thread_Pool();
    tp->ThreadPoolInit();
    while(1){
        int x=rand()%10 + 1;
        Task t(x);
        tp->Put(t);
        sleep(1);
    }
    return 0;
}

template <typename T>
class Singleton {
    static T data; //定义静态的类对象，程序加载类就加载对象
public:
    static T* GetInstance() {
      return &data;
    }
};

template <typename T>
class Singleton {
  static T* inst;  //定义静态的类对象，程序运行时才加载对象
public:
    static T* GetInstance() {
        if (inst == NULL) {  
          inst = new T(); 
        }
        return inst;
    }
};

// 懒汉模式, 线程安全
template <typename T>  
class Singleton {
  volatile static T* inst; // 需要设置 volatile 关键字, 否则可能被编译器优化.
  static std::mutex lock;
public:
  static T* GetInstance()  
  {
    if (inst == NULL) // 双重判定空指针, 降低锁冲突的概率, 提高性能. //判断两个线程不同时进去直接return
    { 
      lock.lock(); // 使用互斥锁, 保证多线程情况下也只调用一次 new. //两个线程同时进去加锁
      if (inst == NULL)   
      {
        inst = new T(); 
      } 
      lock.unlock();
    } 
    return inst;
  }
};