并发编程–互斥锁与读写锁
1. 基本概念
互斥与同步是最基本的逻辑概念：
- 互斥指的是控制两个进度使之互相排斥，不同时运行。
- 同步指的是控制两个进度使之有先有后，次序可控。
2. 互斥锁
2.1 基本逻辑
使得多线程间互斥运行的最简单办法，就是增加一个互斥锁。任何一条线成要开始运行互斥区间的代码，都必须先获取互斥锁，而互斥锁的本质是一个二值信号量，因此当其中一条线程抢先获取了互斥锁之后，其余线程就无法再次获取了，效果相当于给相关的资源加了把锁，直到使用者主动解锁，其余线程方可有机会获取这把锁。
2.2 函数接口
定义
互斥锁是一个特殊的变量，定义如下：
#include <pthread>
pthread_mutex_t m;
一般而言，由于互斥锁需要被多条线程使用，因此一般会将互斥锁定义为全局变量。
初始化与销毁
未经初始化的互斥锁是无法使用的，初始化互斥锁有两种办法：
- 静态初始化
- 动态初始化
静态初始化很简单，就是在定义同时赋予其初值：
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
由于静态初始化互斥锁不涉及动态内存，因此无需显式释放互斥锁资源，互斥锁将会伴随程序一直存在，直到程序退出为止。而所谓动态初始化指的是使用 pthread_mutex_init() 给互斥锁分配动态内存并赋予初始值，因此这种情形下的互斥锁需要在用完之后显式地进行释放资源，接口如下:
#include <pthread.h>
// 初始化互斥锁
int pthread_mutex_init(pthread_mutex_t *restrict mutex,
const pthread_mutexattr_t *restrict attr);
// 销毁互斥锁
int pthread_mutex_destroy(pthread_mutex_t *mutex);
接口说明：
- mutex：互斥锁
- attr：互斥锁属性（一般设置为NULL）
加锁与解锁
互斥锁的基本操作就是加锁与解锁，接口如下：
#include <pthread.h>
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
// 加锁
pthread_mutex_lock( &m );
// 解锁
pthread_mutex_unlock( &m );
2.3示例代码1
将此前判断偶数的代码用互斥锁加以改进如下：
// concurrency.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <string.h>
#include <pthread.h>
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
int global = 100;
void *isPrime(void *arg)
{
while(1)
{
pthread_mutex_lock(&m);
// 一段朴素的代码
if(global%2 == 0)
printf("%d是偶数\n", global);
pthread_mutex_unlock(&m);
}
}
int main()
{
pthread_t tid;
pthread_create(&tid, NULL, isPrime, NULL);
// 一条人畜无害的赋值语句
while(1)
{
pthread_mutex_lock(&m);
global = rand() % 5000;
pthread_mutex_unlock(&m);
}
}
运行结果如下：
gec@ubuntu:~$ ./concurrency
492是偶数
2362是偶数
2778是偶数
3926是偶数
540是偶数
3426是偶数
4172是偶数
112是偶数
368是偶数
2576是偶数
1530是偶数
1530是偶数
2862是偶数
4706是偶数
...
gec@ubuntu:~$
可见，有了互斥锁之后，输出的结果正确了。
2.4示例代码2
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
pthread_mutex_t m;
void *routine(void *arg)
{
char *msg = (char *)arg;
#ifdef MUTEX
pthread_mutex_lock(&m);
#endif
while(*msg != '\0')
{
fprintf(stderr,"%c",*msg);
usleep(100);
msg++;
}
#ifdef MUTEX
pthread_mutex_unlock(&m);
#endif
pthread_exit(NULL);
}
int main(void)
{
pthread_mutex_init(&m,NULL);
pthread_t t1,t2;
pthread_create(&t1,NULL,routine,"AAAAAAAAAAA");
pthread_create(&t2,NULL,routine,"BBBBBBBBBBB");
pthread_exit(NULL);
}
通过宏定义实现代码的不同运行，输出不同的结果。若不使用互斥锁的话，则直接运行，结果将会是AB交互是输出，两个线程t1，t2会同时运行，交互式输出；若使用互斥锁的话，会输出单独输出一个线程的结果，然后再输出另一个线程的结果。
若要使用互斥锁则如下：
gcc pthread_mutex.c -o pthread_mutex -lpthread -DMUTEX
3. 读写锁
3.1 基本逻辑
对于互斥锁而言，凡是涉及临界资源的访问一律加锁，这在并发读操作的场景下会大量浪费时间。要想提高访问效率，就必须要将对资源的读写操作加以区分：读操作可以多任务并发执行，只有写操作才进行恰当的互斥。这就是读写锁的设计来源。
读写锁提高了资源访问的效率
定义
与互斥锁类似，读写锁也是一种特殊的变量：
pthread_rwlock_t rw;
初始化
与互斥锁类似，读写锁也分成静态初始化和动态初始化：
#include <pthread.h>
// 静态初始化：
pthread_rwlock_t rw = PTHREAD_RWLOCK_INITIALIZER;
// 动态初始化与销毁：
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,
const pthread_rwlockattr_t *restrict attr);
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
加锁
读写锁最大的特点是对即将要做的读写操作做了区分：
- 读操作可以共享，因此多条线程可以对同一个读写锁加多重读锁
- 写操作天然互斥，因此多条线程只能有一个拥有写锁。（注意写锁与读锁也是互斥的）
#include <pthread.h>
// 读锁
// 1，阻塞版本
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
// 2，非阻塞版本
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
// 写锁
// 1，阻塞版本
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
// 2，非阻塞版本
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
操作原则：
- 如果只对数据进行读操作，那么就加 → 读锁。
- 如果要对数据进行写操作，那么就加 → 写锁。
解锁
#include <pthread.h>
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
3.2示例代码
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
char global = 'X';
pthread_rwlock_t rwlock;
void *routine(void *arg)
{
#ifdef RDLOCK
pthread_rwlock_rdlock(&rwlock);
#elif WRLOCK
pthread_rwlock_wrlock(&rwlock);
#endif
int i = 1000;
while(i > 0)
{
fprintf(stderr,"[%c:%c]",*(char*)arg,global);
i--;
}
pthread_rwlock_unlock(&rwlock);
pthread_exit(NULL);
}
int main(void)
{
pthread_rwlock_init(&rwlock,NULL);
pthread_t t1,t2,t3;
pthread_create(&t1,NULL,routine,"1");
pthread_create(&t2,NULL,routine,"2");
pthread_create(&t3,NULL,routine,"3");
pthread_exit(NULL);
}