多執行緒共享變數會涉及到資料的安全問題。

驗證測試程式如下，兩個執行緒共同對一個（非全域性）變數操作，根據初始列印可知地址一樣，非全域性。

#include <stdio.h>
#include <pthread.h>
static pthread_t thread_a_id;
static pthread_t thread_b_id;
void *printA(void *pA)
{
        printf("%p!\n",pA);
        int *p = pA;
        while(1)
        {
                *p = 2;
                if(5 == *p)
                {
                        printf("=============\n");
                }
        }
        return NULL;
}
void *changeA(void *pA)
{
        printf("%p!\n",pA);
        int *p = pA;
        while(1){
                *p = 5;
        }      
        return NULL;
}
int main()
{

        int a;
        a = 1;
        int iRet = 0;
        iRet = pthread_create(&thread_a_id,NULL,printA,&a);
        if(iRet != 0)
        {
                printf("create failed!\n");
        }

        iRet = pthread_create(&thread_b_id,NULL,changeA,&a);
        if(iRet != 0)
        {
                printf("create failed!\n");
        }

        while(1)
{
        sleep(5);
}


}
 

執行結果：

=============
=============
=============
=============
=============
=============

證明執行緒間資料被互相篡改，不安全。

執行緒b就不列印了，肯定也會遇到a被改成2的情況。（為了演示更全面，下邊的例子會把a和b執行緒改對等）

解決思路

我目前所用的，通常是資料加鎖和變數不共享兩種思路，但是資料不共享很侷限，不能滿足很多需求，比如多執行緒需要共同維護一個使用者雜湊表。

所以就需要給資料加鎖。

手動加（實際上簡陋、不可用的爛）鎖：

#include <stdio.h>
#include <pthread.h>
static pthread_t thread_a_id;
static pthread_t thread_b_id;
static int i = 0;

void *printA(void *pA)
{
        printf("%p!\n",pA);
        int *p = pA;
        while(1)
        {
                if(i == 0)
                {
                        i = 1;//lock
                        *p = 2;
                        if(5 == *p)
                        {
                                printf("=============\n");
                        }
                        i = 0;//unlock

                }
        }
        return NULL;
}
void *changeA(void *pA)
{
        printf("%p!\n",pA);
        int *p = pA;
        while(1){
                if(i == 0)
                {
                        i = 1;//lock
                        *p = 5;
                        if(2 == *p)
                        {
                                printf("*************\n");
                        }
                        i = 0;//unlock
                }
        }
        return NULL;
}
int main()
{
        int a;
        a = 1;
        int iRet = 0;
        iRet = pthread_create(&thread_a_id,NULL,printA,&a);
        if(iRet != 0)
        {
                printf("create failed!\n");
        }

        iRet = pthread_create(&thread_b_id,NULL,changeA,&a);
        if(iRet != 0)
        {
                printf("create failed!\n");
        }

        while(1)
        {
                sleep(5);
        }


}
 

=============
*************
=============
*************
*************
*************
=============
*************
*************
*************
*************
=============
*************
=============
=============
*************
*************
=============
=============
*************
*************
=============
=============
*************
=============
=============

這個程式證明了C語言的語句非原子操作，是可以分解成更多更細的指令的，不是一個真正意義上的原語，所以程式連死鎖的機會都沒有，各種亂跑。
PS：在所謂的lock操作i = 1;後加一個i等於0的判斷，就可以知道i也是發生變化的。

        while(1)
        {
                if(i == 0)
                {
                        i = 1;//lock
                        if(0 == i)
                        {
                                printf("..............\n");
                        }
                        *p = 2;
                        if(5 == *p)
                        {
                                printf("=============\n");
                        }
                        i = 0;//unlock

                }
        }

手動設的普通變數解決不了安全性問題，怎麼辦？其實，pthread庫裡是自帶方法了。應該是執行緒鎖吧，有指定的變數pthread_mutex_t和指定操作pthread_mutex_lock()、pthread_mutex_unlock()

#include <stdio.h>
#include <pthread.h>
static pthread_t thread_a_id;
static pthread_t thread_b_id;
static int i = 0;
static pthread_mutex_t sMux;
void *printA(void *pA)
{
        printf("%p!\n",pA);
        int *p = pA;
        while(1)
        {
                pthread_mutex_lock(&(sMux));//lock
                *p = 2;
                if(5 == *p)
                {
                        printf("=============\n");
                }

                pthread_mutex_unlock(&(sMux));//unlock
        }
        return NULL;
}
void *changeA(void *pA)
{
        printf("%p!\n",pA);
        int *p = pA;
        while(1){
                pthread_mutex_lock(&(sMux));//lock
                *p = 5;
                if(2 == *p)
                {
                        printf("*************\n");
                }

                pthread_mutex_unlock(&(sMux));//unlock
        }
        return NULL;
}
int main()
{
        int a;
        a = 1;
        int iRet = 0;
        iRet = pthread_create(&thread_a_id,NULL,printA,&a);
        if(iRet != 0)
        {
                printf("create failed!\n");
        }

        iRet = pthread_create(&thread_b_id,NULL,changeA,&a);
        if(iRet != 0)
        {
                printf("create failed!\n");
        }

        while(1)
        {
                sleep(5);
        }


}

[[email protected] multi_thread]# ./a.out
0xbfa82be8!
0xbfa82be8!

PS:一個執行緒鎖只能互斥保護一個臨界資源，這個臨界資源其實也不是固定的，全看lock在哪用，其實是一個鎖同時只能鎖一處資源。

很多不互斥使用的資源，如果用同一個鎖，肯定就尷尬了。這就好比你上鎖，把自己的鎖鎖到別人自行車上了，別人拿不了車。這是不想要的結果。

所以要給不同的臨界資源陪不同的鎖——多初始化一個鎖變數，用那個變數去加鎖解鎖就好了。

測試程式碼：

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/syscall.h>
#define gettid() syscall(__NR_gettid)
pthread_t thread1;
pthread_t thread2;
pthread_mutex_t lock1;
pthread_mutex_t lock2;

void* pThreadFunc(void * pMutex)
{
//先鎖
        pthread_mutex_lock((pthread_mutex_t *)pMutex);
        printf("the thread's id is %lu\n",gettid());
//再睡
        printf("lock,sleep\n");
        sleep(10);
        printf("sleep over,unlock,exit!\n");

        pthread_mutex_unlock((pthread_mutex_t *)pMutex);
        return NULL;
}
int main(){
        int iRet = 0;
        void * status;
//初始化執行緒鎖
        pthread_mutex_init(&lock1,NULL);
//先多執行緒
        iRet = pthread_create(&thread1, NULL, pThreadFunc, &lock1); //建立服務執行緒
        if(iRet != 0)
        {
                return iRet;
        }
        iRet = pthread_create(&thread2, NULL, pThreadFunc, &lock2); //建立服務執行緒
        if(iRet != 0)
        {
                return iRet;
        }

        pthread_join(thread1,&status);
        pthread_join(thread2,&status);
}

# ./a.out
the thread's id is 9475
lock,sleep
the thread's id is 9476
lock,sleep
sleep over,unlock,exit!
sleep over,unlock,exit!

# ps -efL | grep ./a.out
root      9474  8507  9474  0    3 22:28 pts/1    00:00:00 ./a.out
root      9474  8507  9475  0    3 22:28 pts/1    00:00:00 ./a.out
root      9474  8507  9476  0    3 22:28 pts/1    00:00:00 ./a.out
root      9479  9447  9479  2    1 22:28 pts/2    00:00:00 grep

# ./a.out
the thread's id is 9534
lock,sleep
sleep over,unlock,exit!
the thread's id is 9533
lock,sleep
sleep over,unlock,exit!