쓰레드 동기화 (Synchronization)

Thread Synchronization(쓰레드 동기화)

 

-쓰레드를 생성하는 것은 매우 쉽지만, 그 쓰레드들이 데이터를 공유할 때 문제가 생기지 않도록 동기화 시키는 것이 정말 중요하다.

- 문제가 발생할 확률은 정말 낮지만, critical system에서는 한번 문제가 발생하게 되면 심각한 결과를 초래하게 된다.

- 문제가 발생할 확률이 낮기에 오류를 찾아 내는 것이 무척 어렵다.

 

 

* Synchronization Tool

 

1. pthread_join function : Thread 수행 종료시까지 기다린다.

2. Mutex variable function : Rock 을 가진 쓰레드만 코드를 진행할 수 있다.

3. Condition variable functions

4. Reader/writer exclusion : 읽는 것은 동시에 수행가능하지만, 쓰는것은 한번에 한 쓰레드만 쓸 수 있도록 한다.

5. Semaphores(세마포어): POSIX real-time extensions(POSIX.1b)

 

 

 

 

<Mutex Variables>

 

 - Mutual exclution( mutex )

    : 한 쓰레드가 데이터를 엑세스 할때, 다른 쓰레드 들은 그 데이터를 엑세스 할 수 없다.

 - Critical section을 잘 찾아내는 것이 중요 !

 - 보호하고자 하는 부분(Critical section)에 mutex 사용

 - 쓰레드는 pthread_mutex_lock을 사용해 리소스의 mutex를 rock하고 그 리소스를 엑세스 해야 한다. 오직 하나의 쓰레드만 그 시간에 mutex를 rock 할수 있고, 다른 쓰레드들은 그동안 기다린다.

 - 쓰레드가 리소스 사용을 마치면, phtread_mutex_unlock함수를 사용하여 mutex를 unlock한다.

 - mutex는 초기에 unlocked되어있어야 한다(초기화)

   : pthread_mutex_t mymutex = THREAD_MUTEX_INITIALIZER;

 

 

<예제>

 

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

 

typedef struct{
        double *a;
        double *b;
        double sum;
        int veclen;
}DOTDATA;

#define NUMTHRDS 4
#define VECLEN 100

 

DOTDATA dotstr;

pthread_t callThd[NUMTHRDS];
pthread_mutex_t mutexsum;

 

void *dotprod(void *arg){
        int i, start, end, offset, len,j;

        double mysum, *x, *y;
        double result = 0.0;

        offset = (int)arg;
        len = dotstr.veclen;
        start = offset*len;
        end = start+len;
        x = dotstr.a;
        y = dotstr.b;

        mysum = 0;

        for(i=start;i<end;i++){
                mysum+=(x[i]*y[i]);
        }

 

        for(j=0;j<1000000;j++){
                 result = result+(double)random();
        }

        result = 0.0;
        pthread_mutex_lock(&mutexsum);             //mutex lock
        dotstr.sum+=mysum;
        pthread_mutex_unlock(&mutexsum);         //mutex unlock

        pthread_exit((void*)0);                           //스레드 종료
}

 

int main(int argc, char *argv[]){
        int i;
        double *a, *b;
        int status;
        pthread_attr_t attr;

        a = (double*)malloc(NUMTHRDS*VECLEN*sizeof(double));
        b = (double*)malloc(NUMTHRDS*VECLEN*sizeof(double));

        for(i=0;i<VECLEN*NUMTHRDS;i++){
                a[i] = 1;
                b[i] = a[i];
        }

        dotstr.veclen  = VECLEN;
        dotstr.a = a;
        dotstr.b = b;
        dotstr.sum = 0;
        pthread_mutex_init(&mutexsum, NULL); //mutex 초기화
        pthread_attr_init(&attr);
        pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);

 

        for(i=0;i<NUMTHRDS;i++){
                pthread_create(&callThd[i],&attr,dotprod,(void*)i);
        }

        pthread_attr_destroy(&attr);

        for(i=0;i<NUMTHRDS;i++){
                pthread_join(callThd[i],(void**)&status); //thread들이 종료되길 기다린다
        }

        printf("Sum = %f\n", dotstr.sum);

        free(a);
        free(b);

        pthread_mutex_destroy(&mutexsum); //mutex destroy
        pthread_exit(NULL);

}