수안이의 컴퓨터 연구실

3 Articles, Search for 'pthread'

2007/05/14 pthread API 레퍼런스 (2)
2007/05/11 쓰레드 객체의 사용
2007/05/11 쓰레드 종료 상태

Programming/UNIX/Linux C2007/05/14 09:29

pthread API 레퍼런스

출처 : http://teamblog.joinc.co.kr/yundream

pthread API의 레퍼런스 문서이다. 비록 모든 API들에 대한 레퍼런스를 담고 있지않지만, 자주 사용되는 주요 API 들에 대한 레퍼런스에 대한 설명과 예제까지를 포함하고 있다. 몇몇 빠진 API 들은 추후 보강하도록 할것이다.

1절. 소개
2절. 기본 쓰레드 함수
2.1절. pthread_create
2.2절. pthread_join
2.3절. pthread_detach
2.4절. pthread_exit
2.5절. pthread_cleanup_push
2.6절. pthread_cleanup_pop
2.7절. pthread_self
3절. 쓰레드 동기화 함수
3.1절. pthread_mutex_init
3.2절. pthread_mutex_destory
3.3절. pthread_mutex_lock
3.4절. pthread_mutex_unlock
3.5절. pthread_cond_init
3.6절. pthread_cond_signal
3.7절. pthread_cond_boradcast
3.8절. pthread_cond_wait
3.9절. pthread_cond_timewait
3.10절. pthread_cond_destroy
3.11절. 예제코드
4절. Thread Attribute 함수
4.1절. pthread_attr_init
4.2절. pthread_attr_distroy
4.3절. pthread_attr_getscope
4.4절. pthread_attr_setscope
4.5절. pthread_attr_getdetachstate
4.6절. pthread_attr_setdetachstate

--------------------------------------------------------------------------------

1절. 소개
이 문서는 pthread 레퍼런스 문서이다. pthread 에서 제공하는 모든 함수의 레퍼런스를 제공하고 있지는 않지만, 자주 쓰일만한 대부분의 함수들은 정리되어 있음으로 참고할만한 가치가 있을것이다.

이 문서에 빠진 내용들은 계속 추가해 나갈 예정이다.

--------------------------------------------------------------------------------

2절. 기본 쓰레드 함수
주로 쓰레드 생성과 종료에 관련된 가장 기본적인 함수들이다.

--------------------------------------------------------------------------------

2.1절. pthread_create

int pthread_create(pthread_t *thread, const pthread_attr_t *attr, 
                  void *(*start_routine)(void *), void *arg);

쓰레드 생성을 위해서 사용한다. 첫번째 아규먼트인 thread 는 쓰레드가 성공적으로 생성되었을때 생성된 쓰레드를 식별하기 위해서 사용되는 쓰레드 식별자이다. 두번째 아규먼트인 attr 은 쓰레드 특성을 지정하기 위해서 사용하며, 기본 쓰레드 특성을 이용하고자 할경우에 NULL 을 사용한다. 3번째 아규먼트인 start_routine는 분기시켜서 실행할 쓰레드 함수이며, 4번째 아규먼는인 arg는 쓰레드 함수의 인자이다.

성공적으로 생성될경우 0을 리턴한다.

예제 : pthread_create.cc

#include <pthread.h> 
#include <stdio.h> 
#include <unistd.h> 
#include <stdlib.h> 

// 쓰레드 함수 
void *t_function(void *data) 
{ 
   int id; 
   int i = 0; 
   id = *((int *)data); 

   while(1) 
   { 
       printf("%d : %d\n", id, i); 
       i++; 
       sleep(1); 
   } 
} 

int main() 
{ 
   pthread_t p_thread[2]; 
   int thr_id; 
   int status; 
   int a = 1; 
   int b = 2; 

   // 쓰레드 생성 아규먼트로 1 을 넘긴다.   
   thr_id = pthread_create(&p_thread[0], NULL, t_function, (void *)&a); 
   if (thr_id < 0) 
   { 
       perror("thread create error : "); 
       exit(0); 
   } 

   // 쓰레드 생성 아규먼트로 2 를 넘긴다. 
   thr_id = pthread_create(&p_thread[1], NULL, t_function, (void *)&b); 
   if (thr_id < 0) 
   { 
       perror("thread create error : "); 
       exit(0); 
   } 

   // 쓰레드 종료를 기다린다. 
   pthread_join(p_thread[0], (void **)&status); 
   pthread_join(p_thread[1], (void **)&status); 

   return 0; 
}

실행된 쓰레드에 대해서는 pthread_join 등의 함수를 이용해서 쓰레드 종료때까지 기다려줘야 한다. ptherad_join 은 일종의 fork 의 wait 와 비슷하게 작동하며, 쓰레드자원을 해제 시켜준다.

--------------------------------------------------------------------------------

2.2절. pthread_join

#include <pthread.h> 
int pthread_join(pthread_t th, void **thread_return);

첫번째 아규먼트 th는 기다릴(join)할 쓰레드 식별자이며, 두번째 아규먼트 thread_return은 쓰레드의 리턴(return) 값이다. thread_return 이 NULL 이 아닐경우 해다 포인터로 쓰레드 리턴 값을 받아올수 있다.

pthread_joinc.c

#include <pthread.h> 
#include <stdio.h> 
#include <unistd.h> 
#include <stdlib.h> 

// 쓰레드 함수 
// 1초를 기다린후 아규먼트^2 을 리턴한다. 
void *t_function(void *data) 
{ 
   int num = *((int *)data); 
   printf("num %d\n", num); 
   sleep(1); 
   return (void *)(num*num); 
} 

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 가 종료되길 기다렸다가 
   // 종료리턴값을 가져온다. 
   pthread_join(p_thread, (void *)&status); 
   printf("thread join : %d\n", status); 

   return 0; 
}

--------------------------------------------------------------------------------

2.3절. pthread_detach

int pthread_detach(pthread_t th);

detach 는 "떼어내다" 라는 뜻을 가지며 main 쓰레드에서 pthread_create 를 이용해 생성된 쓰레드를 분리시킨다. 이 함수는 식별번호th인 쓰레드를 detach 시키는데, detach 되었을경우 해당(detach 된) 쓰레드가 종료될경우 pthread_joinc 을 호출하지 않더라도 즉시 모든 자원이 해제(free) 된다.

여기에서는 pthread_create 호출후 detach 하는 방법을 설명하고 있는데, pthread_create 호출시에 쓰레드가 detach 되도록 할수도 있다. 이에 대한 내용은 pthread_attr_setdetachstate 를 다루면서 설명하도록 하겠다.

예제 : pthread_detach.c

#include <pthread.h> 
#include <stdio.h> 
#include <unistd.h> 
#include <stdlib.h> 

// 쓰레드 함수 
// 1초를 기다린후 아규먼트^2 을 리턴한다. 
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; 

       printf("Before Thread\n"); 
   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); 
   pause(); 
   return 0; 
}

위의 쏘쓰 코드에서 detach 시켰을때와 그렇지 않았을때의 메모리 상황을 비교해보기 바란다. detatach 를 했을경우 프로세스의 메모리 사용율과 detache 를 주석 처리했을경우의 메모리 사용율의 변화를 서로 비교해보면 되는데, detach 를 사용하지 않았을경우 t_function 이 종료가 되더라도 자원이 해제되지 않음을 볼수 있을것이다. 테스트는 간단한 스크립트를 이용하도록 한다.
[root@localhost test]# while [ 1 ]; do ps -aux | grep pthread | grep -v grep | grep -v vim; sleep 1; done
root 2668 0.0 0.1 1436 292 pts/8 S 18:37 0:00 ./pthread_detach
root 2668 0.0 0.1 1436 292 pts/8 S 18:37 0:00 ./pthread_detach

위의 ps 내용에서 5번째 필드의 변화를 확인하면 된다.

--------------------------------------------------------------------------------

2.4절. pthread_exit

void pthread_exit(void *retval);

pthread_exit 는 현재 실행중인 쓰레드를 종료시키고자 할때 사용한다. 만약 pthread_cleanup_push 가 정의되어 있다면, pthread_exit 가 호출될경우 cleanup handler 가 호출된다. 보통 이 cleanup handler 은 메모리를 정리하는 등의 일을 하게 된다.

예제 : pthread_exit.c

#include <pthread.h> 
#include <stdio.h> 
#include <unistd.h> 
#include <stdlib.h> 

// 쓰레드 함수 
// 1초를 기다린후 아규먼트^2 을 리턴한다. 
void *t_function(void *data) 
{ 
   int num = *((int *)data); 
   int i = 0; 
   while(1) 
   { 
       if (i == 3) 
           pthread_exit(0); 
       printf("loop %d\n", i); 
       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); 
   return 0; 
}

--------------------------------------------------------------------------------

2.5절. pthread_cleanup_push

void pthrad_cleanup_push(void (*routine) (void *), void *arg);

이것은 cleanup handlers 를 인스톨하기 위해서 사용된다. pthread_exit(3) 가 호출되어서 쓰레드가 종료될때 pthread_cleanup_push 에 의해서 인스톨된 함수가 호출된다. routine이 쓰레드가 종료될때 호출되는 함수이다. arg는 아규먼트이다.

cleanup handlers 는 주로 자원을 되돌려주거나, mutex 잠금등의 해제를 위한 용도로 사용된다. 만약 mutex 영역에서 pthread_exit 가 호출되어 버릴경우 다른쓰레드에서 영원히 block 될수 있기 때문이다. 또한 malloc 으로 할당받은 메모리, 열린 파일지정자를 닫기 위해서도 사용한다.

예제 : pthread_cleanup.c

#include <pthread.h> 
#include <stdio.h> 
#include <unistd.h> 
#include <stdlib.h> 
#include <sys/types.h> 

// 쓰레드 함수 
// 1초를 기다린후 아규먼트^2 을 리턴한다. 
// 

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 == 3) 
       { 
           // pthread_exit 가 호출되면서 
           // cleanup 을 호출하게 된다. 
           pthread_exit(0); 
           return 1; 
       } 
       printf("loop %d\n", i); 
       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("Join finish\n"); 
} 

// cleanup handler 
void cleanup(void *myarg) 
{ 
   printf("thread is clean up\n"); 
   printf("resource free\n"); 
   free(mydata); 
}

--------------------------------------------------------------------------------

2.6절. pthread_cleanup_pop
pthread_cleanup_push 와 함께 사용되며, install 된 cleanup handler 을 제거하기 위해서 사용된다.

void pthread_cleanup_pop(int execute);

만약 execute 가 0 이라면, pthread_cleanup_push 에 의해 인스톨된 cleanup handler 를 (실행시키지 않고)삭제만 시킨다. 0 이 아닌 숫자라면 cleanup handler 을 실행시키고 삭제 된다. 사용예제는 2.5절을 참고하라.

그리고 pthread_cleanup_push 와 pthread_cleanup_pop 은 반드시 같은 함수내의 같은 레벨의 블럭에서 한쌍으로 사용해야 한다.

--------------------------------------------------------------------------------

2.7절. pthread_self

pthread_t pthread_self(void);

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

예제 : pthread_self.c

#include <pthread.h> 
#include <stdio.h> 

void *func(void *a) 
{ 
   pthread_t id; 
   id = pthread_self(); 
   printf("->%d\n", id); 
} 

int main(int argc, char **argv) 
{ 
   pthread_t p_thread; 
   pthread_create(&p_thread, NULL, func, (void *)NULL); 
   printf("%d\n", p_thread); 
   pthread_create(&p_thread, NULL, func, (void *)NULL); 
   printf("%d\n", p_thread); 

       return 1; 
}

--------------------------------------------------------------------------------

3절. 쓰레드 동기화 함수
쓰레드 동기화와 관련된 함수들이다.

--------------------------------------------------------------------------------

3.1절. pthread_mutex_init

int pthread_mutex_init(pthread_mutex_t * mutex, 
          const pthread_mutex_attr *attr);

mutex 는 여러개의 쓰레드가 공유하는 데이타를 보호하기 위해서 사용되는 도구로써, 보호하고자 하는 데이타를 다루는 코드영역을 단지 한번에 하나의 쓰레드만 실행가능 하도록 하는 방법으로 공유되는 데이타를 보호한다. 이러한 코드영역(하나의 쓰레드만 점유가능한)을 critical section 이라고 하며, mutex 관련 API 를 이용해서 관리할수 있다.

pthread_mutex_init 는 mutex 객체를 초기화 시키기 위해서 사용한다. 첫번째 인자로 주어지는 mutex 객체 mutex를 초기화시키며, 두번째 인자인 attr 를 이용해서 mutex 특성을 변경할수 있다. 기본 mutex 특성을 이용하기 원한다면 NULL 을 사용하면 된다.

mutex 특성(종류) 에는 "fast", "recurisev", "error checking" 의 종류가 있으며, 기본으로 "fast" 가 사용된다.

// 뮤텍스 객체 선언 
pthread_mutex_t mutex_lock; 
... 
void *t_function() 
{ 
   pthread_mutex_lock(&mutex_lock); 
   // critical section 
   pthread_mutex_unlock(&mutex_lock); 
} 
int main() 
{ 
   pthread_t p_thread; 
   int state; 
   // 뮤텍스 객체 초기화, 기본 특성으로 초기화 했음 
   pthread_mutex_init(&mutex_lock, NULL); 
   pthread_create(&p_thread, NULL, t_function, (void *)&a); 
   ... 
   pthread_joinc(&p_thread, (void **)&status); 
}

--------------------------------------------------------------------------------

3.2절. pthread_mutex_destory

int pthread_mutex_destory(pthread_mutex_t *mutex);

인자로 주어진 뮤텍스 객체 mutex 를 제거하기 위해서 사용된다. mutex 는 pthread_mutex_init()함수를 이용해서 생성된 뮤텍스 객체이다.

pthread_mutex_destory 를 이용해서 제대로 mutex 를 삭제하려면 이 mutex 는 반드시 unlock 상태이여야 한다.

--------------------------------------------------------------------------------

3.3절. pthread_mutex_lock

int pthread_mutex_lock(pthread_mutex_t *mutex);

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

만약 다른 어떤 쓰레드에서도 mutex lock 을 사용하고 있지 않다면, 즉시 mutex lock 을 얻을수 있게 되고 critcal section 에 진입하게 된다. critcal section 에서의 모든 작업을 마쳐서 사용하고 있는 mutex lock 이 더이상 필요 없다면 pthread_mutex_unlock 를 호출해서 mtuex lock 를 되돌려준다.

--------------------------------------------------------------------------------

3.4절. pthread_mutex_unlock

int pthread_mutex_unlock(pthread_mutex_t *mutex);

critical section 에서의 모든 작업을 마치고 mutex lock 을 돌려주기 위해서 사용한다. pthread_mutex_unlock 를 이용해서 mutex lock 를 되돌려주면 다른 쓰레드에서 mutex lock 를 얻을수 있는 상태가 된다.

--------------------------------------------------------------------------------

3.5절. pthread_cond_init

int pthread_cond_init(pthread_cond_t *cond, 
                   const pthread_cond_attr *attr);

pthread_cond_init는 조견변수 (condition variable)cond를 초기화하기 위해서 사용한다. attr 를 이용해서 조건변수의 특성을 변경할수 있으며, NULL 을 줄경우 기본특성으로 초기화된다.

조건변수 cond는 상수 PTHREAD_COND_INITIALIZER 을 이용해서도 초기화 할수 있다. 즉 다음과 같은 2가지 초기화 방법이 존재한다.
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
or
pthread_cond_init(&cond, NULL);

--------------------------------------------------------------------------------

3.6절. pthread_cond_signal

int pthread_cond_signal(pthread_cond_t *cond);

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

--------------------------------------------------------------------------------

3.7절. pthread_cond_boradcast

int pthread_cond_broadcast(pthread_cond_t *cond);

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

--------------------------------------------------------------------------------

3.8절. pthread_cond_wait

int pthread_cond_wait(pthread_cond_t cond, pthread_mutex_t *mutex);

조건변수 cond를 통해서 신호가 전달될때까지 블럭된다. 만약 신호가 전달되지 않는다면 영원히 블럭될수도 있다. pthread_cond_wait는 블럭되기 전에 mutex 잠금을 자동으로 되돌려준다.

--------------------------------------------------------------------------------

3.9절. pthread_cond_timewait

int pthread_cond_timedwait(pthread_cont_t *cond, pthread_mutex_t *mutex, 
                          const struct timespec *abstime);

조건변수 cond를 통해서 신호가 전달될때까지 블럭되며 자동으로 mutex을 돌려주는 점에서는 pthread_cond_wait와 동일하다. 그러나 시간체크가 가능해서 abstime시간동안 신호가 도착하지 않는다면 error 를 발생하면서 리턴한다. 이때 리턴값은 ETIMEDOUT 이다. errno 가 세팅되는게 아닌, 리턴값으로 에러가 넘어오는것에 주의해야 한다.

또한 pthread_cond_timedwait함수는 다른 signal 에 의해서 interrupted 될수 있으며 이때 EINTR 을 리턴한다. 이 함수를 쓸때는 interrupted 상황에 대한 처리를 해주어야 한다.

--------------------------------------------------------------------------------

3.10절. pthread_cond_destroy

int pthread_cond_destroy(pthread_cond_t *cond);

pthread_cond_init를 통해서 생성한 조건변수cond에 대한 자원을 해제한다. destroy 함수를 호출하기 전에 어떤 쓰레드도 cond에서의 시그널을 기다리지 않는걸 확인해야 한다. 만약 cond 시그널을 기다리는 쓰레드가 존재한다면 이 함수는 실패하고 EBUSY 를 리턴한다.

--------------------------------------------------------------------------------

3.11절. 예제코드
이번장에서 설명한 쓰레드 동기화 관련 함수의 이해를 돕기 위해서 간단한 예제를 준비했다. 설명은 주석으로 대신한다.

예제 : pthrad_sync_api.c

#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("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++; 
   } 
}

위의 예제는 ping&pong 프로그램으로 ping 쓰레드와 pong 쓰레드가 각각 번갈아가면서 "ping", "pong" 을 날리는 프로그램이다. 2개의 영역에 걸쳐서 크리티컬섹션이 지정되어 있으며 각 크리티컬섹션안에는 쓰레드 동기화를 위해서 ptread_cond_signal 이 쓰여지고 있다.

위의 코드는 기본적으로 pong 쓰레드가 먼저 시그널을 대기하고 있다가 그 후 ping 쓰레드가 진입해서 "ping"을 날리고 시그널을 발생시키면 "pong" 메시지를 발생시키도록 되어 있다. 그렇다면 while 문에 있는 크리티컬 섹션에 반드시 pong 쓰레드가 먼저 진입할수 있도록 만들어줘야 할것이다. 그래서 위의 코드에서는 pong 쓰레드를 먼저 생성시켰다. 그러나 이것만으로는 충분하지 않다. 예를들어서 pong 쓰레드에서 크리티컬섹션에 들어가기 위해서 어떤 부가적인 작업이 있다고 했을때(메모리초기화, 기타 다른 함수 호출과 같은, 위에서는 sleep 으로 대신했다), 우리가 의도했던 바와는 다르게 ping 가 먼저 크리티컬섹션에 진입할수도 있다. 이럴경우 2개의 쓰레드는 교착상태에 빠지게 된다.

ping 쓰레드가 크리티컬섹션에 먼저 진입했을경우 ping 쓰레드는 "ping" 출력시키고 시그널을 발생시킬 것이고 pong 쓰레드가 "pong"를 출력시키고 시그널을 발생시킬때까지 시그널대기 하게 된다. ping 쓰레드가 시그널대기 하게 되면, 크리티컬섹션에 대한 뮤텍스 잠금이 해제됨으로 뒤늦게 크리티컬섹셔네 진입을 시도하던 pong 가 크리티컬섹션에 진입하고 ping 쓰레드에서부터 신호가 있는지 기다리게 될것이다. 그러나 ping 쓰레드는 이미 신호를 날려버렸음으로, pong 쓰레드는 결코 도착하지 않을 신호를 기다리며 영원히 시그널대기 하게 될것이다. 이런식으로 2개의 쓰레드는 교착상태에 빠져 버린다.

이 문제는 쓰레드간 동기화를 이용해서 해결할수 있으며, 위 코드에서는 mutex 잠금과, 조건변수를 이용해서 해결하고 있다. 물론 쓰레드간 동기화를 위해서 사용할수 있는 원시?적인 방법으로 sleep 나 usleep 같은 함수를 호출하는 방법도 있긴 하지만, ping 쓰레드에서 크리티컬 섹션에 진입하기전 1초 정도 sleep 을 주는 식으로 사용가능하지만 추천할만하진 않다. (간혹 간단하게 사용할수는 으며, 가장 확실한 방법을 제공해 주기도 한다)

--------------------------------------------------------------------------------

4절. Thread Attribute 함수
4.1절. pthread_attr_init

int pthread_attr_init(pthread_attr_t *attr);

pthread_attr_init는 thread attribute 객체인 attr을 디폴트 값으로 초기화 시킨다.

성공할경우 0을 돌려주고 실패할경우 -1 을 되돌려준다.

--------------------------------------------------------------------------------

4.2절. pthread_attr_distroy

int pthread_attr_destroy(pthread_attr_t *attr);

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

--------------------------------------------------------------------------------

4.3절. pthread_attr_getscope

int pthread_attr_getscope(const pthread_attr_t *attr, 
            int *scope);

쓰레드가 어떤 영역(scope)에서 다루어지고 있는지를 얻어오기 위해서 사용된다. PTHREAD_SCOPE_SYSTEM과 PTHREAD_SCOPE_PROCESS 의 2가지 영역중에 선택할수 있다. SYSTEM 영역 쓰레드는 user 모드 쓰레드라고 불리우며, PROCESS 쓰레드는 커널모드 쓰레드라고 불리운다. 리눅스의 경우 유저모드 쓰레드인데, 즉 커널에서 쓰레드를 스케쥴링하는 방식이 아닌 쓰레드 라이브러리를 통해서 쓰레드를 스케쥴링 하는 방식을 사용한다.

#include <pthread.h> 
#include <stdlib.h> 
#include <stdio.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; 
}

위 프로그램을 컴파일한후 Linux 에서 실행시키면 "user mode thread"를 출력하고 솔라리스 상에서 실행시키면 "kernel mode thread"를 출력한다.

--------------------------------------------------------------------------------

4.4절. pthread_attr_setscope

int pthread_attr_setscope(pthread_attr_t *attr, int scope);

쓰레드가 어떤 영역(scope)에서 작동하게 할것인지 결정하기 위해서 사용한다. 리눅스의 경우 Kernel mode 쓰레드를 지원하지 않음으로 오직 PTHREAD_SCOPE_SYSTEM 만을 선택할수 있다. 반면 솔라리스는 유저모드와 커널모드중 선택이 가능하다.

pthread_attr_setscope.c

#include <pthread.h> 
#include <stdlib.h> 
#include <stdio.h> 


int main() 
{ 
   pthread_attr_t pattr; 
   int scope; 

   pthread_attr_init(&pattr); 

   pthread_attr_setscope(&pattr, PTHREAD_SCOPE_PROCESS); 
   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; 
}

위코드에서 쓰레드가 커널 모드에서 작동하도록 지정을 했다. 리눅스에서 실행시킬경우에는 비록 커널모드로 지정을 했다고 하더라도 유저모드 쓰레드로 작동하게 된다. 솔라리스의 경우에는 setscope 로 지정한대로 커널모드에서 작동하게 된다.

--------------------------------------------------------------------------------

4.5절. pthread_attr_getdetachstate

int pthread_attr_getdetachstate(pthread_attr_t *attr, 
          int detachstate);

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

기본은 PTHREAD_CREATE_JOINABLE 이며, pthread_detach를 이용해서 생성된 쓰레드를 detach 상태로 만들었을경우 또는 pthread_attr_setdetachstate함수를 이용해서 쓰레드를 detache 상태로 변경시켰을경우 PTHREAD_CREATE_DETACHED 상태가 된다.

예제 : pthread_attr_getdetachstate.c

#include <pthread.h> 
#include <stdlib.h> 
#include <stdio.h> 

pthread_attr_t attr; 
void *test(void *a) 
{ 
   int policy; 
   printf("Thread Create\n"); 
   pthread_attr_getdetachstate(&attr, &policy); 
   if (policy == PTHREAD_CREATE_JOINABLE) 
   { 
       printf ("Join able\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) 
   { 
       exit(0); 
   } 

   pthread_join(p_thread, (void **)&status); 
}

위의 프로그램을 실행시키면 분명 "Join able"를 출력할것이다.

--------------------------------------------------------------------------------

4.6절. pthread_attr_setdetachstate

int  pthread_attr_setdetachstate(pthread_attr_t *attr, 
            int detachstate);

쓰레드의 상태를 PTHREAD_CREATE_JOINABLE 혹은 PTHREAD_CREATE_DETACHED 상태로 변경시키기 위해서 사용된다. 아래와 같은 방법으로 사용하면 된다.

pthread_attr_t attr; 
... 
// JOINABLE 상태로 변경하고자 할때 
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); 
// DETACHED 상태로 변경하고자 할때 
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

"UNIX/Linux C" 카테고리의 다른 글

Posted by webdizen

Tags API, pthread, Thread, 레퍼런스

1 Trackback 2 Comments

Leave your greetings.

yundream

쓰레드 관련 글을 찾다가 들어왔습니다.
예전에 제가 작성한 글이군요.
쓰레드와 관련되어서 몇개 참고할만한 글들이 더 있어서 트랙백겁니다.

쓰레드와 관련된 많은 정보교환 부탁드립니다. 그럼 오늘도 좋은 하루 되세요.

2007/05/30 10:34 [ Permalink : Modify/Delete : Reply ]
webdizen

안녕하세요.
저도 joinc가 아닌 다른 곳에서 정보를 얻었는지라...
지금보니 출처 표시를 미처 하지 못했었네요. 죄송합니다.

해당 주소로 출처 표시 하겠습니다.
2007/05/31 10:41 [ Permalink : Modify/Delete : Reply ]

Programming/UNIX/Linux C2007/05/11 09:20

쓰레드 객체의 사용

pthread에서 쓰레드로 클래스 객체를 이용하는 방법과 프로세스 종료시 메인 쓰레드에서 생성된 자식쓰레드에게서 어떤 일이 일어나는지 어떻게 하면 좀더 깔끔하게 종료할 수 있을지에 대한 고민?을 담고 있다. 함께 고민해 보자.

목 적 #
C++ 에서 자바의 그것과 비슷한 쓰레드 객체를 만들어 사용한다
객체지향개념에서 각 쓰레드란건 프로그램에서 가장 큰 객체덩어리로 볼 수 있으며, 그런 관점에서 하나의 클래스의 인스턴스 자체로 쓰레드가 된다면 개념적으로 좋을것이다
클래스의 인스턴스를 생성하는순간 클래스의 멤버변수와 메소드를 가지고 활동하는 쓰레드가 가동된다
덧붙여, 데몬 프로그램에서 stop, restart 시에 보통 발생시키는 SIGTERM 신호를 받아서 각 자식 쓰레드들을 종료시킨 후 쓰레드 객체의 소멸자를 호출되게 하여 동적으로 생성한 메모리 및 각종 정리해야할 핸들러들을 해제시킨다

Code 1 #
/* 자바의 그것과 비슷한 쓰레드 객체 클래스 또는 인터페이스 구현 */
/* 데몬으로 실행시 stop 에 의한 SIGTERM 신호에 쓰레드객체의 소멸자 호출처리 */

#include <pthread.h> 
#include <stdlib.h> 
#include <unistd.h> 
#include <iostream> 

using namespace std; 

class tClass { 

  private : 
     pthread_t pt; 
     int* a; 
     void prn(void) { 
        cout << "This is private method " << *a << endl; 
     } 
     // 아래는 쓰레드에서 실제 사용될 메인 함수이다. 순수가상함수로 정의하여 이 클래스를 
     // 인터페이스화하여 상속받는 클래스에서 쓰레드함수로 필요한 작업을 정의하여 사용할 
     // 수 도 있겠다. 그럴땐 protected 혹은 public 멤버로 만들어놓아야 상속받는 클래스에서 
     // 이 순수가상함수의 내용을 정의하여 사용할 수가 있겠다. 또한 pthread_create를 생성자에서 
     // 호출하면 상속받은 클래스에서 내용을 정의해놓은 tFunc 가 호출될 수 없으므로 생성자에선 
     // pthread_create를 하지 않고 따로 멤버함수를 두어 거기서 쓰레드호출을 해야한다. 
     void tFunc(void) { 
        *a = 1; 
        prn(); 
        while (1) { 
           cout << "This is thread method " <<  (*a)++ << endl; 
           sleep(1); 
        } 
     } 
     static void* callThread(void* arg); // 실제 pthread_create에 사용되는 메소드 

  public : 
     tClass(void) { 
        cout << "This is constructor" << endl; 
        a = new int; 
        pthread_create(&pt, NULL, callThread, this); 
        // static 멤버메소드는 static멤버에만 접근가능하므로 이 클래스의 객체주소를 
        // 인자로 넘겨 private를 포함한 모든 멤버를 사용할 수 있도록 한다. 
     } 
     ~tClass(void) { 
        int i; 
        // main의 종료시 종속쓰레드를 먼저 종료시키는지 인스턴스들의 메모리해제를 
        // 먼저 시키는지 알아보기 위하여 루프를 돌림 
        for (i = 0; i < 3; i++) { 
           cout << "This is destructor" << endl; 
           sleep(1); 
        } 
        delete a; 
     } 

}; 

// static 멤버변수는 클래스 선언 밖에서 정의해야함 
void* tClass :: callThread(void* arg) { 
  tClass* tp; 
  tp = (tClass*) arg; 
  tp->tFunc();   // 쓰레드작업을 할 메소드를 실행시킨다 
  // 이 곳에서 직접 쓰레드작업들을 하여도 되겠으나, 클래스멤버를 사용할때마다 
  // 포인터를 통해 접근해야 하므로 깔끔하지 못하며 이 클래스를 인터페이스화하지 못한다 
} 

int main () { 
  int i; 
  tClass tc; 
  for (i = 0; i <  3; i++) { 
     cout << "This is main" << endl; 
     sleep(1); 
  } 
  cout << "main exit" << endl; 
  return (1); 
}

실행을 시켜보면 main 종료시에 객체(변수를 포함한 모든 인스턴스들)의 해제가 먼저 일어나고 - 소멸자가 실행되는 동안 객체 쓰레드가 계속 실행되고 있음 - 그 다음 각 쓰레드을 종료하고 main이 종료되는것을 알 수 있다. 이것은 보통 아무 문제도 되지 않는다. 소멸자가 실행되고 쓰레드가 종료되는건 아주 빠른 순간에 일어날것이다. 그러나, 이미 해제된 메모리나 핸들러에 어떤 엑세스가 가해질 확률이 존재한다는것은 결코 깔끔하지 못하다(적어도 나는 찝찝하다). 그리하여, 보통 데몬의 stop 스크립트에서 발생시키는 SIGTERM을 처리하는 핸들러를 두어 수동으로 먼저 쓰레드를 종료시킨 후 소멸자가 호출되게 해보자.

Code 2 #
/* 자바의 그것과 비슷한 쓰레드 객체 클래스 또는 인터페이스 구현 */
/* 데몬으로 실행시 stop 에 의한 SIGTERM 신호에 쓰레드객체의 소멸자 호출처리 */

#include <signal.h> 
#include <pthread.h> 
#include <stdlib.h> 
#include <unistd.h> 
#include <iostream> 

using namespace std; 

class tClass { 

  private : 
     int* a; 
     void prn(void) { 
        cout << "This is private method " << *a << endl; 
     } 
     // 쓰레드함수이다. 순수가상함수로 정의하여 이 클래스를 인터페이스화하여 
     // 상속받는 클래스에서 쓰레드함수로 필요한 작업을 정의하여 사용할 수 도 있겠다. 
     void tFunc(void) { 
        *a = 1; 
        prn(); 
        while (1) { 
           cout << "This is thread method " <<  (*a)++ << endl; 
           sleep(1); 
        } 
     } 
     static void* callThread(void* arg); // 실제 pthread_create에 사용되는 메소드 

  public : 
     pthread_t pt;  // main 에서의 pthread_cacel 호출을 위해 public으로 함 
     tClass(void) { 
        cout << "This is constructor" << endl; 
        a = new int; 
        pthread_create(&pt, NULL, callThread, this); 
        // static 멤버메소드는 static멤버에만 접근가능하므로 이 클래스의 객체주소를 
        // 인자로 넘겨 private를 포함한 모든 멤버를 사용할 수 있도록 한다. 
     } 
     ~tClass(void) { 
        int i; 
        // main의 종료시 종속쓰레드를 먼저 종료시키는지 인스턴스들의 메모리해제를 
        // 먼저 시키는지 알아보기 위하여 루프를 돌림 
        for (i = 0; i < 3; i++) { 
           cout << "This is destructor" << endl; 
           sleep(1); 
        } 
        delete a; 
     } 

}; 

// static 멤버 메소드는 클래스 선언 밖에서 정의해야함 
void* tClass :: callThread(void* arg) { 
  tClass* tp; 
  pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); 
  pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL); 
  tp = (tClass*) arg; 
  tp->tFunc();   // 쓰레드작업을 할 메소드를 실행시킨다 
  // 이 곳에서 직접 쓰레드작업들을 하여도 되겠으나, 클래스멤버를 사용할때마다 
  // 포인터를 통해 접근해야 하므로 깔끔하지 못하며 이 클래스를 인터페이스화하지 못한다 
} 

tClass tc;  // sigHandler에서의 작업을 위해 전역으로 선언 

void sigHandler(int sig) { 
  cout << "Got signal " << sig << endl; 
  pthread_cancel(tc.pt);        // 쓰레드 종료 
  pthread_join(tc.pt, NULL); 
  cout << "Signal Handler exit" << endl; 
  exit(EXIT_SUCCESS); 
  // 객체의 소멸자는 main이 종료되면서 자동으로 호출된다. 이것도 직접 호출할려면 
  // tClass* tc로 선언하여 new하여 사용한 후 여기서 delete 하면 된다 
} 

int main () { 
  signal(SIGTERM, sigHandler); 
  while (1) { 
     cout << "This is main" << endl; 
     sleep(1); 
  } 
}

ps 하여 나오는 프로세스중에 이 프로그램명의 최상위 pid를 kill 해보자 (kill pid 혹은 kill -TERM pid)
자식 쓰레드를 먼저 종료시킨 후 소멸자가 호출되는것을 알 수 있다

미비점 #
신호처리기에서 쓰레드객체에 접근하기 위하여 쓰레드객체의 인스턴스를 전역으로 선언하였다. 이러한것은 객체지향개념에서는 좋지 못하다. 가능한한 전역변수는 쓰지 않는것이 좋다. 허나 전통적인 시그널은 데이터를 전달할 수 가 없다. 때문에 RTS 를 사용하여 이를 해결할 수 있을것이다. 혹은, 데몬종료시의 메모리와 쓰레드 정리를 위한 더 좋은 방법이 있으면 알려달라 (정리안해도 된다는 말은 하지말아달라. 나도 안다. -.-; 그러나 하는게 좋지 않겠는가?)

출처 : http://www.joinc.co.kr/modules.php?name ··· 3Dnested

"UNIX/Linux C" 카테고리의 다른 글

Zlib를 이용한 압축 프로그래밍 (0)2007/05/11
proc파일시스템 프로그래밍 (0)2007/05/11
쓰레드 객체의 사용 (0)2007/05/11
쓰레드 종료 상태 (0)2007/05/11
Strsafe.h: Safer String Handling in C (0)2007/04/24

Posted by webdizen

Tags pthread, Thread 사용

No Trackback No Comment

Leave your greetings.

Programming/UNIX/Linux C2007/05/11 09:18

쓰레드 종료 상태

이번 글은 쓰레드 종료와 관련된 얘기를 다루고 있다.

본문 출처 : joinc yundream님

차례
1절. 소개
2절. Thread 취소(cancellation)와 종료
2.1절. Thread 취소
2.1.1절. 쓰레드 취소상태의 설정
2.1.2절. 쓰레드 취소종류의 설정
2.1.3절. 취소지점
2.2절. 쓰레드 기본 취소상태와 취소 종류
2.3절. 쓰레드 종료시 자원정리
2.3.1절. 쓰레드 종료시 자원해제
2.4절. 총정리
3절. 참고문헌

--------------------------------------------------------------------------------

1절. 소개
쓰레드에 대해서 학습을 해본적이 있다면 Thread 취소와 종료에 대한 내용은 뻔한 것 아니냐 라고 생각할 수 있을 것이다. 하지만 이 문서를 읽어 보면 왜 별도의 문서를 만들어서 종료와 취소에 대해서 다루었는지 이해하게 될 것이다.

--------------------------------------------------------------------------------

2절. Thread 취소(cancellation)와 종료
쓰레드는 제어가능한 객체로 필요에 따라 생성시킬 수 있듯이 필요에 따라서 중단 시킬 수도 있다. 이 쓰레드 중단이라는 것이 매우 단순한 행위라고 생각되지만 생각처럼 그렇게 단순한 행위가 아니다. 멀티 쓰레드 프로그램이라면 쓰레드간 동기화를 위해서 조건변수 뮤텍스등 을 사용하고 있을 것이며, 여러가지 공유 자원들 역시 가지고 있을 것이다.

몇명의 인원이 같이 참가해서 진행하는 프로젝트가 있다고 생각해 보자. 그중 한명이 프로젝트에서 빠지면 나머지 인원이 프로젝트를 진행하는데 문제가 생기지 않도록 이런 저런 뒷수습을 해주는게 매우 중요하다. 쓰레드 역시 마찬가지로 중단(종료)시 뒷수습을 해주는 것은 매우 중요한 일이다. 이 문서는 쓰레드 취소에 관련된 내용과 쓰레드 종료시 신경써야될 (자원정리 와 같은)것들에 대해서 알아보도록 한다.

--------------------------------------------------------------------------------

2.1절. Thread 취소
멀티 쓰레드 프로그램에서 특정 쓰레드를 중단 시키고자 할때를 위해서 Pthread는 ptread_cancel()이라는 함수를 제공한다. int pthread_cancel(pthread_t thread);

이 함수는 인자로 주어진 쓰레드 식별번호 thread를 가지는 쓰레드를 중지시킨다. 명확히 말하자면 쓰레드를 중지 시키는게 아니고 쓰레드에 취소 요청을 하는 것으로 봐야 한다. 취소 요청을 받은 쓰레드가 어떻게 반응 할런지는 요청을 받은 쓰레드의 취소 상태 설정에 의존한다. 취소 요청을 받은 쓰레드는 취소 상태에 의해서 필요한 작업을 한 후 종료 하게 된다. 취소 요청을 받아서 종료하는 쓰레드는 pthread_exit(PTHREAD_CANCELED)를 호출하고 종료한다.

pthread_cancel()에 의해서 취소가 통보된 쓰레드는 쓰레드 취소 상태의 설정에 따라서 취소 요청을 무시할 수도 취소지점(cancellation point) 지점까지 수행한뒤에 종료 될수도 있기 때문이다.

쓰레드 취소와 종료는 엄연히 다르다는 것을 이해하기 바란다. 그렇지 않으면 앞으로 문서의 내용을 읽는데 헛갈릴 수 있다.

--------------------------------------------------------------------------------

2.1.1절. 쓰레드 취소상태의 설정
쓰레드가 pthread_cancel()에 의해서 취소요청을 받았을 때 어떻게 반응할런지를 결정하는 쓰레드 취소상태는 여러가지 방법에 의해서 결정된다. 취소 상태는 pthread_setcancelstat() 함수에 의해 결정한다. int pthread_setcancelstate(int state, int *oldstate);

첫번째 인자인 state는 새로운 취소상태를 설정하기 위해서 사용된다. 두번째 인자인 oldstate는 이전의 취소상태의 설정값을 받아오기 위해서 사용된다. 이 함수는 다음과 같이 사용할 수 있다.

int old_cancel_state; 
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old_cancel_state); 
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &old_cancel_state);

만약 이전의 취소상태 설정값이 필요 없다면 old_cancel_state대신 NULL을 사용하면 된다. 위의 사용에서 처럼 쓰레드는 PTHREAD_CANCEL_DISABLE와 PTHREAD_CANCEL_ENABLE 둘중 하나의 취소상태를 가질 수 있다.

만약 PTHREAD_CANCEL_ENABLE 상태라면 쓰레드는 취소요청을 받아들이고 취소지점까지 진행한다음 취소 지점을 벗어나야지 종료한다. ENABLE 상태일 경우 별도로 취소지점까지 진행한다음 종료할 것인지 아니면 바로 종료할 것인지를 pthread_setcanceltype() 를 통해 지정할 수 있다. 만약 PTHREAD_CANCEL_DISABLE 상태라면 취소요청을 받은 후 취소지점까지의 진행을 하지 않고 바로 종료한다.

--------------------------------------------------------------------------------

2.1.2절. 쓰레드 취소종류의 설정
쓰레드 취소상태가 PTHREAD_CANCEL_ENABLE인 경우 취소의 종류를 결정할 수 있다. 취소종류의 결정은 pthread_setcanceltype()을 통해서 이루어진다. int pthread_setcanceltype(int type, int *oldtype);

취소종류는 type를 통해서 결정된다. PTHREAD_CANCEL_ASYNCHRONOUS와 PTHREAD_CANCEL_DEFERRED 둘 중 하나를 선택할 수 있다. 전자일 경우 바로 종료하며, 후자의 경우 취소지점을 벗어날 때까지 기다리게 된다. oldtype를 이용해서 이전 취소타입을 얻어 올 수 있다. NULL이라면 받아오지 않는다. 이 함수는 당연하지만 취소상태가 PTHREAD_CANCEL_DISABLE 라면 의미 없는 함수다.

--------------------------------------------------------------------------------

2.1.3절. 취소지점
쓰레드에게 취소요청이 왔다고 해서 무조건 취소해 버리면 문제가 생길 수도 있다. 어떤 일을 처리하고 있는 중에 취소요청이 전달했는데, 별로 중요하지 않는 (무시해도 될만한) 일이라면 중단후 바로 취소해도 되겠지만 중요한 일을 처리하는 중이라면 일을 처리한후 종료 해야 할것이다. 이 마지 노선이 취소지점이다.

취소지점으로 설정될 수 있는 영역은 다음과 같다.

pthread_join(3) 
pthread_cond_wait(3) 
pthread_cond_timedwait(3) 
pthread_testcancel(3) 
sem_wait(3) 
sigwait(3)

pthread_setcancelstate()함수에 의해서 PTHREAD_CANCEL_ENABLE 상태로 되어 있다면 취소지점을 무시하고 즉시 종료 된다. PTHREAD_CANCEL_DISABLE로 되어 있다면 위의 취소지점을 벗어날 때까지 기다린다. 즉 취소요청을 받은 쓰레드가 pthread_cond_wait()에서 조건변수를 기다리는고 있다면 조건변수 를 받을 때까지 취소를 유보하게 된다.

--------------------------------------------------------------------------------

2.2절. 쓰레드 기본 취소상태와 취소 종류
별다른 설정이 없을 경우 pthread_create()로 만들어 지는 쓰레드는 PTHREAD_CANCEL_ENABLE, PTHREAD_CANCEL_DEFERRED로 상태로 생성된다.

--------------------------------------------------------------------------------

2.3절. 쓰레드 종료시 자원정리
pthread_cancel()등을 통해서 종료 통보를 받은 쓰레드는 종료하기 전에 여러가지 일을 해주어야 할 것이다. 뭐 간단한 쓰레드라면 관계 없겠지만 복잡하게 얽혀 있는 멀티 쓰레드 프로그램이라면 이런 저런 정리해줘야 할 것들이 많을 것이다.

--------------------------------------------------------------------------------

2.3.1절. 쓰레드 종료시 자원해제
쓰레드에서 malloc()등을 호출해서 메모리 공간을 확보했다거나 DB나 파일, 소켓등을 열어서 작업했다면 반드시 이들 자원을 해제시켜줘야 한다. 간단하게 생각하자면 쓰레드 종료시점에서 free(), close(), DB라면 이런 저런 정리를 해주면 될것이다. 그러나 pthrad_cancel()등에 의해서 작업중간에 요청을 받았다면 그리 간단한 문제가 아니다. 쓰레드 마지막까지 루틴을 진행할 수 없기 때문이다. 이럴 경우를 대비해서 pthread_cleanup_push(), pthread_cleanup_pop()와 같은 함수를 제공한다.

이 함수들을 이용해서 쓰레드가 종료할 때 호출해야할 함수를 지정할 수 있다. 그러므로 프로그래머는 이들 함수에 자원해제와 같은 필요한 코드를 넣어두기만 하면 된다. 이들 함수에 대한 자세한 내용은 Pthread_API를 참고하기 바란다.

--------------------------------------------------------------------------------

2.4절. 총정리
지금까지의 내용을 예제를 통해서 정리해보도록 하자.

#include <pthread.h> 
#include <unistd.h> 
#include <stdlib.h> 
#include <stdio.h> 
#include <sys/time.h> 

// 쓰레드 종료시 호출될 함수 
void clean_up(void *); 

// 쓰레드 함수 
void *thread_func(void *); 

pthread_cond_t cond = PTHREAD_COND_INITIALIZER; 
pthread_mutex_t lmu = PTHREAD_MUTEX_INITIALIZER; 

int main(int argc, char **argv) 
{ 
   pthread_t pt; 
   pthread_create(&pt, NULL, thread_func, NULL); 

   // 생성된 쓰레드 pt에 취소 요청을 보낸다. 
   pthread_cancel(pt); 

   // 5초를 쉰 후에 시그널을 보낸다. 
   sleep(5); 
   pthread_cond_signal(&cond); 

   // join후 종료한다. 
   pthread_join(pt, NULL); 
   printf("exit\n"); 
   exit(1); 
} 

// 쓰레드 종료시 효출될 함수 
// 여기에 자원해제루틴을 입력할 수 있을 것이다. 
void clean_up(void *arg) 
{ 
   printf("Thread cancel Clean_up function\n"); 
} 

void *thread_func(void *arg) 
{ 
   // DISABLE 상태다. 
   // 이경우 쓰레드에 대해서 취소 요청이 들어오면 
   // 바로 취소된다.   
   pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); 

   // 쓰레드 종료시 호출될 함수 등록 
   pthread_cleanup_push(clean_up, (void *)NULL); 

   while(1) 
   { 
       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); 
}

main 쓰레드는 thread_func를 실행시킨다. thread_func는 pthread_cond_wait()에서 신호가 발생하기를 기다리게 된다. 잠시후 main 쓰레드는 pthread_cancel()을 이용해서 thread_func 쓰레드에 취소 요청을 하게 된다. 위의 경우 thread_func쓰레드는 취소상태가 PTHREAD_CANCEL_DISABLE로 되어 있기 때문에 취소 지점등은 부시하고 바로 종료된다. 이때 pthread_cleanup_push()에 등록된 clean_up함수가 실행되는걸 확인할 수 있을 것이다.

PTHREAD_CANCEL_ENABLE로 되어 있을 경우 취소 요청을 받아들이기 때문에 취소 요청이 들어오더 라도 thread_func가 현재 종료 지점에 머물러 있기 때문에 곧바로 종료하지 않는다. main 쓰레드에서 pthread_cond_signal()를 호출해서 thread_func가 cond_wait상태를 벗어난 후 종료된다. 물론 cleanup 함수도 실행된다.

--------------------------------------------------------------------------------

3절. 참고문헌

pthread API 레퍼런스
: http://www.joinc.co.kr/modules/moniwiki ··· read_api

mutex와 조건변수
: http://www.joinc.co.kr/modules/moniwiki ··· EC%88%98

"UNIX/Linux C" 카테고리의 다른 글

proc파일시스템 프로그래밍 (0)2007/05/11
쓰레드 객체의 사용 (0)2007/05/11
쓰레드 종료 상태 (0)2007/05/11
Strsafe.h: Safer String Handling in C (0)2007/04/24
호출 규약 (Calling Convention) (0)2007/04/06

Posted by webdizen

Tags pthread, Thread 종료, Thread 취소

No Trackback No Comment

Leave your greetings.

«Prev 1 Next»

수안이의 컴퓨터 연구실

3 Articles, Search for 'pthread'

pthread API 레퍼런스

Trackback URL : http://www.webdizen.net/blog/trackback/2931

Pthread 채널 Delete

Leave your greetings.

쓰레드 객체의 사용

Trackback URL : http://www.webdizen.net/blog/trackback/2921

Leave your greetings.

쓰레드 종료 상태

Trackback URL : http://www.webdizen.net/blog/trackback/2920

Leave your greetings.

Categories

Notice

Tags

Recent Articles

Recent Comments

Recent Trackbacks

Archive

Calendar

Bookmarks