파일은 바이너리 파일(binary file)과 텍스트 파일(text file)로 나누어서 다룬다. 바이너리 파일은 데이터의 저장과 처리를 목적으로 0과 1의 이진 형식으로 인코딩된 파일이며, 텍스트 파일은 사람이 알아볼 수 있는 문자열로 이루어진 파일이다.

📌 파일 열고 닫기

open() / close()

# 파일 열기
file_object = open(str: path, str: mode)
# 파일 닫기
file_object.close()

mode 지정 방식

📌 with 키워드

코드 작성 시 파일을 열고 닫지 않는 실수를 방지하기 위해 with 키워드를 사용하며, with 구문이 종료될 때 자동으로 닫히게 된다.

with open(str: path, str: mode) as file_object:

    code

📌 파일 읽기/쓰기

read() / write()

# 파일 읽기
file_object.read()
# 파일 쓰기
file_object.write(str)

📌 for문을 이용하여 텍스트 한 줄씩 읽기

예제 데이터 생성

# random 모듈을 이용하여 데이터 구성
import random

# 알파벳 리스트 생성
alphabet = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
# 파일 열기
with open("C:\\Users\\wooju\\Desktop\\wooju\\file_example.txt","w") as file:
    for i in range(100):
        # 랜덤값으로 변수 생성
        first_str = random.choice(alphabet)
        first_int = random.randrange(50)
        second_str = random.choice(alphabet) + random.choice(alphabet)
        second_int = random.random()

        # 텍스트 쓰기
        file.write("{}, {}, {}, {}\n".format(first_str,first_int,second_str,second_int))

반복문으로 한 줄씩 읽기

# 파일 열기
with open("C:\\Users\\wooju\\Desktop\\wooju\\file_example.txt","r") as file:
    for line in file:
        # 변수를 생성하여 한줄씩 넣기
        first_str,first_int,second_str,second_int = line.strip().split(", ")
        # 한 줄씩 출력
        print(f"{first_str} {first_int} {second_str} {second_int}")

참고

• 혼자서 공부하는 파이썬(윤인성 지음)

람다(lambda) : 함수의 기능을 매개변수로 전달하는 코드를 좀 더 효율적으로 작성할 수 있게 해주는 기능이다.

# 기본적인 형태
lambda 매개변수: 리턴 값

📌 함수의 매개변수로 함수 전달

콜백 함수(callback function) : 함수의 매개변수에 사용하는 함수

# 매개변수로 받은 함수를 5번 반복하는 함수 생성
def call_repeat(func):
    for i in range(5):
        func()

# hello를 출력하는 함수        
def print_hello():
    print('hello')

# 함수 호출
call_repeat(print_hello)

# hello
# hello
# hello
# hello
# hello

call_repeat 함수는 함수를 매개변수로 받는 콜백함수이며, 위 코드를 실행하면 'hello' 라는 문자열을 5번 반복한다.

📌 map() 함수 & filter() 함수

함수를 매개변수로 사용하는 대표적인 내장 함수로 map()과 filter()가 있다.

map() : 리스트의 요소를 함수에 넣고 리턴된 값으로 새로운 리스트를 구성 filter() : 리스트의 요소를 함수에 넣고 리턴된 값이 True인 것으로 새로운 리스트 구성

# 기본 생성 방법

map(함수,리스트)

filter(함수,리스트)

example

def test1(num1):
    return num1*num1
def test2(num2):
    return num2 < 3

test_list = [1, 2, 3, 4, 5]

map_test1 = map(test1,test_list)
print(map_test1)
# <map object at 0x0000017CBA02A7D0>
print(list(map_test1))
# [1, 4, 9, 16, 25]

filter_test2 = filter(test2,test_list)
print(filter_test2)
# <filter object at 0x0000017CBA02AF50>
print(list(filter_test2))
# [1, 2]

위 코드를 보면 map 과 filter 를 사용해 새로운 리스트를 생성했을 때 바로 출력하게 되면 map object, filter object 와 같은 제너레이터(generator)가 나오게 된다. 각 변수에 제대로 할당되었는지 보기 위해 리스트타입으로 형변환하여 출력하면 제대로 할당된 것을 알 수 있다.

❗ 제너레이터(generator)는 다음 포스팅할 주제로 좀 더 자세히 다룰 예정이다.

❗ 간단하게 짚고 넘어가자면 파이썬의 특수한 문법 구조로 이터레이터( next() 함수를 적용해 하나하나 꺼낼 수 있는 요소 )를 직접 만들 때 사용하는 코드이다.

📌 인라인 람다(inline lambda)

map() 함수와 filter() 함수는 함수를 매개변수로 받는 것을 알게 되었으니 그 자리에 람다를 통해 직접적으로 함수를 넣을 수 있다.

위에서 구현한 코드를 람다를 이용하여 바꿔보자.

test_list = [1, 2, 3, 4, 5]

map_test1 = map(lambda x:x*x,test_list)
print(list(map_test1))
# [1, 4, 9, 16, 25]

filter_test2 = filter(lambda x:x<3,test_list)
print(list(filter_test2))
# [1, 2]

실행 결과는 이전과 같고, 람다를 사용하면 코드를 더 직관적이고 깔끔하게 작성할 수 있다.

참고

• 혼자 공부하는 파이썬 (윤인성 지음)

튜플(tuple)은 리스트와 비슷한 자료형이며, 리스트와 다른 점은 한번 결정된 요소는 바꿀 수 없다는 것이다.

📌 튜플 생성 방법

tuple_test = (10, 20, 30)

tuple_test[0]
# 10

tuple_test[1]
# 20

tuple_test[:]
# (10, 20, 30)

type(tuple_test)
# tuple

위의 코드와 같이 튜플은** (,) 소괄호를 통해 선언** 하며, 리스트와 같이** 인덱싱, 슬라이딩 모두 가능** 하다. 소괄호를 사용하여 요소를 넣은 변수를type() 함수를 사용하여 확인했을 때 tuple이 나오는 것으로 tuple_test는 튜플이라는 자료형이라는 것을 알 수 있다.

📌 튜플 내부 요소 변경

tuple_test = (10, 20, 30)

tuple_test[0] = 1

tuple_test의 0번 째 요소를 1로 바꾸려고 하면 위와 같이 TypeError가 발생하게 된다. 즉 튜플은 수정, 삽입, 삭제가 불가하다. (한번 결정된 요소는 변경 불가)

📌 요소를 하나만 가지는 튜플

요소를 하나만 가지는 튜플은 어떻게 만들까?

tuple_test = (10)
type(tuple_test)
# int

tuple_test = (10,)
type(tuple_test)
# tuple

위의 코드에서 보면 (10)을 tuple_test에 넣었을 때 타입을 보면 int형이 나온다. 즉 10이라는 숫자에 괄호를 감싼 것으로 인식한다는 것이다. 그렇기에 요소를 하나만 가지는 튜플을 만들기 위해서는** (10,)과 같이 쉼표를 함께 넣어서 선언**해야한다.

❗ 요소를 하나만 가지는 튜플은 많이 사용하나 잊기 쉬운 내용으로 꼭 기억하자

📌 괄호 없는 튜플

튜플을 사용하는 이유는 외관이 간단하고 요소를 변경할 수 없는 것으로 구분할 수 있다. 이 중 튜플의 외관이 간단하다고 말할 수 있는 이유는 튜플을 선언할 때 괄호를 생략할 수 있는 상황에서는 괄호 생략이 가능하기 때문이다.

• 튜플의 다중 할당 구문

파이썬에는 [a, b] = [10, 20] 과 같이 a와 b에 10과 20을 각각 할당해주는 다중 할당 구문이라는 문법이 있다.

# 튜플로 a,b에 10,20 할당 
(a, b) = (10, 20)
print(a,b)
# 10 20 

# 튜플의 특징인 괄호 생략
a,b = 10, 20
print(a,b)
# 10 20

a,b = 10, 20같은 코드는 파이썬에서 자주 사용되는 구문으로 튜플을 기반으로 작성된 코드라고 할 수 있다.

• 여러 개의 값 리턴

  def tuple_test():
    return (10, 20, 30)
  

a, b, c = tuple_test() print(a,b,c,)

10 20 30

-------------------------- 동일한 결과값 def tuple_test(): # 튜플의 괄호 생략 return 10, 20, 30

a, b, c = tuple_test() print(a,b,c,)

10 20 30

```

참고

• 혼자 공부하는 파이썬 (윤인성 지음)

Complexity : 알고리즘의 성능을 나타내는 척도

컴퓨터는 1초에 대략 3-5억 개 정도의 연산이 가능하다. 다만 AND, OR, 비교, 덧셈과 같은 단순한 연산인지 나눗셈, 곱셈, 대입, 함수 같은 복잡한 연산인 지에 따라 횟수의 차이가 날 수는 있다.

결과를 먼저 말하자면 복잡도가 낮을 수록 좋은 알고리즘이라고 할 수 있다.

Time complexity(시간 복잡도)

Time complexity : 입력의 크기와 문제를 해결하는데 걸리는 시간의 상관 관계

시간 복잡도를 어떻게 구하는 지 알아보기 위해서 간단한 예제를 통해 흐름을 알아볼 수 있다.

# lst -> 리스트 타입
# n -> 정수 타입
def func1(lst, n):
    cnt = 0
    for i in range(n):
        if lst[i] % 5 == 0:
            cnt += 1
    return cnt

위의 코드는 lst[0] 부터 lst[num-1]까지 돌면서 5의 배수일 때 cnt 라는 변수의 값을 1 증가 시킨다.

이 코드는 몇 번의 연산을 수행하는 지 알아보자면

• cnt 변수를 선언하고 0을 넣을 때 : 1
• 반복문이 n번 반복 : n
• 반복문 안에서 lst[i] 값을 5로 나눌 때 : 1
• lst[i] 값을 5로 나눈 나머지가 0인지 판별할 때 : 1
• lst[i]가 5의 배수라면 cnt 값이 증가하므로 : 1
• return cnt = 1

총 1+nx(1+1+1) +1 ⇒ 3n + 2

위의 코드는 3n+2번 연산을 하는데 n의 값에 따라서 연산이 증가한다. 그래서 예시 코드의 연산은 n에 비례한다 라고 말할 수 있고, 시간 복잡도는 입력의 크기와 문제를 해결하는데 걸리는 시간의 상관 관계이기 때문에 예시 코드의 시간 복잡도는 n 이다.

Big-O Notation(빅오 표기법)

Big-O Notation : 가장 빠르게 증가하는 항만을 고려하는 표기법

| 표기법        | 설명                 | 예시 알고리즘              |
|--------------|----------------------|--------------------------|
| O(1)         | 상수 시간 복잡도     | 배열에서 요소 하나 찾기       |
| O(logN)      | 로그 시간 복잡도     | 이진 검색                   |
| O(N)         | 선형 시간 복잡도     | 선형 탐색                   |
| O(NlogN)     | 로그 선형 시간 복잡도 | 퀵 정렬, 병합 정렬          |
| O(N²)        | 이차 시간 복잡도     | 버블 정렬, 삽입 정렬         |
| O(N³)        | 삼차 시간 복잡도     | 3중 루프 알고리즘           |
| O(2ⁿ)        | 지수 시간 복잡도     | 부분집합 생성, 완전탐색      |

연산 횟수가 2N³ + 5N² + 1,000,000인 알고리즘이 있다면 시간 복잡도는 O(N³) 라고 부른다

<출처 : https://blog.encrypted.gg/922>

그래프를 보면 N의 크기에 따라 시간 복잡도의 차이가 수행 시간이 큰 영향을 준다는 것을 알 수 있다.

<출처 : https://blog.encrypted.gg/922>

문제에서 주어지는 시간 제한은 대부분 1초에서 5초사이로, 입력의 범위를 보고 요구하는 시간 복잡도가 어느 정도인지를 알 수 있다.

Space complexity(공간 복잡도)

→ 입력의 크기와 문제를 해결하는데 필요한 공간의 상관 관계 → 알고리즘이 필요로 하는 메모리의 양

빅오 표기법을 사용한 표기법

크기가 N인 1차원 배열이 필요하다면 O(N) 크기가 N인 2차원 배열이 필요하다면 O(N²) 배열이 필요 없다면 O(1)

🍯꿀Tip : 512MB = 1.2억개의 int

참고

• https://blog.encrypted.gg/922 (바킹독 블로그)
• https://www.youtube.com/watch?v=m-9pAwq1o3w&list=PLRx0vPvlEmdAghTr5mXQxGpHjWqSz0dgC (이코테 유튜브)

: 반복문을 이용하여 짧게 한 줄로 리스트 작성

# 기본 형식
리스트 이름 = [ 표현식 for 반복 변수 in 반복할 수 있는 것]

# 조건문을 포함한 형식
리스트 이름 = [ 표현식 for 반복 변수 in 반복할 수 있는 것 if 조건문]

EX

# 기본 형식
example_list = [i*i for i in range(0,10,2)]

print(example_list)
# [0, 4, 16, 36, 64]

# 조건문을 포함한 형식
example_list_if = [i*i for i in range(0,10) if i%2 == 0]

print(example_list_if)
# [0, 4, 16, 36, 64]

list comprehensions 줄바꿈

리스트 이름 = [ 표현식
    for 반복 변수 in 반복할 수 있는 것
    if 조건문 ]

EX

line_change = [str(i)+'길게 써보자' 
                   for i in range(0,10) 
                   if i%2 == 0]
print(line_change)
# ['0길게 써보자', '2길게 써보자', '4길게 써보자', '6길게 써보자', '8길게 써보자']

참고

• 혼자 공부하는 파이썬 (윤인성 지음)

• 현재 index가 몇 번째인지 확인해야 하는 경우

enumerate_list = ['우주','은하','별']

# enumerate() 함수 적용
print(enumerate(enumerate_list))
# <enumerate object at 0x0000012650076D90>

# list() 함수로 강제 변환 후 출력
print(list(enumerate(enumerate_list)))
# [(0, '우주'), (1, '은하'), (2, '별')]

# 반복문과 조합하여 사용
for i, j in enumerate(enumerate_list):
    print("{}번째 = {}".format(i,j)) 

"""
0번째 = 우주
1번째 = 은하
2번째 = 별
"""

items() 와 dictionary

• dictionary의 key와 value값을 모두 출력하고 싶을 때

items_dic = {
    "key1" : "value1",
    "key2" : "value2",
    "key3" : "value3"
}

#items() 함수 적용
print(items_dic.items())
# dict_items([('key1', 'value1'), ('key2', 'value2'), ('key3', 'value3')])

# 반복문과 조합하여 사용
for key,value in items_dic.items():
    print("key:{} value:{}".format(key,value))
"""
key:key1 value:value1
key:key2 value:value2
key:key3 value:value3
"""

결론 : enumerate() 함수와 items() 함수를 이용하면 반복변수를 2개 사용할 수 있다.

참고

• 혼자 공부하는 파이썬 (윤인성 지음)

방법 1 range()함수의 매개변수 이용

for i in range(5,-1,-1):
    print("i = {} ".format(i),end=' ')

# i = 5  i = 4  i = 3  i = 2  i = 1  i = 0  

• range(5,-1,-1) : 5부터 0까지 -1씩 감소

방법 2 reversed()함수 사용

for i in reversed(range(5)):
    print("i = {} ".format(i),end=' ')

# i = 4  i = 3  i = 2  i = 1  i = 0  

• [0, 1, 2, 3, 4]의 범위를 reversed()를 통해서 [4, 3, 2, 1, 0]로 뒤집기

for 반복문을 통해 피라미드 만들기

방법1을 사용하여 피라미드 구현

star = int(input("별 개수"))

for k in range(star):
    for i in range(star-k,-1,-1):
        print(end=' ')
    for j in range(0,k*2+1):
        print("*",end='')
    print()

 # 10 입력 시
           *
          ***
         *****
        *******
       *********
      ***********
     *************
    ***************
   *****************
  *******************

방법2를 사용하여 피라미드 구현

star = int(input("별 개수"))

for k in range(star):
    for i in reversed(range(star-k)):
        print(end=' ')
    for j in range(0,k*2+1):
        print("*",end='')
    print()

# 10 입력 시
          *
         ***
        *****
       *******
      *********
     ***********
    *************
   ***************
  *****************
 *******************

구현 과정
1. 공백을 출력하는 반복문 (역반복문 이용) : 변수i
2. 별을 출력하는 반복문 : 변수j
3. 1,2,번을 감싸는 총 몇번 반복할 지 결정하는 반복문 : 변수 k

특징 : 변수 k가 증가할수록 i는 줄어들며 j는 증가하는 형태

참고

• 혼자 공부하는 파이썬 (윤인성 지음)

• 키를 기반으로 값을 저장하는 것
• 딕셔너리 내부 값에 문자열, 숫자, 불, 리스트, 딕셔너리 등 다양한 자료를 넣을 수 이 있음

선언 형식

dictionary = {key:value, key:value, key:value ···}

내부 요소 접근법

dictionary[key] => value

# 딕셔너리 값에 여러가지 자료를 가지고 있는 경우

dictionary = {
    "apple": 1.00,
    "banana": [0.75, 2.13, 3,34],
    "Strawberry": 2.50,
    "orange": 1.20,
    "grape": 2.00 }

# 추가로 인덱스를 설정하여 내부 요소 접근 가능
print(dictionary["banana"][0])
# 0.75

딕셔너리 값 추가/제거

값 추가

dictionary[new key] = new value

값 제거

del dictionary[key]

ex

dictionary = {
    "apple": 1.00,
    "banana": [0.75, 2.13, 3,34],
    "Strawberry": 2.50,
    "orange": 1.20,
    "grape": 2.00 }
# 값 추가
dictionary["peach"] = 7.56

print(dictionary)
"""
{'apple': 1.0, 'banana': [0.75, 2.13, 3, 34], 'Strawberry': 2.5,
 'orange': 1.2, 'grape': 2.0, 'peach': 7.56}
"""

# 값 제거
del dictionary["banana"]

print(dictionary)
"""
{'apple': 1.0, 'Strawberry': 2.5, 'orange': 1.2, 'grape': 2.0,
'peach': 7.56}
"""

존재하지 않는 키에 접근하는 상황

• 딕셔너리에 존재하지 않는 키에 접근하면 KeyError가 발생하기 때문에 내부에 존재하는지 확인이 필요함

in 키워드

# key in dictionary
# 값이 bool 형태

print("peach" in dictionary)
# True

print("melon" in dictionary)
# False

get()

# 딕셔너리의 키로 값을 추출하는 함수
# 존재하지 않는 키에 접근할 경우 KeyError가 아닌 None을 출력함

print(dictionary.get("peach"))
# 7.56

print(dictionary.get("melon"))
# None

참고

• 혼자 공부하는 파이썬 (윤인성 지음)

⬇ (Matplotlib를 통해 그래프를 시각화하였을 때 발생한 한글 깨짐 현상)

1. Code 작성을 통해 해결

import os

if os.name == 'posix':
    plt.rc("font", family="AppleGothic")

else:
    plt.rc("font", family="Malgun Gothic")

# 마이너스 폰트가 깨지는 문제를 대처하기 위한 코드

plt.rc("axes", unicode_minus=False)

2. pip 설치를 통해 해결

# !pip install koreanize-matplotlib 터미널에 입력하여 설치
# 설치 후 import로 불러오기

import koreanize_matplotlib

위의 방법을 적용하였을 경우 ⬇ matplotlib를 사용하여 시각화를 해보면 한글이 깨지지 않는 것을 볼 수 있다.

import pandas

import pandas as pd

Basic data structures in pandas

• Series : 모든 유형의 데이터를 보관하는 1차원 배열
• DataFrame : 행과 열이 있는 테이블과 같은 데이터를 보관하는 2차원 배열

Creating a Series

• list의 값으로 Series 생성

#In
s = pd.Series([1,2,3,4,5])

#Out
0    1
1    2
2    3
3    4
4    5
dtype: int64

2. Creating a DataFrame

• Numpy를 사용하여 DataFrame 생성

  import numpy as np
  

#In number = [1,2,3,4,5,6]

df = pd.DataFrame(np.random.randn(6,4), index=number, columns=list('ABCD'))

#Out A B C D 1 -0.713372 0.487297 0.175619 1.126466 2 -2.031435 0.338329 0.047565 0.239074 3 1.197670 -0.361998 -0.247807 -1.301809 4 -0.162813 0.635130 0.497010 -1.128038 5 0.986570 0.801526 -0.835925 0.173154 6 -1.369150 -0.034347 0.027706 -0.928288

✅ np.random.randn(6,4)를 사용하여 무작위 숫자로 데이터를 채움
✅ index=number : index를 number라는 리스트로 생성
✅ columns=list('ABCD') : 'ABCD'라는 문자열을 list로 변환하여 columns 생성


<br>

- `딕셔너리`를 사용하여 `DataFrame` 생성
```python
#In
df2 = pd.DataFrame({'A' : 1,
                    'B' : ["test1", "test2", "test3"],
                    'C' : pd.Series(2, index=list(range(3)), dtype='float32')})

#Out

     A        B      C
0    1    test1    2.0
1    1    test2    2.0
2    1    test3    2.0

✅ A : 1이라는 정수를 가진 열 생성 ✅ B : "test1", "test2", "test3" 문자열을 가지는 열 생성 ✅ C : 2라는 실수를 가진 열 생성 ( 인덱스는 0, 1, 2 데이터 형식은 float32로 지정된 시리즈로 생성 )

참고

• https://pandas.pydata.org/pandas-docs/version/1.0.0/getting_started/10min.html

• 여러가지 자료를 저장할 수 있는 자료
• 인덱스를 기반으로 값을 저장

list = [277,32,"문자열",True]
# 요소(element) : 대괄호 [ ] 내부에 넣는 자료 

list[0]
# 277

list[0:3]
# [277, 32, '문자열']
# [0:3] ➡ `슬라이싱` : 범위 선택 연산자

리스트 표현

인덱스 음수표현

list = [277,32,"문자열",True]

list[-1]
# True

list[-2]
# '문자열'

리스트 접근 연산자 이중 사용

 list = [277,32,"문자열",True]

 list[2][0]
 # '문'
 # list[2] `문자열` 의 [0]번째 '문'

리스트 연산

연결(+), 반복(*)

list_a = [1,2,3]
list_b = [4,5,6]

print(list_a+list_b)
# [1, 2, 3, 4, 5, 6]

print(list_a * 3)
# [1, 2, 3, 1, 2, 3, 1, 2, 3]

리스트에 요소 추가

append()

리스트.append(요소) / 뒤에 이어서 붙이기

list = [1,2,3]
list.append(4)

print(list)
# [1, 2, 3, 4]

insert()

리스트.inseret(요소) / 원하는 위치에 요소 추가

list = [1,2,3]
list.insert(2,4)

print(list)
# [1, 2, 4, 3]

extend()

리스트1.extend(리스트2) / 리스트 합치기

list_a = [1,2,3]
list_b = [4,5,6]
list_a.extend(list_b)

print(list_a)
# [1, 2, 3, 4, 5, 6]

리스트 연결 연산자와 요소 추가의 차이

list_a = [1,2,3]
list_b = [4,5,6]

print(list_a + list_b)
# [1, 2, 3, 4, 5, 6]
print(list_a)
# [1, 2, 3]

• print(list_a + list_b) 값이 출력이 되며, list_a가 변하지 않음
• 비파괴적 : 원본에 영향을 주지 않는 것

list_a = [1,2,3]
list_b = [4,5,6]

print(list_a.extend(list_b))
# None
print(list_a)
# [1, 2, 3, 4, 5, 6]

• print(list_a.extend(list_b)) 값이 출력되지 않으며, list_a가 변함
• 파괴적 : 리스트에 직접적인 영향을 주는것

리스트 요소 제거

인덱스로 제거

① del 키워드 ➡ del 리스트명[인덱스]

• 슬라이싱을 사용해 제거 가능

② pop() ➡ 리스트명.pop(인덱스)

• 매개변수를 입력하지 않으면 -1이 들어가는 것으로 취급하여 마지막 요소 제거

list = [1,2,3]

del list[0]
print(list)
# [2, 3]

list.pop()
print(list)
# [2]

값으로 제거

remove() ➡ 리스트.remove(값)

list = [1,2,3]

list.remove(2)

print(list)
# [1, 3]

요소 모두 제거

clear() ➡ 리스트.clear()

list = [1,2,3]

list.clear()

print(list)
# []

리스트 정렬

• 리스트.sort() : 오름차순 정렬
• 리스트.sort(reverse=True) : 내림차순 정렬

list = [1,2,3,4,5]

list.sort()
print(list)
# [1, 2, 3, 4, 5]

list.sort(reverse=True)
print(list)
# [5, 4, 3, 2, 1]

리스트 내부 확인

• in 연산자 ➡ 값 in 리스트
• not in 연산자 ➡ 값 not in 리스트

list = [1,2,3,4,5]

print(3 in list)
# True
print(6 in list)
# False

print(3 not in list)
# False
print(6 not in list)
# True

비전공자였던 내가 학원에 들어가 수업을 처음 들었을 때 수업 내용을 이해하기 어려웠던 나는 원래 처음에는 입문하기 위한 허들이 높다 라고 생각했다. 하지만 이상함을 느꼈던 건 수업을 한 달 정도 들었을 때, 같은 내용을 듣고 같은 반 학생분들과 의견을 나누면서 이해하는 정도가 남들보다 떨어졌다고 느낀 후였다.

🤔 왜 나는 같은 수업의 내용을 듣고 남들보다 이해를 못했을까?

계속해서 고민해보면서 CS 지식이 부족하기 때문이란 것을 알게 되었다. 그 이유는 학원에서 프로그래밍 언어, 운영체제 등등 개발에 관련된 공부를 할 때 같은 단어가 중복되어 나오고 비슷한 개념으로 이루어져 있어 모든 것이 나무처럼 연결되어 있고 뿌리가 computer science 라고 생각했던 것 같다.

🤓 왜 스터디 형식의 공부를 선택했을까?

처음 혼자서 CS 공부를 시작했을 때 강의와 책을 다양하게 찾아서 공부했지만, 내가 확실하게 이해를 했는지 확인할 방법이 없어서 공부를 해도 불안한 마음을 가지고 있었다. 그래서 사람들과 공부한 내용을 서로 이야기하고 더해서 개발직군에 관련된 정보를 얻고자 스터디를 생각하게 되었다.

[JSCODE] 모의면접으로 학습하는 운영체제 스터디에 참여

스터디는 매주 1회 2시간 총 5주 동안 온라인 ZOOM을 통해서 진행되었다. 매주 주제에 관련된 10개 정도의 실전 면접 질문을 제공받고 질문에 대한 답을 하기 위해 공부 및 블로그에 정리하는 과제를 받았다. ZOOM에서 모의 면접을 진행할 때는 면접자, 지원자, 관찰자로 역할을 나누어 모의면접을 진행했다.

스터디를 하는 동안 어려웠던 점

아무래도 스터디, CS 공부, 면접 세 가지 모두가 처음이다보니 많은 어려움을 겪었었고, 그 어려움을 해결해보려고 노력했다.

지원자

➡ 모의 면접에서 지원자의 역할을 맡았을 때 가장 어려웠던 점은 아무래도 답에 대해 기억이 나지 않았을 때 대처하는 방법이었다. 외웠던 대답이 기억이 안 나면 보통 자신이 기억했던 개념을 상기시키며 대답을 대처하지만 질문에 대한 답을 문장으로 외우는 공부를 했던 나는 기억이 나지 않으면 그에 대한 대처를 하나도 하지 못했었다. 그렇게 되면서 지원자의 역할이 점점 무서워지게 되었다.

이 어려움을 극복하기 위해서 나는 공부 방법을 바꾸는 것을 택했다. 강의와 책을 보면서 개념을 정리하고 끝나는 것이 아닌 정리한 개념의 흐름을 이해하려고 노력했다. 예를 들면 시간의 순서로 개념을 익힌다던지 벤 다이어그램으로 개념을 정리한다던지 말이다. 그렇게 개념을 공부하고 질문에 답을 정리할 때는 키워드로 암기를 했다. 공부 방법을 바꾼 후 모의 면접에서 지원자의 역할을 맡았을 때는 기억이 나지 않더라도 스스로 생각해서 어느 정도 대답을 만들어 낼 수 있었다.

면접자

➡ 모의 면접에서 면접자의 역할을 맡았을 때 어려웠던 점은 추가 질문을 만들어 내는 것이었다. 제공 받은 질문 외에 질문을 해야 팀원들도 나도 한층 더 나은 면접을 대비할 수 있기 때문에 서로를 위해서라도 다양한 질문들을 하기 위해 노력해야했다. 이 어려움은 스터디에 지속적으로 참여하면서 팀원들이 하는 방식을 보다보니 자연스럽게 다양하게 질문하는 법을 터득하게 되었다. 하지만 압박 질문 만큼은 아직도 어렵다...

관찰자

➡ 모의 면접에서 관찰자의 역할은 면접자와 지원자에게 피드백을 주는 역할이다. 나는 이 역할만큼은 자신이 있었는데 그 이유는 스스로 객관적인 평가에 자신이 있었기 때문이다. 그래서 팀원들이 나의 피드백을 듣고 세세하게 문제점을 잘 파악해준다고 칭찬을 해주셨다. 그래도 관찰자의 어려운 점을 뽑자면 답변의 형태를 옳은 지 옳지 않은 지 구별하는 것이었다. 팀원들이 답변 방식은 모두 달랐기에 누가 틀린 것이고 맞는 것인지 알 수가 없어 판단하기에 어려움을 느꼈었다.

이 어려움은 코치(토마스)님의 말씀을 통해서 해결할 수 있었는데 처음 질문에는 간결하게 대답을 하고 그 뒤에 따라오는 꼬리 질문에 자신이 이해한 부분을 자세하게 대답하는 것이 가장 이상적인 대답이라고 해주셨다.

과제

➡ 이 스터디의 과제는 학습한 내용을 Blog에 포스팅 하는 것이다. 나는 Blog를 시작한지 얼마 되지 않았기에 이 과제는 나에게 고민거리였다. 글은 간결하게 작성해야 하는 지 하나하나 나의 생각을 담는 것이 좋은 건지 아직도 알 수가 없다. 포스팅하는 글마다 다르게 써보고 남들이 하는 것을 참고해봐도 모두가 달랐다. 블로그라는 것은 정답이 없는 게 아닐까 싶기도 하고 그래서 이 어려움은 앞으로 Blog에 공부를 정리하면서 나만의 방식을 찾아가려고 한다.

좋았던 점

스터디를 통해서 나는 IT 취업과 관련된 꿀팁들을 많이 얻을 수 있었다. 커뮤니티 활동을 하지 않았던 나는 개발 직군의 사람들과 네트워크를 형성할 기회가 없어 정보가 많이 없었는데 이번 스터디를 통해서 이력서 꿀팁, 공부 방향성, 기술 스택 추천등 많은 정보를 얻어갈 수 있었다.

두번째로 공부를 좀 더 깊게 할 수 있다는 점이 좋았다. 혼자서 공부를 하게 되면 개별적인 선생님이 없다면 개념을 이해하기만으로도 벅차다. 하지만 스터디에서 질문에 대한 대답을 공유하면서 잘못 이해했던 부분, 추가적으로 알면 좋은 내용 등을 서로 주고 받다보니 효율적으로 공부를 할 수 있었다.

세번째로 면접을 대비할 수 있었던 점이 좋았다. 실제 면접을 보는 것 보다는 긴장감이 덜하지만 모의 면접을 통해 대답을 깔끔하게 말할 수 있도록 연습할 수 있었고 추가로 인성면접 질문도 제공해주시고 대답하는 팁도 알려주시면서 실제 면접을 이떻게 준비하면 좋을지 틀을 잡을 수 있었다.

아쉬웠던 점

모의면접 스터디를 하기 전에는 사람들과 활발하게 네트워킹을 할 수 있을 줄 알았다. 하지만 막상 스터디를 했을 때는 기대했던 점이 잘 이루어지지 않았다. 단톡방이 있긴 하지만 토마스님만 공지사항에 관련된 말씀을 해주실 뿐 다른 분들은 거의 말하지 않으셨고 모르는 질문을 할 때에는 토마스님이 답변해주시기를 기다리거나, 모의 면접을 하는 날에 모아서 질문을 해야했다. 나도 마찬가지로 점점 질문은 줄어갔고 누군가 먼저 얘기하기를 계속 기다리게 되는 것이 아쉬웠다. 적극성같은 부분은 개인의 몫이기에 다음에 참여할 때는 내가 먼저 나서서 질문을 많이 하고, 분위기를 좋게 만드는 스몰토크를 시도하여 많은 사람들이 편안하게 의견을 주고 받을 수 있도록 노력해야겠다.

마지막으로

나의 첫 스터디가 한 달이라는 시간이 지나 끝이났다. 짧은 시간이었지만 그 시간 내에서도 포기하고 싶었던 순간이 있었다. 각종 과제가 겹쳐 해야할 일이 많아 벅찼을 때, 면접에 잘 대답할 자신이 없어서 ZOOM의 찾가 버튼을 누르지 못하고 한참동안 들어가지 못했을 때, 직장인이셨던 팀원분들에 비해 한참 지식이 부족했던 내 자신이 비교되었을 때.. 처음이다보니 힘든 시간이 종종 찾아왔지만 내가 버틸 수 있었던 건 도전에 대한 즐거움이 아닐까 싶다. 모르는 내용을 알아갈 때, 면접은 무섭지만 끝나고 팀원들과 이야기를 나눌 때, 지난 주와는 다른 내가 느껴질 때 ! 끝나고 보니 더 잘하지 못한 아쉬움과 그래도 완주했다는 뿌듯함이 느껴진다. 다음 스터디도 화이팅 해야겠다.

💭 병행성은 한 개의 CPU가 다수의 프로세스들을 서로 번갈아 가면 수행하여 동시에 작업이 실행되는 것처럼 느끼게 해주는 것입니다. 컴퓨터에서 자주 쓰이는 변수나 함수는 모든 프로세스들이 접근 가능한 전역 메모리에 적재하여 공유되는데 병행성으로 인하여 프로세스간 메모리 공유는 문제를 야기할 수 있습니다.

❓ 병렬성에 대해 설명해주세요.

💭 병행성과 다르게 병렬성은 실제로 동시에 작업이 처리되는 것입니다. 보통 멀티 코어에서 멀티 쓰레드를 동작시키는 방식이며 한번에 많은 일을 처리할 수 있기 때문에 병렬처리를 이용하여 이미지나 비디오를 인코딩하거나, 대규모 데이터를 처리하는 등의 실행 시간을 줄이거나 처리량을 늘리는 데에 사용됩니다.

❓ 프로세스 동기화에 대해 설명해 주세요.

💭 Concurrency Control(병행 제어)라고 부르기도 하며, 여러 프로세스 또는 스레드가 동시에 실행해도 공유 데이터의 일관성을 유지하는 것을 말합니다. 이 뜻은 프로세스나 스레드 사이의 수행 시기를 맞추는 것을 의미하는 데 수행 시기를 맞춘다는 것은 첫번쨰로 프로세스를 올바른 순서대로 실행하는 것이며(실행 순서 제어) 두번째는 동시에 접근해서는 안되는 자원에 프로세스만 접근하게 하는것입니다.(상호배제)

❓ Critical Section에 대해 설명해주세요.

💭 Critical Section은 공유 데이터의 일관성을 보장하기 위해 하나의 프로세스 또는 스레드만 진입해서 실행 가능한 영역입니다.

❓ Race Condition이 무엇인가요?

💭 여러 프로세스가 동시에 같은 데이터를 조작할 때 타이밍이나 접근 순서에 따라 결과가 달라질 수 있는 상황입니다. 공유 데이터의 최종 연산 결과는 마지막에 공유 데이터를 다룬 프로세스가 누구인지에 따라 달라지며 Race Condition을 막기 위해선 공유 데이터에 대한 동시 접근을 동기화 해야합니다.

❓ Race Condition을 어떻게 해결할 수 있나요?

💭 Semaphore(세마포어)와 Mutex(뮤텍스)로 Race Condition을 예방할 수 있습니다.

❓ Mutual Exclusion에 대해 설명해주세요.

💭 특정 한 시점에 단 하나의 프로세스만이 Critical section에 접근할 수 있는 것으로 공유가 불가능한 자원의 동시 사용을 피하기 위해 사용하는 알고리즘입니다.

❓ Mutual Exclusion을 할 수 있는 방법은?

💭 (잘 모르겠습니다...!)

• SW solutions
  • Dekker’s algorithm (Peterson’s algorithm)
  • Dijkstra’s algorithm, Knuth’s algorithm, Eisenberg and McGuire’s algorithm, Lamport’salgorithm
• HW solution
  • TestAndSet(TAS) instruction
• OS supported SW solution
  • Spinlock
  • Semaphore
  • Eventcount/sequencer
• Language-Level solution
  • Monitor

❓ 뮤텍스(Mutex)에 대해 설명해주세요.

💭 뮤텍스는 공유 자원에 대해 lock와 unlock을 함으로써 상호배제를 보장하는 기법입니다.

❓ 세마포어에 대해 설명해주세요.

💭 뮤텍스와 비슷하지만, 좀 더 일반화된 방식의 동기화 도구입니다. Mutex는 하나의 공유 자원에 접근하는 프로세스를 상정한 방식이지만 Semaphore는 공유 자원이 여러 개 일때 접근하는 프로세스를 상정한 방식입니다. 세마포어의 종류는 이진 세마포와 카운팅 세마포가 있습니다.

❓ 뮤텍스(Mutex)와 이진 세마포어의 차이에 대해 설명해주세요.

💭 - 뮤텍스에서는 lock을 설정한 프로세스만이 unlock을 할 수 있다. 하지만 이진 세마포어에서는 lock을 설정한 프로세스와 unlock을 하는 프로세스가 서로 다를 수 있다.

❓ 모니터에 대해 설명해주세요.

💭 프로세스 또는 스레드를 동기화하는 방법 중 하나로서 사용자가 사용하기에 세마포어보다 훨씬 편리한 도구입니다. 모니터는 공유자원과 공유 자원에 접근하기 위한 인터페이스를 묶어서 관리하며 프로세스는 반드시 인터페이스를 통해서만 공유 자원에 접근하도록 해야합니다. 모니터는 모니터는 모니터에 진입하기 위한 큐를 만들고, 모니터 안에 항상 하나의 프로세스만 들어오도록 하여 상호 배제를 위한 동기화 제공하고 모니터는 조건 변수를 이용하여 프로세스 실행 순서 제어를 위한 동기화를 제공합니다.

❓ 데드락이 무엇인가요?

💭 두 개 이상의 프로세스 혹은 스레드가 서로가 가진 리소스를 기다리는 상태입니다.

❓ 데드락 발생 조건 4가지를 설명해 주세요.

💭 리소스를 공유해서 사용할 수 없다는 상호 배제 , 프로세스가 이미 하나 이상의 리소스를 취득한 상태에서 다른 프로세스가 사용하고 있는 리소스를 추가로 기다리는 점유와 대기, 리소스 반환은 오직 그 리소스를 취득한 프로세스만 할 수 있다는 비선점, 프로세스들이 순환형태로 서로의 리소스를 기다리는 원형 대기가 있습니다.

❓ 데드락 회피 방법은 무엇이 있나요?

💭 데드락 회피 방법에는 은행원 알고리즘이 있습니다. 은행원 알고리즘은 프로세스가 시작시 자신이 필요한 자원의 최대 개수를 미리 선언하고 각 프로세스에서 자원요청이 있을때 시스템이 안전한 상태라고 유지되는 경우에만 자원을 할당합니다. 그렇지 않은 불안정 상태가 예상되면 다른 프로세스가 자원을 반환할 때 까지 대기하는 알고리즘 입니다.

❓ 최근에 관심가지고 있는 기술에 대해서 설명해주세요.

💭 최근에 Linux에 관심이 있어 공부하고 있습니다. 리눅스는 컴퓨터 운영체제 중 하나로 오픈소스 프로그램이며, 리눅스는 다중작업이 가능하고 CLI 기반이라는 특징이 있습니다. 또한 리눅스는 우분투, 페도라, 레드햇, 센트오에스 등 여러 종류로 나누어져 있습니다.

❓ 기술을 어떤식으로 학습 하는지 설명해주세요.

💭 저는 강의나 책 또는 공식 문서를 보며 기술을 이해하고 문법을 학습합니다. 문법을 학습하면서 실제로 간단하게 구현해보고 그 과정을 블로그에 기록하며 복습합니다. 이론을 공부한 후 스터디나 프로젝트 등 함께모여서 공부할 수 있는 환경을 만들어 제가 잘못이해한 부분이나 다른 방식으로는 어떻게 접근할 수 있는지 학습합니다.

❓ 안정적인 시스템을 개발하는 팀에서 꼭 지켜야할 개발 프로세스는 뭐라고 생각하시나요?

💭 저는 사용자 피드백이라고 생각합니다. 시스템을 개발하기 위해서 개발자는 많은 노력을 기울이고 수많은 테스트를 거치지만 결국 시스템은 배포를 거쳐 사용자가 사용하게 되고 개발하며 생각하지 못했던 문제점들이 나타나게 됩니다. 그래서 안정적으로 시스템을 개발하기 위해서 꼭 지켜야 할 것은 최종적으로 시스템을 사용하는 사용자의 피드백을 수집하고 고려하여 시스템을 지속적으로 개선하는 프로세스를 꼭 지켜야 한다고 생각합니다.

추가 질문

❓ Process Synchronization 문제를 풀기 위한 조건

💭 mutual exclusion (상호 배제) / progress (진행) /bounded waiting (유한 대기)/동일 속도

❓ race condition이 발생하는 예를 하나만 설명해주세요

💭

❓ Busy wating(Spin-Lock)으로 구현한 Semaphores 와 Sleep-Lock 으로 구현한 Semaphores 중 어느 것이 더 좋나요?

💭 일반적으로는 Sleep-Lock 으로 구현한 세마포어가 더 좋다. 하지만 임계구역의 길이가 매우 짧은 경우는 Sleep-Lock 오버헤드가 busy-wait 오버헤드보다 클 수 있다.

<이미지 출처> https://seamless.tistory.com/42

<이미지 출처>https://www.codeproject.com/Articles/1267757/Concurrency-vs-Parallelism

Parallelism (병렬성)

• 실제로 동시에 작업이 처리되는 것
• 멀티 코어에서 멀티 쓰레드를 동작시키는 방식
• 한번에 많은 일을 처리
• 물리적인 개념

Concurrency (병행성)

• 동시에 작업이 실행되는 것 처럼 느끼게 해주는 것
• 싱글 코어에서 멀티 쓰레드를 동작시키는 방식
• 한번에 많은 것을 처리할 수 있음
• 논리적인 개념
• 한 개의 CPU가 다수의 프로세스들을 서로 번갈아 가며 수행 ➡ 인터리빙(interleaving)
• 빠른 CPU의 처리 속도로 인해 인터리빙이 빠르게 이루어지며 사용자가 여러 프로그램이 동시작동하는 것 처럼 느끼게 해줌

병행성의 문제점

• 컴퓨터에서 자주 쓰이는 변수 또는 함수는 모든 프로세스들이 접근 가능한 전역 메모리에 적재하여 공유
• 하지만 병행성으로 인하여 프로세스간 메모리 공유는 문제를 야기할 수 있음

참고

• [JSCODE] 운영체제 스터디 1기 개념 정리 노트
• https://seamless.tistory.com/42

Deadlock (교착 상태) : 두 개 이상의 프로세스 혹은 스레드가 서로가 가진 리소스를 기다리는 상태

자원 할당 그래프 (Resource-Allocation Graph)

<이미지 출처>https://kukuta.tistory.com/281

• 어떤 프로세스가 어떤 자원을 사용하고 있고, 또 어떤 프로세스가 어떤 자원을 기다리고 있는지 표현하는 간단한 그래프이다.
• 자원 할당 그래프를 보고 데드락의 발생 여부를 판별할 수 있다.

자원 할당 그래프 규칙

- 프로세스는 원으로, 자원의 종류는 사각형으로 표현
- 사용할 수 있는 자원의 개수는 자원 사각형 내에 점으로 표현
- 프로세스가 어떤 자원을 할당받아 사용 중이라면 자원에서 프로세스를 향해 화살표를 표시
- 프로세스가 어떤 자원을 기다리고 있다면 프로세스에서 자원으로 화살표를 표시

Deadlock을 만드는 4가지 조건

1. Mutual exclusion(상호 배제) : 리소스를 공유해서 사용할 수 없다.

2. Hold and wait(점유와 대기) : 프로세스가 이미 하나 이상의 리소스를 취득한(hold) 상태에서 다른 프로세스가 사용하고 있는 리소스를 추가로 기다린다.(wait)

3. No preemption(비선점) : 리소스 반환(release) 은 오직 그 리소스를 취득한 프로세스만 할 수 있다.

4. Circular wait(원형 대기) : 프로세스들이 순환형태로 서로의 리소스를 기다린다.

Deadlock 해결 방법

데드락 방지 (Deadlock prevention)

• 네 가지 조건 중 하나가 충족되지 않게 시스템을 디자인

- Mutual exclusion :리소스를 공유 가능하게 함

- Hold and wait : 사용할 리소스들을 모두 획득한 뒤에 시작 or 리소스를 전혀 가지지 않은 상태에서만 리소스 요청

- No preemption : 추가적인 리소스를 기다려야 한다면 이미 획득한 리소스를 다른 프로세스가 선점 가능하도록 한다

- Circular wai : 모든 리소스에 순서 체계를 부여해서 오름차순으로 리소스를 요청

데드락 회피 (Deadlock avoidance)

• 실행 환경에서 추가적인 정보를 활용해서 데드락이 발생할 것 같은 상황을 회피하는 것

Safe state : safe sequence(교착상태를 발생시키지 않고 자원을 할당하는 순서)가 존재하며 모든 프로세스가 정상적으로 종료될 수 있는 상태를 의미

Unsafe state : 교착상태가 발생할 가능성이 있는 상태

데드락을 회피하기 위한 알고리즘

①

은행원 알고리즘(Banker's Algorithm) 
: 리소스 요청을 허락해줬을 때 데드락이 발생할 가능성이 있으면 리소스를 할당해도 
  안전할 때 까지 계속 요청을 거절하는 알고리즘


- 은행에서 모든 고객의 요구가 충족되도록 현금을 할당하는데서 유래

- 프로세스가 자원을 요구할 때, 시스템은 자원을 할당한 후에도 안정 상태로 남아있게 되는지 
사전에 검사하여 교착 상태 회피

- 안정 상태면 자원 할당, 아니면 다른 프로세스들이 자원 해지까지 대기

②

자원 할당 그래프 알고리즘(Resource-Allocation Graph Algorithm)
: 자원 할당 그래프에 예약 간선을 추가하여 예약 간선으로 설정한 자원에 대해서만 
  자원 할당을 요청할 수 있고 사이클이 형성되지 않을 때만 자원을 할당받는 알고리즘

데드락 감지와 복구

• 데드락을 허용하고 데드락이 발생하면 복구하는 전략

#감지 자원 할당 그래프를 통해 교착 상태를 탐지함 자원 요청 시, 탐지 알고리즘을 실행시켜 그에 대한 오버헤드 발생함

#복구 사용자 처리 교착상태에 있는 프로세스 중 하나의 프로세스를 사용자가 강제 종료

시스템 처리 ①프로세스 중지 데드락에 속해있는 모든 프로세스를 중지 데드락이 해결될 때까지 한 프로세스씩 중지

②자원 선점 프로세스들로부터 자원을 빼앗아 데드락이 해결될 때까지 다른 프로세스들에게 자원을 할당

데드락 무시

• 드물게 발생하는 잠재적 문제를 무시로 대처하는 방식 ➡ 타조 알고리즘 (ostrich algorithm)

참고

• 혼자 공부하는 컴퓨터 구조 + 운영체제 (강민철 지음)
• https://cocoon1787.tistory.com/858
• https://gyoogle.dev/blog/computer-science/operating-system/DeadLock.html

Mutex (뮤텍스) : 공유 자원에 대해 동시에 접근해서는 안되는 자원에 동시에 접근하지 않도로록 만드는 기법 즉, 상호 배제를 위한 동기화 도구이다.

Mutex 매커니즘은 하나의 전역 변수와 두 개의 함수로 구현할 수 있다.

• 프로세스들이 공유하는 전역변수 lock
• 임계 구역을 잠그는 acquire 함수
• 임계 구역의 잠금을 해제하는 release 함수

# 뮤텍스 변수 초기화
lock = False

def acquire():
    global lock
    while lock == True:

    lock = True

def release():
    global lock
    lock = False

# 뮤텍스 획득
acquire()

# --- critical section ---

# 뮤텍스 해제
release()

(위 코드는 while문에서 expected an indented block 에러 발생함)

위의 코드를 A와B라는 프로세스가 실행한다면 먼저 들어간 A가 실행이 끝나고 lock이 true가 될때까지 B는 while 반복문에서 대기해야한다. A가 실행이 끝나고 release 함수를 실행하게되면 lock은 false가 되고 B는 반복문에서 빠져나올 수 있다.

이 코드에서 while 반복문은 반복적으로 lock의 상태를 계속 확인하게되는데 이런 대기 방식을 바쁜 대기(busy wait)라고 한다

Semaphore (세마포어)

Semaphore (세마포어) : 뮤텍스와 비슷하지만, 좀 더 일반화된 방식의 동기화 도구이다.

• Mutex는 하나의 공유 자원에 접근하는 프로세스를 상정한 방식이지만 Semaphore는 공유 자원이 여러 개 일때 접근하는 프로세스를 상정한 방식이다.
• Semaphore를 구현할 때
  • 세마포어의 P 연산은 세마포어 변수를 하나 감소 시킨다.
  • 세마포어의 V 연산은 세마포어 변수를 하나 증가 시킨다.
• critical section 진입 전에는 P연산으로 자원을 획득하고, critical section 수행후에는 V연산으로 자원을 반납한다.

Busy wating(Spin-Lock)으로 구현한 Semaphores

# 사용 가능한 공유 자원의 개수
S = 3

def P():
    global S
    while S <= 0:

    S = S - 1

def V():
    global S
    S = S + 1

# 세마포어 획득
P()

# --- critical section ---

# 세마포어 해제
V()

(위 코드는 while문에서 expected an indented block 에러 발생함)

위 코드는 Mutex처럼 busy waiting이 발생한다. 이는 즉 CPU 주기를 낭비한다는 점에서 손해이다.

Sleep-Lock 으로 구현한 Semaphores

import threading

# 사용 가능한 공유 자원의 개수
S = 10

lock = threading.Lock()

condition = threading.Condition(lock)

def P():
    global S

    while S <= 0:
        # 다른 스레드가 세마포어를 해제할 때까지 대기
        condition.wait()
    S = S - 1

def V():
    global S

    S = S + 1
    # 세마포어를 해제한 후 대기 중인 스레드 깨우기
    condition.notify()

# 세마포어 획득
P()

# --- critical section ---

# 세마포어 해제
V()

위 코드는 Busy wating(Spin-Lock)으로 구현한 세마포어와는 다르게 임계구역에 먼저 들어간 스레드가 끝난 후 condition.notify()로 세마포어를 해제하기 전까지 Busy wating하고 있는 것이 아닌 대기를 하게 된다.

어떤 구현방식이 더 좋을까?

일반적으로는 Sleep-Lock 으로 구현한 세마포어가 더 좋다. 하지만 임계구역의 길이가 매우 짧은 경우는 Sleep-Lock 오버헤드가 busy-wait 오버헤드보다 클 수 있다.

Semaphore의 종류

• 이진 세마포(binary semaphore)

  • 세마포어 변수가 0 또는 1의 값만 가질 수 있는 세마포어이다.
  • 주로 mutual exclusion (lock/unlock)에 사용한다.

• 카운팅 세마포(counting semaphore)

  • 세마포어 변수는 0이상인 임의의 정수 값
  • 주로 resource counting에 사용한다.
  
  

Monitor (모니터)

Monitor (모니터) : 프로세스 또는 스레드를 동기화하는 방법 중 하나로서 사용자가 사용하기에 세마포어보다 훨씬 편리한 도구이다.

• 공유자원과 공유 자원에 접근하기 위한 인터페이스(통로)를 묶어서 관리한다.

• 프로세스는 반드시 인터헤이스를 통해서만 공유 자원에 접근하도록 해야한다.

  
  

모니터는 상호 배제와 실행 순서 제어를 위한 동기화이다

상호 배제 ① 모니터를 통해 공유 자원에 접근하고자 하는 프로세스를 큐에 삽입 ② 큐에 삽입된 순서대로 하나씩 공유 자원 이용

➡ 모니터는 모니터에 진입하기 위한 큐를 만들고, 모니터 안에 항상 하나의 프로세스만 들어오도록 하여 상호 배제를 위한 동기화 제공

실행 순서 제어 ① 특정 조건을 바탕으로 프로세스를 실행하고 일시 중단하기 위해 조건 변수(condition variable) 사용

     조건 변수 : 프로세스나 스레드의 실행 순서를 제어하기 위해 사용하는 특별한 변수

     - 조건변수.wait() : 대기 상태로 변경
     - 조건변수.signal() : wait() 으로 대기 상태로 접어든 조건변수를 실행 상태로 변경

➡ 모니터는 조건 변수를 이용하여 프로세스 실행 순서 제어를 위한 동기화를 제공

참고

• https://www.youtube.com/watch?v=vp0Gckz3z64 (쉬운코드 유튜브)
• 혼자 공부하는 컴퓨터 구조 + 운영체제 (강민철 지음)
• [JSCODE] 운영체제 스터디 1기 개념 정리 노트

동기화 (synchronization) :여러 프로세스/스레드가 동시에 실행해도 공유 데이터의 일관성을 유지하는 것 (== 프로세스/스레드 사이의 수행 시기를 맞추는 것)

프로세스/스레드 사이의 수행 시기를 맞춘다는 것은?

• 실행 순서 제어 : 프로세스/스레드를 올바른 순서대로 실행하기
• 상호 배제 : 동시에 접근해서는 안되는 자원에 하나의 프로세스만 접근하게 하기

실행 순서 제어를 위한 동기화

Example

프로세스1 : writer ➡ Book.txt 파일에 값을 저장하는 프로세스 프로세스2 : reader ➡ Book.txt 파일에 저장된 값을 읽는 프로세스

① 프로세스1

# 값을 파일에 저장하는 코드
def writer(filename, data):

   with open(filename, 'w') as file:
           file.write(data)

book_data = "example"
writer("book.txt", book_data)

② 프로세스2

# 파일에서 값을 읽어오는 코드
def reader(filename):

with open(filename, 'r') as file:
    data = file.read()
    return data

read_data = reader("book.txt")

위 예제를 보면 두 프로세스는 동시에 실행할 수 있을까?

정답은 X 이다.

프로세스2(reader)는 프로세스1(writer) 실행이 끝나야 실행할 수 있기 때문이다. 즉 프로세스2는 'book.txt안에 값이 존재한다'는 특정 조건이 만족되어야 실행을 이어나갈 수 있다.

이렇게 동시에 실행 되는 프로세스를 올바른 순서로 실행하는 것이 실행 순서 제어를 위한 동기화이다.

상호 배제를 위한 동기화

상호 배제 (mutual exclusion) : 공유가 불가능한 자원의 동시 사용을 피하기 위해 사용하는 알고리즘

• 즉, 특정 한 시점에 단 하나의 프로세스만이 Criticla Section에 접근할 수 있는 것
• ex) 공유 자원을 사용하는 A,B스레드가 있을 때 A스레드가 공유 자원을 사용하는 중에 B가 데이터를 변경해버리면 다시 A스레드가 데이터를 읽을 때 올바르게 결과값이 나오지 않을 수 있다.

Producer & Consumer Problem

Producer & Consumer Problem (생산자와 소비자 문제)

import threading

# 공유 변수
sum = 0


def produce():
    global sum
    for i in range(100000):
            sum += 1

def consume():
    global sum
    for i in range(100000):
            sum -= 1


print("초기 합계:", sum)

# 스레드 생성
producer = threading.Thread(target=produce)
consumer = threading.Thread(target=consume)

# 스레드 시작
producer.start()
consumer.start()

# 스레드가 종료할 때까지 대기
producer.join()
consumer.join()


print("producer, consumer 스레드 실행 이후 합계:", sum)

https://github.com/kangtegong/self-learning-cs/blob/main/producer_consumer/producer_consumer.cpp 사이트를 참고하여 python 으로 구현한 코드

위 코드는 언뜻 보기에 아무 문제가 없어 보인다. 생산자는 sum이란 공유 변수에 1을 증가시키고, 소비자는 sum이란 공유 변수에 1을 감소시킨다. 그래서 보통은 총합 변수가 계속 0일 것이라고 기대한다.

하지만 이 코드에서는 produce와 consume 함수가 락 또는 다른 동기화 메커니즘 없이 sum을 동시에 수정하므로, 실행 결과가 예측할 수 없다. race condition이 발생할 사능성이 있으며, 최종 합계가 0이 아닐 수도 있다.

즉 Producer & Consumer Problem는 동시에 접근해서는 안 되는 자원에 동시에 접근했기에 발생한 문제이다

critical section (임계 구역)

critical section (임계 구역) : 공유 데이터의 일관성을 보장하기 위해 하나의 프로세스/스레드만 진입해서 실행 가능한 영역

critical section problem의 해결책이 되기 위한 조건

① mutual exclusion (상호 배제) : 어떤 프로세스가 critical section(CS)에 진입해서 작업을 수행 중이면 다른 모든 프로세스들은 CS에 진입할 수 없다.

② progress (진행) : CS에 진입한 프로세스가 없고 CS에 진입하려는 프로세스가 있으면, CS 진입을 허용한다.

③ bounded waiting (유한 대기) : CS에 들어가기 위해서 무한대기 하는 프로세스가 존재하면 안 된다. (starvation 현상)

④ 동일 속도 : 프로세스들의 상대적인 속도에 대해서는 어떠한 가정도 하지 않는다.

race condition (경쟁 상태)

race condition (경쟁 상태) : 여러 프로세스/스레드가 동시에 같은 데이터를 조작할 때 타이밍이나 접근 순서에 따라 결과가 달라질 수 있는 상황

• 공유 데이터의 최종 연산 결과는 마지막에 공유 데이터를 다룬 프로세스가 누구인지에 따라 달라진다.
• race condition을 막기 위해서는 공유 데이터에 대한 동시 접근을 동기화 해야한다.

race condition이 발생하는 예

① 공유 메모리를 사용하는 프로세스 사이에서 발생

② 커널 모드 수행 중 interrupt가 발생하여 인터럽트 처리루틴이 수행되는 경우

• 인터럽트 처리 루틴(Interrupt Service Routine, ISR) ➡ 커널 코드
• 커널 모드 수행 중 interrupt가 발생하면 커널 영역의 공유 데이터에 동시(중복) 접근이 일어나는 race condition 상황이 발생한다.

③ 프로세스가 시스템콜을 하여 커널 모드로 수행중인데 context switch가 일어나는 경우

• A 프로세스가 시스템 콜을 하여 커널 모드로 수행 중인 상황이다. (커널 영역의 공유 데이터를 처리하고 있다고 가정)
• 그런데 A 프로세스 작업 중간에 B 프로세스가 CPU를 선점하고, B 프로세스가 시스템 콜을 통해 커널 영역의 공유 데이터에 접근하면 race condition 상황이다.

④ Multi-processor에서 shared memory 내의 kernel data에 동시 접근하는 경우

• 해결방법은 한번에 하나의 CPU만 커널에 들어갈 수 있게 하거나
• 커널 내부에 있는 각 공유 데이터에 접근할 때마다 그 데이터에 대한 lock / unlock을 수행한다.

참고

• https://www.youtube.com/watch?v=vp0Gckz3z64 (쉬운코드 유튜브)
• 혼자 공부하는 컴퓨터 구조 + 운영체제 (강민철 지음)
• [JSCODE] 운영체제 스터디 1기 개념 정리 노트

컴퓨터는 0과 1로 모든 정보를 표현하고, 0과 1로 표현된 정보만을 이해할 수 있다. 그리고 이렇게 0과 1로 표현되는 정보에는 크게 데이터(data)와 명령어(instruction)가 있다.

명령어(instruction)

• 명령어는 데이터를 움직이고 컴퓨터를 작동시키는 정보
• 데이터는 명령어를 위해 존재하는 일종의 재료

저급 언어 vs 고급 언어

저급 언어

저급 언어 (low-level programming language) : 컴퓨터가 직접 이해하고 실행할 수 있는 언어

저급 언어의 종류 ① 기계어(machine code) : 0과 1의 명령어 비트로 이루어진 저급 언어 ② 어셈블리어(assembly language) : 0과 1로 이루어진 기계어를 읽기 편한 형태로 번역한 저급 언어

고급 언어

고급 언어 (high-level programming language) : 개발자가 이해하기 쉽게 만든 언어

고급 언어의 종류

① 컴파일 언어 : 컴파일어에 의해 소스 코드 전체가 저급 언어로 변환되어 실행되는 고급 언어

컴파일(compile) : 컴파일 언어로 작성된 소스코드 전체가 저급 언어로 변환되는 과정
컴파일러(compiler) : 컴파일을 수행해 주는 도구
목적 코드(object code) : 컴파일러를 통해 저급 언어로 변환된 코드

• 소스 코드 전체가 저급 언어로 변환
• 소스 코드 내에 오류가 하나라도 있으면 컴파일이 불가능

② 인터프리터 언어 : 인터프리터에 의해 소스 코드가 한 줄씩 실행되는 고급 언어

인터프리터(interpreter) : 인터프리터 언어로 작성된 소스 코드를 한 줄씩 저급 언어로 변환하여 실행해 주는 도구

• 소스 코드를 한 줄씩 차례로 실행
• 소스 코드 N번째 줄에 문법 오류가 있더라도 N-1번째 줄까지는 올바르게 수행

❗ 하나의 프로그래밍 언어가 반드시 둘 중 하나의 방식만으로 작동한다고 생각하는 것은 오개념이다.

❗  예시로 대표적인 인터프리터 언어로 알려진 파이썬도 컴파일을 하지 않는 것은 아니며, 
자바의 경우 저급 언어가 되는 과정에서 컴파일과 일터프리트를 동시에 수행한다.

❗ 고급 언어와 저급 언어를 이해할 때는 고급 언어가 저급 언어로 변환되는 대표적인 방법에는 
컴파일 방식과 인터프리트 방식이 있다고 이해해야 한다.

명령어의 구조

명령어 : 연산 코드 + 오퍼랜드

연산 코드와 오퍼랜드

오퍼랜드

오퍼랜드 (operand) : 연산에 사용할 데이터 또는 연산에 사용할 데이터가 저장된 위치 (피연산자)

• 오퍼랜드 필드에는 숫자와 문자등을 나타내는 데이터 또는 메모리나 레지스터 주소가 올 수 있다.
• 오퍼랜드는 명령어 안에 하나도 없을 수도 있고, 여러 개가 있을 수도 있다.

0-주소 명령어 : 오퍼랜드 0개 1-주소 명령어 : 오퍼랜드 1개 2-주소 명령어 : 오퍼랜드 2개 3-주소 명렁어 : 오퍼랜드 3개

연산 코드

연산 코드 (operation) : 명령어가 수행할 연산 (연산자)

• 기본적인 연산 코드 유형 : 데이터 전송/ 산술, 논리 연산/ 제어 흐름 변경/ 입출력 제어
• 명령어의 종류와 생김새는 CPU마다 다르기 때문에 연산 코드의 종류와 생김새 또한 CPU마다 다르다.

주소 지정 방식

유효 주소(effective address) : 연산의 대상이 되는 데이터가 저장된 위치 주소 지정 방식(addressing mode) : 유효 주소를 찾는 방법

즉시 주소 지정 방식

즉시 주소 지정 방식(immediate addressing mode) : 연산에 사용할 데이터를 오퍼랜드 필드에 직접 명시하는 방식

• 가장 간단한 형태의 주소 지정 방식
• 장점 : 연산에 사용할 데이터를 메모리나 레지스터로부터 찾는 과정이 없기 때문에 빠름
• 단점 : 표현할 수 있는 데이터의 크기가 작아짐

직접 주소 지정 방식

직접 주소 지정 방식(direct addressing mode) : 오퍼랜드 필드에 유효 주소를 직접적으로 명시하는 방식

• 데이터 크기는 즉시 주소 지정 방식보다 커짐
• 여전히 유효 주소를 표현할 수 있는 범위가 연산 코드의 비트 수만큼 줄어듦

간접 주소 지정 방식

간접 주소 지정 방식(indirect addressing mode) : 유효 주소의 주소를 오퍼랜드 필드에 명시하는 방식

• 직접 주소 지정 방식보다 표현할 수 있는 유효 주소의 범위가 더 넓어짐
• 두 번의 메모리 접근이 필요하기 때문에 일반적으로 느린 방식

레지스터 주소 지정 방식

레지스터 주소 지정 방식(register addressing mode) : 연산에 사용할 데이터를 저장한 레지스터를 오퍼랜드 필드에 직접 명시하는 방식

• CPU 외부에 있는 메모리에 접근하는 것보다 CPU 내부에 있는 레지스터에 접근하는 것이 더 빠르기에 레지스터 주소 지정방식은 직접 주소 지정 방식보다 빠르게 데이터에 접근 가능
• 직접 주소 지정 방식과 비슷하게 표현할 수 있는 레지스터 크기에 제한이 생길 수 있음

레지스터 간접 주소 지정 방식

레지스터 간접 주소 지정 방식(register indirect addressing mode) : 연산에 사용할 데이터를 메모리에 저장하고 그 유효 주소를 저장한 레지스터를 오퍼랜드 필드에 명시하는 방법

• 유효 주소를 찾는 과정이 간접 주소 지정 방식과 비슷하지만, 메모리에 접근하는 횟수가 한 번으로 줄어듦
• 레지스터 간접 주소 지정 방식은 간접 주소 지정 방식보다 빠름

스택과 큐

스택

스택(stack) : 한쪽 끝이 막혀 있는 통과 같은 저장 공간

• 나중에 저장한 데이터를 가장 먼저 빼내는 데이터 관리 방식(후입선출) ➡ LIFO(Last In First Out)

큐

큐(queue) : 스택과는 달리 양쪽이 뚫려 있는 통과 같은 저장 공간

• 가장 먼저 저장된 데이터부터 빼내는 데이터 관리 방식(선입선출) ➡ FIFO(First In First Out)

참고

• 혼자 공부하는 컴퓨터 구조 + 운영체제 (강민철 지음)

컴퓨터는 0과 1로 모든 정보를 표현하고, 0과 1로 표현된 정보만을 이해할 수 있다. 그리고 이렇게 0과 1로 표현되는 정보에는 크게 데이터(data)와 명령어(instruction)가 있다.

데이터

• 컴퓨터가 이해하는 숫자, 문자, 이미지, 동영상과 같은 정적인 정보
• 컴퓨터와 주고받는 정보나 컴퓨터에 저장된 정보를 가리킬 때 통칭하는 말

정보 단위

비트(bit) : 0과 1을 나타내는 가장 작은 정보 단위

⬇ 프로그램의 크기를 말할 때 사용하는 표현⬇ 바이트(byte) == 8비트 1 킬로바이트(kB) == 1,000바이트 1 메가바이트(MB) == 1,000킬로바이트 1 기가바이트(GB) == 1,000메가바이트 1 테라바이트(TB) == 1,000기가바이트

워드(word) : CPU가 한 번에 처리할 수 있는 데이터 크기 ⬇ 하프 워드(half word) : 워드의 절반크기 풀 워드(full word) : 워드의 1배 크기 더블 워드(double word) : 워드의 2배 크기

0과 1을 숫자로 표현하는 방법

이진법(binary)

• 0과 1만으로 모든 숫자를 표현하는 방법

표기 방법 ① ex) 1000(2) ② ex) 0b1000

음수 표현

• 2의 보수(two's complement)를 구해 이 값을 음수로 간주 ① 사전적 의미 : 어떤 수를 그보다 큰 2ⁿ에서 뺀 값 ② 쉽게 풀기 : 모든 0과 1을 뒤집고, 거기에 1을 더한 값

❗ 1의 보수 : 모든 이진수의 1과 0을 뒤집은 수 
❗ 2의 보수 : 1의 보수에 1을 더한 값
❗ 플래그(flag) : 컴퓨터 내부에서 이 수가 양수인지 음수인지를 구분하기 위해 사용하는 것

2의 보수 표현의 한계

• 0이나 2ⁿ형태의 이진수에 2의 보수를 취하면 원하는 음수값을 얻을 수 없다.

0을 음수로 표현하기

0000 ➡(모든 수 뒤집기) 1111 ➡(1을 더하기) 10000

❗ 이런 경우 자리 올림이 발생한 비트의 1을 버린다.

2³을 음수로 표현하기

1000 ➡(모든 수 뒤집기) 0111 ➡(1을 더하기) 1000

❗ 이런 경우 음수가 자기 자신의 되버리는 경우는 본질적으로 해결하기 힘들다.
❗ 즉, n비트로틑 -2ⁿ과 2ⁿ을 동시에 표현할 수 없다.

십육진법(hexadecimal)

• 수가 15를 넘어가는 시점에 자리 올림하여 수를 표현하는 방법

표기 방법 ① 수학적 표기 방식 : 15(16) ② 코드상 표기 방식 : 0x15

십육진수를 이진수로 변환

ex) 1A2B

⬇각 자리를 이진수로 변환⬇
- 1 == 0001(2)
- A == 1010(2)
- 2 == 0010(2)
- B == 1011(2)

즉 1A2B(16) = 0001101000101011(2)

0과 1을 문자로 표현하는 방법

문자 집합(character set) : 컴퓨터가 인식하고 표현할 수 있는 문자의 모음 문자 인코딩(character encoding) : 문자를 0과 1로 변환하는 과정 문자 디코딩(character decoding) : 0과1로 이루어진 문자 코드를 문자로 변환하는 과정

아스키 코드

• 초창기 문자 집합 중 하나
• 알파벳, 아라비아 숫자, 일부 특수 문자 및 제어 문자 표현 가능
• 코드 포인트(문자를 부여된 값) 사용
• 7비트로 하나의 문자 표현
  • 8비트 중 1비트는 오류 검출을 위해 사용되는 패리티 비트(parity bit)
• 장점 : 간단한 인코딩
• 단점 : 한글을 포함한 다른 언어 문자, 다양한 특수 문자 표현 불가
  • 128개보다 많은 문자를 표현할 수 없음
  • 8비트인 확장 아스키가 등장하였지만 여전히 부족

EUC-KR

한글 인코딩 : 완성형 vs 조합형 인코딩 ①완성형 : 홍 + 길 + 동 ②조합형 : ㅎ + ㅗ + ㅇ

EUC-KR

• 완성형 인코딩
• 한 글자에 2바이트 크기의 코드 부여
• 2바이트 == 16비트
• 2300여 개의 한글 표현 가능
• EUC-KR 확장형 -> 마이크로소프트의 CP949 (Code Page 949)
• 문제점 : 언어별 인코딩을 국가마다 하게 되면 다국어를 지원하는 프로그램을 개발할 때엔 언어별 인코딩 방식을 모두 이해해야 함

유니코드와 UTF-8

유니코드

• 통일된 문자 집합
• 한글, 영여, 화살표와 같은 특수 문자, 심지어 이모티콘까지 표현 가능
• 현대 문자 표현에 있어 매우 중요한 위치
• 유니코드의 인코딩 방식 : UTF-8, UTF-16, UTF-32∙∙∙

UTF-8 인코딩

• 가장 대중적으로 사용
• UTF(Unicode Transformation Format) == 유니코드 인코딩 방법
• 가변길이 인코딩 : 인코딩 결과가 1바이트 ~ 4바이트
• 인코딩 결과가 몇 바이트가 될지는 유니코드에 부여된 값에 따라 다름

참고

• 혼자 공부하는 컴퓨터 구조 + 운영체제 (강민철 지음)

💭 우선순위가 낮은 프로세스들이 우선순위가 높은 프로세스들에 의해 실행이 계속해서 연기되는 현상입니다.

❓ 기아 상태를 어떻게 해결할 수 있나요?

💭 기아 상태를 방지하기 위한 기법으로 에이징이 있습니다. 에이징은 오랫동안 대기한 프로세스의 우선순위를 점차 높이는 방식입니다.

❓ CPU 스케줄링이란 무엇인가요?

💭 CPU 스케줄링은 운영체제가 프로세스들에게 공정하고 합리적으로 CPU 자원을 배분하는 것입니다.

❓ 스케줄러의 종류는 무엇이 있나요?

💭 장기 스케줄러, 중기 스케줄러, 단기 스케줄러가 있습니다. 장기 스케줄러는 작업 스케줄러라고도 부르며 프로세스를 준비큐에 삽입할지 결정하는 역할을 합니다. 중기 스케줄러는 메모리에 적재된 프로세스의 수를 조절하는 역할합니다.(=스와핑) 단기 스케줄러는 CPU스케줄러라고도 부르며 준비 상태에 있는 작업 중 실행할 프로세스를 선택하여 CPU를 할당합니다.

❓ 선점형 스케줄링과 비선점형 스케줄링의 차이가 무엇인가요?

💭 선점형 스케줄링은 프로세스가 자원을 사용하고 있을 때 다른 프로세스가 해당 자원을 빼앗을 수 있지만 비선점형은 빼앗을 수 없습니다.

❓ 선입선출 스케줄링(FCFS)란 무엇인가요?

💭 준비 큐에 삽입된 순서대로 프로세스를 처리하는 비선점형 스케줄링 방식입니다. FCFS 스케줄링은 호위 효과가 발생할 수 있다는 문제가 있습니다.

• 호위 효과(convoy effect) : 모든 다른 프로세스들이 하나의 긴 프로세스가 CPU를 양도하기를 기다리는 것

❓ 최단 작업 우선 스케줄링(SJF)란 무엇인가요?

💭 준비 큐에 삽입된 프로세스들 중 CPU이용시간의 길이가 가장 짧은 프로세스부터 실행하는 스케줄링 방식입니다. 짧은 작업을 먼저 실행하기때문에 평균 대기 시간이 짧지만 실행시간을 예측하기 어려워 실용적이지 못하고 짧은 작업이 항상 먼저 실행되기 때문에 기아 상태가 발생한다는 단점이 있습니다.

❓ 최소 잔류 시간 우선 스케줄링(SRTF)란 무엇인가요?

💭 최단 작업 우선 스케줄링 알고리즘과 라운드 로빈 알고리즘을 합친 스케줄링 방식으로 프로세스들은 정해진 타임 슬라이스만큼 CPU를 사용하되, 사용할 다음 프로세스로는 남아있는 작업 시간이 가장 적은 프로세스가 선택되는 스케줄링입니다. 최소 잔류 시간 우선 스케줄링은 선점형 SJF 스케줄링이라고도 불립니다.

❓ 우선순위 스케줄링이란 무엇인가요?

💭 프로세스들에 우선순위를 부여하고, 가장 높은 우선순위들을 가진 프로세스부터 실행하는 스케줄링 알고리즘입니다. 우선순위 스케줄링은 기아현상이 발생한다는 근본적인 문제를 가지고있습니다.

❓ 라운드 로빈 스케줄링이란 무엇인가요?

💭 정해진 타임 슬라이스만큼의 시간 동안 돌아가며 CPU를 이용하는 선점형 스케줄링 방식입니다. 프로세스들은 정해진 시간만큼만 CPU를 이용하고, 정해진 시간을 모두 사용하였음에도 프로세스가 완료되지 않았다면 다시 큐의 맨 뒤에 삽입됩니다.

라운드 로빈 스케줄링에서 타임 슬라이스가 지나치게 크면 선입 선처리 스케줄링과 같이 호위효과가 생길 여지가 있습니다.

❓ 멀티 레벨 큐 스케줄링이란 무엇인가요?

💭 우선순위별로 준비 큐를 여러 개 사용하는 스케줄링 방식입니다. 우선순위가 가장 높은 큐에 있는 프로세스들을 먼저 처리하고, 우선순위가 가장 높은 큐가 비어있으면 그 다음 우선순위 큐에 있는 프로세스를 처리합니다. 큐마다 다른 스케줄링 알고리즘을 사용할 수 있고 프로세스들은 큐 사이를 이동할 수 없습니다.

❓ 멀티 레벨 피드백 큐 스케줄링이란 무엇인가요?

💭 다단계 큐 스케줄링에 프로세스들이 큐 사이를 이동할 수 있게한 스케줄링입니다. 멀티 레벨 피드백 큐 스케줄링에서 CPU집중 프로세스들은 자연스레 우선순위가 낮아지고, 입출력 집중 프로세스들은 우선순위가 높은 쿠에서 실행이 끝나게 됩니다. 또한 큐 사이를 이동할 수 있기에 에이징 기법을 적용하여 기아 현상을 예방할 수 있습니다.