링크 ux 프로 세 스 와 스 레 드 간 통신 방법 및 동기 화 방법 총화

프로 세 스 와 스 레 드 간 의 통신 방법
프로 세 스 간 통신 방법
1. 메시지 큐 2. 공유 메모리
3. 파이프: 익명 파이프 로 나 뉘 어 부자 프로 세 스 간 통신 에 사용 되 며, 이름 파 이 프 는 부자 프로 세 스 나 관련 프로 세 스 간 통신 에 사 용 됩 니 다.
참고: linux 프로 세 스 간 통신 - 파이프 총 결 실례
4. 부자 프로 세 스 도 파일 설명자 로 통신 하여 같은 파일 을 공동으로 열 수 있 습 니 다.
2. 스 레 드 간 통신 방법
1. 전역 데이터, 전역 변수, 전역 데이터 구조 2. 라인 을 만 들 때 파라미터 arg 메 인 라인 을 통 해 새로운 라인 pthread 에 데 이 터 를 전달 합 니 다.create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg); 새 스 레 드 종료 시 void pthreadexit(void *retval);int pthreadjoin(pthread_t thread, void **retval);메 인 스 레 드 에 정보 전달 하기;블 로그 참조: 다 중 스 레 드 함수 시리즈 pthreadcreate(), pthread_join(), pthread_self()，pthread_exit(), pthread_detach () 실례 상세 설명
3. 파일 핸들, 여러 스 레 드 공유 파일
계속이 부분 은 또 써 야 한다.
프로 세 스 와 스 레 드 간 의 동기 화 방법
1: 신 호 량
보통 0 과 1 두 개의 값 으로 임계 구역 에 들 어가 1 (P 작업) 을 빼 고 임계 구역 을 떠 나 1 (V 작업) 을 더 합 니 다.여러 자원 을 제어 하 는 것 과 관련 이 있다 면 신 호 량 의 값 은 자원 의 수량 으로 설정 합 니 다.
2: 상호 배척 량
상호 배척 량 은 사실 신 호 량 의 일종 이다.하나의 스 레 드 나 프로 세 스 가 임계 구역 에 접근 할 때마다 상호 배척 량 을 가 져 오고 임계 구역 을 떠 날 때 상호 배척 량 을 방출 해 야 합 니 다.상호 배척 량 을 얻 는 데 실패 하면 차단 합 니 다.그래서 서로 배척 하 는 양 으로 여러 스 레 드 나 프로 세 스 가 임계 구역 에 대한 직렬 화;
블 로그 참조: Liux 프로그램 다 중 스 레 드 상호 배척 잠 금 의 간단 한 사용
상호 배척 량 을 조작 하 는 주요 API

#include <pthread.h>
pthread_mutex_t fastmutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t recmutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
pthread_mutex_t errchkmutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);//       
int pthread_mutex_lock(pthread_mutex_t *mutex);//        
int pthread_mutex_trylock(pthread_mutex_t *mutex);//          
int pthread_mutex_unlock(pthread_mutex_t *mutex);//      
int pthread_mutex_destroy(pthread_mutex_t *mutex);//      

#include <pthread.h>
#include <time.h>
int pthread_mutex_timedlock(pthread_mutex_t *restrict mutex,const struct timespec *restrict abs_timeout);

상호 반 발 량 의 속성 을 조작 하 는 주요 API

#include <pthread.h>
int pthread_mutexattr_init(pthread_mutexattr_t *attr);
int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);
int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int kind);
int pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *kind);

int pthread_mutexattr_getpshared(const pthread_mutexattr_t *restrict attr, int *restrict pshared);
int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr,int pshared);//        ; pshared PTHREAD_PROCESS_SHARED              ；
// pshared PTHREAD_PROCESS_PRIVATE                ；

2: 읽 기 - 쓰기 자물쇠
여러 스 레 드 가 공유 메모 리 를 조작 할 때 제어 해 야 합 니 다. 그렇지 않 으 면 공유 메모리 의 데이터 접근 에 경쟁 하기 쉽 습 니 다.공유 메모리 의 내용 을 바 꾸 지 않 기 때문에 여러 스 레 드 가 동시에 읽 을 수 있 습 니 다. 읽 기 - 쓰기 자 물 쇠 를 가 질 수 있 습 니 다.그러나 임의의 시간 에 하나의 스 레 드 만 공유 메모리 에 기록 하거나 변경 할 수 있 습 니 다.
사실 우 리 는 이러한 기록 경쟁 을 통제 하기 위해 상호 배척 량 으로 통제 할 수도 있다.그런데 문제 가 하나 있어 요.서로 배척 하 는 양 을 사용 하면 공유 메모리 에 대해 읽 거나 쓸 수 있 는 스 레 드 만 있 을 수 있 습 니 다.그러나 우 리 는 여러 스 레 드 가 공유 메모리 에 대해 동시에 읽 게 하려 고 합 니 다. 그러면 상호 배척 량 을 사용 하 는 것 이 효율 적 이지 않 습 니 다.이때 우 리 는 읽 기 - 자 물 쇠 를 써 야 한다.비고: 우 리 는 상호 배척 량 에 대해 하나의 자물쇠 추가 요청 만 있 는 것 을 발견 할 수 있 습 니 다. 그러나 읽 기 - 자 물 쇠 를 쓰 는 데 두 개의 자물쇠 추가 요청 이 있 습 니 다.
읽 기 - 자 물 쇠 를 초기 화 / 소각

#include <pthread.h>
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);//   -  
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);//    -  

읽 기 잠 금 요청

#include <pthread.h>
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);//        ，            ，      ；           ，       ；
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);//        ，            ，      ；        ///   ，   ，   ；

소유 요청 / 쓰기 요청 잠 금 시도

#include <pthread.h>
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);//        ，              ，   ，   ；
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);//        ，                          ，        ；

시간 요청 잠 금

#include <pthread.h>
#include <time.h>
int pthread_rwlock_timedrdlock(pthread_rwlock_t *restrict rwlock,const struct timespec *restrict abs_timeout);//    ，       ，      abs_timeout   

시간 요청 잠 금

#include <pthread.h>
#include <time.h>
int pthread_rwlock_timedwrlock(pthread_rwlock_t *restrict rwlock,const struct timespec *restrict abs_timeout);//    ，       ，      abs_timeout   

읽 기 - 자 물 쇠 를 쓰 는 속성 대상 초기 화 / 소각 / 설정 / 획득

#include <pthread.h>
int pthread_rwlockattr_destroy(pthread_rwlockattr_t *attr);//   -       
int pthread_rwlockattr_init(pthread_rwlockattr_t *attr);//    -       

int pthread_rwlockattr_getpshared(const pthread_rwlockattr_t *restrict attr, int *restrict pshared);//    
int pthread_rwlockattr_setpshared(pthread_rwlockattr_t *attr,int pshared);//    ; pshared PTHREAD_PROCESS_SHARED            -  ；
// pshared PTHREAD_PROCESS_PRIVATE              -  ；

3: 조건 변수 구체 적 인 사례 소개 블 로그: Linux 다 중 스 레 드 소비자 와 생산자 모델 인 스 턴 스 (상호 배척 잠 금 및 조건 변수 사용)
조건 변수 와 상호 배척 량 을 함께 사용 합 니 다.
예 를 들 어 우리 가 서로 배척 하 는 양 을 사용 할 때 요청 이 실패 하면 막 힐 수 있다.
상호 배척 자 물 쇠 를 얻 은 경우 가 있 지만 조건 이 만족 하지 않 아 계속 집행 할 수 없다 면 이 때 는 기다 릴 수 밖 에 없다...이 럴 때 는 조건 변 수 를 써 야 한다.우리 가 계속 기다 리 면 다른 스 레 드 는 이 자 물 쇠 를 얻 을 수 없 기 때문이다.이 때 잠 금 상태 로 들 어 갈 수 있 습 니 다.
해결 방법, 이때 pthread 를 호출 해 야 합 니 다.cond_wait (& g cond, & g mutex), 상호 배척 자물쇠 gmutex 는 이 gcond 조건 에서 기다 리 기;
스 레 드 호출 pthreadcond_wait 이 함수 후에 커 널 은 다음 과 같은 일 을 할 것 입 니 다.
1. 자물쇠 의 스 레 드 를 가 져 와 자 물 쇠 를 잠시 풀 어 줍 니 다.
2. 스 레 드 휴면, 대기;
3. 스 레 드 는 통 지 를 기다 리 고 깨 어 나 야 합 니 다.(자물쇠 다시 가 져 오기)
스 레 드 라 이브 러 리 는 위의 세 단 계 를 원자 적 조작 으로 만 들 었 다.Linux 커 널 과 연결 하기;
다른 스 레 드 는 조건 이 만족 할 때 pthread 를 호출 합 니 다.cond_signal(&g_cond);이 조건 변수 gcond 에서 조건 만족 을 표시 하 는 신 호 를 보 냅 니 다.
조건 이 만족 하면 아까 pthread 호출 때문에cond_wait 기다 리 는 스 레 드 가 깨 어 납 니 다 (자 물 쇠 를 다시 가 져 와 조건 이 만족 하 는 지 다시 판단 합 니 다).만약 조건 이 만족 한 후에 임계 구역 에서 조작 을 하고 마지막 으로 자 물 쇠 를 풀 고 임계 구역 을 떠난다.
/ / 다음은 man 수첩 대 pthreadcond_wait 의 소개: pthreadcond_wait atomically unlocks the mutex (as per pthread_unlock_mutex) and waits for the condition variable cond to be signaled. The thread execution  is  
suspended  and  does not consume any CPU time until the condition variable is signaled. The mutex must be locked by the calling thread on entrance to pthread_cond_wait.
Before returning to the calling thread, pthread_cond_wait re-acquires mutex (as per pthread_lock_mutex)
조건 변수 작업 의 주요 API

#include <pthread.h>
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;//         
int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);//       
int pthread_cond_signal(pthread_cond_t *cond);//       g_cond       ,      ；
int pthread_cond_broadcast(pthread_cond_t *cond);//       g_cond       ,      ；
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);//    g_mutex   g_cond     ；
int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime);    g_mutex   g_cond     abstime ；
int pthread_cond_destroy(pthread_cond_t *cond);//      

조건 변수 속성 작업 의 주요 API

#include <pthread.h>
int pthread_condattr_init(pthread_condattr_t *attr);//           
int pthread_condattr_destroy(pthread_condattr_t *attr);//          
int pthread_condattr_getpshared(const pthread_condattr_t *restrict attr,int *restrict pshared);//         
int pthread_condattr_setpshared(pthread_condattr_t *attr, int pshared);//         ; pshared PTHREAD_PROCESS_SHARED               ；
// pshared PTHREAD_PROCESS_PRIVATE                 ；

int pthread_condattr_getclock(const pthread_condattr_t *restrict attr, clockid_t *restrict clock_id);//           clock_id，       
int pthread_condattr_setclock(pthread_condattr_t *attr, clockid_t clock_id);//           clock_id，