Home > CS > 2024 > ๐Ÿ’พ [CS] ๋™์‹œ์„ฑ ํ”„๋กœ๊ทธ๋ž˜๋ฐ(Concurrency Programming)์ด๋ž€ ๋ฌด์—‡์ผ๊นŒ์š”?

๐Ÿ’พ [CS] ๋™์‹œ์„ฑ ํ”„๋กœ๊ทธ๋ž˜๋ฐ(Concurrency Programming)์ด๋ž€ ๋ฌด์—‡์ผ๊นŒ์š”?
CS

๐Ÿ’พ [CS] ๋™์‹œ์„ฑ ํ”„๋กœ๊ทธ๋ž˜๋ฐ(Concurrency Programming)์ด๋ž€ ๋ฌด์—‡์ผ๊นŒ์š”?

  • ๋™์‹œ์„ฑ ํ”„๋กœ๊ทธ๋ž˜๋ฐ(Concurrency Programming)์€ ์—ฌ๋Ÿฌ ์ž‘์—…์„ ๋™์‹œ์— ์ˆ˜ํ–‰ํ•  ์ˆ˜ ์žˆ๋„๋ก ํ”„๋กœ๊ทธ๋žจ์„ ์„ค๊ณ„ํ•˜๋Š” ๊ธฐ๋ฒ•์ž…๋‹ˆ๋‹ค.
  • ๋™์‹œ์„ฑ(Concurrency)์€ ์ž‘์—…์˜ ์‹คํ–‰ ํ๋ฆ„์„ ๊ฒน์น˜๊ฒŒ ํ•˜๊ฑฐ๋‚˜ ๋ณ‘๋ ฌ๋กœ ์ฒ˜๋ฆฌํ•˜์—ฌ, ์‹œ์Šคํ…œ์˜ ํšจ์œจ์„ฑ์„ ๋†’์ด๊ณ  ์ฒ˜๋ฆฌ ์‹œ๊ฐ„์„ ์ค„์ด๋Š” ๋ฐ ์ค‘์ ์„ ๋‘ก๋‹ˆ๋‹ค.
  • ๋™์‹œ์„ฑ ํ”„๋กœ๊ทธ๋ž˜๋ฐ(Concurrency Programming)์€ ๋ฉ€ํ‹ฐ์Šค๋ ˆ๋”ฉ, ๋ฉ€ํ‹ฐํ”„๋กœ์„ธ์‹ฑ์„ ํฌํ•จํ•˜์—ฌ, ๋น„๋™๊ธฐ ํ”„๋กœ๊ทธ๋ž˜๋ฐ๊ณผ ๊ฐ™์€ ๋‹ค์–‘ํ•œ ๊ธฐ๋ฒ•์„ ์‚ฌ์šฉํ•˜์—ฌ ์‹œ์Šคํ…œ ์ž์›์„ ์ตœ๋Œ€ํ•œ ํ™œ์šฉํ•  ์ˆ˜ ์žˆ๋„๋ก ํ•ฉ๋‹ˆ๋‹ค.

1๏ธโƒฃ ๋™์‹œ์„ฑ๊ณผ ๋ณ‘๋ ฌ์„ฑ์˜ ์ฐจ์ด.

  • ๋™์‹œ์„ฑ๊ณผ ๋ณ‘๋ ฌ์„ฑ์€ ์ข…์ข… ํ˜ผ๋™๋˜์ง€๋งŒ, ์„œ๋กœ ๋‹ค๋ฅธ ๊ฐœ๋…์ž…๋‹ˆ๋‹ค.

1๏ธโƒฃ ๋™์‹œ์„ฑ(Concurrency)

  • ๋™์‹œ์„ฑ(Concurrency)์€ ์—ฌ๋Ÿฌ ์ž‘์—…์ด ์‹คํ–‰๋˜๋Š” ๊ฒƒ์ฒ˜๋Ÿผ ๋ณด์ด๊ฒŒ ํ•˜๋Š” ๊ฒƒ์„ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค.
    • ์‹ค์ œ๋กœ๋Š” ์ž‘์—… ๊ฐ„์˜ ์‹คํ–‰ ์‹œ๊ฐ„์„ ์ชผ๊ฐœ์–ด ๋ฒˆ๊ฐˆ์•„ ๊ฐ€๋ฉด์„œ ์‹คํ–‰ํ•˜์—ฌ, ์—ฌ๋Ÿฌ ์ž‘์—…์ด ๋™์‹œ์— ์ง„ํ–‰๋˜๋Š” ๊ฒƒ์ฒ˜๋Ÿผ ๋ณด์ด๊ฒŒ ๋งŒ๋“ญ๋‹ˆ๋‹ค.
  • ์˜ˆ๋ฅผ ๋“ค์–ด, ํ•˜๋‚˜์˜ CPU ์ฝ”์–ด์—์„œ ๋‘ ๊ฐœ์˜ ์ž‘์—…์„ ๋ฒˆ๊ฐˆ์•„๊ฐ€๋ฉฐ ๋น ๋ฅด๊ฒŒ ์‹คํ–‰ํ•˜๋ฉด, ๋‘ ์ž‘์—…์ด ๋™์‹œ์— ์‹คํ–‰๋˜๋Š” ๊ฒƒ์ฒ˜๋Ÿผ ๋Š๊ปด์ง‘๋‹ˆ๋‹ค.
    • ์ด๋Š” ๋ฉ€ํ‹ฐํƒœ์Šคํ‚น(Multitasking)์˜ ๊ฐœ๋…๊ณผ ์œ ์‚ฌํ•ฉ๋‹ˆ๋‹ค.

2๏ธโƒฃ ๋ณ‘๋ ฌ์„ฑ(Parallelism)

  • ๋ณ‘๋ ฌ์„ฑ(Parallelism)์€ ์—ฌ๋Ÿฌ ์ž‘์—…์„ ๋™์‹œ์— ์‹คํ–‰ํ•˜๋Š” ๊ฒƒ์„ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค.
    • ๋™์‹œ์„ฑ๊ณผ ๋‹ฌ๋ฆฌ, ์‹ค์ œ๋กœ ์—ฌ๋Ÿฌ CPU ์ฝ”์–ด์—์„œ ์—ฌ๋Ÿฌ ์ž‘์—…์„ ๋™์‹œ์— ์ฒ˜๋ฆฌํ•ฉ๋‹ˆ๋‹ค.
  • ๋ณ‘๋ ฌ์„ฑ(Parallelism)์€ ๋ฉ€ํ‹ฐ์ฝ”์–ด ํ”„๋กœ์„ธ์„œ ํ™˜๊ฒฝ์—์„œ ์ฃผ๋กœ ์ด๋ฃจ์–ด์ง€๋ฉฐ, ํ•˜๋‚˜์˜ ์ž‘์—…์„ ์—ฌ๋Ÿฌ ์กฐ๊ฐ์œผ๋กœ ๋‚˜๋ˆ  ์—ฌ๋Ÿฌ ์ฝ”์–ด์—์„œ ๋™์‹œ์— ์ฒ˜๋ฆฌํ•  ์ˆ˜ ์žˆ๊ฒŒ ํ•ด์ค๋‹ˆ๋‹ค

2๏ธโƒฃ ๋™์‹œ์„ฑ ํ”„๋กœ๊ทธ๋ž˜๋ฐ(Concurrency Programming)์˜ ํ•„์š”์„ฑ

1๏ธโƒฃ ํšจ์œจ์ ์ธ ์ž์› ์‚ฌ์šฉ.

  • ์ปดํ“จํ„ฐ ์‹œ์Šคํ…œ์€ CPU, ๋ฉ”๋ชจ๋ฆฌ, I/O ์žฅ์น˜์™€ ๊ฐ™์€ ๋‹ค์–‘ํ•œ ์ž์›์ด ์žˆ์Šต๋‹ˆ๋‹ค.
    • ๋™์‹œ์„ฑ ํ”„๋กœ๊ทธ๋ž˜๋ฐ(Concurrency Programming)์„ ํ†ตํ•ด ์ด๋Ÿฌํ•œ ์ž์›์„ ํšจ์œจ์ ์œผ๋กœ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
  • ์˜ˆ๋ฅผ ๋“ค์–ด, ํŒŒ์ผ์„ ์ฝ๊ฑฐ๋‚˜ ๋„คํŠธ์›Œํฌ ์š”์ฒญ์„ ๊ธฐ๋‹ค๋ฆฌ๋Š” ๋™์•ˆ CPU๊ฐ€ ์œ ํ›„ ์ƒํƒœ์— ๋จธ๋ฌด๋ฅด์ง€ ์•Š๋„๋ก, ๋‹ค๋ฅธ ์ž‘์—…์„ ์‹คํ–‰ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

๐Ÿ“ ์œ ํ›„ ์ƒํƒœ(Idle State)

CPU๊ฐ€ ํ˜„์žฌ ์‹คํ–‰ํ•  ์ž‘์—…์ด ์—†์–ด์„œ ๋Œ€๊ธฐํ•˜๊ณ  ์žˆ๋Š” ์ƒํƒœ๋ฅผ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค.
์ฆ‰, CPU๊ฐ€ ์•„๋ฌด๋Ÿฐ ์ž‘์—…๋„ ์ˆ˜ํ–‰ํ•˜์ง€ ์•Š๊ณ  ์‰ฌ๊ณ  ์žˆ๋Š” ์ƒํƒœ๋ฅผ ๋œปํ•ฉ๋‹ˆ๋‹ค.

์ปดํ“จํ„ฐ ์‹œ์Šคํ…œ์—์„œ CPU๋Š” ํ•ญ์ƒ ์ž‘์—…์„ ํ• ๋‹น๋ฐ›์•„์•ผ ์ œ๋Œ€๋กœ ์ž‘๋™ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
๊ทธ๋Ÿฌ๋‚˜ ์ž…์ถœ๋ ฅ ์ž‘์—…์ด ์™„๋ฃŒ๋˜๊ธฐ๋ฅผ ๊ธฐ๋‹ค๋ฆฌ๊ฑฐ๋‚˜, ๋‹ค์Œ ๋ช…๋ น์–ด๊ฐ€ ์ค€๋น„๋˜์ง€ ์•Š์€ ๊ฒฝ์šฐ ๋“ฑ, ํŠน์ • ์ƒํ™ฉ์—์„œ๋Š” CPU๊ฐ€ ์œ ํ›„ ์ƒํƒœ๋กœ ๋จธ๋ฌผ๊ฒŒ ๋ฉ๋‹ˆ๋‹ค.

2๏ธโƒฃ ๋น ๋ฅธ ์‘๋‹ต์„ฑ.

  • ๋™์‹œ์„ฑ ํ”„๋กœ๊ทธ๋ž˜๋ฐ(Concurrency Programming)์€ ํ”„๋กœ๊ทธ๋žจ์˜ ์‘๋‹ต์„ฑ์„ ํ–ฅ์ƒ์‹œํ‚ต๋‹ˆ๋‹ค.
    • ์˜ˆ๋ฅผ ๋“ค์–ด, ์‚ฌ์šฉ์ž๊ฐ€ ๋ฒ„ํŠผ์„ ํด๋ฆญํ•  ๋•Œ๋งˆ๋‹ค ์ƒˆ๋กœ์šด ์š”์ฒญ์ด ์ฒ˜๋ฆฌ๋˜๋„๋ก ํ•˜๊ณ , ๋ฉ”์ธ ์Šค๋ ˆ๋“œ๊ฐ€ ๋‹ค๋ฅธ ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•˜๋Š” ๋™์•ˆ์—๋„ UI๊ฐ€ ๋ฉˆ์ถ”์ง€ ์•Š๊ฒŒ ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
  • ์ด๋Š” ํŠนํžˆ ์›น ์„œ๋ฒ„์™€ ๊ฐ™์€ ํ™˜๊ฒฝ์—์„œ ์ค‘์š”ํ•ฉ๋‹ˆ๋‹ค.
    • ์—ฌ๋Ÿฌ ์‚ฌ์šฉ์ž์˜ ์š”์ฒญ์„ ๋™์‹œ์— ์ฒ˜๋ฆฌํ•˜์—ฌ ๋น ๋ฅด๊ฒŒ ์‘๋‹ตํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

3๏ธโƒฃ ๋ฐฐ์น˜ ์ฒ˜๋ฆฌ ๋ฐ ๋ณ‘๋ ฌ ๊ณ„์‚ฐ.

  • ๋™์‹œ์„ฑ ํ”„๋กœ๊ทธ๋ž˜๋ฐ(Concurrency Programming)์€ ๋Œ€๋Ÿ‰์˜ ๋ฐ์ดํ„ฐ๋ฅผ ๋ณ‘๋ ฌ๋กœ ์ฒ˜๋ฆฌํ•  ๋•Œ ์œ ๋ฆฌํ•ฉ๋‹ˆ๋‹ค.
    • ์˜ˆ๋ฅผ ๋“ค์–ด, ๋น…๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ๋ฅผ ์œ„ํ•ด ์—ฌ๋Ÿฌ ๋…ธ๋“œ์—์„œ ๋ฐ์ดํ„ฐ๋ฅผ ๋™์‹œ์— ์ฒ˜๋ฆฌํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

๐Ÿ“ ๋…ธ๋“œ(Node)

์ปดํ“จํ„ฐ ๋„คํŠธ์›Œํฌ์—์„œ ๋ฐ์ดํ„ฐ๋ฅผ ์ฒ˜๋ฆฌํ•˜๊ฑฐ๋‚˜ ์ „์†กํ•˜๋Š” ์žฅ์น˜๋‚˜ ์‹œ์Šคํ…œ์„ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค.
๋…ธ๋“œ๋Š” ๋„คํŠธ์›Œํฌ๋ฅผ ๊ตฌ์„ฑํ•˜๋Š” ๊ฐœ๋ณ„์ ์ธ ์žฅ์น˜๋กœ, ์„œ๋ฒ„, ์ปดํ“จํ„ฐ, ๋ผ์šฐํ„ฐ, ์Šค์œ„์น˜, ๋˜๋Š” ํด๋ผ์ด์–ธํŠธ ๋“ฑ์ด ๋ชจ๋‘ ๋…ธ๋“œ๊ฐ€ ๋  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
๋ถ„์‚ฐ ์‹œ์Šคํ…œ์—์„œ ๋…ธ๋“œ๋Š” ๊ฐ๊ฐ ๋…๋ฆฝ์ ์œผ๋กœ ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•˜๊ฑฐ๋‚˜, ์„œ๋กœ ํ˜‘๋ ฅํ•˜์—ฌ ํฐ ์ž‘์—…์„ ๋ถ„๋‹ดํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

3๏ธโƒฃ ๋™์‹œ์„ฑ ํ”„๋กœ๊ทธ๋ž˜๋ฐ(Concurrency Programming)์˜ ์ฃผ์š” ๊ฐœ๋….

1๏ธโƒฃ ์Šค๋ ˆ๋“œ(Thread)

  • ์Šค๋ ˆ๋“œ๋Š” ํ”„๋กœ์„ธ์Šค ๋‚ด์—์„œ ์‹คํ–‰๋˜๋Š” ์ž‘์€ ์‹คํ–‰ ๋‹จ์œ„์ž…๋‹ˆ๋‹ค.
    • ํ•œ ํ”„๋กœ์„ธ์Šค๋Š” ์—ฌ๋Ÿฌ ์Šค๋ ˆ๋“œ๋ฅผ ๊ฐ€์งˆ ์ˆ˜ ์žˆ์œผ๋ฉฐ, ์ด๋“ค ์Šค๋ ˆ๋“œ๋Š” ๋ฉ”๋ชจ๋ฆฌ์™€ ์ž์›์„ ๊ณต์œ ํ•ฉ๋‹ˆ๋‹ค.
  • ๋™์‹œ์„ฑ ํ”„๋กœ๊ทธ๋ž˜๋ฐ(Concurrency Programming)์—์„œ ๋ฉ€ํ‹ฐ์Šค๋ ˆ๋”ฉ(Multithreading)์„ ํ†ตํ•ด ์—ฌ๋Ÿฌ ์Šค๋ ˆ๋“œ๋ฅผ ๋™์‹œ์— ์‹คํ–‰ํ•˜์—ฌ ์ž‘์—…์„ ๋™์‹œ์— ์ฒ˜๋ฆฌํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

2๏ธโƒฃ ๋ฝ(Lock)

  • ์—ฌ๋Ÿฌ ์Šค๋ ˆ๋“œ๊ฐ€ ๊ณต์œ  ์ž์›์— ๋™์‹œ์— ์ ‘๊ทผํ•˜๋ฉด ๋ฐ์ดํ„ฐ ์ถฉ๋Œ(Race Condition)์ด ๋ฐœ์ƒํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
    • ์ด๋ฅผ ๋ฐฉ์ง€ํ•˜๊ธฐ ์œ„ํ•ด, ๊ณต์œ  ์ž์›์— ์ ‘๊ทผํ•  ๋•Œ ๋ฝ์„ ์‚ฌ์šฉํ•˜์—ฌ ํ•œ ๋ฒˆ์— ํ•˜๋‚˜์˜ ์Šค๋ ˆ๋“œ๋งŒ ์ž์›์— ์ ‘๊ทผํ•˜๋„๋ก ํ•ฉ๋‹ˆ๋‹ค.
  • ํ•˜์ง€๋งŒ ๋ฝ์„ ์ž˜๋ชป ์‚ฌ์šฉํ•  ๊ฒฝ์šฐ ๋ฐ๋“œ๋ฝ(DeadLock)์ด๋‚˜ ๋ผ์ด๋ธ”๋ก(Livelock) ๊ฐ™์€ ๋ฌธ์ œ๊ฐ€ ๋ฐœ์ƒํ•  ์ˆ˜ ์žˆ์Šค๋ฏ€๋กœ, ์ฃผ์˜๊ฐ€ ํ•„์š”ํ•ฉ๋‹ˆ๋‹ค.

3๏ธโƒฃ ๋ฎคํ…์Šค(Mutex)์™€ ์„ธ๋งˆํฌ์–ด(Semaphore)

  • ๋ฎคํ…์Šค(Mutex)๋Š” ๋‘ ๊ฐœ ์ด์ƒ์˜ ์Šค๋ ˆ๋“œ๊ฐ€ ๋™์‹œ์— ์ž์›์— ์ ‘๊ทผํ•˜๋Š” ๊ฒƒ์„ ๋ฐฉ์ง€ํ•˜๊ธฐ ์œ„ํ•ด ์‚ฌ์šฉ๋˜๋Š” ๋ฝ์˜ ์ผ์ข…์ž…๋‹ˆ๋‹ค.
    • ํŠน์ • ์Šค๋ ˆ๋“œ๊ฐ€ ์ž์›์„ ์‚ฌ์šฉํ•˜๋ฉด, ๋‹ค๋ฅธ ์Šค๋ ˆ๋“œ๋Š” ๊ทธ ์ž์›์ด ํ•ด์ œ๋  ๋•Œ๊นŒ์ง€ ๋Œ€๊ธฐํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.
  • ์„ธ๋งˆํฌ์–ด(Semaphore)๋Š” ๋ฆฌ์†Œ์Šค์˜ ์ ‘๊ทผ ๊ฐ€๋Šฅํ•œ ์ˆ˜๋Ÿ‰์„ ๊ด€๋ฆฌํ•˜์—ฌ, ์—ฌ๋Ÿฌ ์Šค๋ ˆ๋“œ๊ฐ€ ๋ฆฌ์†Œ์Šค๋ ˆ ์ ‘๊ทผํ•˜๋„๋ก ์ œ์–ดํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
    • ์ œํ•œ๋œ ์ˆ˜์˜ ์Šค๋ ˆ๋“œ๋งŒ ๋ฆฌ์†Œ์Šค์— ์ ‘๊ทผํ•  ์ˆ˜ ์žˆ๊ฒŒ๋” ํ—ˆ์šฉํ•ฉ๋‹ˆ๋‹ค.

4๏ธโƒฃ ๋น„๋™๊ธฐ ํ”„๋กœ๊ทธ๋ž˜๋ฐ(Asynchronous Programming)

  • ๋น„๋™๊ธฐ ํ”„๋กœ๊ทธ๋ž˜๋ฐ(Asynchronous Programming)์€ ๋™์‹œ์„ฑ ํ”„๋กœ๊ทธ๋ž˜๋ฐ(Concurrency Programming)์˜ ํ•œ ํ˜•ํƒœ๋กœ, ํŠน์ • ์ž‘์—…์ด ์™„๋ฃŒ๋  ๋•Œ ๊นŒ์ง€ ๋Œ€๊ธฐํ•˜์ง€ ์•Š๊ณ  ๋‹ค๋ฅธ ์ž‘์—…์„ ๋จผ์ € ์ˆ˜ํ–‰ํ•˜๋„๋ก ํ•ฉ๋‹ˆ๋‹ค.
  • ์˜ˆ๋ฅผ ๋“ค์–ด, ๋„คํŠธ์›Œํฌ ์š”์ฒญ์„ ๋ณด๋‚ด๊ณ  ์‘๋‹ต์„ ๊ธฐ๋‹ค๋ฆฌ๋Š” ๋™์•ˆ, ํ”„๋กœ๊ทธ๋žจ์€ ๋‹ค๋ฅธ ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
  • Java์—์„œ๋Š” CompletableFuture, JavaScript์—์„œ๋Š” Promise๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ๋น„๋™๊ธฐ ํ”„๋กœ๊ทธ๋ž˜๋ฐ(Asynchronous Programming)์„ ์‰ฝ๊ฒŒ ๊ตฌํ˜„ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

4๏ธโƒฃ ๋™์‹œ์„ฑ ํ”„๋กœ๊ทธ๋ž˜๋ฐ(Concurrency Programming)์˜ ์˜ˆ์‹œ.

1๏ธโƒฃ ๋ฉ€ํ‹ฐ์Šค๋ ˆ๋”ฉ ์˜ˆ์‹œ.

class MyThread extends Thread {
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getId() + ": " + i);
            try {
                Thread.sleep(500); // 0.5์ดˆ ๋Œ€๊ธฐ
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MYThread();
        t1.start(); // t1 ์Šค๋ ˆ๋“œ ์‹œ์ž‘
        t2.start(); // t2 ์Šค๋ ˆ๋“œ ์‹œ์ž‘
    }
}
  • ์œ„ ์ฝ”๋“œ๋Š” ๋‘ ๊ฐœ์˜ ์Šค๋ ˆ๋“œ๋ฅผ ์ƒ์„ฑํ•˜๊ณ , ๋™์‹œ์— ์‹คํ–‰์‹œ์ผœ ๋™์‹œ์„ฑ์„ ๊ตฌํ˜„ํ•˜๋Š” ์˜ˆ์‹œ์ž…๋‹ˆ๋‹ค.

2๏ธโƒฃ ๋น„๋™๊ธฐ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์˜ˆ์‹œ.

import java.util.concurrent.CompletableFuture;

public class AsyncExample {
    public static void main(String[] args) {
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            try {
                Thread.sleep(1000);
                System.out.println("๋น„๋™๊ธฐ ์ž‘์—… ์™„๋ฃŒ!");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        
        System.out.println("๋ฉ”์ธ ์Šค๋ ˆ๋“œ ์ž‘์—… ์‹คํ–‰ ์ค‘...");
        future.join(); // ๋น„๋™๊ธฐ ์ž‘์—…์ด ๋๋‚  ๋•Œ๊นŒ์ง€ ๋Œ€๊ธฐ
    }
}
  • ์ด ์ฝ”๋“œ๋Š” ๋น„๋™๊ธฐ์ ์œผ๋กœ ์‹คํ–‰๋˜๋Š” ์ž‘์—…์„ ๋งŒ๋“ค๊ณ , ๋ฉ”์ธ ์Šค๋ ˆ๋“œ๊ฐ€ ์ž‘์—…์„ ๊ธฐ๋‹ค๋ฆฌ์ง€ ์•Š๊ณ  ๋‹ค๋ฅธ ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•  ์ˆ˜ ์žˆ๊ฒŒ ํ•ฉ๋‹ˆ๋‹ค.

5๏ธโƒฃ ๋™์‹œ์„ฑ ํ”„๋กœ๊ทธ๋ž˜๋ฐ(Concurrency Programming)์˜ ์žฅ์ .

1๏ธโƒฃ ์ž์› ํšจ์œจ์„ฑ ๊ทน๋Œ€ํ™”.

  • CPU๊ฐ€ ์ž‘์—…์„ ๋Œ€๊ธฐํ•˜๋Š” ๋™์•ˆ ์œ ํœด ์ƒํƒœ๋กœ ์žˆ์ง€ ์•Š๊ณ , ๋‹ค๋ฅธ ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•  ์ˆ˜ ์žˆ์–ด ์‹œ์Šคํ…œ ์ž์›์˜ ํšจ์œจ์„ฑ์„ ๋†’์ผ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

2๏ธโƒฃ ๋น ๋ฅธ ์‘๋‹ต์„ฑ

  • ์—ฌ๋Ÿฌ ์ž‘์—…์„ ๋™์‹œ์— ์ˆ˜ํ–‰ํ•˜๊ฑฐ๋‚˜, ํŠน์ • ์ž‘์—…์„ ๊ธฐ๋‹ค๋ฆฌ๋Š” ๋™์•ˆ์—๋„ ํ”„๋กœ๊ทธ๋žจ์ด ์‘๋‹ตํ•  ์ˆ˜ ์žˆ๋„๋ก ํ•˜์—ฌ, ์‚ฌ์šฉ์ž์˜ ๊ฒฝํ—˜์„ ๊ฐœ์„  ํ•ฉ๋‹ˆ๋‹ค.

3๏ธโƒฃ ๋ณ‘๋ ฌ ์ฒ˜๋ฆฌ

  • ์—ฌ๋Ÿฌ ์ฝ”์–ด๋ฅผ ์‚ฌ์šฉํ•˜๋Š” ๋ฉ€ํ‹ฐ์ฝ”์–ด ํ”„๋กœ์„ธ์„œ ํ™˜๊ฒฝ์—์„œ ๋ณ‘๋ ฌ ์ฒ˜๋ฆฌ๋ฅผ ํ†ตํ•ด ์ž‘์—… ์†๋„๋ฅผ ํฌ๊ฒŒ ํ–ฅ์ƒ์‹œํ‚ฌ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

6๏ธโƒฃ ๋™์‹œ์„ฑ ํ”„๋กœ๊ทธ๋ž˜๋ฐ(Concurrency Programming)์˜ ๋‹จ์ .

1๏ธโƒฃ ๋ณต์žก์„ฑ ์ฆ๊ฐ€.

  • ์—ฌ๋Ÿฌ ์Šค๋ ˆ๋“œ๊ฐ€ ๋™์‹œ์— ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•  ๋•Œ ๋™๊ธฐํ™” ๋ฌธ์ œ๊ฐ€ ๋ฐœ์ƒํ•  ์ˆ˜ ์žˆ์–ด, ํ”„๋กœ๊ทธ๋žจ์˜ ๋ณต์žก์„ฑ์ด ์ฆ๊ฐ€ํ•ฉ๋‹ˆ๋‹ค.
    • ๊ฐœ๋ฐœ์ž๋Š” ๋ฐ๋“œ๋ฝ(DeadLock), ๋ ˆ์ด์Šค ์ปจ๋””์…˜(Race Condition) ๋“ฑ ์—ฌ๋Ÿฌ ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.

2๏ธโƒฃ ๋””๋ฒ„๊น…์˜ ์–ด๋ ค์›€.

  • ๋™์‹œ์„ฑ ์ฝ”๋“œ์˜ ๋””๋ฒ„๊น…์€ ๋‹ค๋ฅธ ์‹œ๊ฒ€์— ๋”ฐ๋ผ ๋‹ค๋ฅธ ๊ฒฐ๊ณผ๊ฐ€ ๋ฐœ์ƒํ•  ์ˆ˜ ์žˆ๊ธฐ ๋•Œ๋ฌธ์— ์˜ˆ์ธกํ•˜๊ธฐ ์–ด๋ ค์šด ๋ฒ„๊ทธ๊ฐ€ ๋‚˜ํƒ€๋‚  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

3๏ธโƒฃ ์„ฑ๋Šฅ ์˜ค๋ฒ„ํ—ค๋“œ.

  • ์Šค๋ ˆ๋“œ๋ฅผ ์ƒ์„ฑํ•˜๊ณ  ๊ด€๋ฆฌํ•˜๋Š” ๋ฐ์—๋„ ๋น„์šฉ์ด ๋ฐœ์ƒํ•˜๋ฉฐ, ๋™๊ธฐํ™”๋ฅผ ์œ„ํ•ด ๋ฝ์„ ์‚ฌ์šฉํ•˜๋ฉด ์„ฑ๋Šฅ์ด ์ €ํ•˜๋  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

6๏ธโƒฃ ์š”์•ฝ.

  • ๋™์‹œ์„ฑ ํ”„๋กœ๊ทธ๋ž˜๋ฐ(Concurrency Programming)์€ ์—ฌ๋Ÿฌ ์ž‘์—…์„ ๋™์‹œ์— ์ˆ˜ํ–‰ํ•  ์ˆ˜ ์žˆ๋„๋ก ์„ค๊ณ„๋œ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ๋ฐฉ์‹์œผ๋กœ, ๋ฉ€ํ‹ฐ์Šค๋ ˆ๋”ฉ(Multilthreading), ๋น„๋™๊ธฐ ํ”„๋กœ๊ทธ๋ž˜๋ฐ(Asyncronous Programming), ๋ฉ€ํ‹ฐํ”„๋กœ์„ธ์‹ฑ(Multiprocessing)์„ ํฌํ•จํ•˜์—ฌ ์‹œ์Šคํ…œ ์ž์›์„ ํšจ์œจ์ ์œผ๋กœ ์‚ฌ์šฉํ•˜๊ณ  ํ”„๋กœ๊ทธ๋žจ์˜ ์‘๋‹ต์„ฑ์„ ๋†’์ด๋Š” ๊ฒƒ์„ ๋ชฉํ‘œ๋กœ ํ•ฉ๋‹ˆ๋‹ค.
  • ๋™์‹œ์„ฑ ํ”„๋กœ๊ทธ๋ž˜๋ฐ(Concurrency Programming)์€ CPU๊ฐ€ ์ž‘์—…์„ ๋Œ€๊ธฐํ•˜๋Š” ๋™์•ˆ ์œ ํœด ์ƒํƒœ๋กœ ์žˆ์ง€ ์•Š๊ณ , ๋‹ค๋ฅธ ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•˜์—ฌ ์„ฑ๋Šฅ์„ ์ตœ์ ํ™”ํ•ฉ๋‹ˆ๋‹ค.
    • ๊ทธ๋Ÿฌ๋‚˜ ์ฝ”๋“œ์˜ ๋ณต์žก์„ฑ, ๋””๋ฒ„๊น…์˜ ์–ด๋ ค์›€, ์„ฑ๋Šฅ ์˜ค๋ฒ„ํ—ค๋“œ ๋“ฑ๊ณ  ํ•จ๊ป˜ ๊ณ ๋ คํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.