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

class B;

class A{
public:
  //pthread_t p;
  int thr_id;
  int count = 0;
  B* b;
  void setB(B* _b) {b = _b;}
  pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
  // mutex가 A에 선언되었기에 A인스턴스 내부만 방어가 된다.

  void startThr() {
    //thr_id = pthread_create(&p, NULL, &A::threadA, (void*)&thr_id);
  }


};

class B{
public:
  //pthread_t p;
  int thr_id;
  int count = 0;
  A* a;
  void setA(A* _a) {a = _a;}
  pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

  void startThr() {
    //thr_id = pthread_create(&p, NULL, &B::threadB, (void*)&thr_id));
  }

};

void* threadA(void* p){
  B* b = (B*)p;
  while(1)
  {
    pthread_mutex_lock(&(b->mutex));    // 2번 호출되면 unlock 호출 시 까지 여기서 대기
    // 여기가 제일 중요한데, 이게 무슨말이냐고 하면 mutex lock이 걸려있는 동안 B 인스턴스의 변수를 변경할 수 있는 권한은 현재 스레드 밖에 없다는 점.
    // 따라서 다른 스레드(혹은 자기 자신이라도) 접근하려고 할 수 없고 대기해 있게 된다.
    printf("A : %d\n", (b->a->count)++);
    //b->a->count++;
    sleep(2);
    pthread_mutex_unlock(&(b->mutex));
  }
}


void* threadB(void* p){
  B* b = (B*)p;

  while(1)
  {
    //pthread_mutex_lock(&(b->mutex));
    printf("threadB to a : %d\n", (b->a->count)++);
    sleep(1);
    //pthread_mutex_unlock(&(b->mutex));
  }

}

int main(int argc, char **argv)
{
  A* a = new A;
  B* b = new B;
  a->setB(b);
  b->setA(a);
  pthread_t p[2];
  a->thr_id = pthread_create(&p[0], NULL, threadA, (void*)a);
  b->thr_id = pthread_create(&p[1], NULL, threadB, (void*)b);

void* threadA(void* p){
  B* b = (B*)p;
  while(1)
  {
    pthread_mutex_lock(&(b->mutex));    // 2번 호출되면 unlock 호출 시 까지 여기서 대기
    printf("A : %d\n", (b->count)++);
    sleep(2);
    //pthread_mutex_unlock(&(b->mutex));
  }
}


void* threadB(void* p){
  B* b = (B*)p;

  while(1)
  {
    //pthread_mutex_lock(&(b->mutex));
    printf("threadB to b : %d\n", (b->count)++);
    sleep(1);
    //pthread_mutex_unlock(&(b->mutex));
  }

}

#include <pthread.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);
    }

    // 쓰레드가 종료되기를 기다린다. (넣지 않을 시 Main 쓰레드가 먼저 종료되기에 테스팅이 불가능!)
    pthread_join(p_thread[0], (void**)&status);
    pthread_join(p_thread[1], (void**)&status);

    // (참고) pthread_join에 대한 설명 : join을 할 시 해당 쓰레드가 종료 될때까지 다음 라인으로 넘어가지 않음
    /*
    pthread_join(p_thread[0], (void**)&status);
    printf("End Thread \n");
    */
    // p_thread[0]이 종료되고 나서 printf가 호출된다.

    return 0;
}

pthread_detach(p_thread[0]);
// main 쓰레드에서 p_thread[0]을 컨트롤 할 수 없게된다.
// 거의 사용할 일이 없다고 보면됨.

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

int ncount;    // 쓰레드간 공유되는 자원
pthread_mutex_t  mutex = PTHREAD_MUTEX_INITIALIZER; // 쓰레드 초기화

// 쓰레드 함 수 1
void* do_loop(void *data)
{
    int i;

    pthread_mutex_lock(&mutex); // 잠금을 생성한다.
    for (i = 0; i < 10; i++)
    {
        printf("loop1 : %d", ncount);
        ncount ++;
        sleep(1);
    }
    pthread_mutex_unlock(&mutex); // 잠금을 해제한다.
}

// 쓰레드 함수 2
void* do_loop2(void *data)
{
    int i;

    // 잠금을 얻으려고 하지만 do_loop 에서 이미 잠금을 
    // 얻었음으로 잠금이 해제될때까지 기다린다.  
    pthread_mutex_lock(&mutex); // 잠금을 생성한다.
    for (i = 0; i < 10; i++)
    {
        printf("loop2 : %d", ncount);
        ncount ++;
        sleep(1);
    }
    pthread_mutex_unlock(&mutex); // 잠금을 해제한다.
}    
	
int main()
{
    int thr_id;
    pthread_t p_thread[2];
    int status;
    int a = 1;

    ncount = 0;
    thr_id = pthread_create(&p_thread[0], NULL, do_loop, (void *)&a);
    sleep(1);
    thr_id = pthread_create(&p_thread[1], NULL, do_loop2, (void *)&a);

    pthread_join(p_thread[0], (void *) &status);
    pthread_join(p_thread[1], (void *) &status);

    status = pthread_mutex_destroy(&mutex);
    printf("code  =  %d", status);
    printf("programing is end");
    return 0;
}