【项目-轻量级Web Server lock类】

Lock类

信号量——sem类

信号量是一种特殊的变量，它只能取自然数并且只支持两种操作，P(wait)和V(signal)

• P 操作会使得信号量的值减 1，如果此时信号量的值小于 0，则调用进程或线程会被阻塞，等待其他进程或线程对信号量进行 V 操作，使得信号量的值大于 0，此时阻塞的进程或线程才能继续执行

• V 操作会使得信号量的值加 1，如果此时信号量的值小于等于 0，则会唤醒阻塞在该信号量上的某个进程或线程

信号量的取值可以是任何自然数，根据初始值的不同可以分为两类：

• 二进制信号量：指初始值为 1 的信号量，此类信号量只有 1 和 0 两个值，通常用来替代互斥锁实现线程同步

• 计数信号量：指初始值大于 1 的信号量，当进程中存在多个线程，但某公共资源允许同时访问的线程数量是有限的，这时就可以用计数信号量来限制同时访问资源的线程数量

根据使用场景的不同，信号量也可以分为两类：

• 无名信号量：也被称作基于内存的信号量，只可以在共享内存的情况下，比如实现进程中各个线程之间的互斥和同步
• 命名信号量：通常用于不共享内存的情况下，比如进程间通信
  在本项目中主要实现的是线程同步，只需要使用无名信号量，主要使用以下几个函数

初始化信号量sem_init()

include <semaphore.h>
int sem_init(sem_t *sem,int pshared,unsignedint value)		//初始化一个信号量

sem：指向要初始化的信号量的指针
pshared：指定信号量的共享方式。如果值为 0，则信号量将在进程内部共享。如果值为非 0，则信号量可以在不同进程之间共享，需要使用共享内存
value：指定信号量的初值
return：成功则返回0，否则返回-1

销毁信号量sem_destory()

include <semaphore.h>
int sem_destroy(sem_t *sem)			//销毁一个信号量

sem：指向要销毁的信号量的指针
return：成功返回0，否则返回-1

对信号量进行P操作sem_wait()

include <semaphore.h>
int sem_wait(sem_t *sem)			//对信号量进行 P 操作，如果信号量的值小于等于 0，则会阻塞当前线程

sem：指向要操作的信号量的指针
return：成功返回0，否则返回-1

对信号进行V操作sem_post()

include <semaphore.h>
int sem_post(sem_t *sem)			//对信号量进行 V 操作，如果信号量的值小于等于 0，则会唤醒阻塞在该信号量上的某个线程

sem：指向要操作的信号量的指针
return：成功返回0，否则返回-1

互斥锁——locker类

互斥锁，也称互斥量,可以保护关键代码段,以确保独占式访问.当进入关键代码段,获得互斥锁将其加锁;离开关键代码段,唤醒等待该互斥锁的线程

互斥量是一种用于保护临界区的同步机制，可以确保同一时刻只有一个线程访问共享资源。当一个线程访问共享资源时，需要先获取互斥量的锁，其他线程需要等待该锁释放才能继续执行

互斥量不是为了消除竞争，实际上，资源还是共享的，线程间也还是竞争的，只不过通过这种“锁”机制就将共享资源的访问变成互斥操作，也就是说一个线程操作这个资源时，其它线程无法操作它，从而消除与时间有关的错误。但是，这种锁机制不是强制的，互斥锁实质上是操作系统提供的一把“建议锁”（又称“协同锁”），建议程序中有多线程访问共享资源的时候使用该机制

因此，即使有了mutex，其它线程如果不按照这种锁机制来访问共享数据的话，依然会造成数据混乱。所以为了避免这种情况，所有访问该共享资源的线程必须采用相同的锁机制

初始化互斥量pthread_mutex_init()

include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr)		//初始化互斥量

mutex：指向要初始化的互斥量的指针
attr：指向互斥量属性对象的指针，通常设置为 NULL
return：成功则返回0，否则返回一个正整数的错误码

销毁互斥量pthread_mutex_destroy()

include <pthread.h>
int pthread_mutex_destroy(pthread_mutex_t *mutex)			//销毁互斥量

mutex：指向要销毁的互斥量的指针
return：成功则返回0，否则返回一个正整数的错误码

给互斥锁加锁pthread_mutex_lock()

include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex)				//给互斥量加锁，如果互斥量已经被锁住，则阻塞当前线程，直到互斥量被解锁

mutex：指向要加锁的互斥量的指针
return：成功则返回0，否则返回一个正整数的错误码

解锁互斥量pthread_mutex_unlock()

include <pthread.h>
int pthread_mutex_unlock(pthread_mutex_t *mutex)			//解锁互斥量，如果有等待该互斥量的线程，则唤醒其中的一个线程

mutex：指向要加锁的互斥量的指针
return：成功则返回0，否则返回一个正整数的错误码

条件变量——cond类

条件变量提供了一种线程间的通知机制,当某个共享数据达到某个值时,唤醒等待这个共享数据的线程

条件变量利用线程间共享的全局变量进行同步，主要包括两个动作：一个线程等待条件变量的条件成立而挂起;另一个线程使条件成立（给出条件成立信号）。为了防止竞争，条件变量的使用总是和一个互斥量结合在一起

初始化条件变量pthread_cond_init()

include <pthread.h>
int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr)		//初始化条件变量对象，设置相关属性

cond：指向条件变量对象的指针
attr：指向线程条件属性对象的指针。一般为 NULL
return：成功则返回0，失败返回错误号

销毁条件变量对象pthread_cond_destory()

include <pthread.h>
int pthread_cond_destroy(pthread_cond_t *cond)		//销毁条件变量对象，释放资源

cond：指向条件变量对象的指针
return：成功则返回0，失败返回错误号

唤醒线程pthread_cond_broadcast()

函数以广播的方式唤醒所有等待目标条件变量的线程

include <pthread.h>
int pthread_cond_broadcast(pthread_cond_t *cond)		//唤醒所有在条件变量上等待的线程

cond：指向条件变量对象的指针
return：成功则返回0，失败返回错误号

阻塞线程pthread_cond_wait()

函数执行时,先把调用线程放入条件变量的请求队列,然后将互斥锁mutex解锁,当函数成功返回为0时,互斥锁会再次被锁上. 也就是说函数内部会有一次解锁和加锁操作

include <pthread.h>
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)		//让当前线程阻塞在条件变量上等待唤醒

cond：指向条件变量对象的指针
mutex：指向互斥锁对象的指针，用于保护条件变量
return：成功则返回0，失败返回错误号

发送信号通知线程pthread_cond_signal()

pthread_cond_signal 只会通知一个等待该条件变量的线程，如果有多个线程在等待，则只有一个线程会收到通知，其余线程还会继续等待，直到下一次收到信号
必须在已经获得与条件变量相关的互斥锁之后才能调用该函数
如果没有等待该条件变量的线程，调用该函数也不会产生任何作用

include <pthread.h>
int pthread_cond_signal(pthread_cond_t *cond)

cond：指向条件变量的指针
return：成功则返回0，失败返回错误号

锁机制的功能

锁机制用来实现多线程同步，通过锁机制，确保任一时刻只能有一个线程能进入关键代码段

为便于实现同步类的RAII机制(“Resource Acquisition is Initialization”直译过来是“资源获取即初始化”)，该项目在pthread库的基础上进行了封装，实现了类似于C++11的mutex标准库功能
————————————————

源码

/****************locker.h*******************/
#ifndef LOCKER_H
#define LOCKER_H

#include <exception>
#include <semaphore.h>
#include <pthread.h>

class sem {
public:
    sem(int value = 0) {
        if (sem_init(&m_sem, 0, value) != 0) {
            throw std::exception();
        }
    }
    ~sem() {
        sem_destroy(&m_sem);
    }
    bool wait() {
        return sem_wait(&m_sem) == 0;
    }
    bool post() {
        return sem_post(&m_sem) == 0;
    }
private:
    sem_t m_sem;
};

class locker {
public:
    locker() {
        if (pthread_mutex_init(&m_mutex, NULL) != 0) {
            throw std::exception();
        }
    }
    ~locker() {
        pthread_mutex_destroy(&m_mutex);
    }
    bool lock() {
        return pthread_mutex_lock(&m_mutex);
    }
    bool unlock() {
        return pthread_mutex_unlock(&m_mutex);
    }
    pthread_mutex_t* get() {
        return &m_mutex;
    }
private:
    pthread_mutex_t m_mutex;
};

class cond {
public:
    cond() {
        if (pthread_cond_init(&m_cond, NULL) != 0) {
            throw std::exception();
        }
    }
    ~cond() {
        pthread_cond_destroy(&m_cond);
    }
    bool wait(pthread_mutex_t* m_mutex) {
        int ret = pthread_cond_wait(&m_cond, m_mutex);
        return ret == 0;
    }
    bool timewait(pthread_mutex_t* m_mutex, struct timespec t) {
        return pthread_cond_timedwait(&m_cond, m_mutex, &t);
    }
    bool signal() {
        return pthread_cond_signal(&m_cond) == 0;
    }
    bool broadcast() {
        return pthread_cond_broadcast(&m_cond) == 0;
    }
private:
    pthread_cond_t m_cond;
};

#endif

/*测试locker类代码
// 生产者线程函数
void* producer(void* arg) {
    block_queue<int>* queue = static_cast<block_queue<int>*>(arg);
    for (int item = 0; item < 20; item++) {
        queue->push(item);
        LOG_INFO("生产者产生数据i = %d", item);
        usleep((rand() % 5 + 1) * 50000);
    }
    return nullptr;
}

// 消费者线程函数
void* consumer(void* arg) {
    block_queue<int>* queue = static_cast<block_queue<int>*>(arg);
    for (int item = 0; item < 20; item++) {
        queue->pop(item);
        LOG_INFO("消费者处理数据i = %d", item);
    }
    return nullptr;
}

int main() {
    block_queue<int> queue;
    pthread_t tid_prod, tid_cons;
    pthread_create(&tid_prod, nullptr, producer, &queue);
    pthread_create(&tid_cons, nullptr, consumer, &queue);
    pthread_join(tid_prod, nullptr);
    pthread_join(tid_cons, nullptr);
    return 0;
}
*/