Linux多執行緒_(行程與執行緒，執行緒的生命周期認識執行緒，執行緒互斥)

多行程強調獨立但不是完全獨立，比如fork之后，行程間通信，
多執行緒強調共享但不是完全共享，他也要有自己私有的資料，

5. P-thread庫

P-thread庫采用prosix標準，是一個用戶級別庫

5.1 執行緒創建，pthread_create

Linux沒有關于執行緒的資料結構，所以沒有創建執行緒的介面，但是他有創建輕量級行程的介面，執行緒會與輕量級行程關聯起來，P-thread庫就是第三方提供的一套庫，所以鏈接的時候需要鏈接這個庫，

他為什么不加-i,-L，那些呢，因為他是在系統默認目錄下的，

而在用戶的庫，也要對這個執行緒先描述在組織，描述用結構體描述，組織用陣列

• 第一個引數是輸出型引數，無符號長整形，用戶級執行緒的id，作業系統是看不見的，屬于用戶級id，他和執行緒的地址數值相等
• 第二個引數是執行緒的屬性，
• 第三個引數是回傳值為void*，引數為void*的函式指標，
• 第四個引數是傳遞給函式指標的引數
• 回傳值為錯誤碼（傳統函式成功回傳0，失敗回傳-1）

#include<stdio.h>
#include<pthread.h>
#include<unistd.h>
void* thread_run(void *args)
{
  while(1)
  {
    printf("i am %s\n",(char*)args);
    sleep(1);
  }
}
int main()
{
  pthread_t tid;
  pthread_create(&tid,NULL,thread_run,(void*)"thread 1");

  while(1)
  {
    printf("i am main pthread\n");
    sleep(1);
  }
  return 0;
}

兩個回圈同時列印，因為有兩個執行流，其中main中的叫做主執行流，

當./運行這個程式的時候，記憶體中就有一個行程，兩個執行流，
加入getpid介面，返現他們的pid一致，

ps -aL,查看

lwp為輕量級行程，而一個輕量級行程呼叫一個執行緒，cpu調度是以他為基本單位，執行緒同屬于一個執行緒組（大行程），getpid回傳為執行緒組的pid，為所以作業系統就能區分你們是同一個行程的兩個執行流

5.2 獲取用戶級執行緒id，pthread_self

獲取自己用戶級的執行緒id

列印變數tid

5.3 執行緒終止，pthread_exit函式

5.3.1 行程終止的三種情況

需要注意的是
main函式中return相當于exit(),相當于終止行程，行程的地址空間都沒了，肯定都完蛋了，

但是主執行緒呼叫pthread_exit的話是不會影響別的執行緒的，

這兩種都是執行緒自己主動退出，

這種是通過pthread_cancel,可以別的執行緒通過你的用戶級執行緒id來終止執行緒，

5.4 執行緒等待，pthread_join

在主執行緒中等待create創建的執行緒，在thread 1 sleep的10s中，主執行緒一直在阻塞式等待，

5.4.1 為什么需要執行緒等待？

和行程類似，執行緒退出，沒有其他行程等待，也會造成類似僵尸行程一樣的結果，導致記憶體泄漏，所以需要等待，
其他行為和行程類似嗎？在之前學到，一個行程退出方式有三種，代碼運行完，結果正確，代碼運行完結果錯誤，行程例外終止，前兩個可以獲取退出碼，后一個可以可以查看退出信號，
那執行緒等待，也是一樣嗎，肯定不一樣，任意一個執行緒例外，整個行程直接結束，因為作業系統是向行程發信號的，
所以執行緒等待，只關心他的退出碼，也就是我們只關系執行緒退出時正確與否的退出碼，例外是不關心的，你一錯行程去背鍋，因為信號是給行程設計的，也側面說明了，雖然block表執行緒各自私有，pending表屬于整個行程，

5.4.2 執行緒等待的四種情況

執行緒終止有三種情況，那么對應的join等待也會得到3種不同的狀態，還有我們不關系他的狀態可以設定為NULL，

1. 如果thread執行緒通過return回傳,value_ ptr所指向的單元里存放的是thread執行緒函式的回傳值，
2. 如果thread執行緒被別的執行緒呼叫pthread_ cancel例外終掉,value_ ptr所指向的單元里存放的是常數PTHREAD_ CANCELED，他為(void*)-1，
3. 如果thread執行緒是自己呼叫pthread_exit終止的,value_ptr所指向的單元存放的是傳給pthread_exit的引數，
4. 如果對thread執行緒的終止狀態不感興趣,可以傳NULL給value_ ptr引數，

5.5 執行緒分離

可以自己把自己分離，

也可以別人將你分離

這種經過分離的執行緒就不需要在pthread_wait，在他結束后自動回收資源，

雖然分離！！但是執行緒例外也會影響其他執行緒，

6. 執行緒互斥

6.1 互斥引出

在執行緒中，子行程不修改這個資料時，資料只有一份與父行程共享，當修改時發生寫時拷貝將資料私有，這個兩個資料的虛擬地址一樣，但是虛擬地址空間不是一套，經過頁表轉換后的物理地址不同，

但在執行緒中，由于執行緒共享地址空間，此時代碼中a為全域變數，全域變數處于資料段不私有，所以他們即使修改了，也訪問的是同一個資料，

#include<stdio.h>
#include<pthread.h>
#include<unistd.h>
int a=10;
void* pthread_run(void* str)
{
  while(1)
  {
    sleep(1);
  printf("%s, %d\n",(char*)str,a);
  }
}

int main()
{
  pthread_t t1,t2,t3,t4;

  pthread_create(&t1,NULL,pthread_run,(void*)"mythread1");
  pthread_create(&t2,NULL,pthread_run,(void*)"mythread2");
  pthread_create(&t3,NULL,pthread_run,(void*)"mythread3");
  pthread_create(&t4,NULL,pthread_run,(void*)"mythread4");

  sleep(5);
  a=20;
  sleep(5);
  //前5s列印10，后5s列印20
  //
  //
  //寫上等待規范一點，實際上那個是死回圈，不退出，
  pthread_join(t1,NULL);
  pthread_join(t2,NULL);
  pthread_join(t3,NULL);
  pthread_join(t4,NULL);
  return 0;
}

一個地址空間，資料段沒有私有，看到同一個資料，虛擬記憶體，物理記憶體一致，
a就是一個臨界資源，printf是臨界區

• 臨界資源：多個執行流可能同時訪問的要有修改權限的資源叫臨界資源，（只讀權限的話不叫臨界資源)
• 臨界區：執行緒內部訪問臨界資源的代碼，叫做臨界區

在實際生活中是怎么搶票的呢？
當票大于0，用戶購買，票數–，當票數小于0，那么就wait等待重新放票，ticket叫做臨界資源，if與距離的就叫做臨界區，

ticket–，++,都不是原子性，因為它要經歷三個程序，對應三潭訓編指令，

load ：將共享變數ticket從記憶體加載到暫存器中
update : 更新暫存器里面的值，執行-1操作
store ：將新值，從暫存器寫回共享變數ticket的記憶體地址

在這三個程序當中，ticket肯定有未發生變化的程序，所以當另一個執行緒來訪問它的時候，就可能訪問的是未修改的值，就有可能多個用戶搶到一張票，甚至只剩一張票時,多個執行流對ticket>0，進行判斷時多個用戶拿到同一個最后一張票，因為ticket–并不是原子性的，
所謂原子性就是只有兩態，要么有，要么沒有，其實也可以有中間狀態，但是只要你不影響其他人，也可以認為你具有原子性，

我們可以模擬一個搶票的多執行緒程式，來看看

#include<stdio.h>
#include<pthread.h>
#include<unistd.h>
int ticket=100;

void* route(void* args)
{
  while(1)
  {
  usleep(1000);
  if(ticket>0)
  {
    ticket--;
    printf("thread %d get %d \n",(int)args,ticket);
  }
  else{
    break;
  }
  }
}
int main()
{
  pthread_t tid[4];

  int i=0;
  for( i=0;i<4;i++)
  {
    pthread_create(&tid[i],NULL,route,(void*)i);
  }
  int j=0;
  for(j=0;j<4;j++)
  {
    pthread_join(tid[j],NULL);
  }
  return 0;
}

由于非原子性，造成了搶票出現bug，
由于這三種情況導致的

1. if 陳述句判斷條件為真以后，代碼可以并發的切換到其他執行緒(多個cpu)
2. usleep 這個模擬漫長業務的程序，在這個漫長的業務程序中，可能有很多個執行緒會進入該代碼段
3. –ticket 操作本身就不是一個原子操作

本質上下面三種方法可以解決，

1. 代碼必須要有互斥行為：當代碼進入臨界區執行時，不允許其他執行緒進入該臨界區，
2. 如果多個執行緒同時要求執行臨界區的代碼，并且臨界區沒有執行緒在執行，那么只能允許一個執行緒進入該臨界區，
3. 如果執行緒不在臨界區中執行，那么該執行緒不能阻止其他執行緒進入臨界區，

6.2 鎖（互斥量）

要做到這三點，Linux提供了一把mutex鎖，叫做互斥量，鎖也有很多，pthread有對應的資料結構描述，組織，

6.2.1 創建鎖

要給執行緒加鎖，首先要讓他們看到同一把鎖

pthread_mutex_t lock;

6.2.2 初始化鎖

pthread_mutex_init(&lock,NULL);

6.2.3 加鎖與 解鎖

pthread_mutex_lock(&lock);
pthread_mutex_unlock(&lock);

6.2.4 銷毀鎖

pthread_mutex_t destory(&lock);

那么將剛才有問題的搶票代碼，修改加上鎖，

#include<stdio.h>
#include<pthread.h>
#include<unistd.h>
int ticket=100;

pthread_mutex_t lock;

void* route(void* args)
{
  while(1)
  {
  usleep(1000);
    pthread_mutex_lock(&lock); 
  if(ticket>0)
  {
    ticket--;
    printf("thread %d get %d \n",(int)args,ticket);
    pthread_mutex_unlock(&lock);
  }
  else
  {
    pthread_mutex_unlock(&lock);
    break;
  }
   //假如在這里解鎖，假如在之前break了，行程帶著鎖跑了，這個解鎖就不執行了，
  //pthread_mutex_unlock(&lock);
  }
}
int main()
{
  pthread_t tid[4];
  pthread_mutex_init(&lock,NULL);

  int i=0;
  for( i=0;i<4;i++)
  {
    pthread_create(&tid[i],NULL,route,(void*)i);
  }
  int j=0;
  for(j=0;j<4;j++)
  {
    pthread_join(tid[j],NULL);
  }
  
  pthread_mutex_destroy(&lock);
  
  return 0;
}

一切正常

1. 當這一把鎖保護了臨界區，意味著進來的所有執行緒都必須遵守規則，
2. 即先lock->訪問臨界區->unlock
3. 那么所有的行程都看到了這把鎖，鎖也是一種臨界資源，–不是原子性，所以要在外面加鎖，那么鎖就要保證不會出現中間態，那么他是怎么實作的呢？
4. 在一個執行緒，lock->訪問臨界區->unlock，訪問臨界區執行任務的時候，另一個執行緒來了，另一個執行緒申請鎖，沒有申請到，那么他就會阻塞等待，將執行緒pcb放到等待佇列中，假如鎖unlock，就把執行緒喚醒，從等待佇列拿出來，狀態設為R，之后調度器開始調度
5. mutex，實際是一個結構體 ，
   struct mutex
   {
   int lock;//0或1
   wait_queue *head;
   }
   加鎖代表由1變0，解鎖代表由0變1，

6.3 互斥鎖實作原理

lock:

當每個執行緒執行第一步時，由于執行緒的暫存器私有，互不影響

第二步
交換暫存器和mutex的值，那么此時來了其他執行緒會不會影響呢？
也是不會的，第二個執行緒來，執行第一條陳述句暫存器置為0，mutex并不私有，交換mutex的值，mutex的值此時為0，那么0和0交換，此時他為0，執行else于是掛起等待，在這個程序中和傳統的記憶體到暫存器不同，這里的是exchange交換，并不是傳統的拷貝，實際mutex為1的時候，只有一個行程會有，

然后申請到鎖的那個執行緒，切換回來執行if申請成功，

unlock:
能解鎖的一定是加過鎖的，能走到這個unlock的陳述句的代碼，一定只有一條，

這里暫存器的值為什么還是1呢，因為一把鎖只能申請一次，

6.4 可重入與執行緒安全

• 執行緒安全：多個執行緒并發同一段代碼時，不會出現不同的結果，常見對全域變數或者靜態變數進行操作，并且沒有鎖保護的情況下，會出現該問題，
• 重入：同一個函式被不同的執行流呼叫，當前一個流程還沒有執行完，就有其他的執行流再次進入，我們稱之為重入，一個函式在重入的情況下，運行結果不會出現任何不同或者任何問題，則該函式被稱為可重入函式，否則，是不可重入函式，

假如多個執行緒呼叫一個函式，導致出錯，那么這個函式叫做不可重入函式，發生的情況叫執行緒安全，

他們的情況也可以多了解，

6.5 死鎖

死鎖是指在一組行程中的各個行程均占有不會釋放的資源，但因互相申請被其他行程所站用不會釋放的資源而處于的一種永久等待狀態，

兩個執行緒，執行緒1，擁有1鎖申請2鎖，執行緒2擁有2鎖，申請1鎖，且雙方互不釋放鎖，

死鎖四個必要條件

互斥條件：一個資源每次只能被一個執行流使用
請求與保持條件：一個執行流因請求資源而阻塞時，對已獲得的資源保持不放
不剝奪條件:一個執行流已獲得的資源，在末使用完之前，不能強行剝奪
回圈等待條件:若干執行流之間形成一種頭尾相接的回圈等待資源的關系

產生死鎖，一定是由于著四個條件同時發生，破壞死鎖只需要破壞其中一個條件就好，

避免死鎖

• 破壞死鎖的四個必要條件
• 加鎖順序一致
• 避免鎖未釋放的場景
• 資源一次性分配

一個執行緒一把鎖，也可以產生死鎖，當你還未釋放時，再次申請鎖，由于鎖被自己拿著，沒有釋放，是申請不到的，一直被掛起，