Linux多執行緒編程鎖詳解：如何避免競爭與死鎖-Linux-PHP中文網

在Linux多執行緒程式設計中，鎖是一種非常重要的機制，可以避免執行緒間的競爭和死鎖。然而，如果不正確使用鎖，可能會導致效能下降和不穩定的行為。本文將介紹Linux中常見的鎖定類型，如何正確使用它們，以及如何避免競爭和死鎖等問題。

在程式設計中，引入了物件互斥鎖的概念，來保證共享資料操作的完整性。每個物件都對應到一個可稱為” 互斥鎖” 的標記，這個標記用來保證在任一時刻，只能有一個執行緒存取該物件。 Linux實現的互斥鎖機制包括POSIX互斥鎖和核心互斥鎖，本文主要講POSIX互斥鎖，即線程間互斥鎖。

信號量用在多線程多任務同步的，一個線程完成了某一個動作就透過信號量告訴別的線程，別的線程再進行某些動作(大家都在sem_wait的時候，就阻塞在那裡)。而互斥鎖是用在多執行緒多任務互斥的，一個執行緒佔用了某一個資源，那麼別的執行緒就無法訪問，直到這個執行緒unlock，其他的執行緒才開始可以利用這個資源。例如對全域變數的訪問，有時要加鎖，操作完了，在解鎖。有的時候鎖和信號量會同時使用的”

也就是說，信號量不一定是鎖定某一個資源，而是流程上的概念，例如：有A,B兩個線程，B線程要等A線程完成某一任務以後再進行自己下面的步驟，這個任務不一定是鎖定某一資源，還可以是進行一些計算或資料處理之類。而執行緒互斥量則是「鎖住某一資源」的概念，在鎖定期間內，其他執行緒無法對被保護的資料進行操作。在有些情況下兩者可以互換。

兩者之間的差異:

作用域

信號量 : 進程間或執行緒間(linux僅執行緒間)

互斥鎖 : 執行緒間

上鎖時

#信號量 : 只要信號量的value大於0，其他執行緒就可以sem_wait成功，成功後訊號量的value減一。若value值不大於0，則sem_wait阻塞，直到sem_post釋放後value值加一。一句話，信號量的value>=0 。

互斥鎖 : 只要被鎖住，其他任何執行緒都不可以存取被保護的資源。如果沒有鎖，獲得資源成功，否則進行阻塞等待資源可用。一句話，線程互斥鎖的vlaue可以是負數。

多執行緒

執行緒是電腦中獨立運作的最小單位，執行時間佔用很少的系統資源。與多進程相比，多進程具有多進程不具備的一些優點，其最重要的是：對於多執行緒來說，其能夠比多進程更加節省資源。

執行緒建立

在Linux中，新建的執行緒並不是在原先的進程中，而是系統透過一個系統呼叫clone()。這個系統copy了一個和原先行程完全一樣的行程，並且在這個行程中執行執行緒函數。

在Linux中，透過函數pthread_create()函數實作執行緒的建立：

pthread_create()

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*st

登入後複製

其中：

thread表示的是一個pthread_t類型的指標;

attr用於指定線程的一些屬性;

start_routine表示的是一個函數指針，該函數是線程呼叫函數;

arg表示的是傳遞給執行緒呼叫函數的參數。

當執行緒建立成功時，函數pthread_create()傳回0，若回傳值不為0則表示建立執行緒失敗。對於執行緒的屬性，則在結構體pthread_attr_t中定義。

線程創建的過程如下所示：

#include  
#include  
#include  
#include  
 
void* thread(void *id){ 
   pthread_t newthid; 
 
   newthid = pthread_self(); 
   printf("this is a new thread, thread ID is %u\n", newthid); 
   return NULL; 
} 
 
int main(){ 
 int num_thread = 5; 
 pthread_t *pt = (pthread_t *)malloc(sizeof(pthread_t) * num_thread); 
 
 printf("main thread, ID is %u\n", pthread_self()); 
 for (int i = 0; i if (pthread_create(&pt[i], NULL, thread, NULL) != 0){ 
          printf("thread create failed!\n"); 
          return 1; 
       } 
 } 
 sleep(2); 
 free(pt); 
 return 0; 
}

登入後複製

在上述程式碼中，使用到了pthread_self()函數，該函數的作用是取得本線程的線程ID。在主函數中的sleep()用於將主進程處於等待狀態，以讓執行緒執行完成。最終的執行效果如下圖所示：

那麼，如何利用arg向子執行緒傳遞參數呢?其具體的實作如下所示：

#include  
#include  
#include  
#include  
 
void* thread(void *id){ 
  pthread_t newthid; 
 
  newthid = pthread_self(); 
  int num = *(int *)id; 
  printf("this is a new thread, thread ID is %u,id:%d\n", newthid, num); 
  return NULL; 
} 

int main(){ 
  //pthread_t thid; 
  int num_thread = 5; 
  pthread_t *pt = (pthread_t *)malloc(sizeof(pthread_t) * num_thread); 
  int * id = (int *)malloc(sizeof(int) * num_thread); 
 
  printf("main thread, ID is %u\n", pthread_self()); 
  for (int i = 0; i if (pthread_create(&pt[i], NULL, thread, &id[i]) != 0){ 
        printf("thread create failed!\n"); 
        return 1; 
     } 
  } 
  sleep(2); 
  free(pt); 
  free(id); 
  return 0; 
}

登入後複製

其最終的執行效果如下圖所示：

如果在主流程提前結束，會出現什麼情況呢?如下述的程式碼：

#include  
#include  
#include  
#include  
 
void* thread(void *id){ 
  pthread_t newthid; 
 
  newthid = pthread_self(); 
  int num = *(int *)id; 
  printf("this is a new thread, thread ID is %u,id:%d\n", newthid, num); 
  sleep(2); 
  printf("thread %u is done!\n", newthid); 
  return NULL; 
} 
 
int main(){ 
  //pthread_t thid; 
int num_thread = 5; 
  pthread_t *pt = (pthread_t *)malloc(sizeof(pthread_t) * num_thread); 
  int * id = (int *)malloc(sizeof(int) * num_thread); 
 
  printf("main thread, ID is %u\n", pthread_self()); 
  for (int i = 0; i if (pthread_create(&pt[i], NULL, thread, &id[i]) != 0){ 
        printf("thread create failed!\n"); 
        return 1; 
     } 
   } 
   //sleep(2); 
   free(pt); 
   free(id); 
   return 0; 
}

登入後複製

此時，主程序提前結束，程序會將資源回收，此時，執行緒都會退出執行，運行結果如下所示：

執行緒掛起

在上述的實作過程中，為了讓主執行緒能夠等待每一個子執行緒執行完成後再退出，使用了free()函數，在Linux的多執行緒中，也可以使用pthread_join()函數用於等待其他線程，函數的具體形式為：

int pthread_join(pthread_t thread, void **retval);

登入後複製

函數pthread_join()用來等待一個執行緒的結束，其呼叫這將被掛起。

一个线程仅允许一个线程使用pthread_join()等待它的终止。

如需要在主线程中等待每一个子线程的结束，如下述代码所示：

#include  
#include  
#include  
#include  
 
void* thread(void *id){ 
  pthread_t newthid; 
 
  newthid = pthread_self(); 
  int num = *(int *)id; 
  printf("this is a new thread, thread ID is %u,id:%d\n", newthid, num); 
 
  printf("thread %u is done\n", newthid); 
  return NULL; 
} 
int main(){ 
   int num_thread = 5; 
   pthread_t *pt = (pthread_t *)malloc(sizeof(pthread_t) * num_thread); 
   int * id = (int *)malloc(sizeof(int) * num_thread); 
 
   printf("main thread, ID is %u\n", pthread_self()); 
   for (int i = 0; i if (pthread_create(&pt[i], NULL, thread, &id[i]) != 0){ 
         printf("thread create failed!\n"); 
         return 1; 
       } 
   } 
   for (int i = 0; i return 0; 
}

登入後複製

最终的执行效果如下所示：

注：在编译的时候需要链接libpthread.a：

g++ xx.c -lpthread -o xx

互斥锁mutex

多线程的问题引入

多线程的最大的特点是资源的共享，但是，当多个线程同时去操作(同时去改变)一个临界资源时，会破坏临界资源。如利用多线程同时写一个文件：

#include  
#include  
 
const char filename[] = "hello"; 
 
void* thread(void *id){ 
  int num = *(int *)id; 
 
  // 写文件的操作 
  FILE *fp = fopen(filename, "a+"); 
  int start = *((int *)id); 
  int end = start + 1; 
  setbuf(fp, NULL);// 设置缓冲区的大小 
  fprintf(stdout, "%d\n", start); 
  for (int i = (start * 10); i "%d\t", i); 
  } 
  fprintf(fp, "\n"); 
  fclose(fp); 
  return NULL; 
} 
 
int main(){ 
   int num_thread = 5; 
   pthread_t *pt = (pthread_t *)malloc(sizeof(pthread_t) * num_thread); 
   int * id = (int *)malloc(sizeof(int) * num_thread); 
 
   for (int i = 0; i if (pthread_create(&pt[i], NULL, thread, &id[i]) != 0){ 
         printf("thread create failed!\n"); 
         return 1; 
         } 
   } 
   for (int i = 0; i return 0; 
}

登入後複製

执行以上的代码，我们会发现，得到的结果是混乱的，出现上述的最主要的原因是，我们在编写多线程代码的过程中，每一个线程都尝试去写同一个文件，这样便出现了上述的问题，这便是共享资源的同步问题，在Linux编程中，线程同步的处理方法包括：信号量，互斥锁和条件变量。

互斥锁

互斥锁是通过锁的机制来实现线程间的同步问题。互斥锁的基本流程为：

初始化一个互斥锁：pthread_mutex_init()函数

加锁：pthread_mutex_lock()函数或者pthread_mutex_trylock()函数

对共享资源的操作

解锁：pthread_mutex_unlock()函数

注销互斥锁：pthread_mutex_destory()函数

其中，在加锁过程中，pthread_mutex_lock()函数和pthread_mutex_trylock()函数的过程略有不同：

当使用pthread_mutex_lock()函数进行加锁时，若此时已经被锁，则尝试加锁的线程会被阻塞，直到互斥锁被其他线程释放，当pthread_mutex_lock()函数有返回值时，说明加锁成功;

而使用pthread_mutex_trylock()函数进行加锁时，若此时已经被锁，则会返回EBUSY的错误码。

同时，解锁的过程中，也需要满足两个条件：

解锁前，互斥锁必须处于锁定状态;

必须由加锁的线程进行解锁。

当互斥锁使用完成后，必须进行清除。

有了以上的准备，我们重新实现上述的多线程写操作，其实现代码如下所示：

#include  
#include  
 
pthread_mutex_t mutex; 
 
const char filename[] = "hello"; 
 
void* thread(void *id){ 
 
   int num = *(int *)id; 
   // 加锁 
 
   if (pthread_mutex_lock(&mutex) != 0){ 
     fprintf(stdout, "lock error!\n"); 
   } 
   // 写文件的操作 
   FILE *fp = fopen(filename, "a+"); 
   int start = *((int *)id); 
   int end = start + 1; 
   setbuf(fp, NULL);// 设置缓冲区的大小 
fprintf(stdout, "%d\n", start); 
   for (int i = (start * 10); i "%d\t", i); 
   } 
   fprintf(fp, "\n"); 
   fclose(fp); 
 
   // 解锁 
   pthread_mutex_unlock(&mutex); 
   return NULL; 
} 
 
int main(){ 
   int num_thread = 5; 
   pthread_t *pt = (pthread_t *)malloc(sizeof(pthread_t) * num_thread); 
   int * id = (int *)malloc(sizeof(int) * num_thread); 
 // 初始化互斥锁 
   if (pthread_mutex_init(&mutex, NULL) != 0){ 
     // 互斥锁初始化失败 
     free(pt); 
     free(id); 
     return 1; 
   } 
   for (int i = 0; i if (pthread_create(&pt[i], NULL, thread, &id[i]) != 0){ 
         printf("thread create failed!\n"); 
         return 1; 
      } 
   } 
   for (int i = 0; i return 0; 
}

登入後複製

最终的结果为：