并发编程--互斥锁与读写锁

并发编程–互斥锁与读写锁

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);
}