[Philosophers] Bonus part 함수 공부 (sem)

Mandatory와의 차이점

Mandatory Part가 쓰레드를 사용하는 문제였다면 Bonus Part는 프로세스 사용함.

쓰레드는 Mutex라는 함수를 이용하여 Lock을 걸기 때문에 Mutex를 공부했고

Bonus는 semaphore를 이용하기 때문에 semaphore를 공부하려고 한다.

---

Semaphore

• exit, fork, kill은 이전 과제에서 사용해본 적이 있기 때문에 사용법 pass

P & V 공부하기

• 세마포어 개념 먼저 공부하고 싶어서 P, V도 한번 짜봤다.

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

int g_num = 0;

void p() {
    while (g_num <= 0)
    {
        usleep(1000 * 1000);
        if (g_num > 0)
            break;
        printf("busy waiting[%d]...\n", g_num);
    }
    g_num--;
    printf("p made g_num `%d`\n", g_num);
 }

void v() {
    g_num++;
    printf("v made g_num `%d`\n", g_num);
 }

void
    *routine_1(void *arg)
{
    p(); // get the key. key: 0
    return ((void *)0);
}

void
    *routine_2(void *arg)
{
    v(); // return the key. key: 1
    return ((void *)0);
}

int main()
{
    pthread_t   t[2];
    
    pthread_create(&t[0], NULL, &routine_1, NULL);
    usleep(1000 * 1000 * 5);
    pthread_create(&t[1], NULL, &routine_2, NULL);
   
    pthread_join(t[0], NULL);
    pthread_join(t[1], NULL);

}

결과창

busy waiting[0]...
busy waiting[0]...
busy waiting[0]...
busy waiting[0]...
v made g_num `1`
p made g_num `0`

 

세마포어

• header: semaphore.h
• 사용예시

// exit stdlib.h
// fork stdio.h
// kill signal.h sys/types.h

// semaphore.h
// sem_close
// sem_open
// sem_post
// sem_unlink
// sem_wait
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <sys/types.h>
#include <semaphore.h>
#include <pthread.h>

int g_num = 0;
sem_t       *sem;

void
    *routine_print(void *arg)
{
    char *str;

    //wait : lock the semaphore.(until call `post`)
    sem_wait(sem); // get the key.
    str = (char *)arg;
    while (*str)
    {
        printf("[%d]%c\n", g_num, *str);
        str++;
    }
    //post : unlock the semaphore.
    sem_post(sem); // return the key.
    return ((void *)0);
}

void
    *routine_edit(void *arg)
{
    char *str;

    sem_wait(sem);
    str = (char *)arg;
    while (*str)
    {
        g_num++;
        str++;
    }
    sem_post(sem);
    return ((void *)0);
}


int main()
{
    pthread_t   t[2];
   
    char        *str = "ABCDE";

    // init :   create semaphore without name.
    // open :   create semaphore with name.
    //          return semaphore descriptor(sd).(until call `close`)
    sem = sem_open("sem", 0, 0);

    // wait & post(inside the function)
    pthread_create(&t[0], NULL, &routine_print, (void *)str);
    usleep(1000);
    pthread_create(&t[1], NULL, &routine_edit, (void *)str);
   
    pthread_join(t[0], NULL);
    pthread_join(t[1], NULL);

    //unlink :  It is destroyed when all processes unlink the semaphore.
    //close :   destroy semaphore.
    sem_close(sem);
}