2. 程式人生 > >Linux執行緒淺析[執行緒的同步和互斥之執行緒互斥鎖]

Linux執行緒淺析[執行緒的同步和互斥之執行緒互斥鎖]

阿新 • • 發佈：2019-01-31

Linux執行緒淺析[執行緒的同步和互斥]

  1. 執行緒同步
  2. 執行緒互斥
  3. 執行緒互斥的相關函式
  4. 執行緒同步的相關函式

執行緒同步

是巨集觀上的一個概念，在微觀上面包含執行緒的相互排斥和執行緒的執行順序的約束問題
解決方法：
    條件變數
    執行緒訊號量

例子：一棟大樓的建造，包含了質監局的檢驗和工程隊的施工，那麼假設質監局和工程隊是兩個執行緒，而大樓則為共享資源，首先相互排斥的原則為工程隊施工的時候，質監局是不能進行檢驗的，因為這個時候大樓還沒有建好，而質監局的檢驗依賴於工程隊施工的結果，所以質監局必須等待工程隊將大樓建造好．所以後一個執行緒依賴於前一個執行緒對共享資源操作的結果．所以說執行緒同步是包含了相互排斥和執行緒的執行順序．

執行緒互斥

執行緒的相互排斥
解決方法：
    互斥鎖
    讀寫鎖
    執行緒訊號量

　例子：
　一個公用廁所，假設只有一個坑，那麼很多人去上廁所的時候，後一個就必須等後一個上完廁所之後才能上廁所．所以同一時間只能有一個人上廁所．這就是互斥．其實在生活中有很多例子．如銀行賬戶的操作問題．１２３０６的售票問題等．都是互斥
　注意：同步包含了互斥，互斥僅僅只是相互排斥，而同步是互斥加順序

　先來一段有問題的程式碼：兩個執行緒同時去訪問同一個賬戶的問題：
　 account.h

/*
 * ===========================================================================
 *
 *       Filename:  account.h
 *    Description:  
 *        Version:  1.0
 *        Created:  2017年03月28日 22時04分18秒
 *       Revision:  none
 *       Compiler:  gcc
 *         Author:   (), 
 *        Company:  
 *
 * ===========================================================================
 */
 


#ifndef __ACCOUNT_H_
#define __ACCOUNT_H_
//宣告銀行賬戶的結構體
  typedef struct{
    int code;
    double balance;
  }Account;

//建立銀行賬戶
extern Account* create_account(int code,double balance);

//銷燬一個賬戶
extern void destory_account(Account* account);

//存款
extern double withdraw(Account* account,double amt);

//取款
extern
 
 double deposit(Account* a,double amt);

//檢視賬戶餘額
extern double get_balance(Account* account);

#endif

account.c

/*
 * ===========================================================================
 *
 *       Filename:  account.c
 *    Description:  
 *        Version:  1.0
 *        Created:  2017年03月30日 21時16分28秒
 *       Revision:  none
 *       Compiler:  gcc
 *         Author:   (), 
 *        Company:  
 *
 * ===========================================================================
 */

#include"account.h"
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<malloc.h>
#include<assert.h>
#include<pthread.h>
/* 
 *建立一個賬戶
 *返回這個賬戶的指標
 *
 * */
extern Account* create_account(int code,double balance){
    Account* account = (Account*)malloc(sizeof(Account));
    assert(account !=NULL);
    account->code = code;
    account->balance = balance;
    //初始化鎖的過程
    return account;
}
/* *
 *銷燬一個賬戶
 * */
extern void destory_account(Account* account){
   assert(account!=NULL);
   free(account);
}

/* *
 *取款，返回的是賬戶的餘額
 *
 * */
extern double withdraw(Account * account,double amt){
  assert(account != NULL);
  if(amt < 0 || amt > account->balance){
    return 0.0;
  }
  int balance = account -> balance;
  sleep(1);
  int result = balance - amt;
  account ->balance = result;
  //pthread_mutex_unlock(&account->pthreadmutex);
  return amt;
}
/* *
 *存款，返回的也是賬戶的餘額
 *
 * */
extern double deposit(Account* account,double amt){
   assert(account != NULL);
   if(amt < 0){
      return 0.0;
   }
   int result = account ->balance + amt;
   sleep(2);
   account->balance = result;
   return result;
}

/* *
 *獲取的就是這個賬戶的餘額
 *
 * */
extern double get_balance(Account* account){
  assert(account !=NULL);
  return account -> balance;
}

accountTest.c

/*
 * ===========================================================================
 *
 *       Filename:  accountTest.c
 *    Description:  
 *        Version:  1.0
 *        Created:  2017年03月30日 21時31分19秒
 *       Revision:  none
 *       Compiler:  gcc
 *         Author:   (), 
 *        Company:  
 *
 * ===========================================================================
 */

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

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

/* *
 *檢查賬戶的函式
 * */
void* th_check(void *argv){
  ArgvType* argvType = (void*)argv;
  double balance = get_balance(argvType->account);
  printf("name:%s,balance:%f,pthread:%lx\n",argvType->name,balance,pthread_self());
  return (void*)0;
}

/* *
 *取款函式
 * */
void* th_withdraw(void *argv){
  ArgvType* argvType = (ArgvType*)argv;
  double balance = withdraw(argvType->account,argvType->amt);
  printf("name:%s,balance:%f,pthread:%lx\n",argvType->name,balance,pthread_self());
  return (void*)0;
}

/* *
 *存款函式
 * */
void* th_deposite(void *argv){
  ArgvType* argvType = (ArgvType*)argv;
  double balance = deposit(argvType->account,argvType->amt);
  printf("name:%s,balance:%f,pthread:%lx\n",argvType->name,balance,pthread_self());
  return (void*)0;
}

int main(int argc,char *argv[]){
  int result;
  pthread_t boyfriend,girlfriend;
  Account *account = create_account(10001,10000);
  ArgvType argv_typeboy,argv_typegirl;
  strcpy(argv_typeboy.name,"zhangsan");
  strcpy(argv_typegirl.name,"xiaoli");
  argv_typeboy.account = account;
  argv_typegirl.account = account;
  argv_typeboy.amt = 10000;
  argv_typegirl.amt = 10000;

  if((result = pthread_create(&boyfriend,NULL,th_withdraw,(void*)&argv_typeboy))!=0){
     perror("boythread create error");
     exit(EXIT_FAILURE);
  }
  if((result = pthread_create(&girlfriend,NULL,th_withdraw,(void*)&argv_typegirl))!=0){
    perror("girlthread create error");
    exit(EXIT_FAILURE);
  }

  pthread_join(boyfriend,NULL);
  pthread_join(girlfriend,NULL);
  printf("get_balance:%f\n",get_balance(account));
  printf("thread:%lx exe ended\n",pthread_self());



  return 0;
}

name:zhangsan,withdraw:10000.000000,balance:0.000000,pthread:7f34bf2a9700
name:xiaoli,withdraw:10000.000000,balance:0.000000,pthread:7f34beaa8700
get_balance:0.000000
thread:7f34bfa94740 exe ended

　輸出的結果如下所示：
　從上面輸出結果中我們可以看到，其實ｘｉａｏｌｉ和ｚｈａｎｇｓａｎ都取到了１００００，但是這中情況是及其不符合日常生活的邏輯的，而我們的執行緒互斥的目的也就是為了解決這樣一種併發，即多個執行緒訪問同一個共享資源的時候，怎麼去進行處理，後面在此例子基礎上面去做修改．

執行緒互斥的相關函式

互斥鎖：

互斥鎖是一種簡單的加鎖的方法來控制對共享資源的訪問。在同一時刻只能有一個執行緒掌握某個互斥鎖，擁有上鎖狀態的執行緒能夠對共享資源的訪問，若其他執行緒希望上鎖一個已經被上了鎖的資源，則該執行緒掛起，知道上鎖的執行緒釋放互斥鎖為止；

互斥鎖資料型別：pthread_mutex_t

#include<pthread.h>
int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *mutexattr);//初始化互斥鎖
int pthread_mutex_destory(pthread_mutex_t * mutex);
／／銷燬互斥鎖
返回：成功返回0,失敗返回錯誤編號
引數：
    mutex:互斥鎖
    mutexattr：互斥鎖建立方式
        PTHREAD_MUTEX_INITIALIZER:建立快速互斥鎖
        PTHREAD_RECERSIVE_MUTEX_INITIALIZER_NP:建立遞迴互斥鎖
        PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP:建立檢錯互斥鎖

互斥鎖的加鎖和釋放鎖的過程

#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
一個共享資源繫結一把鎖，
建議：定義在結構體中，儘量不設定成為全域性變數，否則可能會出現一把鎖去鎖幾百個賬戶，導致併發性的下降：
臨界區：對共享資源進行加鎖到釋放鎖的整個程式碼區域（從上鎖開始到釋放鎖結束）

互斥鎖的屬性建立和銷燬;

    #include<pthread.h>
    int pthread_mutexattr_init(pthread_mutexattr_t *attr);
    int pthread_mutexattr_destory(pthead_muteattr_t *attr);
    返回值：成功返回0,失敗返回錯誤碼

引數：
    attr:互斥鎖屬性

互斥鎖的程序共享屬性：

#include<pthread.h>

int pthread_mutexattr_getpshared(const pthread_mutexattr_t *restrict attr,int *restrict　pshared)
int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr,int pshared)
返回：成功返回0,失敗返回錯誤編號
引數：
    attr：互斥鎖屬性
    pshared：程序共享屬性
    PTHREAD_PROCESS_PRIVATE(預設)
        鎖只能用於一個程序內部的兩個執行緒進行互斥
    PTHREAD_PROCESS_SHARED
        鎖能夠用於兩個不同程序中的執行緒進行互斥(跨程序)

一般情況下我們都是在同一個程序中去使用互斥鎖

互斥鎖的型別：

#include<pthread.h>
int pthread_mutexattr_gettype(const pthread_mutexattr_t *restrict attr,int *restrict type)
int pthreａd_mutexattr_settype(pthread_amutexattr_t *attr,int type)
引數
    attr 互斥鎖屬性
    type:互斥鎖型別
        標準互斥鎖：PTHREAD_MUTEX_NOMAL
            第一次上鎖成功，第二次上鎖失敗
        遞迴互斥鎖：PTHREAD_MUTEX_RECURSIVE
            第一次上鎖成功，第二次上鎖還是成功，內部計數
        檢錯互斥鎖：PTHREAD_MUTEX_ERRORCHECK
            第一次上鎖成功，第二次上錯會出錯
預設互斥鎖：PTHREAD_MUTEX_DEFAULT(同標準互斥鎖)

　先上一個簡單的上鎖的案例：，在上述基礎上修改的

/*
 * ===========================================================================
 *
 *       Filename:  account.h
 *    Description:  
 *        Version:  1.0
 *        Created:  2017年03月28日 22時04分18秒
 *       Revision:  none
 *       Compiler:  gcc
 *         Author:   (), 
 *        Company:  
 *
 * ===========================================================================
 */

#ifndef __ACCOUNT_H_
#define __ACCOUNT_H_
//宣告銀行賬戶的結構體
//引用ｐｔｈｒｅａｄ標頭檔案．方便後面加鎖
#include<pthread.h>
  typedef struct{
    int code;
    double balance;
    //將鎖宣告在結構體中，有助於每一個這樣的結構體都有一把鎖，那麼在操作的時候，有利於優化併發效果
    pthread_mutex_t pthreadmutex;
  }Account;

//建立銀行賬戶
extern Account* create_account(int code,double balance);

//銷燬一個賬戶
extern void destory_account(Account* account);

//存款
extern double withdraw(Account* account,double amt);

//取款
extern double deposit(Account* a,double amt);

//檢視賬戶餘額
extern double get_balance(Account* account);

#endif
/*
 * ===========================================================================
 *
 *       Filename:  account.c
 *    Description:  
 *        Version:  1.0
 *        Created:  2017年03月30日 21時16分28秒
 *       Revision:  none
 *       Compiler:  gcc
 *         Author:   (), 
 *        Company:  
 *
 * ===========================================================================
 */

#include"account.h"
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<malloc.h>
#include<assert.h>
#include<pthread.h>
/* 
 *建立一個賬戶
 *返回這個賬戶的指標
 *
 * */
extern Account* create_account(int code,double balance){
    Account* account = (Account*)malloc(sizeof(Account));
    assert(account !=NULL);
    account->code = code;
    account->balance = balance;
    //初始化鎖的過程
    pthread_mutex_init(&account->pthreadmutex,NULL);
    return account;
}
/* *
 *銷燬一個賬戶
 * */
extern void destory_account(Account* account){
   assert(account!=NULL);
   free(account);
   //銷燬鎖的過程
   pthread_mutex_destroy(&account->pthreadmutex);
}

/* *
 *取款，返回的是賬戶的餘額
 *
 * */
extern double withdraw(Account * account,double amt){
  assert(account != NULL);
  //上鎖的過程
  pthread_mutex_lock(&account->pthreadmutex);
  if(amt < 0 || amt > account->balance){
    //解鎖的過程
    pthread_mutex_unlock(&account->pthreadmutex);
    return 0.0;
  }
  int balance = account -> balance;
  sleep(1);
  int result = balance - amt;
  account ->balance = result;
  //解鎖的過程
  pthread_mutex_unlock(&account->pthreadmutex);
  return amt;
}
/* *
 *存款，返回的也是賬戶的餘額
 *
 * */
extern double deposit(Account* account,double amt){
   assert(account != NULL);
   //上鎖的過程
   pthread_mutex_lock(&account->pthreadmutex);
   if(amt < 0){
     //解鎖的過程
    pthread_mutex_unlock(&account->pthreadmutex);
      return 0.0;
   }
   int balance = account ->balance;
   sleep(2);
   int result = balance + amt;
   account->balance = result;
   //解鎖的過程
   pthread_mutex_unlock(&account->pthreadmutex);
   return result;
}

/* *
 *獲取的就是這個賬戶的餘額
 *
 * */
extern double get_balance(Account* account){
  assert(account !=NULL);
  return account -> balance;
}
/*
 * ===========================================================================
 *
 *       Filename:  accountTest.c
 *    Description:  
 *        Version:  1.0
 *        Created:  2017年03月30日 21時31分19秒
 *       Revision:  none
 *       Compiler:  gcc
 *         Author:   (), 
 *        Company:  
 *
 * ===========================================================================
 */

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

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

/* *
 *檢查賬戶的函式
 * */
void* th_check(void *argv){
  ArgvType* argvType = (void*)argv;
  double balance = get_balance(argvType->account);
  printf("name:%s,balance:%f,pthread:%lx\n",argvType->name,balance,pthread_self());
  return (void*)0;
}

/* *
 *取款函式
 * */
void* th_withdraw(void *argv){
  ArgvType* argvType = (ArgvType*)argv;
  double balance = withdraw(argvType->account,argvType->amt);
  printf("name:%s,balance:%f,pthread:%lx\n",argvType->name,balance,pthread_self());
  return (void*)0;
}

/* *
 *存款函式
 * */
void* th_deposite(void *argv){
  ArgvType* argvType = (ArgvType*)argv;
  double balance = deposit(argvType->account,argvType->amt);
  printf("name:%s,balance:%f,pthread:%lx\n",argvType->name,balance,pthread_self());
  return (void*)0;
}

int main(int argc,char *argv[]){
  int result;
  pthread_t boyfriend,girlfriend;
  Account *account = create_account(10001,10000);
  ArgvType argv_typeboy,argv_typegirl;
  strcpy(argv_typeboy.name,"zhangsan");
  strcpy(argv_typegirl.name,"xiaoli");
  argv_typeboy.account = account;
  argv_typegirl.account = account;
  argv_typeboy.amt = 10000;
  argv_typegirl.amt = 10000;

  if((result = pthread_create(&boyfriend,NULL,th_withdraw,(void*)&argv_typeboy))!=0){
     perror("boythread create error");
     exit(EXIT_FAILURE);
  }
  if((result = pthread_create(&girlfriend,NULL,th_withdraw,(void*)&argv_typegirl))!=0){
    perror("girlthread create error");
    exit(EXIT_FAILURE);
  }

  pthread_join(boyfriend,NULL);
  pthread_join(girlfriend,NULL);
  printf("get_balance:%f\n",get_balance(account));
  printf("thread:%lx exe ended\n",pthread_self());



  return 0;
}

這裡寫圖片描述
　輸出的結果如上所示，這個時候其實取款的時候就已經沒有併發情況再出現了

/*
 * ===========================================================================
 *
 *       Filename:  account.c
 *    Description:  
 *        Version:  1.0
 *        Created:  2017年03月30日 21時16分28秒
 *       Revision:  none
 *       Compiler:  gcc
 *         Author:   (), 
 *        Company:  
 *
 * ===========================================================================
 */

#include"account.h"
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<malloc.h>
#include<assert.h>
#include<pthread.h>

static pthread_mutexattr_t attr;
/* 
 *建立一個賬戶
 *返回這個賬戶的指標
 *
 * */
extern Account* create_account(int code,double balance){
    Account* account = (Account*)malloc(sizeof(Account));
    assert(account !=NULL);
    account->code = code;
    account->balance = balance;
    //初始化鎖的過程
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_NORMAL);
    //pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE);
    //pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_ERRORCHECK);
    //pthread_mutex_init(&account->pthreadmutex,NULL);
    pthread_mutex_init(&account->pthreadmutex,&attr);
    return account;
}
/* *
 *銷燬一個賬戶
 * */
extern void destory_account(Account* account){
   assert(account!=NULL);
   free(account);
   //銷燬鎖的過程
   pthread_mutexattr_destroy(&attr);
   pthread_mutex_destroy(&account->pthreadmutex);
}

/* *
 *取款，返回的是賬戶的餘額
 *
 * */
extern double withdraw(Account * account,double amt){
  assert(account != NULL);
  //上鎖的過程
  pthread_mutex_lock(&account->pthreadmutex);
  if(amt < 0 || amt > account->balance){
    //解鎖的過程
    pthread_mutex_unlock(&account->pthreadmutex);
    return 0.0;
  }
  int balance = account -> balance;
  sleep(1);
  int result = balance - amt;
  account ->balance = result;
  //解鎖的過程
  pthread_mutex_unlock(&account->pthreadmutex);
  return amt;
}
/* *
 *存款，返回的也是賬戶的餘額
 *
 * */
extern double deposit(Account* account,double amt){
   assert(account != NULL);
   //上鎖的過程
   pthread_mutex_lock(&account->pthreadmutex);
   if(amt < 0){
     //解鎖的過程
    pthread_mutex_unlock(&account->pthreadmutex);
      return 0.0;
   }
   int balance = account ->balance;
   sleep(2);
   int result = balance + amt;
   account->balance = result;
   //解鎖的過程
   pthread_mutex_unlock(&account->pthreadmutex);
   return result;
}

/* *
 *獲取的就是這個賬戶的餘額
 *
 * */
extern double get_balance(Account* account){
  assert(account !=NULL);
  return account -> balance;
}

　以上都是對ｃ的ｐｔｈｒｅａｄ互斥鎖做的一個相對比較簡單的一些使用方法．有興趣的可以ｃｏｐｙ下來ｒｕｎ一下，因為我也是新手，寫的不好的地方歡迎指出

相關推薦

Linux執行緒淺析[執行緒的同步和互斥之執行緒互斥鎖]

Linux執行緒淺析[執行緒的同步和互斥] 執行緒同步 執行緒互斥 執行緒互斥的相關函式 執行緒同步的相關函式 執行緒同步 是巨集觀上的一個概念，在微觀上面包含執行緒的相互排斥和執行緒的執行順序的約束問題 解決方法： 條件變數 執行

《linux下執行緒的建立，同步和退出》

概述         前面有一篇文章專門講述了程序建立，監控和終止，這一篇文章進一步來談談執行緒的建立和同步等操作（這裡指的是POSIX規範下的執行緒，即Pthreads）。和探討程序的文章類似，還是通過講述相關呼叫的使用和注意事項來推進，並提供一些例項來做說明。 第一部

執行緒間機制（同步和互斥）

執行緒間機制 { 多執行緒共享同一個程序子地址空間 優點： 執行緒間很容易進行通訊 1、 通過全域性變數實現資料共享和交換 缺點： 多個執行緒同時訪問共享物件時需要引入同步和互斥機制 }

程序和執行緒的區別？同步和非同步的區別？並行和併發的區別？

程序是資源的分配和排程的一個獨立單元，而執行緒是CPU排程的基本單元 同一個程序中可以包括多個執行緒，並且執行緒共享整個程序的資源（暫存器、堆疊、上下文），一個進行至少包括一個執行緒。 程序的建立呼叫fork或者vfork，而執行緒的建立呼叫pthread_create，程序結束後它擁有的所有執行緒都將銷燬

多執行緒程式在多核和單核上執行的不同

1、鎖 在單核上，多個執行緒執行鎖或者臨界區時，實際上只有一個執行緒在執行臨界區程式碼，而核心也只支援一個執行緒執行，因此不存在衝突。如果某個執行緒持有鎖，那只有其他執行緒不會被排程到CPU上執行，影

Python 多執行緒、多程序 （三）之 執行緒程序對比、多程序

Python 多執行緒、多程序 （一）之 原始碼執行流程、GIL Python 多執行緒、多程序 （二）之 多執行緒、同步、通訊 Python 多執行緒、多程序 （三）之 執行緒程序對比、多執行緒 一、多執行緒與多程序的對比 在之前簡單的提過，CPython中的GIL使得同一時刻只能有一個執行緒執行，即併

Linux 免密碼切換到root使用者和免密碼執行命令

背景： 在Linux下，我們經常會使用su從普通賬戶切換到root賬戶，但預設情況下，切換到root賬戶都需要輸入密碼，比較麻煩，可以通過配置免密碼切換到root賬號。 1.使用root賬號登入建立使

promise、async和await之執行順序

() time end AI mis ont set then cti async function async1(){ console.log(‘async1 start‘) await async2() console.log(‘async1

三十九、Linux 線程——線程的同步和互斥

cdi 案例 turn size 文件替換 .com pwd || col 39.1 概念 線程同步 是一個宏觀概念，在微觀上包含線程的相互排斥和線程先後執行的約束問題 解決同步方式 條件變量 線程信號量 線程互斥 線程執行的相互排斥 解決互斥的方式 互斥

promise、async和await之執行順序的那點事

故事要從一道今日頭條的筆試題說起～ 題目來源：半年工作經驗今日頭條和美團面試題面經分享！！！！！

從整理上理解進程創建、可執行文件的加載和進程執行進程切換，重點理解分析fork、execve和進程切換

files 修改 eve rdquo ces 堆棧分配 初始 data led 一.進程的創建 　　Linux創建進程是通過子進程復制父進程所擁有的資源來實現的。現代Linux通過寫時復制、共享數據等方法優化這一過程，提高創建子進程的效率。 　　在Linux中，進程創建

Python之Linux下的 virtualenv Mac下Python和Pycharm之virtualenv

Mac下Python和Pycharm之virtualenv   一、python如何配置virtualenv 1.安裝virtualenv pip3 install virtualenvpip install -i https://

Linux運維：現狀、入門和未來之路

十年前所有的公司都注重網路技術，所以那個時候網路工程師大熱。如今大公司的網路都早已成形，市場上的CCIE到處可見，網路技術的門檻越來越低。如今，linux行業崛起，在雲端計算大環境下，市場上對linux高階運維人員的需求將越來越大。這樣的人才是不可批量生產的，高階運維不是你想做，想做就能做的。一個職位最怕的是

三十九、Linux 執行緒——執行緒的同步和互斥

39.1 概念 執行緒同步 是一個巨集觀概念，在微觀上包含執行緒的相互排斥和執行緒先後執行的約束問題 解決同步方式 條件變數 執行緒訊號量 執行緒互斥 執行緒執行的相互排斥 解決互斥的方式

介紹Linux下面執行緒的操作、多執行緒的同步和互斥

 執行緒？為什麼有了程序還需要執行緒呢，他們有什麼區別？使用執行緒有什麼優勢呢？還有多執行緒程式設計的一些細節問題，如執行緒之間怎樣同步、互斥，這些東西將在本文中介紹。我在某QQ群裡見到這樣一道面試題： 是否熟悉POSIX多執行緒程式設計技術？如熟悉，編寫程式完成如下功能

Java執行緒-同步和非同步的區別

1.                                         &nb

執行緒的同步和非同步理解

//當個執行緒訪問同一個資源的時候，要注意執行緒同步的問題，如果不同步容易造成資料沒及時修改，然後就被另一個執行緒訪問，得到的資料還是上一次的資料，造成資料錯誤的情況，以下demo可以很容易發現，為了便於發現我在上面休眠100毫秒，如果將ticket設為方法內的區域性變數則就不會共享了。 pa

程序同步和執行緒同步

怎樣同步多個執行緒或多個程序的活動。為允許線上程或程序間共享資料，同步是必需的。 互斥鎖和條件變數是同步的基本組成部分。互斥鎖和條件變量出自POSIX.1執行緒標準，它們總是可用來同步一個程序內的各個執行緒的。如果一個互斥鎖或條件變數存放在多個程序間共享的某個記憶體中，那麼POSIX

Java5 多執行緒(三)--Lock和Condition實現執行緒同步通訊

  1<Lock:   Lock比傳統執行緒模型中的Synchronied方式更加面向物件,與生活中的鎖類似,鎖本身也應該是一個物件.兩個執行緒執行的程式碼段要實現同步互斥的效果,它們必須用同一個Lock物件,鎖是在代表要操作的資源的類的內部方法中,而不是

多執行緒同步之——兩個執行緒序列順序列印奇數和偶數的兩種實現

題目：一道經典的執行緒併發的問題，執行緒a列印1、3、5……，執行緒b列印2、4、6……，兩個執行緒交替執行輸出1、2、3、4、5、6…… 要點： package com.test; import java.util.concurrent.locks.