【阅读笔记】Linux高性能服务器编程（2）

多线程编程

创建线程，pthread_t是标识符类型，其实就是整形

/* Create a new thread, starting with execution of START-ROUTINE
   getting passed ARG.  Creation attributed come from ATTR.  The new
   handle is stored in *NEWTHREAD.  */
int pthread_create (pthread_t *__newthread, const pthread_attr_t *__attr,
			   void *(*__start_routine) (void *), void *__arg);
		

设置属性：
函数名字均以pthread_attr_开头

#  define __SIZEOF_PTHREAD_ATTR_T 56	   
union pthread_attr_t
{
  char __size[__SIZEOF_PTHREAD_ATTR_T];
  long int __align;
};

int pthread_attr_init(pthread_attr_t *attr);
int pthread_attr_destroy(pthread_attr_t *attr);
int pthread_attr_getdetachstate (const pthread_attr_t *__attr,
					int *__detachstate);
int pthread_attr_setdetachstate (pthread_attr_t *__attr,
					int __detachstate);

detachstate两种：PTHREAD_CREATE_JOINABLE，PTHREAD_CREATE_DETACHED
分别对应可join可分离两种状态

信号量、互斥锁、条件变量

#include <exception>
#include <semaphore.h>
//POSIX信号量
class Sem{
public:
    Sem(){
        if(sem_init(&sem, 0,0) != 0){
            throw std::exception();
        }
    }
    ~Sem(){
        sem_destroy(&sem);
    }
    //P操作
    bool wait(){
        return sem_wait(&sem) == 0;
    }
    //V操作
    bool post(){
        return sem_post(&sem) == 0;
    }
private:
    sem_t sem;
};

//互斥锁
#include <pthread.h>
class LockGuard{
public:
    LockGuard(Lock *lk): lock(lk){
        lock->lock();
    }
    ~LockGuard(){
        lock->unlock();
    }
    
private:
    Lock *lock;
};

class Lock{
public:
    Lock(){
        pthread_mutex_init(&mutex, NULL);//普通锁
    }
    ~Lock(){
        pthread_mutex_destroy(&mutex);
    }
    bool lock(){
        return pthread_mutex_lock(&mutex) == 0;
    }
    bool unlock(){
        return pthread_mutex_unlock(&mutex) == 0;
    }

private:
    pthread_mutex_t mutex;
};

//条件变量-linux c
class Cond{
public:
    Cond(){
        pthread_mutex_init(&mutex, NULL);
        pthread_cond_init(&cond, NULL);
    }
    ~Cond(){
        pthread_mutex_destroy(&mutex);
        pthread_cond_destroy(&cond);
    }

    //wait
    bool wait(){
        pthread_mutex_lock(&mutex);
        int ret = pthread_cond_wait(&cond, &mutex);
        pthread_mutex_unlock(&mutex);
        return ret == 0;
    }
    //唤醒
    bool signal(){
        return pthread_cond_signal(&cond);
    }
private:
    pthread_cond_t cond;
    pthread_mutex_t mutex;
};

//条件变量-c++
//实现类信号量机制
#include <mutex>
#include <condition_variable>
class Semaphore{
public:
    Semaphore(int cnt = 0):count(cnt){}
    void wait(){
        std::unique_lock<std::mutex> unique(mt);
        --count;
        if(count < 0){
            cond.wait(unique);
        }
    }
    void signal(){
        std::unique_lock<std::mutex> unique(mt);
        ++count;
        if(count<=0){
            cond.notify_one();
        }
    }
private:
    std::mutex mt;
    std::condition_variable cond;
    int count;
};

线程池