第9章 线程编程（4）_线程同步1：互斥锁

5. 线程的互斥和同步

5.1 同步和互斥的概念

（1）线程同步：是一个宏观概念，在微观上包含线程的相互排斥和线程的先后执行的约束问题。解决同步方式一般采用条件变量和信号量。

（2）线程互斥：线程执行的相互排斥（注意，它不关心线程间执行的先后顺序！）。解决互斥一般使用互斥锁、读写锁和信号量。

【编程实验】银行ATM（线程不安全的例子）

//account.h

#ifndef __ACCOUNT_H__
#define __ACCOUNT_H__

typedef struct
{
    int      code;    //帐号
    double   balance; //余额
}Account;

//创建账户
extern Account* create_account(int code, double balance);
//销毁帐户
extern void destroy_account(Account* a);
//取款
extern double withdraw(Account* a, double amt); //amt == amount
//存款
extern double deposit(Account* a, double amt);
//查看帐户余额
extern double get_balance(Account* a);

#endif  //__ACCOUNT_H__

//account.c

#include "account.h"
#include <malloc.h>
#include <string.h>
#include <assert.h>

//创建账户
Account* create_account(int code, double balance)
{
    Account* ret = (Account*)malloc(sizeof(Account));
    assert(ret != NULL);

    ret->code = code;
    ret->balance = balance;

    return ret;
}

//销毁帐户
void destroy_account(Account* a)
{
    assert( a != NULL);

    free(a);
}

//取款
double withdraw(Account* a, double amt) //amt == amount
{
    assert(a != NULL);

    if((amt < 0) || (amt > a->balance)){
        return 0.0;
    }

    double balance = a->balance; //先取余额

    sleep(1); //为模拟多线程下可能出现的问题

    balance -= amt;
    a->balance = balance; //更新余额。在读取余额和更新余额之间有
                          //故意留出“时间窗口”。

    return amt;    
}

//存款
double deposit(Account* a, double amt)
{
    assert(a != NULL);

    if(amt < 0){
        return 0.0;
    }

    double balance = a->balance; //先取余额

    sleep(1); //为模拟多线程下可能出现的问题

    balance += amt;
    a->balance = balance; //更新余额。

    return amt;    
}

//查看帐户余额
double get_balance(Account* a)
{
    assert(a != NULL);

    double balance = a->balance;

    return balance;
}

//account_test.c

#include "account.h"
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
//#include <string.h> //for strcpy

typedef struct
{
    char name[20];
    Account* account;
    double amt;
}OperArg;

//定义取款操作的线程函数
void* withdraw_fn(void* arg)
{
    OperArg* oa = (OperArg*)arg;
   
    double amt = withdraw(oa->account, oa->amt);
    printf("%s(0x%lx) withdraw %f from account(%d)
", 
              oa->name,pthread_self(), amt, oa->account->code);

    return (void*)0;
}

//定义存款操作的线程函数
void* deposit_fn(void* arg)
{
    OperArg* oa = (OperArg*)arg;
    
    double amt = deposit(oa->account, oa->amt);
    printf("%s(0x%lx) deposit %f from account(%d)
", 
              oa->name,pthread_self(), amt, oa->account->code);

    return (void*)0;
}

int main(void)
{
    int err = 0;
    pthread_t boy, girl;

    Account* a = create_account(100001, 10000);
    OperArg o1 = {"boy",  a, 10000}; //strcpy(o1.name, "boy");
    OperArg o2 = {"girl", a, 10000};
    
    //启动两个子线程（boy和girl线程）同时去操作同一个银行帐户
    if((err = pthread_create(&boy, NULL, withdraw_fn, (void*)&o1)) != 0){
        perror("pthread_create error");
    }

    if((err = pthread_create(&girl, NULL, withdraw_fn, (void*)&o2)) != 0){
        perror("pthread_create error");
    }
    
    pthread_join(boy, NULL);
    pthread_join(girl, NULL);

    //查看余额
    printf("account balance: %f
", get_balance(a));
    
    destroy_account(a);
    
    return 0;
}
/*输出结果：
 [root@bogon]# bin/account_test
 girl(0xb6d5eb70) withdraw 10000.000000 from account(100001)
 boy(0xb775fb70) withdraw 10000.000000 from account(100001) //错误，余额共1万，但取了2万
 account balance: 0.000000
 */

5.2 互斥锁

5.2.1 互斥锁简介

（1）互斥锁（mutex）是用一种简单的加锁方法来控制对共享资源的访问。在同一时刻只能有一个线程拥有某个互斥锁，拥有上锁状态的线程能够对共享资源进行访问。若其他线程希望上锁一个己经被上了互斥锁的资源，则该线程挂起，直到上锁的线程释放互斥锁为止。

（2）互斥锁数据类型：pthread_mutex_t

5.2.2 互斥锁的使用

（1）创建和销毁互斥锁

头文件	#include <pthread.h>
函数	int pthread_mutex_init(pthread_mutex_t* mutex, const pthread_mutex_attr_t* mutex); int pthread_mutex_destroy(pthread_mutex_t* mutex);
返回值	成功返回0，否则返回错误编号
参数	（1）mutex：互斥锁 （2）mutexattr：互斥锁创建方式 　　①PTHREAD_MUTEX_INITIALIZER：创建快速互斥锁 　　②PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP：创建递归互斥锁 　　③PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP：创建检错互斥锁

（2）上锁和解锁

头文件	#include <pthread.h>
函数	int pthread_mutex_lock(pthread_mutex_t* mutex); //上锁，拿不到锁阻塞 int pthread_mutex_trylock(pthread_mutex_t* mutex); //上锁，拿不到锁返回出错信息 int pthread_mutex_unlock(pthread_mutex_t* mutex);//释放锁
返回值	成功返回0，否则返回错误编号
参数	mutex：互斥锁

【编程实验】银行帐号ATM（利用互斥锁实现线程安全的操作）

//account.h

#ifndef __ACCOUNT_H__
#define __ACCOUNT_H__
#include <pthread.h>

typedef struct
{
    int      code;    //帐号
    double   balance; //余额

    //使用互斥锁，用来对多线程操作的银行帐户（共享资源）进行加锁保护。
    /*
     *建议互斥锁和一个帐户绑定。尽量不设置成全局变量，否则可能出现用一
     *个锁去锁定多个帐户，从而导致并发性能降低。
     */
    pthread_mutex_t mutex;
}Account;

//创建账户
extern Account* create_account(int code, double balance);
//销毁帐户
extern void destroy_account(Account* a);
//取款
extern double withdraw(Account* a, double amt); //amt == amount
//存款
extern double deposit(Account* a, double amt);
//查看帐户余额
extern double get_balance(Account* a);

#endif  //__ACCOUNT_H__

//account.c

#include "account.h"
#include <malloc.h>
#include <string.h>
#include <assert.h>

//创建账户
Account* create_account(int code, double balance)
{
    Account* ret = (Account*)malloc(sizeof(Account));
    assert(ret != NULL);

    ret->code = code;
    ret->balance = balance;
    
    //对互斥锁进行初始化
    pthread_mutex_init(&ret->mutex, NULL);
 
    return ret;
}

//销毁帐户
void destroy_account(Account* a)
{
    assert( a != NULL);
    
    //销毁互斥锁
    pthread_mutex_destroy(&a->mutex);

    free(a);
}

//取款
double withdraw(Account* a, double amt) //amt == amount
{
    assert(a != NULL);

    pthread_mutex_lock(&a->mutex); //对共享资源加锁

    if((amt < 0) || (amt > a->balance)){
        //释放互斥锁
        pthread_mutex_unlock(&a->mutex);
        return 0.0;
    }

    double balance = a->balance; //先取余额

    sleep(1); //为模拟多线程下可能出现的问题

    balance -= amt;
    a->balance = balance; //更新余额。在读取余额和更新余额之间有
                          //故意留出“时间窗口”。
    
    pthread_mutex_unlock(&a->mutex);
    return amt;    
}

//存款
double deposit(Account* a, double amt)
{
    assert(a != NULL);

    if(amt < 0){
        return 0.0;
    }
    
    pthread_mutex_lock(&a->mutex);

    double balance = a->balance; //先取余额

    sleep(1); //为模拟多线程下可能出现的问题

    balance += amt;
    a->balance = balance; //更新余额。
    
    pthread_mutex_unlock(&a->mutex);
    return amt;    
}

//查看帐户余额
double get_balance(Account* a)
{
    assert(a != NULL);

    pthread_mutex_lock(&a->mutex);
    double balance = a->balance;
    pthread_mutex_unlock(&a->mutex);

    return balance;
}

//account_test.c

#include "account.h"
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
//#include <string.h> //for strcpy

typedef struct
{
    char name[20];
    Account* account;
    double amt;
}OperArg;

//定义取款操作的线程函数
void* withdraw_fn(void* arg)
{
    OperArg* oa = (OperArg*)arg;
   
    double amt = withdraw(oa->account, oa->amt);
    printf("%s(0x%lx) withdraw %f from account(%d)
", 
              oa->name,pthread_self(), amt, oa->account->code);

    return (void*)0;
}

//定义存款操作的线程函数
void* deposit_fn(void* arg)
{
    OperArg* oa = (OperArg*)arg;
    
    double amt = deposit(oa->account, oa->amt);
    printf("%s(0x%lx) deposit %f from account(%d)
", 
              oa->name,pthread_self(), amt, oa->account->code);

    return (void*)0;
}

int main(void)
{
    int err = 0;
    pthread_t boy, girl;

    Account* a = create_account(100001, 10000);
    OperArg o1 = {"boy",  a, 10000}; //strcpy(o1.name, "boy");
    OperArg o2 = {"girl", a, 10000};
    
    //启动两个子线程（boy和girl线程）同时去操作同一个银行帐户
    if((err = pthread_create(&boy, NULL, withdraw_fn, (void*)&o1)) != 0){
        perror("pthread_create error");
    }

    if((err = pthread_create(&girl, NULL, withdraw_fn, (void*)&o2)) != 0){
        perror("pthread_create error");
    }
    
    pthread_join(boy, NULL);
    pthread_join(girl, NULL);

    //查看余额
    printf("account balance: %f
", get_balance(a));
    
    destroy_account(a);
    
    return 0;
}

5.2.3 互斥锁的属性

（1）互斥锁属性的创建和销毁

头文件	#include <pthread.h>
函数	int pthread_mutexattr_init(pthread_mutexattr_t* attr); int pthread_mutexattr_destroy(pthread_mutexattr_t* attr);
返回值	成功返回0，否则返回错误编号
参数	attr：互斥锁属性

（2）互斥锁的进程共享属性

头文件	#include <pthread.h>
函数	int pthread_mutexattr_getpshared(const pthread_mutexattr_t* attr, int* pshared);//获取互斥锁的共享属性，结果存在入pshared中 int pthread_mutexattr_setpshared(pthread_mutexattr_t* attr, int pshared); //设置互斥锁的进程共享属性
返回值	成功返回0，否则返回错误编号
参数	（1）attr：互斥锁属性 （2）pshared：进程共享属性： 　　①PTHREAD_PROCESS_PRIVATE(默认情况)：锁只能用于一个进程内部的两个线程进行互斥 　　②PTHREAD_PROCESS_SHARED：可用于两个不同进程中的线程进行互斥

（3）互斥锁的类型

头文件	#include <pthread.h>
函数	int pthread_mutexattr_gettype(const pthread_mutexattr_t* attr, int* type);//获取互斥锁的类型，结果存在入type中 int pthread_mutexattr_settype(pthread_mutexattr_t* attr, int type); //设置互斥锁的类型
返回值	成功返回0，否则返回错误编号
参数	（1）attr：互斥锁属性 （2）type：互斥锁的类型： 　　①标准互斥锁：PTHREAD_MUTEX_NORMAL：第1次上锁成功，第2次上锁会阻塞。 　　②递归互斥锁：PTHREAD_MUTEX_RECURSIVE：第1次上锁成功，第2次以后上锁还是成功，内部计数。 　　③检错互斥锁：PTHREAD_MUTEX_ERRORCHECK:第1次上锁成功，第2次上锁会出错。 　　④默认互斥锁：PROCESS_MUTEX_DEFAULT：（同标准互斥锁）

【编程实验】不同类型的互斥锁

//lock_type.c

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/*不同互斥锁的多次上锁操作*/

int main(int argc, char* argv[])
{
    pthread_mutex_t  mutex;
    
    if(argc < 2){
        printf("-usage: %s [error|normal|recursive]
", argv[0]);
        exit(1);
    }

    //定义互斥锁属性
    pthread_mutexattr_t mutexattr;
    //初始化互斥锁属性
    pthread_mutexattr_init(&mutexattr);
    
    if(!strcmp(argv[1], "error")){
        //设置互斥锁类型
        pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_ERRORCHECK);
    }else if(!strcmp(argv[1], "normal")){
        pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_NORMAL);
    }else if(!strcmp(argv[1], "recursive")){
        pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_RECURSIVE);
    }

    //初始化互斥锁
    pthread_mutex_init(&mutex, &mutexattr);
    //第1次上锁
    if(pthread_mutex_lock(&mutex) != 0){
        printf("first lock failure
");
    }else{
        printf("first lock success
");
    }

    //第2次上锁
    if(pthread_mutex_lock(&mutex) != 0){
        printf("second lock failure
");
    }else{
        printf("second lock success
");
    }

    pthread_mutex_unlock(&mutex);
    pthread_mutex_unlock(&mutex);

    pthread_mutexattr_destroy(&mutexattr);
    pthread_mutex_destroy(&mutex);

    return 0;
}
/*输出结果：
[root@bogon]# bin/lock_type error  //检错互斥锁  
first lock success
second lock failure
[root@bogon]# bin/lock_type recursive //递归互斥锁
first lock success
second lock success
[root@bogon]# bin/lock_type normal   //标准互斥锁
first lock success
^C                     //阻塞
[root@bogon]# 
*/