互斥锁的使用就是当有线程访问进程空间中的公共资源时，线程执行“加锁”操作(将资源锁起来)，阻止其它线程的访问。访问完成后，该线程（谁锁上的必须由谁来解锁）负责完成“解锁”操作，将资源让给其它线程。当有多个线程同时需要访问同一个公共资源时，谁先上锁成功，这公共资源就归谁使用，只有等他用完了，释放锁了，其他线程才能用
互斥锁的使用流程
（1）定义一个互斥锁
在<pthread.h>头文件中，有一个专门用来定义互斥锁变量的结构体，叫pthread_mutex_t，我们直接拿来用就是了，使用方法如下
pthread_mutex_t myMutex;
（2）初始化互斥锁
互斥锁的初始化方法有两种，一种是使用特定的宏，一种是使用专门的初始化函数，一般没啥特殊要求我们就用第一种宏就行，对于调用 malloc() 函数分配动态内存的互斥锁，只能使用第二种方式。
使用宏的方法
pthread_mutex_t myMutex = PTHREAD_MUTEX_INITIALIZER;
使用函数的方法
pthread_mutex_t myMutex;
pthread_mutex_init(&myMutex , NULL);
关于pthread_mutex_init() 函数，他的原型是这样的
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);
关于他的参数，mutex 参数表示要初始化的互斥锁；attr 参数用于自定义新建互斥锁的属性，当attr 的值为 NULL 时表示以默认属性创建互斥锁，我们一般也就使用NULL。
（3）加锁
int pthread_mutex_lock(pthread_mutex_t* mutex);
//或者用下面这个
int pthread_mutex_trylock(pthread_mutex_t* mutex);
有关两者的区别，具体如下
pthread_mutex_lock() 函数会使线程进入等待（阻塞）状态，直至互斥锁得到释放；
pthread_mutex_trylock() 函数不会阻塞线程，直接返回非零数（表示加锁失败）。
（4）解锁
int pthread_mutex_unlock(pthread_mutex_t* mutex);
说到最后，用一个实际案例来实验一下，模拟的是网上买票的工作流程。创建了四个子线程，去模拟不同的买票窗口去负责卖票。
#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<unistd.h>
int ticket_sum = 30;//这表示票的总量
//创建互斥锁变量并初始化
pthread_mutex_t myMutex = PTHREAD_MUTEX_INITIALIZER;
//模拟售票员卖票
void *sell_ticket(void *arg)
{
//输出当前线程的ID
printf("id = %u\n", pthread_self());
int i;
int islock = 0;
for (i = 0; i < 10; i++)
{
//当前线程“加锁”
islock = pthread_mutex_lock(&myMutex);
//如果“加锁”成功，执行如下代码
if (islock == 0)
{
//如果票数 >0 ,开始卖票
if (ticket_sum > 0)
{
sleep(1);
printf("%u sell the NO.%d ticket\n",pthread_self(),30-ticket_sum+1);
ticket_sum--;
}
pthread_mutex_unlock(&myMutex);
}
}
return 0;
}
int main()
{
int flag;
int i;
//创建4个线程
pthread_t tids[4];
for (i = 0; i < 4; i++)
{
flag = pthread_create(&tids[i], NULL, &sell_ticket, NULL);
if (flag != 0)
{
printf("fail\n");
return 0;
}
}
sleep(30); //等待4个子线程完成
for (i = 0; i < 4; i++)
{
flag = pthread_join(tids[i], NULL);
if (flag != 0)
{
printf("tid=%d wait fail !", tids[i]);
return 0;
}
}
return 0;
}
程序中pthread_self()这个其实是这样子的，我直接man出来，大家看一下，就是用来返回，调用线程的id的。
关于这个程序案例，写完后，我自己其实运行了几次，之前我将票的总数量设置成10，发现从头到尾只有一个线程在被调用，我以为是我的程序有问题，在网上查阅了一下资料发现，是我们当前的电脑机子性能太好所致，当操作数量少的情况下的多线程，电脑自己其实就使用一个线程就给我们安排了，于是我加大了数量，这才发生点变化出来
互斥锁的状态值只有开锁和解锁两个方面，信号量则不同，他可以根据实际场景的不同设置自己想要的转态值，可以说是更加灵活吧。
信号量可以分成是二进制信号量和计数信号量，二进制信号量就可以用来替代互斥锁，就是只将信号量的初始值设置成1，然后只能0,1间变换，可以理解成每次只允许一个线程同时访问一片公共资源，而计数信号量就是将信号量的初始值设置的多一点，大于1的那种，意味着每次可以同时接待多个线程来访问公共资源。
下面来看看信号量这东西的用法，具体咋用
sem_t mySem; //先定义一个信号量
//信号量的初始化
int sem_init(sem_t *sem, int pshared, unsigned int value);
各个参数的含义分别为：
1、参数sem：表示要初始化的目标信号量；
2、参数pshared：表示该信号量是否可以和其他进程共享，pshared 值为 0 时表示不共享，值为 1 时表示共享；
3、参数value：设置信号量的初始值。
对于初始化好了的信号量，我们可以借助 <semaphore.h> 头文件提供的一些函数操作
入参都是要操作的信号量
//将信号量的值“加 1”
int sem_post(sem_t* sem);
//对信号量做“减 1”操作,当信号量的值为 0 时，阻塞当前线程等待
int sem_wait(sem_t* sem);
//当信号量的值为 0 时，sem_trywait() 函数并不会阻塞当前线程，而是立即返回 -1；
int sem_trywait(sem_t* sem);
//手动销毁信号量
int sem_destroy(sem_t* sem);
当一个线程要用公共资源的时候就先，sem_wait，等待处理完后再sem_post，把位置让出来，就好比银行里的多个服务窗口，你坐那办理业务的时候就需要把可用位置减1，也就是sem_wait，等你办理完后就需要把位置让出来，也就是sem_post。
条件变量是线程同步的另一种手段，主要逻辑就是等待和唤醒。条件不满足时，线程等待；条件满足时，线程被(其他线程)唤醒。条件变量一般和互斥量一起使用，因为需要保证多线程互斥地修改条件。条件变量阻塞的是线程，不像互斥锁阻塞的是资源。
读写锁的核心思想是：将线程访问共享数据时发出的请求分为两种，分别是：
读请求：只读取共享数据，不做任何修改；
写请求：存在修改共享数据的行为。
| 当前读写锁的状态 | 发起读请求 | 发起写请求 |
| 无锁 | 允许 | 允许 |
| 读锁 | 允许 | 阻塞等待 |
| 写锁 | 阻塞等待 | 阻塞等待 |
其实核心的要点就是，多个读的进程由于并不改变原内容，所以可以多个并行，但一旦设计到写，那就需要等待一下，让写完了，数据内容不变了再进行操作。
产生死锁的原因：当进程空间中的某公共资源不允许多个线程同时访问时，某线程访问公共资源后不及时释放资源，就很可能产生线程死锁。
解决办法：
使用互斥锁的时候，用完后及时地解锁；使用信号量时，用完后及时 sem_post()；读写锁也是一样，及时解锁。
另外，多个线程请求资源的顺序最好保持一致。线程 t1 需要先请求 mutex 锁然后再请求 mutex2 锁，而 t2 需要先请求 mutex2 锁然后再请求 mutex 锁，这是一种典型的因“请求资源顺序不一致”，两个线程之间会相互等待对方解锁而发生死锁。