Linux系统编程系列（16篇管饱，吃货都投降了！）
16、 Linux系统编程系列之线程池
一、什么是互斥锁和读写锁
互斥锁是一种并发机制，用于控制多个线程对共享资源的访问。
读写锁是一种并发机制，用于控制多个线程对共享资源的访问。
二、特性
1、互斥锁
当一个线程获得了互斥锁并进入临界区（对共享资源进行访问）时，其他线程将被阻塞，直到该线程释放互斥锁。这可以确保同时只有一个线程能够访问共享资源，避免多个线程同时修改共享资源导致数据不一致或其他问题。
2、读写锁
读写锁允许多个线程同时读取共享资源，但是只允许一个线程进行写操作。在读取共享资源时，多个线程可以同时获得读锁，不会相互阻塞，从而提高了并发性能。而在写操作时，只有一个线程可以获得写锁，其他线程将被阻塞，以避免同时修改导致数据不一致或其他问题。
使用读写锁可以有效地提高系统的并发性能和吞吐量，访问效率比互斥锁高。
三、使用场景
1、互斥锁
（1）、 线程共享同一个全局变量或者静态变量时，需要使用互斥锁来保证数据的一致性和正确性。
（2）、 多个线程访问共享资源时，需要使用互斥锁来保证同一时间只有一个线程能够访问共享资源。
（3）、 线程需要保证一段代码的原子性操作时，需要使用互斥锁来对这段代码进行加锁保护。
（4）、 多线程并发执行时，需要使用互斥锁来保证线程间执行的顺序和正确性。
总之，互斥锁主要用于控制多个线程对共享资源的访问，确保同一时刻只有一个线程能够访问共享资源。
2、读写锁
（1）、读多写少的情况，读写锁可以提高并发读的性能。读写锁允许多个线程同时读取共享资源，但只允许一个线程进行写操作。
（2）、对于频繁的读取共享资源和不频繁的写入共享资源的场景，使用读写锁可以避免由于写操作的串行化导致的性能瓶颈。
（3）、适用于需要有一定实时性的场景，读写锁中的读操作是共享的，可以在不阻塞其他线程执行的情况下快速地读取数据，提高程序的响应速度。
总之，读写锁适用于读多写少的场景，可以提高并发读的性能，避免由于写操作的串行化导致的性能瓶颈，并且具有一定的实时性。
四、同步与互斥
互斥可以简单理解为控制两个进度使之互相排斥，不同同时运行。
同步可以简单理解为控制两个进度使之有先有后，次序可控。
五、相关的函数API接口
1、互斥锁
（1）、定义
// 互斥锁是一个特殊的变量 // 声明一个互斥锁变量m pthread_mutext_t m;
（2）、初始化和销毁
未经初始化的互斥锁是无法使用的，初始化互斥锁有两种办法：
// 静态初始化 pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER; // 动态初始化 int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr); // 接口说明 返回值：一直都是0 参数mutex：互斥锁 参数attr：互斥锁属性（一般置为NULL） // 销毁互斥锁 int pthread_mutex_destroy(pthread_mutex_t *mutex); // 接口说明 返回值：成功返回0，失败返回错误码 参数mutex：互斥锁 由于静态初始化互斥锁不涉及动态内存，因此无需显式释放互斥锁资源，互斥锁会伴随程序一直存在，直到程序退出为止。而动态初始化指使用 pthread_mutex_init()给互斥锁分配动态内存并赋予初始值，因此这种情况下的互斥锁需要在用完之后显式地进行释放资源。
（3）、加锁
// 阻塞上锁 int pthread_mutex_lock(pthread_mutex_t *mutex); // 接口说明 返回值：成功返回0，失败返回错误码 参数mutex：互斥锁 // 非阻塞上锁 int pthread_mutex_trylock(pthread_mutex_t *mutex); // 接口说明 返回值：成功返回0，失败返回错误码 参数mutex：互斥锁
（4）、解锁
// 解锁 int pthread_mutex_unlock(pthread_mutex_t *mutex); // 接口说明 返回值：成功返回0，失败返回错误码 参数mutex：互斥锁
（5）、锁属性
当某一个线程所执行的功能有可能发生递归时，需要注意互斥锁的属性问题，需要对有可能被同一个线程重复加锁的锁资源设置为允许递归（重复）上锁。但是需要注意的是，同一个线程对同一锁资源上了多次锁，就需要解锁多少次，否则其他线程将永远无法获得该锁资源（死锁）。
// 初始化线程互斥锁属性 int pthread_mutexattr_init(pthread_mutexattr_t *attr); // 销毁线程互斥锁属性 int pthread_mutexattr_destroy(pthread_mutexattr_t *attr); // 设置线程互斥锁属性 int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int kind); // 设置锁类型为递归锁 pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
2、读写锁
（1）、定义
// 读写锁是一种特殊的变量 // 声明一个读写锁变量rw pthread_rwlock_t rw;
（2）、初始化和销毁
跟互斥锁的初始化和销毁差不多
// 静态初始化 pthread_rwlock_t rw = PTHREAD_RWLOCK_INITIALIZER; // 动态初始化 int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr); // 接口说明 返回值：成功返回0，失败返回错误码 参数rwlock：读写锁 参数attr：读写锁属性 // 销毁 int pthread_rwlock_destroy(pthread_rwlock_t *rwlock); // 接口说明 返回值：成功返回0，失败返回错误码 参数rwlock：读写锁
（3）、加锁
// 阻塞加读锁 int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock); // 非阻塞加读锁 int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock); // 阻塞加写锁 int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock); // 非阻塞加写锁 int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
（4）、解锁
// 解锁 int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
（5）、锁属性
// 初始化读写锁属性 int pthread_rwlockattr_init(pthread_rwlockattr_t *attr); // 销毁读写锁属性 int pthread_rwlockattr_destroy(pthread_rwlockattr_t *attr); // 设置读写锁属性 int pthread_rwlockattr_setkind_np(pthread_rwlockattr_t *attr, int pref); // 获取读写锁属性 int pthread_rwlockattr_getkind_np(const pthread_rwlockattr_t *attr, int *pref); // 接口说明 参数pref有以下几种： （1）、PTHREAD_RWLOCK_PREFER_READER_NP，偏向读取（读锁优先） （2）、PTHREAD_RWLOCK_PREFER_WRITER_NP，偏向写入（写锁优先） （3）、PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP，偏向写入非递归 （4）、PTHREAD_RWLOCK_PREFER_DEFAULT_NP，默认 操作步骤： （1）、初始化锁属性 （2）、设置锁属性 （3）、使用动态初始化的方式初始化锁资源 （4）、销毁锁属性
偏向写入：是指读写锁的属性设置为优先考虑写入操作，即在有写锁请求时，读锁请求将被阻塞，直到写锁释放。
偏向读取：是指读锁操作优先处理，如果有读锁请求时，则写锁请求将被阻塞。
写入非递归：写入操作不支持递归调用，即同一个线程不能在持有写入锁的情况下再次请求写入锁。如果在持有写入锁的情况下再次请求写入锁，则会导致死锁。
写入递归：写入操作支持递归调用，即同一个线程可以在持有写入锁的情况下再次请求写入锁。如果使用写入递归模式，需要注意避免出现死锁的情况。
六、案例
用互斥锁来实现两个线程的数据同步，一个负责发送，一个负责接收
// 互斥锁的案例 #include <stdio.h> #include <pthread.h> #include <errno.h> #include <string.h> #include <unistd.h> char data[100]; pthread_mutex_t data_mutex; // 定义互斥锁变量 pthread_once_t data_mutex_once_init; // 函数单例初始化变量 pthread_once_t data_mutex_once_destroy; // 函数单例销毁变量 // 初始化互斥锁data_mutex void data_mutex_init(void) { pthread_mutex_init(&data_mutex, NULL); } // 销毁互斥锁data_mutex void data_mutex_destroy(void) { pthread_mutex_destroy(&data_mutex); } // 线程1的例程函数，用来接收数据 void *recv_routine(void *arg) { printf("I am recv_routine, my tid = %ld\n", pthread_self()); // 设置线程分离 pthread_detach(pthread_self()); // 函数单例，本程序只会执行data_mutex_init()一次 pthread_once(&data_mutex_once_init, data_mutex_init); sleep(1); // 先睡眠1s，保证让线程2先执行 while(1) { pthread_mutex_lock(&data_mutex); // 阻塞等待有数据才可以申请成功，用来同步 printf("pthread1 read data: %s\n", data); memset(data, 0, sizeof(data)); } // 函数单例，本程序只会执行data_mutex_init()一次 pthread_once(&data_mutex_once_destroy, data_mutex_destroy); } // 线程2的例程函数，用来发送数据 void *send_routine(void *arg) { printf("I am send_routine, my tid = %ld\n", pthread_self()); // 函数单例，本程序只会执行data_mutex_init()一次 pthread_once(&data_mutex_once_init, data_mutex_init); // 先申请锁，防止线程1读取空数据，为同步做准备 pthread_mutex_lock(&data_mutex); while(1) { printf("please input data:\n"); fgets(data, 100, stdin); printf("pthread2 send data\n"); pthread_mutex_unlock(&data_mutex); // 解锁，相当于给线程1发送信号 } // 函数单例，本程序只会执行data_mutex_init()一次 pthread_once(&data_mutex_once_destroy, data_mutex_destroy); } int main(int argc, char *argv[]) { pthread_t tid1, tid2; // 创建线程1，用来接收数据 errno = pthread_create(&tid1, NULL, recv_routine, NULL); if(errno == 0) { printf("pthread create recv_routine success, tid = %ld\n", tid1); } else { perror("pthread create recv_routine fail\n"); } // 1、定义线程属性变量 pthread_attr_t attr2; // 2、初始化线程属性变量 pthread_attr_init(&attr2); // 3、设置分离属性 pthread_attr_setdetachstate(&attr2, PTHREAD_CREATE_DETACHED); // 4、创建线程2，用来发送数据，线程拥有分离属性 errno = pthread_create(&tid2, &attr2, send_routine, NULL); if(errno == 0) { printf("pthread create send_routine success, tid = %ld\n", tid2); } else { perror("pthread create send_routine fail\n"); } // 5、销毁属性变量 pthread_attr_destroy(&attr2); // 一定要加这个，否则主函数直接退出，相当于进程退出，所有线程也退出 // 或者加上while(1)等让主函数不退出 pthread_exit(0); return 0; }
用读写锁来实现对一个整型数据的操作和访问，一条线程使数据自增，另外一条线程判断该数据的奇偶性，并设置写锁优先。
// 读写锁的案例 #include <stdio.h> #include <pthread.h> #include <errno.h> #include <string.h> #include <unistd.h> int data = 100; // 共享变量 pthread_rwlock_t data_rwlock; // 定义互斥锁变量 pthread_once_t data_rwlock_once_init; // 函数单例初始化变量 pthread_once_t data_rwlock_once_destroy; // 函数单例销毁变量 // 初始化互斥锁data_rwlock void data_rwlock_init(void) { pthread_rwlockattr_t data_rwlock_attr; // 设置锁属性为写锁优先 // 1、初始化读写锁属性 pthread_rwlockattr_init(&data_rwlock_attr); // 2、设置读写锁属性为写锁优先 pthread_rwlockattr_setkind_np(&data_rwlock_attr, PTHREAD_RWLOCK_PREFER_WRITER_NP); // 3、动态初始化锁资源，此时读写锁是写锁优先的 pthread_rwlock_init(&data_rwlock, NULL); // 4、销毁读写锁属性 pthread_rwlockattr_destroy(&data_rwlock_attr); } // 销毁互斥锁data_rwlock void data_rwlock_destroy(void) { pthread_rwlock_destroy(&data_rwlock); } // 线程1的例程函数，用来接收数据 void *recv_routine(void *arg) { printf("I am recv_routine, my tid = %ld\n", pthread_self()); // 设置线程分离 pthread_detach(pthread_self()); // 函数单例，本程序只会执行data_rwlock_init()一次 pthread_once(&data_rwlock_once_init, data_rwlock_init); while(1) { // 加上读锁 pthread_rwlock_rdlock(&data_rwlock); if(data % 2) { printf("%d 是奇数\n", data); } else { printf("%d 是偶数\n", data); } // 解锁 pthread_rwlock_unlock(&data_rwlock); } // 函数单例，本程序只会执行data_rwlock_init()一次 pthread_once(&data_rwlock_once_destroy, data_rwlock_destroy); } // 线程2的例程函数，用来发送数据 void *send_routine(void *arg) { printf("I am send_routine, my tid = %ld\n", pthread_self()); // 函数单例，本程序只会执行data_rwlock_init()一次 pthread_once(&data_rwlock_once_init, data_rwlock_init); while(1) { // 加上写锁 pthread_rwlock_wrlock(&data_rwlock); data++; // 解锁 pthread_rwlock_unlock(&data_rwlock); } // 函数单例，本程序只会执行data_rwlock_init()一次 pthread_once(&data_rwlock_once_destroy, data_rwlock_destroy); } int main(int argc, char *argv[]) { pthread_t tid1, tid2; // 创建线程1，用来接收数据 errno = pthread_create(&tid1, NULL, recv_routine, NULL); if(errno == 0) { printf("pthread create recv_routine success, tid = %ld\n", tid1); } else { perror("pthread create recv_routine fail\n"); } // 1、定义线程属性变量 pthread_attr_t attr2; // 2、初始化线程属性变量 pthread_attr_init(&attr2); // 3、设置分离属性 pthread_attr_setdetachstate(&attr2, PTHREAD_CREATE_DETACHED); // 4、创建线程2，用来发送数据，线程拥有分离属性 errno = pthread_create(&tid2, &attr2, send_routine, NULL); if(errno == 0) { printf("pthread create send_routine success, tid = %ld\n", tid2); } else { perror("pthread create send_routine fail\n"); } // 5、销毁属性变量 pthread_attr_destroy(&attr2); // 一定要加这个，否则主函数直接退出，相当于进程退出，所有线程也退出 // 或者加上while(1)等让主函数不退出 pthread_exit(0); return 0; }
七、总结
互斥锁和读写锁都是一种并发机制，用于控制多个线程对共享资源的访问。互斥锁主要用于控制多个线程对共享资源的访问，确保同一时刻只有一个线程能够访问共享资源，而读写锁适用于读多写少的场景，可以提高并发读的性能。 读写锁的属性设置需要遵循一定的步骤。
222
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
