线程的同步机制（互斥锁，条件变量，信号量，读写锁，自旋锁）

互斥锁

• 初始化

#inlude <pthread.h>
int pthread_mutex_init(pthread_mutex_t *restrict mutex,
const pthread_mutexattr_t *restrict attr);

attr锁属性非NULL时：
PTHREAD_MUTEX_TIMED_NP:普通锁
PTHREAD_MUTEX_RECURSIVE_NP:嵌套锁（同一锁可多次加锁）
PTHREAD_MUTEX_ERRORCHECK_NP:检错锁
PTHREAD_MUTEX_ADAPTIVE_NP:适应锁，释放后重新竞争

• 销毁

#inlude <pthread.h>
int pthread_mutex_destroy(pthread_mutex_t *mutex);

• 申请互斥锁（加锁）

#inlude <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);//没成功（已被加锁）就阻塞
int pthread_mutex_trylock(pthread_mutex_t *mutex);//没成功（已被加锁）就返回

• 释放互斥锁（解锁）

#inlude <pthread.h>
int pthread_mutex_unlock(pthread_mutex_t *mutex);

示例代码：

#include <pthread.h>
#include <unistd.h>
#include <iostream>
using namespace std;

pthread_mutex_t mutex;

int sum=0;
void *fun1(void *arg)
{
    int i=5;
    pthread_mutex_lock(&mutex);
    

    while(i>0){
        sleep(1);
        cout<<"thread1"<<endl;
        i--;
        sum++;  
    }
    pthread_mutex_unlock(&mutex);
}

void *fun2(void *arg)
{
    int i=5;
    pthread_mutex_lock(&mutex);
    

    while(i>0){
        sleep(1);
        cout<<"thread2"<<endl;
        i--;
        sum--;  
    }
    pthread_mutex_unlock(&mutex);
}

int main()
{
    pthread_t thread1,thread2;
    pthread_mutex_init(&mutex,NULL);
    pthread_create(&thread1,NULL,fun1,NULL);
    pthread_create(&thread2,NULL,fun2,NULL);

    pthread_join(thread1,NULL);
    pthread_join(thread2,NULL);
    pthread_mutex_destroy(&mutex);
    cout << "sum= "<<sum <<endl;
    return 0;
}

运行结果：

若将加锁解锁注释掉后运行结果

条件变量

若有一个临界资源如一个缓冲区（字符数组），当缓冲区为空时线程A写数据，当缓冲区有数据时B取出数据。此时光靠互斥锁不能满足要求，就需要Linux另一个同步机制----条件变量。

• 初始化

#include <pthread.h>
int pthread_cond_init(pthread_cond_t *restrict cond,
const pthread_condattr_t *restrict attr);

• 销毁

#include <pthread.h>
int pthread_cond_destroy(pthread_cond_t *cond);

• 阻塞等待条件变量（p操作）

#include <pthread.h>
int pthread_cond_wait(pthread_cond_t *restrict cond,
pthread_mutex_t *restrict mutex);
int pthread_cond_timedwait(pthread_cond_t *restrict cond,
pthread_mutex_t *restrict mutex,
const struct timespec *restrict abstime);//在指定时间之内等待

wait在调用的时候， 这个线程会释放mutex， 并且给这个cond上锁， 线程被挂起， 不占用CPU，被唤醒的时候这个抢到锁线程会自动重新上锁 —— 即重新获得mutex

无论哪种等待方式，都必须和一个互斥锁配合，以防止多个线程同时请求pthread_cond_wait()（或pthread_cond_timedwait()，下同）的竞争条件（Race Condition）。mutex互斥锁必须是普通锁（PTHREAD_MUTEX_TIMED_NP）或者适应锁（PTHREAD_MUTEX_ADAPTIVE_NP），且在调用pthread_cond_wait()前必须由本线程加锁（pthread_mutex_lock()），而在更新条件等待队列以前，mutex保持锁定状态，并在线程挂起进入等待前解锁。在条件满足从而离开pthread_cond_wait()之前，mutex将被重新加锁，以与进入pthread_cond_wait()前的加锁动作对应。
————————————————
版权声明：本文为CSDN博主「猫已经找不回了」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/hairetz/java/article/details/4535920

• 互斥锁加条件变量使用过程
  1. 临界区加锁
  2. 挂起等待，等待时释放锁
  3. 被唤醒，加锁，进入临界区
  4. 退出临界区时减锁。
     挂起前后锁的变化：挂起等待前加锁，挂起等待时解锁，被唤醒时解锁
• 通知等待该条件变量的线程(v操作)

int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond);//广播通知

示例代码
用条件变量和互斥锁解决生产者消费者问题

#include<iostream>
#include<unistd.h>
#include<stdlib.h>
#include<pthread.h>

using namespace std;

static int count = 0;
// 对于这些pthread中的type要么使用init初始化， 要么使用系统宏初始化
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond_not_full = PTHREAD_COND_INITIALIZER;
static pthread_cond_t cond_not_empty = PTHREAD_COND_INITIALIZER;

void *produce(void *arg) {
    while(1) {
        pthread_mutex_lock(&mutex);

        /*
        这里写上while是没有错的， 这是因为当其他的线程调用signal的时候， 可能会有多个线程同时被唤醒， 但是由于只有一个线程才可以拿到锁， 其他的还是需要继续wait， 所以为了避免“惊群效应”， 同时也为了维护同一个时刻只有一个线程可以进入临界区， 这里使用while
        */
        while(count >= 10) {
            pthread_cond_wait(&cond_not_full, &mutex);
        }

        ++count;
        cout << "produce: count = " << count << endl;
        pthread_mutex_unlock(&mutex);
        pthread_cond_signal(&cond_not_empty);
    }

    return NULL;
}

void *consume(void *arg) {
    while(1) {
        pthread_mutex_lock(&mutex);

        while(count <= 0) {
            pthread_cond_wait(&cond_not_empty, &mutex);
        }

        --count;
        cout << "consume: count = " << count << endl;
        pthread_mutex_unlock(&mutex);
        pthread_cond_signal(&cond_not_full);
    }

    return NULL;
}

int main() {
    pthread_t ptid, ctid;
    pthread_create(&ptid, NULL, produce, NULL);
    pthread_create(&ctid, NULL, consume, NULL);
    pthread_join(ptid, NULL);
    pthread_join(ctid, NULL);
    return 0;
}

---

信号量

注意此地方是posix信号量，用于线程同步。（SYSTEM V信号量用于进程同步）

sem_init(&m_sem, 0, num);
sem_destroy(&m_sem);
sem_wait(&m_sem);//得到资源信号量减一或一直等待
sem_post(&m_sem);//信号量加1

读写锁

pthread_rwlock_init(&rwlock, NULL);
pthread_rwlock_destroy(&rwlock);
pthread_rwlock_rdlock(&rwlock);
pthread_rwlock_wrlock(&rwlock);
pthread_rwlock_unlock(&rwlock);

自旋锁

(忙等而不是阻塞等，用户层不常用)

pthread_spin_init(&m_spin, NULL);
pthread_spin_destroy(&m_spin);
pthread_spin_lock(&m_spin);
pthread_spin_unlock(&m_spin);
pthread_spin_trylock(&m_spin);