philosophers - KimTaebin-ai/study_posts GitHub Wiki

int sum;

void *run1(void *param)
{
    int i;
    for (i = 0; i < 10000; i++)
        sum++;
    pthread_exit(0);
}

void *run2(void *param)
{
    int i;
    for (i = 0; i < 10000; i++)
        sum++;
    pthread_exit(0);
}

int main()
{
    pthread_t tid1, tid2;
    pthread_create(&tid1, NULL, run1, NULL);
    pthread_create(&tid2, NULL, run2, NULL);
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    printf("%d\n", sum);
}

// register1 = sum;
// register1 = register1 + 1;
// sum = register1;

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

int sum;
pthread_mutex_t mutex;

void *run1(void *param)
{
    int i;
    for (i = 0; i < 10000; i++) {
        pthread_mutex_lock(&mutex);
        sum++;
        pthread_mutex_unlock(&mutex);
    }
    pthread_exit(0);
}

void *run2(void *param)
{
    int i;
    for (i = 0; i < 10000; i++) {
        pthread_mutex_lock(&mutex);
        sum++;
        pthread_mutex_unlock(&mutex);
    }
    pthread_exit(0);
}

int main()
{
    pthread_t tid1, tid2;
    pthread_mutex_init(&mutex, NULL);

    pthread_create(&tid1, NULL, run1, NULL);
    pthread_create(&tid2, NULL, run2, NULL);

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);

    printf("%d\n", sum);

    pthread_mutex_destroy(&mutex);
    return 0;
}

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

#define true 1
#define NUM_PHILS 5 // 철학자들의 인원수

// THINKING : 생각중인  상태
// HUNGRY   : 배고픈    상태
// EATING   : 밥을 먹는 상태
enum
{
    THINKING,
    HUNGRY,
    EATING
} state[NUM_PHILS];

pthread_mutex_t mutex_lock;
pthread_cond_t cond_vars[NUM_PHILS];

void init();
int leftOf(int i);
int rightOf(int i);
void *philosopher(void *param);
void think(int id);
void eat(int id);
void pickup(int id);
void putdown(int id);
void test(int i);

int main()
{

    pthread_t tid;
    init();
    for (int i = 0; i < NUM_PHILS; i++)
    {
        pthread_create(&tid, NULL, philosopher, (void *)&i);
    }
    for (int i = 0; i < NUM_PHILS; i++)
    {
        pthread_join(tid, NULL);
    }
    return 0;
}

void init()
{
    for (int i = 0; i < NUM_PHILS; i++)
    {
        state[i] = THINKING;
        pthread_cond_init(&cond_vars[i], NULL);
    }
    pthread_mutex_init(&mutex_lock, NULL);
    srand(time(0));
}

int leftOf(int i)
{
    return (i + NUM_PHILS - 1) % NUM_PHILS;
}

int rightOf(int i)
{
    return (i + 1) % NUM_PHILS;
}

void *philosopher(void *param)
{
    int id = *((int *)param);
    while (true)
    {
        think(id);
        pickup(id);
        eat(id);
        putdown(id);
    }
}

void think(int id)
{
    printf("%d: Now, I'm thinking...\n", id);
    usleep((1 + rand() % 50) * 10000);
}

void eat(int id)
{
    printf("%d: Now, I'm eating...\n", id);
    usleep((1 + rand() % 50) * 10000);
}

void pickup(int id)
{
    pthread_mutex_lock(&mutex_lock);

    state[id] = HUNGRY;
    test(id);
    while (state[id] != EATING)
    {
        pthread_cond_wait(&cond_vars[id], &mutex_lock);
    }

    pthread_mutex_unlock(&mutex_lock);
}

void putdown(int id)
{
    pthread_mutex_lock(&mutex_lock);

    state[id] = THINKING;
    test(leftOf(id));
    test(rightOf(id));

    pthread_mutex_unlock(&mutex_lock);
}

void test(int i)
{
    // 만약 철학자 i가 배고픈 상태이고 이웃하는 젓가락이 eating 상태가 아니라면
    // 밥을 먹습니다.
    if (state[i] == HUNGRY &&
        state[leftOf(i)] != EATING &&
        state[rightOf(i)] != EATING)
    {
        state[i] = EATING;
        pthread_cond_signal(&cond_vars[i]);
    }
}

int		number_of_philosophers;
/*
	철학자의 수 :
	철학자의 수와 포크의 수입니다.
*/

int		time_to_die;
/*
	철학자의 수명(밀리초 단위) :
	철학자가 마지막으로 밥을 먹기 시작한 시점으로부터
	time_to_die 시간만큼이 지나거나,
	프로그램 시작 후 time_to_die 시간만큼이 지나도록
	식사를 시작하지 않으면 해당 철학자는 사망합니다.
*/

int		time_to_eat;
/*
	밥을 먹는데 걸리는 시간(밀리초 단위) :
	철학자가 밥을 먹는데 걸리는 시간입니다.
	해당 시간동안 철학자는 두 개의 포크를 잡고 있어야 합니다.
*/

int		time_to_sleep;
/*
	잠자는 시간(밀리초 단위) :
	잠을 자는 데 소모되는 시간 입니다.
*/
int		number_of_times_each_philosopher_must_eat;
/*
	각 철학자가 최소한 밥을 먹어야 하는 횟수(선택적 인자):
	모든 철학자가 number_of_times_each_philosopher_must_eat 번 이상
	밥을 먹으면 시뮬레이션이 종료됩니다.
	지정되지 않은 경우, 철학자가 죽을 때 시뮬레이션이 종료됩니다.
*/