Operating System Concepts - Processes 실습

이것은 시리즈물입니다🧶

2025.09.21 - [CS] - Operating System Concepts - Introduction

2025.09.22 - [CS] - Operating System Concepts - O/S structures

2025.09.23 - [CS] - Operating System Concepts - Processes

---

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

int main()
{
    pid_t pid;
    pid = fork();
    printf("Hello, Process!\n");
}

// Hello, Process!
// Hello, Process!

• fork() 시스템 콜을 통해 child process가 생성됐지만, parent process와 child process 중 어떤 프로세스가 먼저 CPU를 점유했는지 알 수 없음

 

int main()
{
	pid_t pid;
	pid = fork();
	printf("Hello, Process! %d\n", pid);
}

// Hello, Process! 74917 (parent process)
// Hello, Process! 0 (child process)

• parent process와 child process 중 어떤 프로세스가 먼저 CPU를 점유할지 알 수 없지만, 실행했을 때 출력된 pid 값을 통해 알 수 있음 (지금은 parent prcoess가 먼저 실행됨!)

 

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h> // wait() 호출을 위해 추가

int main()
{
	pid_t pid;
	pid = fork();
	if (pid > 0) // parent process
		wait(NULL);
	printf("Hello, Process! %d\n", pid);
}

// Hello, Process! 0 (child process)
// Hello, Process! 76180 (parent process)

• 조건식이 `pid > 0`이기 때문에 parent process만 조건문 내부를 실행할 수 있음이 명확하고, parent process가 wait() 호출로 인해 child process가 먼저 CPU 할당받음을 코드만 봐도 알 수 있음 (물론 pid 값 출력을 통해서도 알 수 있음)

 

int value = 5;

int main()
{
	pid_t pid;
	pid = fork();

	if (pid == 0) { // child process
		value += 15;
		return 0;
	}
	else if (pid > 0) { // parent process
		wait(NULL);
		printf("Parent: value = %d\n", value);
	}
}

// Parent: value = 5

• child process는 parent process 주소공간의 복제본으로 구성되고 이때 전역 변수도 새로운 공간으로 복제되기 때문에 두 프로세스는 서로의 전역 변수에 영향을 줄 수 없음
• 즉 child process에서 `value += 15`를 통해 value가 20이 되어도, parent process는 value가 그대로이기 때문에 5로 출력됨

 

int main()
{
	fork(); // fork a child process
	fork(); // fork another child process
	fork(); // and fork another
	printf("Hello, fork()!\n");
	return 0;
}

// Hello, fork()! * 8

• fork()로 생성된 child process들도 다시 fork()를 실행하여 또다른 child process들을 생성하고, 2^3이기 때문에 출력 명령이 총 8번 실행됨
  • 재귀법으로 인해 2^n (n = 한번의 fork() 실행으로 인해 fork() 실행이 몇번째까지 실행되는지) 수식으로 계산할 수 있음

 

int main()
{
	int i;

	for (i = 0; i < 4; i++)
		fork();
		printf("Hello, fork()!\n");
	
	return 0;
}

// Hello, fork()! * 16

• 2^4 = 16, 즉 출력 명령이 16번 실행됨

 

int main()
{
	pid_t pid;
	pid = fork();

	if (pid == 0) { // child process
		execlp("/bin/ls", "ls", NULL);
		printf("LINE J\n");
	}
	else if (pid > 0) { // parent process
		wait(NULL);
		printf("Child Complete\n");
	}
	
	return 0;
}

// ...ls 실행...
// Child Complete

• parent process가 wait()를 실행하기 때문에 child process가 먼저 실행되는데, execlp로 인해 `printf("LINE J")` 명령어가 `ls`로 덮어써짐
• child process를 먼저 실행하여 ls 명령이 실행되고, child process 종료에 의해 parent process가 실행되므로 "Child Complete" 출력
  
  • 만약 wait() 명령어가 printf() 명령어 이후 실행된다면 "Child Complete" 출력이 먼저 됐을 것

 

int main()
{
	pid_t pid, pid1;
	pid = fork();

	if (pid == 0) { // child process
		pid1 = getpid();
		printf("child: pid = %d\n", pid); // A
		printf("child: pid1 = %d\n", pid1); // B
	}
	else if (pid > 0) { // parent process
		wait(NULL);
		pid1 = getpid();
		printf("parent: pid = %d\n", pid); // C
		printf("parent: pid1 = %d\n", pid1); // D
	}
	
	return 0;
}

// child: pid = 0
// child: pid1 = 85833 (= child process pid)
// parent: pid = 85833 (= child process pid)
// parent: pid1 = 85832 (= parent process pid)
// 실행 순서 : A -> B -> C -> D

• parent process가 wait를 통해 child process 종료까지 대기하게 되고, A 코드라인부터 실행하게 되는데 child process에서 `pid`는 현재 0이기 때문에 0이 출력됨
• 다음에 B 코드라인이 실행되는데, child process에서 `pid1`은 getpid() 실행으로 인해 현재 프로세스 PID 값이 주입되었기 때문에 child process pid가 출력됨
• child process 종료로 인해 parent process가 재개되고 C 코드라인이 실행되는데, parent process에서 `pid`는 fork() 실행에 대한 반환값이 주입되었기 때문에 child process pid가 출력됨
• 마지막으로 D 코드라인이 실행되는데, getpid() 실행으로 인해 현재 프로스세스 PID 값이 주입되어 parent process pid가 출력됨