멀티 스레드 프로그래밍에서 '잠금'을 사용해야하는시기는 언제입니까?

Question

멀티 스레드 프로그래밍에서 '잠금'을 사용해야하는시기는 언제입니까? 각 스레드가 수정하거나 수정하지 않아도 각 스레드가 액세스 할 수있는 영역을 잠글 영역을 잠그십시오. 좀 더 시간이 있다면 귀하의 관심

struct share_data { 
    /* share data */ 
    thread_id; 
} 

thread 1 will exceute main() function: 
    Initial share data. /* need lock */ 

    join all thread(share_data.thread_id, &status) /* access share data thread_id, lock or not? */ 
    exit. 

other threads will: 
    access share_data, /* lock or not? */ 
    modify share_data, /* lock */ 
    exit. 

덕분에, 그리고 실제 코드에 대한 자세한 내용 :

/* 
the number of threads will be input by user. Structure "tdata" and "tlist" stores 
information of each thread, including: "tid" - thread id which is gaven by 1st argument 
of pthread_create(), "torder" which is the order of calling pthread_create() for each 
thead, "status" stores work status of each thread. I allocate memory for "tlist" 
dynamically. Now, we assume that the number of threads is NUM_THREADS(5). I do not use 
the 4th argument to pass data to each thread, I use global variable "tdata", "tlist" as 
shared data to them. "mutex" variable is used to make sure those threads share data safely, 
but it seems not works correctly. 

I wanna each thread can get "torder", and maybe modify the status before calling 
pthread_exit(). 
*/ 
#include <pthread.h> 
#include <unistd.h> 
#include <stdio.h> 
#include <stdlib.h> 

/* #define NUM_THREADS 5 */ 
struct tdata { 
     pthread_t tid; 
     int torder; 
     int status; 
     struct tdata *next; 
}; 
typedef struct tdata tdata_t; 
struct tdatalist { 
     tdata_t *head; 
     tdata_t *tail; 
}tlist; 

pthread_mutex_t mutex; 
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; 
void *tfunc() { 
     tdata_t *p, *q; 
     unsigned long int tid; 
     int torder; 

     p = tlist.head; 
     q = NULL; 
     pthread_mutex_lock(&mutex); 

     tid = pthread_self(); 

     while (p->tid!=tid && p->next!=NULL) { 
       q = p; 
       p = p->next; 
     } 
     tid = p->tid; 
     torder = p->torder; 
     /* p->status = 0; */ 
     pthread_mutex_unlock(&mutex); 
     /* printf ("I am thread %lu, myorder %d, thread_exit.\n", tid, torder); */ 
     printf ("I am thread %0x, myorder %d, thread_exit.\n", tid, torder); 

     pthread_exit((void *)torder); 
} 

int main (int argc, char *argv[]) { 
/*  pthread_t thread[NUM_THREADS]; */ 

     pthread_attr_t attr; 
     int t; 
     tdata_t *tdata_p; 
     int num_threads; 
     printf ("Input number of threads:"); 
     scanf ("%d", &num_threads); 
     printf ("\n"); 

     printf ("Main thread id: %08x\n", pthread_self()); 

     pthread_mutex_init(&mutex, NULL); 
     pthread_attr_init(&attr); 
     pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); 

     tlist.head=tlist.tail=NULL;  /* create and initial tlist */ 
     for (t=0; t<num_threads; t++) { 

       pthread_mutex_lock(&mutex); 
       tdata_p = (tdata_t *) malloc (sizeof (tdata_t)); 
       pthread_create (&tdata_p->tid, &attr, tfunc, NULL); 
       /* tdata_p->tid = thread[t]; */ 
       tdata_p->torder = t; 
       tdata_p->status = 1;   /* for 0,finished the work. for 1,not*/ 
       tdata_p->next = NULL; 

       if(tlist.head == NULL) { 
         tlist.head = tlist.tail = tdata_p; 
       } 
       else { 
         tlist.tail->next = tdata_p; 
         tlist.tail = tdata_p; 
       } 
       pthread_mutex_unlock(&mutex); 

     } 

     /* Join child threads */ 
     pthread_attr_destroy(&attr); 
     pthread_mutex_lock (&mutex); 
     tdata_t *p; 
     tdata_t *q; 
     void *status; 
     p = tlist.head; 
     while (p != NULL) { 
       q = p->next; 
       pthread_join(p->tid, &status); 
       p = q; 
     } 

     pthread_mutex_unlock (&mutex); 

     pthread_mutex_destroy(&mutex); 
     /* delete the list */ 
     p = tlist.head; 
     while (p != NULL) { 
       q = p->next; 
       free (p); 
       p = q; 
     } 
     tlist.head = tlist.tail = NULL; 

     printf ("Main exit.\n"); 
     pthread_exit(NULL); 

     return 0; 
} 

Answer 1

읽거나 데이터를 기록하려고 할 때마다, 당신은 그것을 고정해야합니다. 이렇게하면 데이터가 아직 쓰여지지 않은 데이터를 읽지 못하게됩니다.

또 다른 방법은 스레드 또는 프로세스간에 공유되는 모든 데이터를 변경하거나 읽기 전에 잠궈 야합니다.

Answer 2

상위 수준의 스레드 간 통신 (예 : 생산자 - 소비자 대기열)의 단기 잠금 이외에는 "자주 벗어날 수있는만큼 드물게"라고 대답 할 것입니다. 잠금은 교착 상태를 발생시키고 교착 상태의 가능성은 수퍼 선형 방식으로 더 많은 잠금과 곱합니다.

또한 앱에서 좋은 pthread_join() 호출은 0입니다. < 0은 불가능하고 1 이상은 너무 많이 있습니다.