사용자와 하드웨어 사이에서 자원을 관리하는 계층으로, 커널, 사용자 인터페이스, 시스템 콜, 파일 시스템, 드라이버 등으로 구성됨.
커널: 프로세스, 메모리, 저장장치를 관리함. 사용자 인터페이스: 사용자는 운영 체제의 커널에 직접 접근할 수 없고, 사용자 인터페이스(GUI, CLI)를 통해 접근 가능함. EX) GUI: 파일 관리자, CLI: cd 명령어 시스템 콜: 프로그램이 운영체제의 커널에 직접 요청을 보내어 하드웨어나 시스템 자원에 접근할 수 있도록 하는 인터페이스 드라이버: 하드웨어와 커널 사이의 인터페이스 => 운영체제가 하드웨어 장치를 제어하고 통신할 수 있도록 도와주는 소프트웨어
1940년 에니악: 특정 명령에 맞는 스위치와 배선을 연결하여 프로그래밍을 함. 문제 1)30톤짜리 기계에 많은 스위치와 배선을 이용하기 때문에 인력이 많이 필요하고 시간이 오래 걸림.
1950년도 초반 직접회로(IC): 진공관과 전선으로 만들어진 논리 회로를 아주 작은 크기로 만든 전자회로 => 스위치와 배선 작업을 하는 것보다 훨씬 편해짐 동작 방식: 펀치 카드를 이용해서 프로그래머가 카드에 구멍을 뚫어 프로그래밍을 하면 컴퓨터가 카드를 읽어 계산을 하고 결과가 프린터로 출력이 됨. 문제 1) 프로그래머가 작성한 펀치 카드(프로그램)를 오퍼레이터가 컴퓨터에 카드를 넣고 그 결과를 프로그래머에게 전달함. 이런 과정이기에 오퍼레이터의 오버헤드가 너무 컸음. 문제 2) 입출력 작업을 하는 동안에는 CPU를 사용할 수 없음
1950년도 중후반 싱글스트림 배치시스템: 프로그래머가 오퍼레이터에게 펀치 카드 여러 개를 한 번에 전달하고, 컴퓨터는 여러 개의 프로그램을 순서대로 실행해서 결과도 한 번에 확인가능하도록 함 => 작업이 끝날 때마다 일일이 오퍼레이터가 결과를 꺼내고 다시 다른 프로그램을 실행시키는 과정이 사라져서 CPU 사용량이 올라감. I/O 디바이스 컨트롤러: 입출력 중에도 CPU가 계산할 수 있도록 함. 입출력 작업이 끝나면 CPU에게 인터럽트 신호를 주고, 인터럽트를 받은 CPU는 다시 처리를 진행함. 문제 1) CPU와 입출력을 분리했지만, 입출력에도 CPU를 기다려야 하는 작업이 존재함 => 입력 처리 작업의 경우 입력이 완료될 때까지 기다려야 함.
1960년도 시분할 시스템: 메모리에 여러 프로그램을 올려놓고 시간을 나누어서 번갈아 가면서 프로그램을 실행함. UNIX: 멀티프로그래밍, 다중 사용자, 파일 시스템을 구현한 운영체제 문제 1) 메모리에 여러 프로그램이 올라와서 작업을 진행하기에 메모리 침범 이슈가 발생함 문제 2) 기존에는 프로그램이 하나라고 가정하고 개발해서 바로 하나의 메모리 위치만 알면 됐는데, 프로그램이 여러 개가 돼서 각 프로그램의 메모리 위치를 알 수가 없어짐. => 베이스 레지스터를 사용하여 해결함. 베이스 레지스터: 메모리에서 프로그램이 사용하는 데이터와 명령어의 시작 주소를 저장하는 레지스터
WHERE INTAKE_CONDITION = "Sick" AND NAME IS NOT NULL
필드 선택하여 정렬 : ORDER BY ~ ASC ASC는 생략 가능
ORDER BY id
필드 선택하여 역정렬 : ORDER BY ~ DESC
ORDER BY ANIMAL_ID DESC
개수로 변환 : COUNT 중복 제거 : DISTINCT 조회한 필드 이름 변환 : AS
SELECT COUNT(DISTINCT NAME) AS count
개수 제한 : LIMIT
LIMIT 1
NULL 인지 확인 : IS, IS NOT
WHERE AGE IS NULL
최대, 최소 값 : MAX, MIN
MAX(PRICE) AS MAX_PRICE
MIN(PRICE) AS MIN_PRICE
필드 지정하여 따로 처리하기 : GROUP BY, HAVING
SELECT NAME, COUNT(NAME) AS COUNT
FROM ANIMAL_INS
WHERE NAME IS NOT NULL
GROUP BY NAME
HAVING COUNT(NAME) > 1
ORDER BY NAME
포함된 글자 찾기(includes) : LIKE % => 모든 경우, _ => 하나는 존재함 el이 포함된 경우 => LIKE "%el%" el로 시작하는 경우 -=> LIKE "el%" el로 끝나는 경우 -=> LIKE "%el" el뒤에 한 글자만 오는 경우 => LIKE "%el_"
LOWER(NAME) LIKE "%el%"
시간 포멧(format) 변경 : DATE_FORMAT Y => 2017, y => 17 M => March, m => 03 D => 1st, d => 01
DATE_FORMAT(HIRE_YMD, "%Y-%m-%d") AS HIRE_YMD
조회 결과가 null인 경우 디폴트값 채워주기 : IFNULL
IFNULL(FREEZER_YN, "N") AS FREEZER_YN
조회 결과를 삼항 연산자처럼 처리하기 : IF
=> IF(조건, 참인 경우의 값, 참이 아닌 경우의 값)
IF(FREEZER_YN IS NULL, "N", FREEZER_YN) AS FREEZER_YN
문자열 자르기 : LEFT, MID, RIGHT, SUBSTRING SUBSTRING(필드, 시작 위치(1이 맨 앞), 길이)
LEFT(PRODUCT_CODE, 2) AS CATEGORY
SUBSTRING(PRODUCT_CODE, 1, 2)
CONCAT(LEFT(tlno,3), '-', MID(tlno,4,4),'-', RIGHT(tlno,4)) AS 전화번호
문자열 합치기: CONCAT
SELECT USER_ID, NICKNAME, CONCAT(CITY, " ", STREET_ADDRESS1, STREET_ADDRESS2) AS 전체주소,
FROM USED_GOODS_USER
문자열 중간에 삽입: INSERT
INSERT(INSERT(U.TLNO, 8, 0, '-'), 4, 0, '-') AS 전화번호
필드에 여러 조건 처리 : CASE
SELECT ORDER_ID, PRODUCT_ID, DATE_FORMAT(OUT_DATE, "%Y-%m-%d") AS OUT_DATE,
CASE
WHEN DATE_FORMAT(OUT_DATE, "%m-%d") <= "05-01"
THEN '출고완료'
WHEN DATE_FORMAT(OUT_DATE, "%m-%d") > "05-01"
THEN '출고대기'
ELSE '출고미정'
END AS 출고여부
FROM FOOD_ORDER
ORDER BY ORDER_ID
일치하는 단어 여러 개 찾기 : IN => OR LIKE를 여러 번 사용한 것과 같은 효과
WHERE CAR_TYPE IN ("세단", "SUV")
정규표현식 : REGEXP | => LIKE "%가죽시트%" 를 여러개 한 것과 같은 효과 => 포함된 단어 여러 개 찾기
WHERE NOT AI.SEX_UPON_INTAKE REGEXP('Spayed|Neutered')
AND AO.SEX_UPON_OUTCOME REGEXP('Spayed|Neutered')
다른 테이블 함께 조회 : join inner, left, right => 교집합, 왼쪽 원만 포함, 오른쪽 원만 포함
SELECT B.CATEGORY AS CATEGORY, SUM(SALES) AS TOTAL_SALES
FROM BOOK_SALES AS BS
LEFT JOIN BOOK AS B USING(BOOK_ID)
JOIN 문에서 WHERE : ON, USING ON => WHERE 처럼 사용
LEFT JOIN BOOK AS B ON B.BOOK_ID = BS.BOOK_ID
USING => 괄호로 쉽게 사용
LEFT JOIN BOOK AS B USING(BOOK_ID)
반올림 : ROUND
SELECT ROUND(SUM(DAILY_FEE) / COUNT(DAILY_FEE)) AS AVERAGE_FEE
내림 : TRUNCATE group by와 함께 사용하여 가격대 별로 조회가 가능함
SELECT TRUNCATE(SUM(DAILY_FEE) / COUNT(DAILY_FEE)) AS AVERAGE_FEE
SELECT TRUNCATE(PRICE, -4) AS PRICE_GROUP, COUNT(PRODUCT_CODE) AS PRODUCTS
FROM PRODUCT
GROUP BY PRICE_GROUP
DATETIME에서 year, month, day, hour, month, second 추출 이름 그래도 함수가 존재하여 사용하면 됨
WHERE YEAR(APNT_YMD) = "2022" AND MONTH(APNT_YMD) = "05"
시간 구간 별로 조회 : GROUP BY, HOUR
SELECT HOUR(DATETIME) AS HOUR, COUNT(DATETIME) AS COUNT
FROM ANIMAL_OUTS
GROUP BY HOUR(DATETIME)
HAVING HOUR >= 9 AND HOUR <= 19
ORDER BY HOUR
기타 등등
서브 쿼리 => 서브 쿼리가 필요한 경우가 상당히 있다.
EX) 첫번째 쿼리는 정상 동작하지 않는다. group_by는 조회된 내용 중 제일 상단에 있는 것을 조회할 뿐이어서 FAVORITES의 최대값으로 조회를 한다고 해도 매칭되는 REST_ID, REST_NAME이 조회되지는 않는다. 그렇기에 2번째 쿼리 처럼 서브쿼리를 통해 조회를 해야한다.
SELECT FOOD_TYPE, REST_ID, REST_NAME, MAX(FAVORITES) AS FAVORITES
FROM REST_INFO
GROUP BY FOOD_TYPE
ORDER BY FOOD_TYPE DESC
SELECT FOOD_TYPE, REST_ID, REST_NAME, FAVORITES AS FAVORITES
FROM REST_INFO
WHERE (FOOD_TYPE, FAVORITES)
IN (
SELECT FOOD_TYPE, MAX(FAVORITES) AS FAVORITES
FROM REST_INFO
GROUP BY FOOD_TYPE
)
ORDER BY FOOD_TYPE DESC
예전에 csv로 저장되어 있던 내용을 데이터베이스로 옮기는 작업을 진행했었다. 여기서 회사 정보가 있는데, 이 회사들의 ID(숫자)는 채용 공고, 이미지 등등 다른 정보들과 관계가 있는 상황이었다. 데이터베이스로 옮기면서 id 바꾸게 되면 다른 정보들도 그에 맞춰서 동기화를 해야 하니 번거롭다는 생각이 들었다. 그렇기에 회사 ID를 autoincrement로 만들고 기존 csv의 회사 ID를 그냥 직접 대입하며 테이블에 추가했다. 아래는 당시 코드이다.
스키마데이터 삽입
이후에 회사 정보를 추가하면 id는 어떻게 되는 걸까?라는 생각이 먼저 들었다. 그때 처음 든 생각은 autoincrement로 설정했으니 1,2,..., 319, 321과 같은 경우라면 알아서 비어있는 320이나 다음으로 제일 큰 숫자인 322로 채워주지 않을까였다. 하지만 회사를 추가하니 companyId를 2로 삽입하여 중복된 id라고 에러가 나왔다.
autoincrement의 시퀸스가 자동이 아니라 직접 저장한 값들은 기억을 못 해서 생긴 문제였다. 그렇기에 이런 경우에는 아래 코드처럼 autoincrement 시퀸스를 직접 업데이트해줘야 한다. 아래는 postgresql, prisma 코드이다.
클라이언트: 웹 사용자의 인터넷이 연결된 장치들과 이런 장치들에서 사용 가능한 크롬 같은 웹 브라우저
서버: 웹페이지, 사이트, 앱 등을 저장하는 컴퓨터
클라이언트와 서버
웹 -> 도로 클라이언트 -> 우리의 집 서버 -> 상점 라고 생각하고 생각하고 아래 글을 이해하면 쉽습니다.
웹에서 실제로 무슨 일이 일어날까?
우리가 브라우저에 웹 주소를 입력하는 것은 우리가 상점에 걸어가는 것과 비슷합니다.
1. 브라우저는 DNS 서버로 가서 웹사이트 서버의 실제 ip 주소를 찾습니다.
EX) 우리가 네이버 지도로 상점의 주소를 찾는다.
2. 브라우저가 서버에게 웹사이트의 사본을 보내달라는 HTTP 요청 메시지를 서버로 전송합니다. 메시지, 클라이언트와 서버 사이에 전송되는 모든 데이터는 TCP/IP 연결을 통해서 전송됩니다.
EX) 상점에 가서 상품을 주문한다.
3. 이 메시지를 받은 서버는 클라이언트의 요청을 승인하고 "200 OK" 메시지를 클라이언트에게 전송합니다. "200 OK"는 넌 웹사이트를 볼 자격이 있어! 라는 의미입니다. 그 후 서버는 웹사이트의 파일들을 데이터 패킷이라 불리는 작은 덩어리들로 브라우저에 전송을 합니다.
EX) 상점에서 우리가 주문한 상품을 전달받고, 우리는 그 상품을 집으로 가져간다.
4. 브라우저는 이 데이터 패킷들을 완전환 웹 사이트로 조립하고 우리에게 보여줍니다.
EX) 상품이 우리 집 문 앞에 도착한다.
인터넷 연결: 웹에서 데이터를 보내고 받게 해준다.
EX) 집과 상점 사이의 거리
TCP/IP: Transmission Control Protocol(전송 제어 규약) / Internet Protocol(인터넷 규약) -> 데이터가 어떻게 웹을 돌아다닐지 정의하는 통신 규약
EX) 주문을 하고, 상점에 가고, 우리가 상품을 살 수 있게 해주는 운송 장치(우리의 다리 또는 자동차 등등)와 같습니다.
DNS: Domain Name System Servers(도메인 이름 시스템 서버) -> 웹사이트를 위한 주소록
우리가 63.245.217.105 같은 ip 주소를 직접 기억하는 것은 쉽지가 않기에 DNS가 발명되었습니다. DNS는 우리가 브라우저에 입력하는 웹주소 예를 들어 naver.com 같은 웹사이트를 실제 ip 주소에 맞춰주는 특별한 서버입니다.
HTTP: Hypertext Transfer Protocol(하이퍼텍스트 전송 규약)은 클라이언트와 서버가 서로 통신할 수 있게 하기 위한 언어를 정의하는 규약? 약속 같은 친구입니다.
EX) 우리가 상품을 주문하기 위해 사용하는 언어와 같습니다.
packet: 패킷
기본적으로 웹에서 데이터가 전송될 때, 아주 작은 덩어리들로 전송됩니다. 그렇기에 다양한 웹 사용자들이 동시에 같은 웹 사이트를 다운로드할 수 있습니다. 만약 데이터가 하나의 큰 덩어리로 전송된다면, 한 번에 한 명의 사용자만 다운로드가 가능해져서 매우 비효율적이게 됩니다.
전체적으로 봤을 때 로직은 아래와 같이 생각보다 간단하다. 실제로 파일 3개면 구현 가능하다.
int main(int ac, char **av, char **envp)
{
int i;
if (ac != 5)
에러 출력 후 종료
i = -1;
while (++i < 2)
{
if (i == 0)
명령어 파싱 -> 첫 번째 프로세스 실행(infile을 stdin으로 받고 명령어 실행)
else if (i == 1)
명령어 파싱 -> 두 번째 프로세스 실행(첫 번째 프로세스 실행 결과를 stdin으로
받고 명령어 실행 결과를 outfile에 저장)
}
포크된 프로세스 만큼 wait를 해준다. 멘덴토리의 경우에는 2번
i = -1;
while (++i < 2)
wait(NULL);
}
다만 여기서 알고 넘어가야 될게 2가지가 있다. minishell 내용 같긴 한데 pipex 하면서 알고 간다면
minishell 할 때 아주 큰 도움이 된다.
1 ) 쉘에서 명령어들은 병렬로 돌아간다.
예를 들어 sleep 3 | sleep 3은 6초를 기다릴 것 같지만, 실제로는 병렬로 돌기에 3초를 기다린다.
병렬이더라도 cat | cat 같은 경우에는 애초에 앞에서 입력이 들어와야 넘어가기 때문에 프로그램이 끝나지 않는다.
2) 파이프 개수만큼 fork 되는 것이 아니라 파이프 개수 + 1 만큼 fork 된다.
실행되는 명령어가 2개(ls | cat)라서 pipe가 한 개라고 fork를 한번 하지 않는다.
실제로 bash에서 그냥 exit은 당연히 꺼지지만 exit | exit 은 bash가 꺼지지 않는다.
bash 꺼짐bash 안 꺼짐
그냥 exit은 fork가 안되고 바로 실행돼서 bash가 꺼지지만, exit | exit의 경우에는 fork가 2번 실행되어서
프로세스가 3개라 bash가 꺼지지 않는다. 이러한 구조를 가지는 것은 자식 프로세스에서 명령어를 수행하고
부모(main) 프로세스에서 모든 자식 프로세스를 기다리게 하기 위함이 아닐까?라고 작성자는 이해했다.
각 프로세스 별로 구현해야 되는 것들을 순서대로 쭉 나열해 보면
1) 첫 번째 프로세스
1.1) infile 읽고 pipe 세팅
자식 프로레스)
infile을 stdin으로 dup2, fd[1]을 stdout으로 dup2 해준다.
여기서 fd[0]만 사용 안 하니까 fd[0]만 close 하는 경우가 많은데, 둘 다 close 해줘야 된다.
fd[0]만 close 하면 yes | head -1 같은 테스트의 경우 프로그램이 끝나지 않는다.
부모 프로레스)
fd[0]을 stdin으로 dup2 해준다. 여기서 fd[0]은 자식 프로세스에서의 명령어 실행 결과가 된다.
결국 첫 번째 명령어의 실행 결과가 stdin으로 들어와 있는 상태라고 생각하면 된다.
여기서도 마찬가지로 fd[0], fd[1] 둘 다 close 해준다.
static void dup_child_1(char **av, int *fd)
{
int infile;
infile = open(av[1], O_RDONLY);
if (infile == -1)
perror_exit("infile error");
if (dup2(infile, STDIN_FILENO) == -1)
perror_exit("dup2 error");
if (dup2(fd[1], STDOUT_FILENO) == -1)
perror_exit("dup2 error");
close(fd[0]);
close(fd[1]);
}
static void child_process_1(char **av, char **envp)
{
int fd[2];
pid_t pid;
if (pipe(fd) == -1)
perror_exit("pipe error");
pid = fork();
if (pid == -1)
perror_exit("fork error");
if (pid == 0)
{
dup_child_1(av, fd);
execute(av[2], envp);
}
if (dup2(fd[0], STDIN_FILENO) == -1)
perror_exit("dup2 error");
close(fd[0]);
close(fd[1]);
}
1.2) 명령어 파싱 후 실행
env 실행 결과
메인에서 인자로 받는 envp 안에는 이런 식으로 환경변수들이 저장되어 있다.
여기서 우리가 필요한 것은 PATH=/Users/jinhokim/.brew/bin:/Users/jinhokim/.brew/bin:/usr/local/bin:/usr/bin:/
bin:/usr/sbin:/sbin:/usr/local/munki이다. PATH= 뒤의 문자열을 : 기준으로 split 하게 되면
["/bin", "/usr/bin", ...] 같은 결과가 되는데 총 6개의 경로가 나오게 된다. 이 경로들 안에 명령어 파일들이 들어있다.
예를 들어 ls는 /bin/ 안에 들어있는데 그렇기에 쉘에서 /bin/ls를 실행하면 ls가 실행된다.
/bin/ls
이제 저 6개의 경로와 첫 번째 명령어를 ft_strjoin한 결과를 access 함수를 통해 실행 가능한 파일인지 확인하고
없는 명령어의 경우에는 에러 출력, 있는 명령어의 경우에는 그냥 execve를 실행해주면 된다.
pipex는 우리가 만들 pipex 프로그램을 위와 같은 방식으로 돌렸을 때, 아래 명령어와 똑같이 동작하도록 구현해야 되는 과제이다.
즉 infile 파일을 읽고 명령어 2개를 실행한 결과를 outfile에 저장해야 된다. 여기서 이 작대기 |가 파이프다.
우리는 이 과제를 통해 프로세스와 프로세스 간 통신을 할 때 사용하는 pipe에 대해 공부해야 한다.
프로세스(process)란?
프로그램은 컴퓨터에서 실행될 때 특정 작업을 수행하는 일련의 명령어들의 집합이다. 이 프로그램의 명령어와
정적 데이터가 메모리에 적재되면 프로세스가 된다. 간단히 말하면 프로세스는 실행 중인 프로그램을 의미한다.
우리가 작업 관리자를 켜면 잔뜩 나오는 것들이 프로세스다.
함수 정리
1. fork
#include <unistd.h>
pid_t fork(void);
fork 함수는 프로세스를 복사해준다. 기존의 프로세스를 부모 프로세스, 복사된 프로세스를 자식 프로세스라고 부른다.
fork 함수는 프로세스의 고유 id인 pid를 반환한다. fork 함수 실행 실패 시 -1을 반환하고 자식 프로세스를 생성하지 않는다.
성공 시에는 부모 프로세스에는 자식 프로세스 피드 값을, 자식 프로세스에는 0이 반환한다.
예시 1)
코드만 보면 if, else문이 다돌아가는 게말이안 되는것 같지만 부모, 자식 프로세스에서 각각 main문이 돌아가기 때문에 2번 출력된다.
int main(void)
{
pid_t pid = fork();
if (pid == 0)
{
printf("Hello from Child\n");
printf("%d %d\n", pid, getpid());
}
else
{
printf("Hello from Parent\n");
printf("%d %d\n", pid, getpid());
}
}
/*
실행 결과
Hello from Parent
48280 48279
Hello from Child
0 48280
*/
예시 2) 자식과 부모 프로세스는 데이터와 상태가 다르기에 변수의 변화가 영향을 끼치지 않는다.
int main(void)
{
int x = 1;
if (fork() == 0)
printf("Child has x = %d\n", ++x);
else
printf("Parent has x = %d\n", --x);
}
/*
실행 결과
Parent has x = 0
Child has x = 2
*/
2. pipe
#include <unistd.h>
int pipe(int fd[2]);
pipe 함수는 파이프를 생성하고 2개의 디스크립터(읽기 전용, 쓰기 전용)를 생성해준다. 실패했을 경우에는 -1을 반환한다.
생성한 2개의 디스크립터와 파이프를 사용해 아래와 같은 방식으로 부모 프로세스를 자식 프로세스를 통신시킬 수 있다.
open 함수를사용할 때와마찬가지로 디스크립터를 사용하기에 pipe 함수 역시 사용하지 않는 디스크립터는 close 함수로 닫아줘야 한다.
부모에서 자식으로 일반통행 방식이기 때문에 부모 프로세스는 읽는 쪽을, 자식 프로세스는 쓰는 쪽을 닫아주면 된다.
예시 1) pipe 생성
int main(void)
{
int fd[2];
pipe(fd);
printf("fd[0]: %d fd[1]: %d\n", fd[0], fd[1]);
}
/*
실행 결과
fd[0]: 3 fd[1]: 4
*/
예시 2) pipe를 사용한 부모와 자식 프로세스 간 통신
#define MAX_BUF 1024
int main()
{
int fd[2];
pid_t pid;
char buf[MAX_BUF];
if (pipe(fd) < 0)
printf("pipe error\n");
pid = fork();
if (pid < 0)
{
printf("fork error\n");
exit(1);
}
if (pid == 0)
{
close(fd[1]);
read(fd[0], buf, MAX_BUF);
printf("Child got message : %s\n", buf);
}
else
{
close(fd[0]);
ft_strcpy(buf, "Massage from Parent");
write(fd[1], buf, ft_strlen(buf));
}
}
/*
실행 결과
Child got message : Massage from Parent
*/
3. wait
#include <sys/wait.h>
pid_t wait(int *statloc);
wait 함수는 자식 프로세스가 종료되었을 때 자식 프로세스의 pid값을 반환하고, 오류가 났을 때는 -1을 반환합니다.
wait 함수를 사용하면 부모 프로세스를 자식 프로세스가 종료될 때까지 기다리게 할 수 있습니다.
만약 자식 프로세스가 종료되었는데 부모 프로세스가 계속 돌아가고 있다면 자식 프로세스는 좀비 프로세스 상태가 되는데
wait 함수를 사용해 이를 방지할 수도 있다.
예시 1) 부모 프로세스가 자식 프로세스가 끝난 후 다시 돌아가는 것을 확인할 수 있다.
int main()
{
int stat, stat_res;
if ((fork()) == 0)
printf("Child Hi\n");
else
{
stat_res = wait(&stat);
printf("Parent Hi\n");
printf("wait 인자값: %d\nwait 반환값: %d\n", stat, stat_res);
wait(NULL);
printf("Child Bye\n");
}
printf("Process Bye\n");
return 0;
}
/*
실행 결과
Child Hi
Process Bye
Parent Hi
wait 인자값: 0
wait 반환값: 57724
Child Bye
Process Bye
*/
아래 WIF 매크로를 사용해서 stat의 정보를 확인할 수 있다.
WIFEXITED(status): 자식 프로세스가 정상적으로 종료했으면 참을 반환한다.
WEXITSTATUS(status): 자식 프로세스의 종료 상태를 반환한다. 이 매크로는WIFEXITED가 참을 반환했을 때만 써야 한다.
int main()
{
int pid, status;
printf("Parent: %d\n", getpid());
pid = fork();
if (pid == 0)
{
printf("Child %d\n", getpid());
sleep(2);
return (0);
}
waitpid(pid, &status, 0);
if (WIFSIGNALED(status))
printf("Error\n");
else if (WEXITSTATUS(status))
printf("Exited Normally\n");
else if (WIFEXITED(status))
printf("Parent: %d\n", getpid());
return 0;
}
4. waitpid
#include <sys/wait.h>
pid_t waitpid(pid_t pid, int *statloc, int options);
waitpid 함수는 wait 함수와 거의 똑같은데, 옵션을 추가해 동작 방식을 변경할 수 있다.
아래는 옵션들(3번째 인자 종류)이다. 인자가 0일 경우에는 wait 함수와 동일하게 작동한다.
WNOHANG: 기다리는 PID가 종료되지 않아서 즉시 종료 상태를 회수할 수 없는 상황일 때 0을 반환
WUNTRACED: 중단된 자식 프로세스의 상태를 반환
WCONTINUED: 중단되었다가 재개된 자식 프로세스의 상태를 반환
에시 1) WNOHANG 사용
#include <time.h>
int main()
{
pid_t pid;
int status;
time_t t;
pid = fork();
if (pid < 0)
perror("fork error");
else if (pid == 0)
{
sleep(3);
exit(1);
}
else do
{
pid = waitpid(pid, &status, WNOHANG);
if (pid == -1)
perror("wait error");
else if (pid == 0)
{
time(&t);
printf("child is still running at %s", ctime(&t));
sleep(1);
}
else
{
if (WIFEXITED(status))
printf("child exited with status of %d\n", WEXITSTATUS(status));
else
puts("child did not exit successfully");
}
} while (pid == 0);
}
/*
child is still running at Wed Sep 7 12:27:32 2022
child is still running at Wed Sep 7 12:27:33 2022
child is still running at Wed Sep 7 12:27:34 2022
child exited with status of 1
*/
사실 이 과제에서 WNOHANG을 사용했다는 것은 좋은 징조가 아니다. dup2 후 파이프를 전부 다 닫아주면
WNOHANG을 사용하지 않아도 잘 넘어가진다. 파이프를 잘 안 닫았을 경우 yes | head -1이나
/dev/urandom | head -1 같은 경우에 head 한 결과가 출력도 안되고 프로그램이 끝나지도 않는다.
설명할 필요도 없을 듯 하다. python의 combinations를 쓰면 조합을 바로 구할 수 있다.
from itertools import combinations
def solution(number):
return len([s for s in combinations(number, 3) if sum(s) == 0])
2번
2
처음에 그냥 리스트를 쪼개고 set 함수를 사용해서 풀었는데 시간 초과가 나왔다
EX) len(set(topping[:i]) == len(set(topping[i:])
딕셔너리를 사용해서 해결했다. 역시 빠르다 우리 사전!
from collections import Counter, defaultdict
def solution(topping):
front, back = defaultdict(int), dict(Counter(topping))
ans = 0
for t in topping:
front[t] += 1
back[t] -= 1
if back[t] == 0:
del back[t]
if len(front) == len(back):
ans += 1
return ans
3번
3
문제의 글만 보면 군인들이 목적지로 향하는 상황이지만
우리가 문제를 풀 때는 목적지가 군인들을 찾아간다고 생각하는 것이 풀기 쉽다.
목적지 기준으로 bfs 알고리즘을 사용해서 다른 모든 위치까지의 거리를 구하면 사실상 끝이다.
from collections import deque
def solution(n, roads, sources, destination):
graph = [[] for _ in range(n+1)]
ans = []
for s, e in roads:
graph[s].append(e)
graph[e].append(s)
check = [-1 for _ in range(n+1)]
check[destination] = 0
q = deque([destination])
while q:
i = q.popleft()
for node in graph[i]:
if check[node] == -1:
check[node] = check[i]+1
q.append(node)
for s in sources:
ans.append(check[s])
return ans
마지막에 check_li.count(max(check_li))로 한 번에 제일 먼 노드의 개수를 구할 수 있다.
from collections import deque
def solution(N, edge):
graph = [[] for _ in range(N+1)]
q = deque([1])
check_li = [-1]*(N+1)
check_li[1] = 0
for s, e in edge:
graph[s].append(e)
graph[e].append(s)
while q:
node = q.popleft()
for n in graph[node]:
if check_li[n] == -1:
q.append(n)
check_li[n] = check_li[node] + 1
return check_li.count(max(check_li))
def dfs(n, numbers, target, i):
if i == len(numbers):
return 1 if n == target else 0
return dfs(n + numbers[i], numbers, target, i+1) + dfs(n - numbers[i], numbers, target, i+1)
def solution(numbers, target):
return dfs(0, numbers, target, 0)
생각해보니 굳이 dfs 함수를 만들 필요도 없었다.
아래와 같은 방식으로 numbers 리스트의 앞에 값을 빼가면서, target이 0이 되는지 확인하는 방법도 있다.
def solution(numbers, target):
if not numbers:
return 1 if target == 0 else 0
return solution(numbers[1:], target + numbers[0]) + solution(numbers[1:], target - numbers[0])
BFS 풀이
from collections import deque
def solution(numbers, target):
q = deque([(0, 0)])
ans = 0
while q:
n, i = q.popleft()
if i == len(numbers):
if n == target:
ans += 1
else:
q.append([n + numbers[i], i+1])
q.append([n - numbers[i], i+1])
return ans
풀이 DFS, BFS 사용 X
def solution(numbers, target):
res_li = [0]
for n in numbers:
li = []
for res in res_li:
li.append(res + n)
li.append(res - n)
res_li = li
return res_li.count(target)
2. 스킬 순서에 포함되는 스킬이 나왔는데 선행 스킬이 아니면 불가능한 스킬트리이므로 check = 0을 해준다.
3. 반대로 선행 스킬이 맞다면 스킬 순서 큐를 popleft 해준다.
4. ans += check(1: 올바른 스킬트리, 0: 불가능한 스킬트리)
def solution(skill, skill_trees):
ans = 0
for skill_tree in skill_trees:
q = list(skill)
check = 1
for s in skill_tree:
if s in q and s != q.pop(0):
check = 0
break
ans += check
return ans
풀이 for-else O
for 문이 break 등으로 중간에 빠져나오지 않고 끝까지 실행됐을 경우 else문이 실행된다.
check 변수가 필요 없어지기에 코드 한 줄이 줄었다.
from collections import deque
def solution(skill, skill_trees):
ans = 0
for skill_tree in skill_trees:
q = deque(skill)
for s in skill_tree:
if s in q and s != q.popleft():
break
else:
ans += 1
return ans
