线程安全--互斥

线程互斥

相关概念：

• 临界资源：多线程执行流共享的资源就叫做临界资源

• 临界区：每个线程内部，访问临界区的代码，就叫做临界区

• 互斥：任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用

• 原子性：不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成

 

互斥量：

    大部分情况，线程使用的数据都是线程自己局部存储的变量，变量的地址空间在该线程栈空间内，这种情况，变量归属单个线程，其他线程无法获得这种变量。

    但有时候，很多变量都需要在线程间共享，这样的变量称为共享变量，可以通过数据的共享，完成线程之间的交互。

多个线程并发的操作共享变量带来的问题：

// 操作共享变量从而导致的线程安全问题
// 售票系统
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>

// 模拟售票
int ticket = 100;      

void* route(void* args) {
    char* id = (char*)args;
    while (1) {
        if (ticket > 0) {
            usleep(1000);
            printf("%s purchase a ticket, remain's tickets: %d\n", id, ticket);
            --ticket;        // 非原子性操作，多个线程并发执行可能会出错
        }
        else {
            printf("no ticket!\n");
            break;
        }
    }
    return NULL;
}
int main(){
    pthread_t tid[4];
    pthread_create(&tid[0], NULL, route, (void*)"thread 1");
    pthread_create(&tid[1], NULL, route, (void*)"thread 2");
    pthread_create(&tid[2], NULL, route, (void*)"thread 3");
    pthread_create(&tid[3], NULL, route, (void*)"thread 4");
    pthread_join(tid[0], NULL);
    pthread_join(tid[1], NULL);
    pthread_join(tid[2], NULL);
    pthread_join(tid[3], NULL);
    return 0;
}

// 存在问题：
if 语句判断条件为真以后，代码可以并发的切换到其他线程
usleep 这个模拟漫长业务的过程，在这个漫长的业务过程中，可能有很多个线程会进入该代码段
--ticket 操作本身就不是一个原子操作
->ticket 操作对应三条汇编指令：
    load ：将共享变量ticket从内存加载到寄存器中
    update : 更新寄存器里面的值，执行-1操作
    store ：将新值，从寄存器写回共享变量ticket的内存地址

解决共享变量安全办法：

•     代码必须要有互斥行为：当代码进入临界区执行时，不允许其他线程进入该临界区。

•     如果多个线程同时要求执行临界区的代码，并且临界区没有线程在执行，那么只能允许一个线程进入该临界区。

•     如果线程不在临界区中执行，那么该线程不能阻止其他线程进入临界区

互斥量的初始化：

// 1.静态分配
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;        // 使用 PTHREAD_ MUTEX_ INITIALIZER 初始化的互斥量不需要销毁
    
// 2.动态分配
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t* restrict attr);
    mutex “要初始化的互斥量”
    attr “通常置 NULL”


销毁互斥量：
1.不要销毁一个已经加锁的互斥量
2.已经销毁的互斥量，要确保后面不会有线程再尝试加锁

int pthread_mutex_destroy(pthread_mutex_t *mutex);



互斥量的使用：
1.互斥量处于未锁状态，该函数会将互斥量锁定，同时返回成功
2.发起函数调用时，其他线程已经锁定互斥量，或者存在其他线程同时申请互斥量，但没有竞争到互斥量，那么pthread_ lock调用会陷入阻塞(执行流被挂起)，等待互斥量解锁。


//   加锁
int pthread_mutex_lock(pthread_mutex_t* mutex);    // 做阻塞加锁，加不上阻塞
int pthread_mutex_trylock(pthread_mutex_t* mutex)    // 非阻塞加锁，加不上报错返回
pthread_mutex_timelock();                        // 限时的阻塞加锁

// 解锁
int pthread_mutex_unlock(pthread_mutex_t* mutex);
返回值:成功返回0,失败返回错误号

加互斥锁之后的购票系统

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
int ticket = 1000;
pthread_mutex_t mutex;    // 定义互斥锁变量
void* route(void* args) {        
    while (1) {        
        pthread_mutex_lock(&mutex);    // 加锁        
        if (ticket > 0) {            
            usleep(1000);            
            printf("%d purchase a ticket, remain's tickets: %d\n",  (long)args, ticket);                        
            --ticket;            
            pthread_mutex_unlock(&mutex);    // 解锁        
        }        
        else {            
            printf("no ticket, eixt\n");            
            pthread_mutex_unlock(&mutex);    // 解锁            
            pthread_exit(NULL);        
        }    
   }    
    return NULL;
}

int main(){    
    pthread_t tid[4];    
    pthread_mutex_init(&mutex, NULL);         // 初始化互斥量    
    int ret;    
    for (int i = 0; i < 4; ++i) {        
        ret = pthread_create(&tid[i], NULL, route, (void*)((long)i));        
            if (ret != 0) {            
                printf("create error\n");            
                return -1;        
            }    
        }    
    for (int i = 0; i < 4; ++i) {        
        pthread_join(tid[i], NULL);    
    }    
    pthread_mutex_destroy(&mutex);            // 销毁互斥量    
    return 0;
}