redis server config pthread

POSIX Thread

레디스 서버 교육 신청	레디스 정기점검/기술지원 Redis Technical Support	레디스 엔터프라이즈 서버 Redis Enterprise Server

---

1. POSIX Thread: PThread

PThread는 "POSIX Thread"의 약자입니다. (발음: 포직스)
POSIX는 Portable Operating System Interface for Unix의 약자로, Unix 계열 운영 체제에서 표준화된 API를 의미합니다. 따라서 pthread는 POSIX 표준에 따라 구현된 스레드 라이브러리를 의미합니다.

이 문서는 JOINC의 Pthread API Reference를 근간으로 pthread에 대해서 설명합니다.
Thread는 '스레드'로 통일합니다.

참고 자료:
1) Man Page: unix.com
2) Man Page: man7.org

목차

• 2. 기본 스레드 함수
• 3. 스레드 동기화 함수
• 4. Thread Attribute 함수
• 5. 스레드 시그널 관련
• 6. 스레드 취소
• 7. Multi thread와 CPU 사용량
• 8. gcc 컴파일 방법

2. 기본 스레드 함수

스레드 생성과 종료에 관련된 가장 기본적인 함수들이다.

2.1. pthread_create

스레드 생성 스레드를 성공적으로 생성하면 0을 반환하고, 실패하면 오류 코드를 반환합니다.

오류 코드

• EAGAIN: 시스템에 사용 가능한 스레드가 더 없는 경우 EAGAIN 오류 코드를 반환합니다. 시스템의 최대 스레드 수는 ulimit -l 명령을 사용하여 확인할 수 있습니다.
• EINVAL: attr 매개변수가 유효하지 않으면 EINVAL 오류 코드를 반환합니다. attr 매개변수는 pthread_attr_t 구조체를 가리킵니다. 이 구조체는 스레드의 속성을 지정합니다.
• EPERM: 프로세스가 스레드를 만들 권한이 없는 경우 EPERM 오류 코드를 반환합니다. 프로세스가 스레드를 만들 권한이 있는지 확인하려면 getrlimit() 함수를 사용하십시오.
• ENOMEM: 스레드를 만들기 위한 메모리가 부족하면 ENOMEM 오류 코드를 반환합니다. 시스템의 메모리 사용량을 확인하려면 top 명령을 사용하십시오.

참고(unix.com): pthread_create()
예제 코드: pthread_create.c
컴파일: gcc -o pthread_create pthread_create.c -lpthread

/* 2024.02.25(Sun) Charlie Kwon redisgate.com * https://www.joinc.co.kr/w/Site/Thread/Beginning/PthreadApiReference * 2.1. pthread_create * pthread_create.c * * https://www.ibm.com/docs/ko/i/7.3?topic=functions-perror-print-error-message * perror() 함수는 오류 메세지를 stderr로 출력합니다. * EBADDATA: 메세지 데이터는 유효하지 않습니다. * EBUSY: 레코드 또는 파일은 사용 중입니다. * ENOENT: 파일 또는 라이브러리를 찾을 수 없습니다. * EPERM: 액세스에 불충분한 권한 부여. * ENOREC: 레코드를 찾을 수 없습니다. * EIOERROR: 회복 불가능한 I/O 오류가 발생했습니다. * EIORECERR: 회복 가능한 I/O 오류가 발생했습니다. * */ #include <pthread.h> #include <stdlib.h> #include <stdio.h> #include <unistd.h> // thread function void *thread_func(void *data) { int id; int i=0; id = *((int *)data); pthread_t trd_id = pthread_self(); while(1) { printf("%d %d: %d\n", trd_id, id, i); if (id <= i) break; sleep(1); i++; } printf("%d stop\n", trd_id); return (void *)(int64_t)i; } int main() { pthread_t p_thread[2]; int thr_id[2]; int status; int a = 3, b = 7; //int a = 7, b = 3; // 스레드 생성 a을 넘긴다. thr_id[0] = pthread_create(&p_thread[0], NULL, thread_func, (void *)&a); if (thr_id < 0) { perror("thread create error:"); exit(0); } // 스레드 생성 b을 넘긴다. thr_id[1] = pthread_create(&p_thread[1], NULL, thread_func, (void *)&b); if (thr_id < 0) { perror("thread create error:"); exit(0); } // 스레드 종료를 기다린다. pthread_join(p_thread[0], (void **)&status); printf("p_thread[0]:%d -> %d\n", p_thread[0], status); pthread_join(p_thread[1], (void **)&status); printf("p_thread[1]:%d -> %d\n", p_thread[1], status); return 0; }

실행: $ ./pthread_create
결과(Case 1): int a = 3, b = 7; -> a가 종료되고 다음에 b가 종료된다.

결과(Case 2): int a = 7, b = 3; -> b가 먼저 종로되었으나 첫 번째 pthread_join()이 a 종료를 기다리고 있으므로 a가 종료될 때까지 기다렸다가 a, b가 순차적으로 처리된다.

2.2. pthread_join

대상 스레드가 종료되기를 기다린다. 자원 해제

주요 기능

• 스레드 종료 대기: pthread_join() 함수는 대상 스레드가 종료될 때까지 호출 스레드를 블로킹합니다.
• 자원 회수: 대상 스레드가 종료되면 pthread_join() 함수는 스레드에 할당된 자원을 자동으로 회수합니다.
• 종료 상태 확인: pthread_join() 함수는 대상 스레드의 종료 상태를 반환합니다.

반환 값

• 0: 성공
• ESRCH: 대상 스레드가 존재하지 않습니다.
• EINVAL: thread가 유효한 스레드 ID가 아닙니다.
• EDEADLK: 호출 스레드가 이미 대상 스레드에 join된 상태입니다.

주의 사항

• pthread_join() 함수는 대상 스레드가 종료될 때까지 호출 스레드를 블로킹합니다. 따라서 pthread_join() 함수를 호출하기 전에 대상 스레드가 얼마나 오래 실행될지 예상하는 것이 중요합니다.
• pthread_join() 함수는 호출 스레드가 이미 대상 스레드에 join된 상태에서 다시 호출하면 오류가 발생합니다.

참고(joinc): pthread_join()
예제 코드: pthread_join.c
컴파일: gcc -o pthread_join pthread_join.c -lpthread

/* 2024.02.25(Sun) Charlie Kwon redisgate.com * https://www.joinc.co.kr/w/Site/Thread/Beginning/PthreadApiReference#AEN25 * 2. 기본 스레드 함수 * 2.2. pthread_join: 스레드가 종료되기를 기다리는 함수, 리턴값을 받을 수 있다. * gcc -o pthread_join pthread_join.c -lpthread */ #include <pthread.h> #include <stdlib.h> #include <stdio.h> #include <unistd.h> // thread function void *t_function(void *data) { int num = *((int *)data); printf("num %d\n", num); sleep(1); return (void *)(int64_t)(num*num); } int main() { pthread_t p_thread; int thr_id; int status; int a = 10;; thr_id = pthread_create(&p_thread, NULL, t_function, (void *)&a); if (thr_id < 0) { perror("thread create error: "); exit(0); } // 스레드가 종료되면 리턴값을 받는다. pthread_join(p_thread, (void *)&status); printf("thread join: %d\n", status); return 0; }

실행: $ ./pthread_join

2.3. pthread_detach

main 스레드에서 스레드를 분리시킨다. detach 하면 해당 스레드가 종료될 때 pthread_join 을 호출하지 않더라도 즉시 모든 자원이 해제(free)된다. malloc()으로 할당한 메모리는 별도로 free()해 주어야 한다.

참고: pthread_detach()
예제 코드: pthread_detach.c
컴파일: gcc -o pthread_detach pthread_detach.c -lpthread

/* 2024.02.25(Sun) Charlie Kwon redisgate.com * https://www.joinc.co.kr/w/Site/Thread/Beginning/PthreadApiReference#AEN25 * 2. 기본 스레드 함수 * 2.3. pthread_detach: main 스레드에서 스레드를 분리시킨다. * detach 되었을경우 해당 스레드가 종료될 경우 pthread_join 을 호출하지 않더라도 * 즉시 모든 자원이 해제(free) 된다. * gcc -o pthread_detach pthread_detach.c -lpthread * $ while [ 1 ]; do ps -aux | grep pthread | grep -v grep | grep -v vim; sleep 1; done * USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND * pthread_detach()를 주석처리해도 메모리 변화가 없었다. * a를 10만에서 100만으로 늘렸는데 VSZ, RSS 항목에 변화가 없다. * 이유는 모르겠다. * STAT S (interruptible Sleep (waiting for an event to complete)): 프로세스가 CPU를 기다리고 있는 상태입니다. R (Running or runnable (on run queue)): 프로세스가 CPU를 사용하고 있는 상태입니다. D (Uninterruptible sleep (usually IO)): 프로세스가 시스템 호출을 기다리고 있는 상태입니다. Z (defunct ("Zombie") process, terminated but not reaped by its parent): 프로세스가 종료되었지만 아직 자원을 해제하지 않은 상태입니다. T (sTopped by job control signal): 프로세스가 중지된 상태입니다. t (stopped by debugger during the tracing) W (Paging (not valid since the 2.6.xx kernel)): 프로세스가 메모리 페이지 교환을 기다리고 있는 상태입니다. X (dead (should never be seen)) < (High-priority (not nice to other users)): 프로세스가 높은 우선 순위를 가지고 있는 상태입니다. N (low-priority (Nice to other users)): 프로세스가 낮은 우선 순위를 가지고 있는 상태입니다. L (has pages Locked into memory (for real-time and custom IO)) s (is a session leader) l (is multi-threaded (using CLONE_THREAD, like NPTL pthreads do)) + (is in the foreground process group) Sl+ : 프로세스가 잠자고 있습니다. S: 프로세스가 잠자고 있습니다. l: multi-threaded +: foreground process */ #include <pthread.h> #include <stdlib.h> #include <stdio.h> #include <unistd.h> // thread function void *t_function(void *data) { char a[100000]; int num = *((int *)data); printf("Thread Start\n"); sleep(5); printf("Thread End\n"); } int main() { pthread_t p_thread; int thr_id; int status; int a = 100; thr_id = pthread_create(&p_thread, NULL, t_function, (void *)&a); if (thr_id < 0) { perror("thread create error:"); exit(0); } // 식별번호 p_thread를 가지는 스레드를 detach 시켜준다. pthread_detach(p_thread); printf("Main thread 프로그램 실행을 일시적으로 중단합니다.\n"); // 함수를 호출하면 프로그램 실행이 중단되고 사용자가 키 입력을 할 때까지 기다립니다. // 사용자가 키 입력을 하면 프로그램 실행이 다시 시작됩니다. // pause() 함수는 Windows 운영 체제에서만 작동합니다. // 멈추기는 하는데 키를 눌러도 아무 반응이 없다. Ctrl+C를 하면 프로그램이 종료된다. // getcahr() 함수는 멈추고 아무키나 누르면 다시 시작한다. getchar(); printf("프로그램 실행을 다시 시작합니다.\n"); return 0; }

실행: $ ./pthread_detach
pthread_detach()를 실행했을 때, pthread_detach()를 주석 처리했을 때로 구분해서 실행하고 아래 명령(ps)로 5번째 필드 메모리(VSZ) 사용량을 관찰한다.
VSZ: virtual memory size of the process in KiB (1024-byte units).
$ while [ 1 ]; do ps -aux | grep pthread | grep -v grep | grep -v vim; sleep 1; done
결과:

• Case 1-1: pthread_detach() 실행, char a[100000]; -> 스레드 함수가 종료되면 VSZ 메모리 사용량이 줄어야 하는데, 변화가 없다.
  STAT가 'Sl+'는 스레드 함수가 실행중이고, 'S+'는 스레드 함수가 종료된 상태이다.
  RSS는 스레드 함수가 종료되고 16kb 증가했다. $ while [ 1 ]; do ps -aux | grep pthread | grep -v grep | grep -v vim; sleep 1; done USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND redis 2407 0.0 0.0 14704 420 pts/0 Sl+ 23:25 0:00 ./pthread_detach redis 2407 0.0 0.0 14704 420 pts/0 Sl+ 23:25 0:00 ./pthread_detach redis 2407 0.0 0.0 14704 420 pts/0 Sl+ 23:25 0:00 ./pthread_detach redis 2407 0.0 0.0 14704 420 pts/0 Sl+ 23:25 0:00 ./pthread_detach redis 2407 0.0 0.0 14704 420 pts/0 Sl+ 23:25 0:00 ./pthread_detach redis 2407 0.0 0.0 14704 436 pts/0 S+ 23:25 0:00 ./pthread_detach redis 2407 0.0 0.0 14704 436 pts/0 S+ 23:25 0:00 ./pthread_detach
• Case 1-2: pthread_detach()주석 처리, char a[100000]; -> VSZ 메모리 변화없다. RSS는 스레드 함수가 종료되고 16kb 증가했다. $ while [ 1 ]; do ps -aux | grep pthread | grep -v grep | grep -v vim; sleep 1; done USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND redis 2844 0.0 0.0 14704 416 pts/0 Sl+ 23:31 0:00 ./pthread_detach redis 2844 0.0 0.0 14704 416 pts/0 Sl+ 23:31 0:00 ./pthread_detach redis 2844 0.0 0.0 14704 416 pts/0 Sl+ 23:31 0:00 ./pthread_detach redis 2844 0.0 0.0 14704 416 pts/0 Sl+ 23:31 0:00 ./pthread_detach redis 2844 0.0 0.0 14704 416 pts/0 Sl+ 23:31 0:00 ./pthread_detach redis 2844 0.0 0.0 14704 432 pts/0 S+ 23:31 0:00 ./pthread_detach redis 2844 0.0 0.0 14704 432 pts/0 S+ 23:31 0:00 ./pthread_detach
• Case 2-1: pthread_detach() 실행, char a[1000000]; -> a를 10만에서 100만으로 늘렸다. VSZ 변화없다. USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND redis 5806 0.0 0.0 14704 420 pts/0 Sl+ 00:22 0:00 ./pthread_detach redis 5806 0.0 0.0 14704 420 pts/0 Sl+ 00:22 0:00 ./pthread_detach redis 5806 0.0 0.0 14704 420 pts/0 Sl+ 00:22 0:00 ./pthread_detach redis 5806 0.0 0.0 14704 420 pts/0 Sl+ 00:22 0:00 ./pthread_detach redis 5806 0.0 0.0 14704 420 pts/0 Sl+ 00:22 0:00 ./pthread_detach redis 5806 0.0 0.0 14704 436 pts/0 S+ 00:22 0:00 ./pthread_detach redis 5806 0.0 0.0 14704 436 pts/0 S+ 00:22 0:00 ./pthread_detach
• Case 2-2: pthread_detach()주석 처리, char a[1000000]; -> a 100만, VSZ 메모리 변화없다. USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND redis 6073 0.0 0.0 14704 420 pts/0 Sl+ 00:25 0:00 ./pthread_detach redis 6073 0.0 0.0 14704 420 pts/0 Sl+ 00:25 0:00 ./pthread_detach redis 6073 0.0 0.0 14704 420 pts/0 Sl+ 00:25 0:00 ./pthread_detach redis 6073 0.0 0.0 14704 420 pts/0 Sl+ 00:25 0:00 ./pthread_detach redis 6073 0.0 0.0 14704 420 pts/0 Sl+ 00:25 0:00 ./pthread_detach redis 6073 0.0 0.0 14704 436 pts/0 S+ 00:25 0:00 ./pthread_detach redis 6073 0.0 0.0 14704 436 pts/0 S+ 00:25 0:00 ./pthread_detach

ps STAT 항목 설명

• S (interruptible Sleep (waiting for an event to complete)): 프로세스가 CPU를 기다리고 있는 상태입니다.
• R (Running or runnable (on run queue)): 프로세스가 CPU를 사용하고 있는 상태입니다.
• D (Uninterruptible sleep (usually IO)): 프로세스가 시스템 호출을 기다리고 있는 상태입니다.
• Z (defunct ("Zombie") process, terminated but not reaped by its parent): 프로세스가 종료되었지만 아직 자원을 해제하지 않은 상태입니다.
• T (sTopped by job control signal): 프로세스가 중지된 상태입니다.
• t (stopped by debugger during the tracing)
• W (Paging (not valid since the 2.6.xx kernel)): 프로세스가 메모리 페이지 교환을 기다리고 있는 상태입니다.
• X (dead (should never be seen))
• < (High-priority (not nice to other users)): 프로세스가 높은 우선 순위를 가지고 있는 상태입니다.
• N (low-priority (Nice to other users)): 프로세스가 낮은 우선 순위를 가지고 있는 상태입니다.
• L (has pages Locked into memory (for real-time and custom IO))
• s (is a session leader)
• l (is multi-threaded (using CLONE_THREAD, like NPTL pthreads do))
• + (is in the foreground process group)
• Sl+ : 프로세스가 대기중이고, multi-thread이다.
  S: 프로세스가 CPU를 기다리고 있는 상태
  l: multi-threaded
  +: foreground process
  
• S+ : 프로세스가 대기중
  S: 프로세스가 CPU를 기다리고 있는 상태
  +: foreground process
  

2.4. pthread_exit

현재 실행중인 스레드를 종료한다. pthread_cleanup_push 가 정의되어 있다면, pthread_exit 가 호출될경우 cleanup handler 가 호출된다. 보통 이 cleanup handler 은 메모리를 정리하는 등의 일을 하게 된다.

예제 코드: pthread_exit.c
컴파일: gcc -o pthread_exit pthread_exit.c -lpthread

/* 2024.02.25(Sun) Charlie Kwon redisgate.com * https://www.joinc.co.kr/w/Site/Thread/Beginning/PthreadApiReference#AEN25 * 2. 기본 스레드 함수 * 2.4. pthread_exit 는 현재 실행중인 스레드를 종료시키고자 할때 사용한다. * void pthread_exit(void *retval); * gcc -o pthread_exit pthread_exit.c -lpthread * */ #include <pthread.h> #include <stdlib.h> #include <stdio.h> #include <unistd.h> // thread function void *t_function(void *data) { int num = *((int *)data); int i = 0; while(1) { if (i == 5) pthread_exit((void *)(int64_t)(num * i)); printf("loop %d\n", i++); sleep(1); } } int main() { pthread_t p_thread; int thr_id; int status; int a = 100; thr_id = pthread_create(&p_thread, NULL, t_function, (void *)&a); if (thr_id < 0) { perror("thread create error:"); exit(0); } pthread_join(p_thread, (void **)&status); printf("thread join : %d\n", status); return 0; }

실행: $ ./pthread_exit
결과:

2.5. pthread_cleanup_push

cleanup handlers 는 주로 자원을 되돌려주거나, mutex 잠금등의 해제를 위한 용도로 사용된다. 또한 malloc 으로 할당받은 메모리, 열린 파일지정자를 닫기 위해서도 사용한다. 자동으로 되는 것은 아니고 코딩해야 한다.

예제 코드: pthread_cleanup.c
컴파일: gcc -o pthread_cleanup pthread_cleanup.c -lpthread

/* 2024.02.25(Sun) Charlie Kwon redisgate.com * https://www.joinc.co.kr/w/Site/Thread/Beginning/PthreadApiReference#AEN25 * 2. 기본 스레드 함수 * 2.5. pthread_cleanup_push: pthread_exit() 가 호출되어서 스레드가 종료될때 * pthread_cleanup_push 에 의해서 인스톨된 함수가 호출된다. * void pthrad_cleanup_push(void (*routine) (void *), void *arg); * pthread_cleanup_push 와 pthread_cleanup_pop 은 반드시 같은 함수내의 같은 레벨의 * 블럭에서 한쌍으로 사용해야 한다. * void pthread_cleanup_pop(int execute); * execute 가 0 이라면, pthread_cleanup_push 에 의해 인스톨된 cleanup handler 를 * (실행시키지 않고)삭제만 시킨다. * 0 이 아닌 숫자라면 cleanup handler 을 실행시키고 삭제 된다. * gcc -o pthread_cleanup pthread_cleanup.c -lpthread * [redis@redisgate pthread]$ ./pthread_cleanup loop 0 loop 1 loop 2 loop 3 loop 4 thread is clean up resource free thread join : 9 * */ #include <pthread.h> #include <stdlib.h> #include <stdio.h> #include <unistd.h> #include <sys/types.h> char *mydata; void cleanup(void *); void *t_function(void *data) { int num = *((int *)data); int i = 0; int a = 1; // cleanup handler로 cleanup 함수를 지정한다. pthread_cleanup_push(cleanup, (void *)&a); mydata = (char *)malloc(1000); while(1) { if (i == 5) { // pthread_exit()가 호출되면서 cleanup을 호출하게 된다. pthread_exit((void *)9); // return (void *)1; 의미없음. } printf("loop %d\n", i++); sleep(1); } pthread_cleanup_pop(0); } int main() { pthread_t p_thread; int thr_id; int status; int a = 100; thr_id = pthread_create(&p_thread, NULL, t_function, (void *)&a); if (thr_id < 0) { perror("thread create error:"); exit(0); } pthread_join(p_thread, (void **)&status); printf("thread join : %d\n", status); return 0; } // cleanup handler void cleanup(void *myarg) { printf("thread is clean up\n"); printf("resource free\n"); free(mydata); }

실행: $ ./pthread_cleanup
결과:

2.6. pthread_cleanup_pop

pthread_cleanup_push 와 함께 사용되며, install 된 cleanup handler 을 제거하기 위해서 사용된다.
pthread_cleanup_push 와 pthread_cleanup_pop 은 반드시 같은 함수내의 같은 레벨의 블럭에서 한쌍으로 사용해야 한다.

2.7. pthread_self

pthread_self를 호출하는 현재 스래드의 스레드 식별자를 되돌려준다.

예제 코드: pthread_self.c
컴파일: gcc -o pthread_self pthread_self.c -lpthread

/* 2024.02.25(Sun) Charlie Kwon redisgate.com * https://www.joinc.co.kr/w/Site/Thread/Beginning/PthreadApiReference#AEN25 * 2. 기본 스레드 함수 * 2.7. pthread_self: pthread_self를 호출하는 현재 스래드의 스레드 식별자를 되돌려준다. * */ #include <pthread.h> #include <stdio.h> #include <unistd.h> void *t_function(void *data) { pthread_t id; int num = *((int *)data); id = pthread_self(); printf("%d -> %lu\n", num, id); } int main() { pthread_t p_thread; int a = 1; int b = 2; pthread_create(&p_thread, NULL, t_function, (void *)&a); printf("%lu\n", p_thread); sleep(1); pthread_create(&p_thread, NULL, t_function, (void *)&b); printf("%lu\n", p_thread); sleep(1); return 1; }

실행: $ ./pthread_self
결과: printf() format에 따라 결과가 다르게 나온다.
printf(%d)

printf(%lu)

3. 스레드 동기화 함수

기본적인 매커니즘은 세마포어와 비슷하다. busy wait 상태에 놓이지 않음을 보장한다.
뮤텍스 메커니즘의 특징: mutex MUTual EXclusion(상호 배제)

• Atomicity: mutex 잠금(lock)는 최소단위 연적(atomic operation) 으로 작동한다. 이말의 뜻은 하나의 스레드가 mutex 를 이용해서 잠금을 시도하는 도중에 다른 스레드가 mutex 잠금을 할수없도록 해준다는 뜻이다. 한번에 하나의 mutex 잠금을 하도록 보증해준다.
• Singularity: 만약 스레드가 mutex 잠금을 했다면, 잠금을 한 스레드(:12)가 mutex 잠금을 해제 하기 전까지 다른 어떠한 스레드도 mutex 잠금을 할수 없도록 보증해준다.
• Non-Busy Wait: 바쁜대기 상태에 놓이지 않는다는 뜻으로, 하나의 스레드가 mutex 잠금을 시도하는데 이미 다른 스레드가 mutex 잠금을 사용하고 있다면 이 스레드는 다른 스레드가 락을 해제하기전까지 해당 지점에 머물러 있으며 이동안은 어떠한 CPU 자원도 소비하지 않는다(이를테면 sleep).

참고: Mutex를 이용한 스레드 동기화 메커니즘

3.1. pthread_mutex_init

mutex 객체를 초기화한다.

참고: pthread_mutex_init()
예제 코드: pthread_mutex_init.c
컴파일: gcc -o pthread_mutex_init pthread_mutex_init.c -lpthread

/* 2024.02.28(Wed) Charlie Kwon redisgate.com * https://www.joinc.co.kr/w/Site/Thread/Beginning/PthreadApiReference#AEN25 * 3. 스레드 동기화 함수 https://www.joinc.co.kr/w/Site/Thread/Beginning/Mutex 기본적인 매커니즘은 세마포어와 비슷하다. busy wait 상태에 놓이지 않음을 보장한다. 뮤텍스 메커니즘의 특징을 정리했다. • Atomicity - mutex 잠금(lock)는 최소단위 연적(atomic operation) 으로 작동한다. 이말의 뜻은 하나의 스레드가 mutex 를 이용해서 잠금을 시도하는 도중에 다른 스레드가 mutex 잠금을 할수없도록 해준다는 뜻이다. 한번에 하나의 mutex 잠금을 하도록 보증해준다. • Singularity - 만약 스레드가 mutex 잠금을 했다면, 잠금을 한 스레드(:12)가 mutex 잠금을 해제 하기 전까지 다른 어떠한 스레드도 mutex 잠금을 할수 없도록 보증해준다. • Non-Busy Wait - 바쁜대기 상태에 놓이지 않는다는 뜻으로, 하나의 스레드가 mutex 잠금을 시도하는데 이미 다른 스레드가 mutex 잠금을 사용하고 있다면 이 스레드는 다른 스레드가 락을 해제하기전까지 해당 지점에 머물러 있으며 이동안은 어떠한 CPU 자원도 소비하지 않는다 (이를테면 sleep). * 3.1. pthread_mutex_init: mutex 객체를 초기화 시키기 위해서 사용한다. * https://www.joinc.co.kr/w/man/3/pthread_mutex_init * int pthread_mutex_init(pthread_mutex_t * mutex, const pthread_mutex_attr *attr); * mutex 특성(종류) 에는 "fast", "recurisev", "error checking" 의 종류가 있으며, * 기본으로 "fast" 가 사용된다. * gcc -o pthread_mutex_init pthread_mutex_init.c -lpthread * $ ./pthread_mutex_init * mutex_lock -> sleep(5) * mutex_unlock * mutex function End * mutex thread End * */ #include <pthread.h> #include <stdio.h> #include <unistd.h> // 뮤텍스 개체 선언 pthread_mutex_t mutex_lock; void *t_function(void *data) { printf("mutex_lock -> sleep(5)\n"); pthread_mutex_lock(&mutex_lock); // critical section sleep(5); printf("mutex_unlock\n"); pthread_mutex_unlock(&mutex_lock); printf("mutex function End\n"); } int main() { pthread_t p_thread; int a = 10; int status; // 뮤텍스 객체 초기화, 기본 특성으로 초기화 했음. pthread_mutex_init(&mutex_lock, NULL); pthread_create(&p_thread, NULL, t_function, (void *)&a); pthread_join(p_thread, (void **)&status); printf("mutex thread End \n"); }

실행: $ ./pthread_mutex_init
결과:

$ while [ 1 ]; do ps -aux | grep pthread | grep -v grep | grep -v vim; sleep 1; done<br> USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND<br> redis 2534 0.0 0.0 14700 420 pts/0 Sl+ 09:35 0:00 ./pthread_mutex_init

3.2. pthread_mutex_destroy

뮤텍스 객체 mutex 를 제거하기 위해서 사용된다. 이 mutex 는 반드시 unlock 상태이여야 한다.

3.3. pthread_mutex_lock

critcal section 에 들어가기 위해서 mutex lock 을 요청한다. 만약 이미 다른 스레드에서 mutex lock 를 얻어서 사용하고 있다면 다른 스레드에서 mutex lock(뮤텍스 잠금)을 해제할때까지(사용할수 있을때까지) 블럭 된다.

참고: pthread_mutex_lock()

• pthread_mutex_lock()함수는 아래의 에러코드를 반환한다.
  • EINVAL: 뮤텍스가 잘못 초기화 되었다.
  • EDEADLK: 이미 잠금을 얻은 스레드가 다시 잠금을 요청할 때 (error checking 뮤텍스일 경우 사용할 수 있다)
  
• pthread_mutex_trylock()함수는 아래의 에러코드를 반환한다.
  • EINVAL: 뮤텍스가 잘못 초기화 되었다.
  • EBUSY: 뮤텍스가 잠겨 있어서 잠금을 얻을 수 없다.
  

예제 코드: pthread_mutex_lock.c
컴파일: g++ -std=c++11 -o pthread_mutex_lock pthread_mutex_lock.c -lpthread
• vector를 사용하고 있으므로 g++(C++)로 컴파일해야 한다. -std=c++11를 추가한다.

/* 2024.02.28(Wed) Charlie Kwon redisgate.com * https://www.joinc.co.kr/w/Site/Thread/Beginning/PthreadApiReference#AEN25 * 3. 스레드 동기화 함수 https://www.joinc.co.kr/w/Site/Thread/Beginning/Mutex 기본적인 매커니즘은 세마포어와 비슷하다. busy wait 상태에 놓이지 않음을 보장한다. 뮤텍스 메커니즘의 특징을 정리했다. • Atomicity - mutex 잠금(lock)는 최소단위 연적(atomic operation) 으로 작동한다. 이말의 뜻은 하나의 스레드가 mutex 를 이용해서 잠금을 시도하는 도중에 다른 스레드가 mutex 잠금을 할수없도록 해준다는 뜻이다. 한번에 하나의 mutex 잠금을 하도록 보증해준다. • Singularity - 만약 스레드가 mutex 잠금을 했다면, 잠금을 한 스레드(:12)가 mutex 잠금을 해제 하기 전까지 다른 어떠한 스레드도 mutex 잠금을 할수 없도록 보증해준다. • Non-Busy Wait - 바쁜대기 상태에 놓이지 않는다는 뜻으로, 하나의 스레드가 mutex 잠금을 시도하는데 이미 다른 스레드가 mutex 잠금을 사용하고 있다면 이 스레드는 다른 스레드가 락을 해제하기전까지 해당 지점에 머물러 있으며 이동안은 어떠한 CPU 자원도 소비하지 않는다 (이를테면 sleep). * 3.3. pthread_mutex_lock: critcal section 에 들어가기 위해서 mutex lock 을 요청한다. * 만약 이미 다른 스레드에서 mutex lock 를 얻어서 사용하고 있다면 다른 스레드에서 * mutex lock(뮤텍스 잠금) 을 해제할때까지(사용할수 있을때까지) 블럭 된다. * int pthread_mutex_lock(pthread_mutex_t *mutex); * https://www.joinc.co.kr/w/man/3/pthread_mutex_lock * pthread_mutex_lock()함수는 아래의 에러코드를 반환한다. * • EINVAL: 뮤텍스가 잘못 초기화 되었다. * • EDEADLK: 이미 잠금을 얻은 스레드가 다시 잠금을 요청할 때 * (error checking 뮤텍스일 경우 사용할 수 있다) * pthread_mutex_trylock()함수는 아래의 에러코드를 반환한다. * • EINVAL: 뮤텍스가 잘못 초기화 되었다. * • EBUSY: 뮤텍스가 잠겨 있어서 잠금을 얻을 수 없다. * */ #include <pthread.h> #include <unistd.h> #include <stdio.h> #include <stdlib.h> #include <vector> #include <iostream> using namespace std; void *ping(void *); void *pong(void *); pthread_muext_t sync_mutex; pthread_cond_t sync_cond; pthread_mutex_t gmetex = PTHREAD_MUTEX_INITIALIZER; pthread_cond_t gcond = PTHREAD_COND_INITIALIZER; int main() { vector<void *(*)(void *)> thread_list; vector<pthread_t> tidend(10); int thresult; int status; int i; pthread_mutex_init(&sync_mutex, NULL); pthread_cnd_init(&sync_cond, NULL); thread_list.push_back(pong); thread_list.push_back(ping); for(i=0; i < thread_list.size(); i++) { pthread_mutex_lock(&sync_mutex); if (pthread_create(&tident[i], NULL, thread_list[i], (void *)NULL) < 0) { perror("pthread create error:"); exit(0); } pthread_cond_wait(&sync_cond, &sync_mutex); pthread_mutex_unlock(&sync_mutex); } for (i=0; i < tident.size(); i++) { pthread_join(tident[i], (void **)&status); } } void *ping(void *data) { int i=0; pthread_mutex_lock(&sync_mutex); pthread_cond_signal(&sync_cond); pthread_mutex_unlock(&sync_mutex); while(1) { pthread_mutex_lock(&gmutex); pring("%d: ping\n",i); pthread_cond_signal(&gcond); pthread_cond_wait(&gcond, &gmutex); pthread_mutex_unlock(&gmutex); usleep(random()%100); i++; } } void *pong(void *data) { int i=0; pthread_mutex_lock(&sync_mutex); sleep(1); pthread_cond_signal(&sync_cond); pthread_mutex_unlock(&sync_mutex); while(1) { pthread_mutex_lock(&gmutex); pthread_cond_wait(&gcond, &gmutex); printf("%d: pong\n",i); pthread_cond_signal(&gcond); pthread_mutex_unlock(&gmutex); i++; } }

3.4. pthread_mutex_unlock

critical section 에서의 모든 작업을 마치고 mutex lock 을 돌려주기 위해서 사용한다.

3.5. pthread_cond_init

조건변수 (condition variable)cond를 초기화하기 위해서 사용한다.

3.6. pthread_cond_signal

조건변수 cond에 시그날을 보낸다. cond에서 기다리는(wait) 스레드가 있다면 스레드를 깨우게 된다(봉쇄가 풀림). 여러 개의 스레드가 기다리고 있다면 그중 하나의 스레드에게만 전달된다. 이때 어떤 스레드에게 신호가 전달될지는 알수 없다.

3.7. pthread_cond_boradcast

조건변수 cond에서 기다리는(wait) 모든 스레드에게 신호를 보내서, 깨운다는 점을 제외하고는 pthread_cond_signal과 동일하게 작동한다.

3.8. pthread_cond_wait

조건변수 cond를 통해서 신호가 전달될때까지 블럭된다. 블럭되기 전에 mutex 잠금을 자동으로 되돌려준다.

3.9. pthread_cond_timewait

시간체크가 가능해서 abstime시간동안 신호가 도착하지 않는다면 error 를 발생하면서 리턴한다.

3.10. pthread_cond_destroy

조건변수 cond에 대한 자원을 해제한다. destroy 함수를 호출하기 전에 어떤 스레드도 cond에서의 시그널을 기다리지 않는걸 확인해야 한다.

3.11. 예제 코드

pthread_mutex_lock.c
C++ 표준 라이브러리 vector를 사용하고 있으므로 C++(g++)로 컴파일해야 한다.
gcc로 컴파일하면 아래와 같은 에러가 발생한다.
gcc -o pthread_mutex_lock pthread_mutex_lock.c -lpthread
pthread_mutex_lock.c:36:10: fatal error: vector: 그런 파일이나 디렉터리가 없습니다
    >> #include <vector>
아래와 같이 g++로 컴파일해야 한다.
$ g++ -std=c++11 -o pthread_mutex_lock pthread_mutex_lock.c -lpthread

/* 2024.02.28(Wed) Charlie Kwon redisgate.com * https://www.joinc.co.kr/w/Site/Thread/Beginning/PthreadApiReference#AEN25 * 3. 스레드 동기화 함수 https://www.joinc.co.kr/w/Site/Thread/Beginning/Mutex 기본적인 매커니즘은 세마포어와 비슷하다. busy wait 상태에 놓이지 않음을 보장한다. 뮤텍스 메커니즘의 특징을 정리했다. • Atomicity - mutex 잠금(lock)는 최소단위 연적(atomic operation) 으로 작동한다. 이말의 뜻은 하나의 스레드가 mutex 를 이용해서 잠금을 시도하는 도중에 다른 스레드가 mutex 잠금을 할수없도록 해준다는 뜻이다. 한번에 하나의 mutex 잠금을 하도록 보증해준다. • Singularity - 만약 스레드가 mutex 잠금을 했다면, 잠금을 한 스레드(:12)가 mutex 잠금을 해제 하기 전까지 다른 어떠한 스레드도 mutex 잠금을 할수 없도록 보증해준다. • Non-Busy Wait - 바쁜대기 상태에 놓이지 않는다는 뜻으로, 하나의 스레드가 mutex 잠금을 시도하는데 이미 다른 스레드가 mutex 잠금을 사용하고 있다면 이 스레드는 다른 스레드가 락을 해제하기전까지 해당 지점에 머물러 있으며 이동안은 어떠한 CPU 자원도 소비하지 않는다 (이를테면 sleep). * 3.3. pthread_mutex_lock: critcal section 에 들어가기 위해서 mutex lock 을 요청한다. * 만약 이미 다른 스레드에서 mutex lock 를 얻어서 사용하고 있다면 다른 스레드에서 * mutex lock(뮤텍스 잠금) 을 해제할때까지(사용할수 있을때까지) 블럭 된다. * int pthread_mutex_lock(pthread_mutex_t *mutex); * https://www.joinc.co.kr/w/man/3/pthread_mutex_lock * pthread_mutex_lock()함수는 아래의 에러코드를 반환한다. * • EINVAL: 뮤텍스가 잘못 초기화 되었다. * • EDEADLK: 이미 잠금을 얻은 스레드가 다시 잠금을 요청할 때 * (error checking 뮤텍스일 경우 사용할 수 있다) * pthread_mutex_trylock()함수는 아래의 에러코드를 반환한다. * • EINVAL: 뮤텍스가 잘못 초기화 되었다. * • EBUSY: 뮤텍스가 잠겨 있어서 잠금을 얻을 수 없다. * * C++로 컴파일하는 방법 * g++ -std=c++11 -o pthread_mutex_lock pthread_mutex_lock.c -lpthread * */ #include <pthread.h> #include <unistd.h> #include <stdio.h> #include <stdlib.h> #include <vector> #include <iostream> using namespace std; void *ping(void *); void *pong(void *); pthread_mutex_t sync_mutex; pthread_cond_t sync_cond; pthread_mutex_t gmutex = PTHREAD_MUTEX_INITIALIZER; pthread_cond_t gcond = PTHREAD_COND_INITIALIZER; int main() { vector<void *(*)(void *)> thread_list; vector<pthread_t> tident(10); int thresult; int status; int i; pthread_mutex_init(&sync_mutex, NULL); pthread_cond_init(&sync_cond, NULL); thread_list.push_back(pong); thread_list.push_back(ping); for(i=0; i < thread_list.size(); i++) { pthread_mutex_lock(&sync_mutex); if (pthread_create(&tident[i], NULL, thread_list[i], (void *)NULL) < 0) { perror("pthread create error:"); exit(0); } pthread_cond_wait(&sync_cond, &sync_mutex); pthread_mutex_unlock(&sync_mutex); } for (i=0; i < tident.size(); i++) { pthread_join(tident[i], (void **)&status); } } void *ping(void *data) { int i=0; pthread_mutex_lock(&sync_mutex); pthread_cond_signal(&sync_cond); pthread_mutex_unlock(&sync_mutex); while(1) { pthread_mutex_lock(&gmutex); printf("%d: ping\n",i); pthread_cond_signal(&gcond); pthread_cond_wait(&gcond, &gmutex); pthread_mutex_unlock(&gmutex); usleep(random()%100); i++; } } void *pong(void *data) { int i=0; pthread_mutex_lock(&sync_mutex); sleep(1); pthread_cond_signal(&sync_cond); pthread_mutex_unlock(&sync_mutex); while(1) { pthread_mutex_lock(&gmutex); pthread_cond_wait(&gcond, &gmutex); printf("%d: pong\n",i); pthread_cond_signal(&gcond); pthread_mutex_unlock(&gmutex); i++; } }

4. Thread Attribute 함수

4.1. pthread_attr_init

thread attribute 객체인 attr을 디폴트 값으로 초기화 시킨다. 성공할 경우 0을 돌려주고 실패할 경우 -1을 되돌려준다.

4.2. pthread_attr_distroy

thread attribute 객체인 attr을 제거한다. 제거된 attr 을 다시 사용하기 위해서는 pthread_attr_init를 이용해서 다시 초기화 해주어야 한다.

4.3. pthread_attr_getscope

스레드가 어떤 영역(scope)에서 다루어지고 있는지를 얻어오기 위해서 사용된다. 리눅스의 경우 유저모드 스레드인데, 즉 커널에서 스레드를 스케쥴링하는 방식이 아닌 스레드 라이브러리를 통해서 스레드를 스케쥴링 하는 방식을 사용한다.

예제 코드: pthread_attr_getscope.c
컴파일: gcc -o pthread_attr_getscope pthread_attr_getscope.c -lpthread

/* 2024.02.28(Wed) Charlie Kwon redisgate.com * https://www.joinc.co.kr/w/Site/Thread/Beginning/PthreadApiReference#AEN25 * 4. Thread Attribute 함수 * 4.3. pthread_attr_getscop: 스레드가 어떤 영역(scope)에서 있는지를 얻어오기 위해서 사용된다. * PTHREAD_SCOPE_SYSTEM과 PTHREAD_SCOPE_PROCESS 의 2가지 영역중에 선택할수 있다. * SYSTEM 영역 스레드는 user 모드 스레드라고 불리우며, * PROCESS 스레드는 커널모드 스레드라고 불리운다. * 리눅스의 경우 유저모드 스레드인데, 즉 커널에서 스레드를 스케쥴링하는 방식이 아닌 * 스레드 라이브러리를 통해서 스레드를 스케쥴링 하는 방식을 사용한다. * gcc -o pthread_attr_getscope pthread_attr_getscope.c -lpthread * $ ./pthread_attr_getscope * user mode thread * */ #include <pthread.h> #include <stdlib.h> #include <stdio.h> #include <unistd.h> int main() { pthread_attr_t pattr; int scope; pthread_attr_init(&pattr); pthread_attr_getscope(&pattr, &scope); if (scope == PTHREAD_SCOPE_SYSTEM) { printf("user mode thread\n"); } else if (scope == PTHREAD_SCOPE_PROCESS) { printf("kernel mode thread\n"); } return 1; }

실행: $ ./pthread_attr_getscope
결과:

4.4. pthread_attr_setscope

스레드가 어떤 영역(scope)에서 작동하게 할것인지 결정하기 위해서 사용한다. 리눅스의 경우 Kernel mode 스레드를 지원하지 않음

4.5. pthread_attr_getdetachstate

스레드가 join 가능한 상태(PTHREAD_CREATE_JOINABLE) 인지 detached 상태인지 (PTHREAD_CREATE_DETACHED) 인지를 알아낸다. 알아낸 값은 아규먼트 detachstate 에 저장된다.

예제 코드: pthread_attr_getdetachstate.c
컴파일: gcc -o pthread_attr_getdetachstate pthread_attr_getdetachstate.c -lpthread

/* 2024.02.28(Wed) Charlie Kwon redisgate.com * https://www.joinc.co.kr/w/Site/Thread/Beginning/PthreadApiReference#AEN25 * 4. Thread Attribute 함수 * 4.5. pthread_attr_getdetachstate: 스레드가 join 가능한 상태(PTHREAD_CREATE_JOINABLE) 인지 * detached 상태인지(PTHREAD_CREATE_DETACHED) 인지를 알아낸다. * 알아낸 값은 아규먼트 detachstate 에 저장된다. * int pthread_attr_getdetachstate(pthread_attr_t *attr, int detachstate); * gcc -o pthread_attr_getdetachstate pthread_attr_getdetachstate.c -lpthread * $ ./pthread_attr_getdetachstate * Thread Created * Joinable */ #include <pthread.h> #include <stdlib.h> #include <stdio.h> #include <unistd.h> pthread_attr_t attr; void *test(void *a) { int policy; printf("Thread Created\n"); pthread_attr_getdetachstate(&attr, &policy); if (policy == PTHREAD_CREATE_JOINABLE) { printf("Joinable\n"); } else if (policy == PTHREAD_CREATE_DETACHED) { printf("Detache\n"); } } int main() { int status; pthread_t p_thread; pthread_attr_init(&attr); if (pthread_create(&p_thread, NULL, test, (void *)NULL) < 0) { perror("pthread_create error:"); exit(0); } pthread_join(p_thread, (void **)&status); }

실행: $ ./pthread_attr_getdetachstate
결과:

4.6. pthread_attr_setdetachstate

스레드의 상태를 PTHREAD_CREATE_JOINABLE 혹은 PTHREAD_CREATE_DETACHED 상태로 변경시키기 위해서 사용된다.

아래와 같은 방법으로 사용하면 된다.

5. 스레드 시그널 관련

스레드간 프로세스와 스레드간 시그널 전달관련 API들이다.

5.1. pthread_sigmask

특정 스레드만 시그널을 받도록 하고 싶을 때 이 함수를 이용한다.

5.2. pthread_kill

스레드 식별번호 thread로 signo 번호의 시그널을 전달한다.

예제 코드

주의 사항

• pthread_kill() 함수는 같은 프로세스 내에 존재하는 스레드에만 시그널을 전송할 수 있습니다.
• SIGKILL 및 SIGSTOP 시그널은 pthread_kill() 함수를 통해 전송할 수 없습니다.
• 전송된 시그널에 대한 처리 방식은 스레드의 시그널 핸들러에 따라 결정됩니다.
• pthread_kill() 함수는 스레드의 실행 상태에 영향을 미치지 않습니다.

pthread_kill() 함수의 활용

• 스레드 종료: SIGKILL 또는 SIGTERM 시그널을 전송하여 스레드를 강제 종료할 수 있습니다.
• 스레드 동기화: 시그널을 사용하여 스레드 간 동기화를 구현할 수 있습니다.
• 스레드 상태 확인: 시그널을 사용하여 스레드의 현재 상태를 확인할 수 있습니다.

Man Page: pthread_kill()

5.3. sigwait

시그널 전달을 동기적으로 기다린다.

6. 스레드 취소

https://www.joinc.co.kr/w/Site/Thread/Advanced/ThreadCancle THREAD 취소와 종료

6.1. pthread_cancel

스레드에 취소 요청을 보낸다.
https://www.joinc.co.kr/w/man/3/pthread_cancel

6.2. pthread_setcancelstate

취소 상태는 이 함수에 의해 결정한다.

• PTHREAD_CANCEL_ENABLE 상태라면 스레드는 취소요청을 받아들이고 취소지점까지 진행한다음 취소 지점을 벗어나야지 종료한다. ENABLE 상태일 경우 별도로 취소지점까지 진행한다음 종료할 것인지 아니면 바로 종료할 것인지를 pthread_setcanceltype() 를 통해 지정할 수 있다.
• PTHREAD_CANCEL_DISABLE 스레드 취소 기능을 비활성화하는 매크로입니다.
  • 중요한 작업을 수행하는 스레드가 취소되어서는 안 되는 경우
  • 스레드가 취소 지점을 명확하게 정의하기 어려운 경우
  • 스레드 취소 기능이 성능 저하를 초래하는 경우
  
• 예제 코드 void func() { // 스레드 취소 기능 비활성화 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); // 중요한 작업 수행 for (int i = 0; i < 1000000; i++) { // ... } // 스레드 취소 기능 활성화 pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); }
• pthread_getcancelstate() get 함수는 없다.

6.3. pthread_setcanceltype

PTHREAD_CANCEL_ENABLE인 경우 취소의 종류를 결정할 수 있다.

• PTHREAD_CANCEL_ASYNCHRONOUS 바로 종료
• PTHREAD_CANCEL_DEFERRED 취소지점을 벗어날 때까지 기다린다.
• 취소지점으로 설정될 수 있는 영역은 다음과 같다. • pthread_join(3)
  • pthread_cond_wait(3)
  • pthread_cond_timedwait(3)
  • pthread_testcancel(3)
  • sem_wait(3)
  • sigwait(3)

6.4. pthread_testcancel

https://www.joinc.co.kr/w/Site/Thread/Advanced/ThreadCancle THREAD 취소와 종료
총 정리 예제 코드이다. (함수 순서는 조금 바꾸었다)
컴파일: gcc -o pthread_cancel pthread_cancel.c -lpthread

/* 2024.02.28(Wed) Charlie Kwon redisgate.com * https://www.joinc.co.kr/w/Site/Thread/Beginning/PthreadApiReference#AEN25 * 6. 스레드 취소 * https://www.joinc.co.kr/w/Site/Thread/Advanced/ThreadCancle THREAD 취소와 종료 * 6.1. pthread_cancel: 스레드에 취소 요청을 보낸다. * int pthread_cancel(pthread_t thread); * 6.2. pthread_setcancelstate: 취소 상태는 이 함수에 의해 결정한다. * int pthread_setcancelstate(int state, int *oldstate); * pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldstate); * pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldstate); * • PTHREAD_CANCEL_ENABLE: 상태라면 스레드는 취소요청을 받아들이고 취소지점까지 진행한다음 * 취소 지점을 벗어나야지 종료한다. * ENABLE 상태일 경우 별도로 취소지점까지 진행한다음 종료할 것인지 아니면 바로 종료할 * 것인지를 pthread_setcanceltype() 를 통해 지정할 수 있다. * • PTHREAD_CANCEL_DISABLE: 스레드 취소 기능을 비활성화하는 매크로입니다. * - 중요한 작업을 수행하는 스레드가 취소되어서는 안 되는 경우 * - 스레드가 취소 지점을 명확하게 정의하기 어려운 경우 * - 스레드 취소 기능이 성능 저하를 초래하는 경우 * * 6.3. pthread_setcanceltype: PTHREAD_CANCEL_ENABLE인 경우 취소의 종류를 결정할 수 있다. * int pthread_setcanceltype(int type, int *oldtype); * • PTHREAD_CANCEL_ASYNCHRONOUS 바로 종료 * • PTHREAD_CANCEL_DEFERRED 취소지점을 벗어날 때까지 기다린다. * 취소지점으로 설정될 수 있는 영역은 다음과 같다. * • pthread_join(3) * • pthread_cond_wait(3) * • pthread_cond_timedwait(3) * • pthread_testcancel(3) * • sem_wait(3) * • sigwait(3) * 6.4. pthread_testcancel * void pthread_testcancel(void); * * $ ./pthread_cancel -> PTHREAD_CANCEL_ENABLE * THREAD cond wait * // pthread_cancel(pt)을 받으면 clean_up()을 실행한다. * Thread cancel Clean_up function -> sleep(5) 5초 있다가 * pthread_cond_signal(&cond)받으면 바로 종료한다. * exit * * $ ./pthread_cancel -> PTHREAD_CANCEL_DISABLE * THREAD cond wait -> sleep(5) 5초 있다가 * pthread_cond_signal(&cond)받아도 thread_func()를 다 실행하고 종료한다. * NO WAIT COND * EXIT * exit * */ #include <pthread.h> #include <stdlib.h> #include <stdio.h> #include <unistd.h> #include <sys/time.h> pthread_cond_t cond = PTHREAD_COND_INITIALIZER; pthread_mutex_t lmu = PTHREAD_MUTEX_INITIALIZER; // 스레드 종료 시 호출될 함수 // 여기에 자원해제루틴을 입력할 수 있다. void clean_up(void *arg) { printf("Thread cancel Clean_up function\n"); } void *thread_func(void *arg) { // clean_up() 함수가 실행된다. // pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); // DISABLE 생태다. // 이 경우 스레드에 대해서 취소 요청을 무시한다. // clean_up() 함수가 실행되지 않는다. pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); // 스레드 종료 시 호출될 함수 등록 pthread_cleanup_push(clean_up, (void *)NULL); pthread_mutex_lock(&lmu); printf("THREAD cond wait\n"); pthread_cond_wait(&cond, &lmu); printf("NO WAIT COND\n"); pthread_mutex_unlock(&lmu); printf("EXIT\n"); pthread_cleanup_pop(0); } int main(int argc, char **argv) { pthread_t pt; pthread_create(&pt, NULL, thread_func, NULL); // 생성된 스레드 pt에 취소 요청을 보낸다. pthread_cancel(pt); // 5초를 쉰 후에 시그널을 보낸다. sleep(5); // 3.6 조건변수 cond에 시그날을 보낸다. // cond에서 기다리는(wait) 스레드가 있다면 스레드를 깨우게 된다(봉쇄가 풀림). // 여러개의 스레드가 기다리고 있다면 그중 하나의 스레드에게만 전달된다. // 이때 어떤 스레드에게 신호가 전달될지는 알수 없다. pthread_cond_signal(&cond); // join후 종료한다. pthread_join(pt, NULL); printf("exit\n"); exit(1); }

실행: $ ./pthread_cancel -> PTHREAD_CANCEL_ENABLE 실행
결과:

실행: $ ./pthread_cancel -> PTHREAD_CANCEL_DISABLE 실행
결과:

Multi thread와 CPU 사용량

스레드를 2개, 4개, 8개 생성해서 테스트했다.

4 threads

CPU가 거의 400% 사용(398%) 사용중이다. top과 ps 명령으로 확인

$ top %Cpu(s): 50.1 us, 0.2 sy, 0.0 ni, 49.6 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 17389 redis 20 0 39288 420 324 S 398.0 0.0 0:46.79 pthread_busy $ while [ 1 ]; do ps -aux | grep pthread | grep -v grep | grep -v vim; sleep 1; done USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND redis 17389 397 0.0 39284 420 pts/1 Sl+ 01:59 0:07 ./pthread_busy redis 17389 400 0.0 39288 420 pts/1 Sl+ 01:59 0:12 ./pthread_busy redis 17389 401 0.0 39288 420 pts/1 Sl+ 01:59 0:16 ./pthread_busy redis 17389 402 0.0 39288 420 pts/1 Sl+ 01:59 0:20 ./pthread_busy redis 17389 403 0.0 39288 420 pts/1 Sl+ 01:59 0:24 ./pthread_busy

스레드별 CPU 사용량 확인

실행: 4 스레드 생성

$ ./pthread_busy Process id: 17686 -> main thread id pthread: 1 create pthread: 2 create pthread: 3 create pthread: 4 create

pid를 지정해서 스레드 이름 확인

$ ps H -o 'tid comm' 17686 -> thread name TID COMMAND 17686 pthread_busy 17716 data_thd_1 17717 data_thd_2 17718 data_thd_3 17719 data_thd_4

top 명령으로 스레드별 CPU 사용량 확인

$ top -H -d 1 -p 17686 %Cpu(s): 50.1 us, 0.1 sy, 0.0 ni, 49.8 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 17716 redis 20 0 39288 420 324 R 99.0 0.0 0:16.86 data_thd_1 17717 redis 20 0 39288 420 324 R 99.0 0.0 0:16.86 data_thd_2 17718 redis 20 0 39288 420 324 R 99.0 0.0 0:16.86 data_thd_3 17719 redis 20 0 39288 420 324 R 99.0 0.0 0:16.86 data_thd_4 17686 redis 20 0 39288 420 324 S 0.0 0.0 0:00.00 pthread_busy

while(1) { } 이렇게 while 안에 아무 문장이 없어도 CPU 100%를 사용하는지 테스트 -> CPU 100%를 사용한다.

$ top -H -d 1 -p 31427 %Cpu(s): 50.1 us, 0.0 sy, 0.0 ni, 49.9 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 31432 redis 20 0 39288 420 324 R 99.9 0.0 0:23.69 data_thd_1 31433 redis 20 0 39288 420 324 R 99.9 0.0 0:23.69 data_thd_2 31434 redis 20 0 39288 420 324 R 99.9 0.0 0:23.69 data_thd_3 31435 redis 20 0 39288 420 324 R 99.9 0.0 0:23.69 data_thd_4 31427 redis 20 0 39288 420 324 S 0.0 0.0 0:00.00 pthread_busy

8 threads

CPU는 사용량은 ps 보다 top이 정확하다.

top %Cpu(s): 99.8 us, 0.2 sy, 0.0 ni, 0.0 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 19927 redis 20 0 72072 420 324 S 800.0 0.0 1:12.67 pthread_busy $ while [ 1 ]; do ps -aux | grep pthread | grep -v grep | grep -v vim; sleep 1; done USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND redis 19927 789 0.0 72072 420 pts/1 Sl+ 02:06 2:22 ./pthread_busy redis 19927 791 0.0 72072 420 pts/1 Sl+ 02:06 2:30 ./pthread_busy redis 19927 794 0.0 72072 420 pts/1 Sl+ 02:06 2:38 ./pthread_busy redis 19927 796 0.0 72072 420 pts/1 Sl+ 02:06 2:47 ./pthread_busy redis 19927 798 0.0 72072 420 pts/1 Sl+ 02:06 2:55 ./pthread_busy

컴파일 방법

Compile: gcc -o pthread_busy pthread_busy.c -lpthread -D_GNU_SOURCE
pthread_setname_np()를 사용하려면 '-D_GNU_SOURCE'이 필요합니다.

[redis@redisgate pthread]$ cat pthread_busy.c /* 2024.03.02(Sat) Charlie Kwon redisgate.com 1. source file name: pthread_busy.c 2. Compile: gcc -o pthread_busy pthread_busy.c -lpthread -D_GNU_SOURCE pthread_setname_np()을 사용하려면-D_GNU_SOURCE 옵션이 필요하다. */ #include <pthread.h> #include <stdlib.h> #include <stdio.h> #include <unistd.h> // thread function void *thread_func(void *data) { //int id = *((int *)data); long id = (unsigned long)data; int j=0; int imax = 1000000000; // 10억, 10G int jmax = 10; pthread_t tid = pthread_self(); char thdname[16]; // thread name (max 16 bytes) snprintf(thdname, sizeof(thdname), "data_thd_%ld", id); pthread_setname_np(tid, thdname); while(1) { for (int i=0; i < imax; i++) { } printf("%s: %d\n",thdname, j++); if (j > jmax) return (void *)(long)j; } } int main() { int thread_num = 4; pthread_t p_thread[thread_num]; int id=1; int ret; long status; printf("Process id: %d\n", getpid()); sleep(5); for (int i=0; i < thread_num; i++) { printf("pthread: %d create\n", id); if (pthread_create(&p_thread[i], NULL, thread_func, (void *)(long)id) < 0) { perror("thread create error:"); exit(0); } id++; } // 스레드 종료를 기다린다. for (int i=0; i < thread_num; i++) { pthread_join(p_thread[i], (void **)&status); printf("Thread stop: %ld\n", status); } return 0; }

gcc 컴파일 방법

gcc 컴파일 방법과 g++(C++) 컴파일 방법을 설명합니다.

1. gcc 컴파일 방법

$ gcc -o my_program my_program.c -lpthread
pthread lib를 사용한다.

2. g++(C++) 컴파일 방법

• 컴파일러 플래그 설정
  컴파일러에 -std=c++11 또는 -std=c++14 플래그를 추가해야 합니다.
  이 플래그는 C++11 또는 C++14 표준을 사용하여 코드를 컴파일하도록 지시합니다.
  vector는 C++11 표준에서 도입되었으므로 이 플래그를 설정하지 않으면 컴파일 오류가 발생합니다.
  예를 들어, 다음과 같이 명령어를 사용하여 코드를 컴파일할 수 있습니다.
  $ g++ -std=c++11 -o my_program my_program.c -lpthread
• 헤더 파일 경로 설정
  컴파일러가 vector 헤더 파일을 찾을 수 있도록 해야 합니다.
  일반적으로 vector 헤더 파일은 /usr/include/c++/ 디렉토리에 설치됩니다.
  하지만 설치된 위치가 다를 수 있으므로 시스템 설정을 확인해야 합니다.
  컴파일러가 헤더 파일을 찾을 수 없는 경우 다음과 같이 -I 플래그를 사용하여 헤더 파일 경로를 지정할 수 있습니다.
  $ g++ -std=c++11 -I/usr/include/c++/ -o my_program my_program.c -lpthread

---

<< Redis Threads	Redis Process >>