O’REILLY Concurrent Programming 리뷰

한빛 미디어 서평단 활동의 일환으로 책을 제공 받고 작성된 리뷰입니다.

SW의 복잡도 늪에서 당신을 꺼내줄 지침서

날이 갈수록 SW는 점점 더 복잡해지고 있다. 여러가지 복잡한 연산과 동작을 동시에 처리해야 하고 그와 동시에 다루는 데이터의 용량은 훨씬 커지고 있다. 이를 해결하기 위해 사용하는 것이 동시성의 개념이다. 아이러니 하게도 정작 개발 언어와 프레임워크는 이런 복잡한 처리 과정을 굳이 알 필요 없도록 프로그래밍 자체는 점점 더 쉬운 방향으로 발전하고 있다. 결과적으로 동시성 프로그래밍을 누구나 손쉽게 필수적으로 사용하게 되었지만, 동시에 개발자는 이런 한꺼풀 아래 숨겨진 동시성 개념과 원리를 더 이상 고민 하려 하지 않는다. 하지만 눈에 보이지 않는다 하더라도 동시성 프로그래밍은 여전히 치명적이게 중요하다.

평소에는 동시성 프로그래밍에 대한 이해 없이 사용하더라도 당장은 큰 문제가 되지 않을 것이다. 하지만 어느 순간 마구잡이로 개발하다간 개발 실력과 어플리케이션 모두 데드락(교착상태)에 빠져버릴 지도 모른다. 그리고 이런 문제를 해결하기 위한 누더기 코드는 심각한 성능저하로 이어질 수 있다. 당신이 동시성 프로그래밍을 공부해야 하는 이유가 여기에 있다. 수준높은 개발자가 되고 싶다면, 또는 최적화 된 코딩을 하고 싶다면 이 책이 당신에게 복잡한 SW 세상에서 살아남기 위한 지침서가 되어 줄 것이다.

이 책은

이 책은 기본적으로 동시성 프로그래밍의 기본적인 개념과 패턴을 설명한다. 컴퓨터공학 전공자라면 운영체제에서 배웠던 멀티 태스킹 챕터를 조금 더 상세히 다룬다고 이해할 수 있을 것이다. 이런 개념 설명을 위해 C와 Rust의 예제를 사용하고 있으며 멀티 스레드 관리, 액터 모델 등 참고하기 좋은 다양한 예제를 포함하고 있다. 이런 멀티 태스킹 자체가 직관적이지 못해서 설명이 어렵다 보니 다양한 그래프와 이미지로 설명을 돕고 있으며 적절한 예제들로 구성되어 있다. 또한 병렬 처리, 비동기 프로그래밍, 멀티 테스크 등 동시성 프로그래밍 전반에 대해 다루고 있다. 그래서 꼭 C나 Rust 개발자가 아니더라도 고수준의 언어(이른바 Managed language)에 익숙한 분들도 코루틴과 같은 비동기 프로그래밍에 대한 이해도 챙기실 수 있을 것이다.

C와 Rust의 경우는 기본 문법을 설명하고는 있긴 하지만 이는 예제를 이해시키기 위한 빌드업 수준이다. 하지만 메모리 수준에서의 동작까지도 설명하고 있으므로 메모리 관리를 알아서 해주는 고수준의 언어에 익숙한 분들이라면 생소할 수는 있겠으나, 언어레벨 밑에서 어떤 동작들이 이루어 지는지를 이해할 수 있게 된다. 예를 들면 Java에서 원시 타입(primitive type)이 왜 따로 분류되고 Call-by-value 와 Call-by-reference의 차이가 생기는 지 자연스럽게 이해할 수 있게 될 것이다.

동시성의 어려움

“Java에서 Exception과 Error의 차이가 무엇인가요?”

현재 재직 중인 회사의 면접에서 받았던 질문이다.

Java에서 Exception은 보통 소스코드의 로직을 잘못 짜거나 충분히 예상 가능한 문제가 발생하는 예외이다. 가령 예를 들면 엉뚱한 값을 요구하거나 호출해서는 안되는 코드를 호출하거나 하는 경우에 발생한다. 즉 같은 조건에서 같은 구문을 실행한다면 동일하게 발생하는 경우가 많고 try-catch로 예외처리를 한다면 프로그램은 원치 않는 동작을 할 지언정 죽지는 않는다. Exception은 코딩을 하다보면 자주 만나게 되고 또 대부분은 원인만 찾으면 어렵지 않게 해결할 수 있다.

그에 비해 Error는 시스템상의 치명적인 오류를 의미한다. 메모리 부족, 데드락(교착상태), 빌드가 잘못되어 클래스의 정의가 애초에 누락되어 있는 등 소스코드 밖의 문제거나 근본적으로 무언가가 심각하게 잘못되어 있을 때 발생하는 경우가 많다. 그래서 Exception과 달리 try-catch로 예외처리를 해도 프로그램이 죽거나 애초에 해결이 어려운 경우가 왕왕 있다.

동시성 프로그래밍은 이 Error를 발생시키는 주범이다. 이 점이 동시성 프로그래밍을 유독 어렵게 만든다. 복잡한 만큼 특유의 버그와 문제점을 내포하고 있다. 또한 테스트가 어렵고 직관적으로 이해하기가 어렵기 때문에 많은 개발자들에게 어렵게 다가올 수 밖에 없다. 대표적으로는 데드락, 재귀락, 메모리 버그 등 심각한 문제를 초래할 수 있다. 게다가 직관적이지 않은 탓에 동시에 코드 한두줄 대충 바꿔서 해결하려다가 오히려 더 심각한 문제를 발생시키기도 한다. 결국 본질적인 동시성 프로그래밍에 대한 이해가 없으면 늪에 빠져버리고 만다.

이런 분들께 추천드립니다.

C기반 언어를 다루시거나 Rust를 하시는 분들에게는 강력 추천드린다. 이런 분들에게는 이미 최적화된 코딩이 전제되어 있으므로 이런 동시성 프로그래밍 개념들이 필연적으로 다가올 것이다. 특히 다양한 예제와 친절한 그림으로 직관적이지 않은 어려운 내용도 비교적 명확하고 차분하게 설명하고 있으며, 멀티 스레드 관리, 액터 모델 등 한번 익혀두면 두고두고 사용할법한 예제들이 다양하게 포함되어 있기 때문에 분명 도움이 될 것이다.

신입개발자에게는 조금 어려울 수 있는 내용이지만, 학부생 때 전공 수업에서 한번씩 배우는 내용임을 감안하면 못읽을 정도는 아니므로 용기만 있다면 읽어보기를 추천드린다. 여기서 배우는 동시성, 비동기 기법들이 이해가 어렵더라도 언젠간 반드시 필요한 순간이 오기 때문에 나중에라도 이 책을 다시 펼쳐보게 될 날이 반드시 올 것이다.

물론 모든 개발자가 동시성 프로그래밍을 익혀야 할 것은 아닐지도 모른다. 메모리 관리와 동시성 까지도 알아서 처리해주는 것에 익숙해져서 그 필요성을 못느끼는 것도 무리는 아닐 것이다. 그러나 더 좋은 SW를 개발하고 싶고, 더 최적화 된 코드를 짜고 싶은 욕심이 있으신 분들이라면 이 책을 통해 우리가 그 동안 우리가 잊고 있었던 동시성 프로그래밍의 중요성과 최적화의 실마리를 찾아내는 계기가 되실 수 있으리라 생각한다. 여러분 모두 한단계 더 깊은 내공을 얻어 가시길 바라는 마음에서 이 책을 추천 드린다.

이 글은 한빛미디어 <나는 리뷰어다> 활동을 위해서 책을 제공받아 작성된 서평입니다.

개요

2000년대에 들어서면서 그 유명한 무어의 법칙이 깨지고 프로세서의 clock rate 향상에 한계가 생기면서 multi-core/many-core 프로세서가 트렌드로 접어든지 오래이다. 프로세서가 하나라고 가정하고 짠 프로그램은 더 많아진 프로세서를 제대로 활용하지 못하기 때문에, 이제는 많은 개발자들이 병렬 프로그래밍에 대해서 잘 알아야한다.

이 책은 동시성 프로그래밍의 개념을 전체적으로 잡고, 관련된 여러 가지 개념을 찍먹하는 데에 좋다. 다만 동시성 프로그래밍은 컴퓨터 구조에 대한 지식을 많이 요구하기 때문에 컴퓨터 구조와 같이 공부하면 더 좋을 것 같다. 책의 내용을 간략하게 정리해봤는데, 읽어보고 흥미가 생긴다면 일독을 권한다.

동시성 vs 병렬성

동시성(Concurrency)이란 2개 이상의 프로세스가 계산 중인 상태에 놓이는 것을 말한다. "동시에 두 프로세스가 계산을 한다"와 "동시에 두 프로세스가 계산을 하는 상태에 놓이는 것"은 의미가 다름에 유의하자. 리눅스로 치면 2개 이상의 프로세스가 TASK_RUNNING 상태에 놓인다면 동시성을 띈다고 할 수 있다.

반면 프로세스 관점에서의 병렬성은 "동시에 두 개 이상의 프로세스가 계산을 할 수 있음"을 말하며,  이는 적어도 2개 이상의 논리적 프로세서가 있을 때 의미가 있다. 왜냐면 병렬성은 기본적으로 (병렬성으로 인한 오버헤드와 추가적인 문제를 감안해서라도) 문제를 더 빨리 계산하기 위한  것이기 때문이다.

하드웨어 병렬성

그런데 프로세스 관점에서의 병렬성 말고, 하드웨어 관점에서 살펴보면 크게 instruction level parallelism, data parallelism, task parallelism으로 나눌 수 있다.

data parallelism

data parallelism은 일반적으로 하나 이상의 프로세서에서 같은 작업을 수행하되 데이터를 병렬로 처리하는 것을 의미한다. 현대적인 프로세서에서는 SIMD 명령어를 통해서 더 좋은 data parallelism을 실현할 수 있게 해준다. (물론 요즘은 GPU/TPU/NPU가 엄청 좋아졌지만...) data parallelism은 데이터를 분산하는 데에 초점을 둔다.

task (thread) parallelism

반면 task parallelism은 서로 같거나 다른 태스크가 동시에 연산을 수행함을 말한다. 예를 들어 어떤 작업을 여러 단계로 나누어서 pipelining (주의: 프로세서 에서의 파이프라이닝을 말하는 것이 아님!) 하고 동시에 실행하는 것을 예로 들 수 있다. task parallelism은 작업을 여러 프로세서, 컴퓨터에 분산하여 처리하는 데에 중점을 둔다.

instruction level parallelism

instruction level parallelism은 하나의 프로세서가 동시에 여러 개의 instruction을 처리할 수 있음을 의미한다.  그렇게 하기 위해서 현대적인 프로세서들은 instruction pipelining을 여러 개의 pipeline을 갖기도 한다. ILP는 명령어 간의 종속성이 적을 수록 효과가 좋아진다.

Amdahl's Law

병렬화를 하면 작업이 얼마나 더 빨리 끝날까? 이상적인 병렬 어플리케이션은 (프로세서가 한 개일 때 걸린 시간)/(프로세서 수)대로 시간이 단축되겠지만, 현실에서는 그렇지 않다. 모든 작업이 병렬화를 할 수 있지 않을 뿐더러, 병렬화로 인한 오버헤드도 존재하기 때문이다. 

Gene Amdahl에 따르면 작업의 일부를 병렬화했을 때 전체 성능이 어떻게 영향을 미치는지는 다음의 식에 따른다.

위 식에서 S_latency는 이론적인 성능 향상률, p는 전체 작업에서 병렬화가 가능한 비율이며, s는 병렬화 수를 나타낸다. 만약 여기서 p = 1.0이라면 아주 이상적으로 s가 증가할 수록 latency가 계속 줄어든다. (물론 위 식은 병렬화의 오버헤드를 고려하지 않으며 현실에서는 오버헤드도 고려해야 한다.)

현실은 이상과 괴리가 있기 때문에 대부분 p < 1이며 병렬화를 조금밖에 할 수 없다면 성능 향상도 크지 않다. 여기서 Amdahl이 말하고 싶었던 것은, "전체 작업 중 일부에 대한 성능을 개선했을 때는 일부에 대한 비율만큼만 개선이 이루어진다"인듯 하다.

다양한 종류의 락들

병렬화 할 때는 여러 태스크 간에 자원을 적절히 공유해야 하기 때문에, 락을 사용해서 동기화를 하게 된다. 락을 구현하기 위해서 아키텍처는 Compare and Swap, Load-Link/Store-Conditional 등의 원자적 연산을 지원하며, 운영체제는 이를 기반으로 태스크들이 상호 배타적으로 자원에 접근할 수 있도록 한다.

락은 종류가 다양하며, 상황에 따라서 적절하게 사용한다. 예를 들어서 일반적인 상황에서는 뮤텍스를 많이 사용하지만, 읽기가 많이 발생할 때는 Readers-Writer락이나 RCU를 사용하기도 한다. 또한 같은 뮤텍스라도 경우에 따라서 Test-And-Set, Ticket, MCS 등 다양한 구현체가 존재한다.

동시성 프로그래밍 특유 버그와 문제점

락을 사용하기 때문에 발생하는 문제들이 몇가지 있다. 락과 락 사이의 의존성으로 인해 컴퓨터가 영원히 멈추게되는 데드락이나, 데드락은 아니지만 락을 획득하고 해제하는 것만 반복할 수 있는 라이브락 등이 그렇다. 락을 사용하기 위해서 이러한 문제들을 적절하게 이해하고 피할 필요가 있다.

Transactional Memory & Lock-free algorithm

락을 획득한 동안에는 다른 프로세스가 같은 임계 영역에 절대로 접근할 수 없다. 이와는 다르게 다른 프로세스가 트랜잭션을 시도할 수 있도록 하되, 하나의 트랜잭션만 성공하고 나머지는 다시 시도하는 transactional memory라는 동시성 제어 방식도 있다. TM은 hardware 기반과 software 기반 두 가지 방식이 존재한다.

원자적 연산과 transactional memory를 이용하면 하나의 프로세스가 터져도(?) 다른 프로세스에 영향을 미치지 않는 Non-blocking algorithm 혹은 lock-free algorithm을 구현할 수 있다. 단, 이때 "중간에 데이터에 변화가 생겼는지" 여부를 대해 잘못 판단을 내리게 되는 ABA problem을 각별히 주의해야 한다.

Asynchoronous Programming

이 책은 Rust에서 정해진 순서대로(synchoronous)가 아닌 이벤트 발생에 따라 비동기(asynchoronous)적으로 작업을 처리할지에 대해서도 설명한다. 비동기적으로 처리한다고 해서 꼭 병렬적이라고 할 수는 없지만, 개발자가 병렬 프로그래밍을 더 쉽게 하도록 도와주지 않나 싶다 (지적 환영).

Further Reading

    현업에서 C언어를 사용하게 될 줄은 몰랐는데, 어쩌다보니 꽤 오랜 기간 사용하고 있다. 회사에서는 필요한 기능만 개발하다보니 몇 달 아니 몇 년을 개발을 하고 있어도 별로 실력이 늘지 않는 것 같은 느낌이 들 때가 많다. 그럴때마다 봐야하는 책이나 자료들은 결국 아주 기본이 되는 내용들과 훌륭한 분들이 먼저 가서 만들어 놓은 기술 자료나 책들이라고 생각한다. 실제로 스레드나 멀티프로세싱을 구현하면서 아주 사소한 것들로 인해 안해도 될 삽질을 하게 되는 경우가 종종 있는데 이 또한 기본을 완벽하게 닦지 않아서 일거다. 이번 책 "동시성 프로그래밍" 은 특히 이런 점을 잘 보완해줄 수 있는 책이고 더불어 C와 함께 떠오르는 언어 중 하나인 Rust 와 정말 정말 너무 어려운 어셈블리어까지 함께 공부할 수 있는 좋은 책이었다. 

    실제 동시성 프로그래밍이라는 것이 사용되는 곳은 무수히 많지만 내부적으로 얼마나 더 완벽하게 구현하는가는 로우 레벨의 언어가 대부분 담당하고 있기 때문에 하이 레벨 언어를 주로 사용하는 경우에는 아주 깊은 내용까지 다룰 필요조차 없는 경우가 많다. 나는 본의 아니게 임베디드와 아주 가까운 일을 하고 있어서 이런 부분을 은근히 접할 수 있어 많은 도움을 받을 수 있는 책이었다. 

    여러가지 프로그램이 동시에 돌아가기 때문에 동시성 프로그래밍, 병렬 처리가 필요하다고도 볼 수 있지만 그 이전에 우리는 하드웨어의 발전도 생각해야한다. CPU, GPU 와 같이 멀티코어의 수가 점점 더 늘어나면서 우리는 기존의 알고리즘이 가지고 있는 싱글 코어 기반의 로직을 일부 수정해야될 필요가 생겼다. 주어진 자원을 더 효율적으로 사용하기 위해 필연적인 것으로 앞으로 이 코어의 수가 더 늘어난다면 병렬 처리의 중요성은 더욱 커질 것이다. 동시성 프로그래밍에 대해 깊게 알아둘 필요성이 있는 것이다.

    다른 무엇보다 정말 궁금했지만 아직 도전하지 않았던 Rust 를 이 책을 통해 아주 가볍게 배울 수 있는 기회가 생겼다. 다음 리눅스에서도 채택되었다고 하는 멋진 언어인데 언젠가 C의 자리를 넘볼 정도로 올라가지 않을까 하는 작은 기대도 있다. 그 때를 대비해서라도 조금은 알아둘 필요가 있을 것이다.

    Deadlock, Starvation ... 학부생 때 운영체제나 병렬프로그램 관련 수업을 배웠던 기억이 다시 살아나는 단원은 바로 챕터 4 동시성 프로그래밍 특유의 버그와 문제점이다. 학교에서 처음 배울때는 직접 몸으로 부딫혀본 경우가 거의 없었기 때문에 시험을 풀기위해 공부한 부분이 많이 있었다면, 실무에서 문제를 조금 겪고 보니 아주 그냥 엄청난 문제점들이었다. 이 책을 통해 기본을 다시 한 번 공부하면서 다양한 새로운 기법들도 같이 공부해볼 수 있게 되었다.

    간단한 서버를 구현하면서 앞에 공부했던 내용들을 실습해볼 수도 있다. 코드가 잘 나와있기 때문에 그냥 자연스럽게 읽거나 써보면서 따라가면 많은 부분이 이해가 된다. 특히 이 부분에 문제점을 몸소 체험해봤다면 더 많은 자극을 느낄 수 있는 단원이었다.

    오랜만에 시간을 많이 내서 깊게 공부해보고 싶은 책이 나와서 정말 좋다. 실제로 내가 일하는 부분에도 많은 부분을 적용할 수 있을 것 같아서 여러번 반복해서 공부할 예정이다. C언어를 아는 사람에게는 더더욱 좋은 책이고 새로운 언어를 동시성 프로그래밍을 통해 배워보고 싶은 분들에게도 (어렵지만) 추천할만한 좋은 책인 것 같다.

끝.

"한빛미디어 <나는 리뷰어다> 활동을 위해서 책을 제공받아 작성된 서평입니다."

이번에는 꽤 재밌어보이는 책이 있어서 신청했다.

동시성 프로그래밍에 대한 책이다. 제목부터 근본이 넘처서 바로 신청하게 되었다.

1장에서는 동시성과 병렬성의 개념과 이 책에서 사용하는 용어들의 정의, 그리고 기술들을 소개해주고 2장에서는 C와 러스트, x86 어셈블리어를 간단하게 알려준다.

3장부터는 C와 러스트를 가지고 예제와 함께 여러가지 방법과 코드를 설명해준다.

OS수업을 들으면 다들 쓰레드를 배우면서 뮤텍스와 세마포어 같은 것들을 배웠을 텐데, 그것들의 전부 예제와 함께 직접 구현한 코드를 보면서 원리를 파악할 수 있게 되어 있다.

책의 후반으로 갈수록 OS수업에서는 보지 못했던 각종 기법들과 이론들을 볼 수 있다.

아마 다른 학교 수업에서 고학년 과목으로 배울 수 있는 그런 것들을 배울 수 있는 것 같다. 락프리나 소프트웨어 트랜잭셔널 메모리 등도 배울 수 있다.

근데 대부분의 코드가 러스트로 짜여져 있어서 러스트에 대해서 기본적으로 알고 있어야 제대로 이 책을 볼 수 있을 것 같다.

​

"한빛미디어 <나는 리뷰어다> 활동을 위해서 책을 제공받아 작성된 서평입니다."

보통 책을 읽을 때, 책의 제목부터 출판사의 홍보, 소개 문구 등을 통해 어느 정도 기대치 혹은 내용을 예상하며 읽게 됩니다. 그 기대에 못 미치거나 예상했던 내용보다 부족할 경우 아쉬움이 남는 독서가 되며, 기대에 걸맞고 예상대로의 내용인 경우 만족스러운 독서가 되겠지요. 드물지만 기대 이상의 내용을 담은 책을 읽게 되면 단순한 독서 그 이상의 정말 특별한 경험이 될 것입니다.

이 책 "동시성 프로그래밍"은 그야말로 기대 이상의 내용을 담은 놀라운 책입니다. 책 소개를 보고 단순히 로우 레벨(Low level)까지 다룬 비동기 프로그래밍 책 정도로 생각했는데 기분 좋게 기대를 무너트려 주었습니다. 제목 그대로 동시성 프로그래밍에 대해 A부터 Z까지, 그야말로 생각도 못했던 부분까지 빠짐없이 담고 있으며, 어려운 개념을 쉽게 설명하기 위한 적절한 비유를 통한 작가의 상세한 설명에 책을 읽는 내내 감탄을 금치 못했습니다. 굳이 왜 Rust를 다뤘을까 싶었던 선입견은 현대(Modern) 프로그래밍 패러다임에서의 동시성 프로그래밍을 같은 동시성 모델에 대해 언어별 비교를 위해 다루는 부분을 읽으며 없던 Rust 언어에 대한 관심이 생길 정도가 되었습니다. 원서가 일어다 보니 영어 번역서 보다 읽기 편한 문체로 잘 번역되어 복잡한 내용을 다루고 있음에도 한결 읽기 편해서 좋았습니다.

비동기 프로그래밍에 대해 깊이 있는 이해를 원하시는 분이라면, 이 책이 더할 나위 없는 만족감을 줄 거라 생각합니다. 강력 추천 드립니다.

한빛미디어 <나는 리뷰어다> 활동을 위해서 책을 제공받아 작성된 서평입니다.

https://www.hanbit.co.kr/store/books/look.php?p_code=B9078925849 

동시성, 병렬처리는 중요하면서도 어렵다. 두 가지를 구현할 때는 단일로 구현할 때보다 더 많은 부분을 고려해야하기 때문이다. 대표적으로 데드락, 재귀락 등의 문제가 있을 수 있다.

동시성 프로그래밍 책은 Rust와 C 그리고 어셈블리어로 구성되어 있다. 각각 예제마다 C인 경우도 있고, Rust인 경우도 있는데 코드를 보는데 큰 어려움이 없도록 잘 분리해서 표시되어 있다.

1장에서는 동시성 의 개념에 대해서 주로 다루고, 실제 동시성에 대한 내용은 3장부터 시작된다. 2장은 C, 어셈블리어, Rust에 대한 이야기가 나오니 이미 개념이 있는 사람의 경우에는 건너 뛸 수 있는 부분이었다.

책은 전반적으로 어렵다. 어려울 수 밖에 없다. 아까 말한 것처럼 동시성과 병렬성을 고려한다면 생각해야 하기 때문이다. 

책을 읽어가면 읽을 수록 동시성에 있어서 고려해야 할 부분들이 명확해진다는 점이 좋았다. 생각하지 못한 부분이 있다면 다시 한번 고민하게 되는 책이었고, 알고 있다면 알고 있는 내용을 정리할 수 있는 책이었다.

아쉽게도 JAVA나 코틀린, 파이썬을 주언어로 쓰는 사람이라면 책의 내용을 실제로 쓸 기회가 별로 없을 것이다. 그리고 어느 정도의 기초지식, 기반 지식이 있어야 책을 읽기가 수월하다는 점이 책을 접하기 어려운 점 중 하나였다.

훗날 동시성을 고려하면서 프로그램을 짜야하는 기회가 온다면 다시 한번 책을 펴볼 것 같다.

한빛미디어 <나는 리뷰어다> 활동을 위해서 책을 제공받아 작성된 서평입니다.

	

		동시성과 병렬성은 다르다
	
	

		이 책은 처음부터 동시성과 병렬성에 대해 설명하고 있다. 사실 동시성/병렬성 두 용어를 혼재하여 사용했다.
	
	

		하지만 책에서는 학부 시절 '운영체제' 과목에서 배웠을 프로세스 라이프사이클에 빗대어 설명하고 있다.
	
	

		즉, 프로세스는 실행상태 ↔︎ 대기상태 전이하는 경우가 있는데 [ 실행~대기~실행 ] 상태에 있는 것을 '계산 중 상태'라 하며 2개 이상의 프로세스가 동시에 '계산 중 상태'에 있는 것을 "동시성" 이라고 한다.
	
	

		반면에 순수하게 2개 이상 프로세스가 '실행상태'에 놓여 있는 것을 "병렬성" 이라고 설명하고 있다.
	
	

		 
	
	

		이 정도로 친절하게 설명해볼께
	
	

		도서는 어셈블리어, C, Rust 언어로 기본 적인 내용을 알려주고 주로 Rust 언어를 통해 설명하고 있다.
	
	

		어셈블리어로는 학부 시절 '시스템 프로그래밍' 에서 배웠던 add, ldr, mov 등 (오랫만에 들어보는) 기본적인 어셈블리어에 대해 설명하고, C언어에는 Pthreads, Rust언어에서는 전체적인 기능을 간단히 설명하고 있다.
	
	

		 
	
	

		도서 전반에 걸쳐 설명을 진행하면서 위의 3가지 언어를 적절히 사용하여 설명하고 있다.
	
	

		 
	
	

		사실 이번 도서는 끝까지 완독하지 못했다.
	
	

		도서는 친절하고 부드럽게 설명을 하고 있는데, 개인적으로는 학부시절 전공 서적을 읽는 듯한 거부감(?)이 들었다.
	
	

		이 또한 나의 내공이 부족함이렸다 ㅠㅠ
	
	
 
	

		동기 처리에 대해 관심을 가지고 있다면 (어쨌든 나보다 내공이 뛰어날테니) 본 도서를 읽어봄도 나쁘지 않을 것 같다!
	
	

		 
	
	

		한빛미디어 <나는 리뷰어다> 활동을 위해서 책을 제공받아 작성된 서평입니다.
	

이 책은 동시성 프로그래밍에 관한 이야기를 담고 있습니다.

동시성 프로그래밍은 사실 매우 중요한 기술 중 하나입니다. 

최근 하드웨어의 발전으로 애플리케이션의 로직이 최적화가 안되어도 일정 수준의 퍼포먼스를 보여주곤 합니다.

하지만 개념을 모르고 개발하는 것은 차이가 매우 큽니다.

이 책을 통해 개념을 익히고 그에 맞는 개발 방식을 고민해보는 것이 좋을 것 같습니다.

rust와 c언어로 구현되어 있기 때문에 생각보다 우리가 구현하고자 하는 애플리케이션에 바로 적용은 힘들 수 있습니다.

이 책을 통해 원리를 이해하는 것에 초점을 맞춰 읽어보시는 것이 좋을 것 같습니다.

한빛미디어 <나는 리뷰어다> 활동을 위해서 책을 제공받아 작성된 서평입니다. 

대상 독자는?

이 책은 소프트웨어를 구현하는 단계의 대학교 3~4학년 혹은 대학원생을 대상으로 한다. 따라서 프로그래밍 경험이 있는 사람을 대상으로 하고, 적어도 C나 Rust언어에 대한 입문정도의 수준을 대상으로 한다.

이책은 친절한가?

어려운 내용을 충분히 체계적으로 설명하고 있으며, 이해하기 쉬운 적절한 그림을 통해 이해를 돕고 있다.

무엇이 좋았는가?

책의 난이도가 있는만큼 독자를 배려

독자를 배려하여 "이 책의 내용 및 읽는 방법" 등을 기술하여 주었으며, 핵심을 잘 정리해 주었다.

무엇이 아쉬운가?

아쉽다라기보다는 대상독자의 기준에 미치지 못하여 해당 책을 읽는데 시간이 모자라 기간 내에 다 읽지는 못하였다.  향후 완독을 하면 업데이트를 할 예정이다.

"한빛미디어 <나는 리뷰어다> 활동을 위해서 책을 제공받아 작성된 서평입니다."

우리가 음원 스트리밍 어플로 음악을 들으면서 동시에 웹 서핑을 하고 메신저 앱으로 메시지를 하는 것.
이는 모두 동시성 프로그래밍 덕분이라고 해도 과언은 아니다.

싱글코어에서, 멀티태스킹을 위한 시분할을 구현하여 여러 일을 동시다발적으로 처리하는 동시성 프로그래밍은, 물리적으로는 단일 업무를 수행하지만 논리적으로는 여러 가지 업무를 동시에 수행할 수 있게 해준다.

물론 최근에는 하드웨어의 발전으로 멀티 코어가 가능해지면서 물리적으로도 여러 일을 동시에 처리하는 병렬 프로그래밍이 많이 사용되지만, 동시성 프로그래밍을 잘 이해할 필요는 여전히 존재한다.

동시성 프로그래밍의 구조를 이해하고, 동기 처리, 레이스 컨디션, 비동기 처리 증 다양한 특징들을 정확히 숙지한다면 훨씬 성능 좋고 안정적이며 유지보수성이 높은 소프트웨어를 만들 수 있다.

이 책은 어셈블리 언어와 알고리즘, 계산 모델에 이르는 광범위한 주제를 담고 있는만큼 동시성 프로그래밍을 공부하고자 하는 사람들에게는 항상 가지고 다니며 참고할만한 가이드가 되리라 생각한다.

사실 동시성 프로그래밍의 개념은 어셈블리, C와 같은 저수준 언어에서 다루는 경우가 많은만큼 고수준 언어인 파이썬의 입지가 커지고 있는 요즘에는 배우려 하는 사람들이 많지는 않을 것 같다.
하지만 그런만큼 동시성 프로그래밍을 완벽히 숙지한 개발자는 매년 쏟아져나오는 많고 많은 개발자 사이에서 더욱 돋보이게 되지 않을까 싶다.

솔직히, 개발자보다는 리서처의 길을 가겠다는 핑계로 효율적인 개발을 등한시하였었는데, 그런 나에게 이 책은 다시금 나를 일깨우는 신선한 자극이 되었던 것 같다.

C, C++보다는 파이썬의 화려함과 간편함에 길들여진 (마치 나같은) 사람들에게 특히 추천한다.

서론

개발을 하다보면 언젠가는 작성한 프로그램의 성능적 한계를 만나게 됩니다. 이는 알고리즘적 비효율성으로 인해 야기 되었을 수도, 언어적 한계로 인해 발생했을 수도 있습니다. 알고리즘적 한계를 개선하고 난 후에도 더 높은 성능이 요구된다면, 요구사항을 만족시키기 위해 우리는 동시성 프로그래밍을 고려할 수 있습니다. 혹자는 ‘그냥 multiprocessing 라이브러리 사용하면 되는거 아니야?’라고 생각할 수도 있지만, 이해 없이 사용하게 되면 원치 않는 동작이 야기됨으로써 시스템의 안정성을 보장할 수 없게 됩니다. 이러한 관점에서 바라볼 때, 이 책은 동시성 프로그래밍을 처음 입문하기에 적절한 책이라고 생각됩니다.

이 책의 내용

책의 첫 단원에서는 프로세스, 그리고 동시성과 병렬성에 대해서 설명합니다. 사실 병렬성과 동시성이 같은 개념이라고 생각하는 경우도 많을 것 같은데, 이 책에서는 그림과 함께 두 용어의 차이점에 대해 설명하고, 카테고리를 나누어 세부적으로 설명합니다. 이후 동시 및 병렬 처리의 필요성에 대해서 설명한 후, 어샘블리어와 근래에 부상하고 있는 RUST언어를 간단하게 설명합니다.

이후 뮤텍스, 세마포어 등의 개념과 동시성 처리 알고리즘을 C의 Pthread 라이브러리를 이용하여 구현된 코드와 함께 제공하는데, 코드의 가독성이 높아 주석이 따로 필요 없을 뿐 아니라, 개념 설명 이후 등장하는 그래프 형태의 그림들이 이해를 돕는데 큰 역할을 해 주었습니다. 또한 비동기 프로그래밍으로 인해 발생할 수 있는 버그들과 해결할 수 있는 방법들을 제시하면서 처음 구현할 때 닥칠 문제상황들을 대비할 수 있었습니다.

전반적으로 보면 개념을 소개하기 전에 예시를 통해 독자의 이해를 도와주는데, 읽다보면 정말 적절한 예시를 들었다라는 생각이 들었습니다.

추천합니다

• 동시성 프로그래밍을 통해 프로그램의 성능을 높이고자 하는 개발자
• 동시성 프로그래밍을 수학적으로 이해하고 싶은 분
• OS단에서 동시성을 다루고자 하는 분

추천하지 않습니다

• 코딩 입문자 및 CS 비전공자
• 수학적 표현에 어려움을 느끼시는 분

 "한빛미디어 <나는 리뷰어다> 활동을 위해서 책을 제공받아 작성된 서평입니다."

책을 보면서 흥미로웠던 점은 전공 기초의 다양한 용어들이 더 깊이있게, 코드와 연관되어 풀어진다는 점이었다.

​

운영체제를 공부하면서 배웠던 개념들이 많이 녹아있어 흥미롭게 읽을수 있었다.

​

기본적인 베이스는 Rust로 구현되어 있다. 멀티 쓰레드, 코루틴, 베타 제어 등 운영체제와 밀접한 코드들을 모두 구현해 볼수 있기 때문에 개인적으로 엄청 많이 배울수 있었다.

​

무엇보다 Rust 언어를 몰라도 운영체제 지식이 어느정도 있다면 문맥을 잘 따라갈 수 있도록 책이 친절하다.

​

깊이감이 상당했고 많이 배울수 있었기 때문에 다시 한 번 천천히 읽어보고 싶을 정도로 좋은 책이었다.

한 줄 요약 : 병렬처리에 대한 바닥부터 다룬 심화학습 책

난 개발을 하며 병렬처리를 해야 할 때면 항상 긴장된다.

내가 원하는 대로 동작을 하지 않을 수도 있다는 두려움 때문이다.

왜 병렬처리를 두려워하게 됐을까?

생각해보면 대학교 다닐때도 운영체제, 시스템 구조 시간에 잠깐 배운 것이 전부이기 때문인 것 같다.

예를 들면 '컴퓨터에서 작업 처리는 프로세스 단위로 메모리가 할당되고, 프로세스는 다시 프로세스의 논리적인 작업 단위인 한 개 ~ 여러 개의 스레드로 분할되어 처리된다.' 과 같은 두루뭉술한 내용말이다.

나의 두려움과 달리 병렬처리는 숨쉬듯이 사용되고 있다.
하지만 실제 개발을 하면서 병렬 처리를 할 때면 프로그래밍 언어에서 제공하는 메소드 코드를 쓰고, 실행하는 것에 그친다. 

이런 나에게 동시성 프로그래밍의 기본부터 다루는 《동시성 프로그래밍》 책은 좋은 참고서가 될 것 같다.

책 《동시성 프로그래밍》은 고급 언어(C, Rust와 같은 사용자 측면에 가까운 언어) 관점에서 사용법을 알려주는 책이라기보다는 동시성 프로그래밍의 기본 원리를 다루고 있다.

물론 설명하는 내용마다 프로그래밍 언어를 이용한 실습 예제도 담고 있다.

책 목차는 아래 사진과 같다.

운영체제, 컴퓨터 구조에 대한 내용을 다룬 책을 공부한 적이 있어서인지 목차의 내용은 익숙했다.

내용은 이론 설명, 실습 예제 순서로 일반적인 구성이다.

단, 이 책은 독자가 프로그래밍 경험이 있다는 전제로 설명을 이어나가기 때문에 프로그래밍 경험이 없는 독자라면 막막하게 느껴질 수 있다.

실습 코드는 주로 Rust 언어로 되어 있고, 일부는 C 언어로 되어 있다. 해당 언어에 경험이 없더라도 if와 같은 조건문, 함수(메소드) 호출, 변수 선언&할당 등 프로그래밍 경험이 있다면 흐름을 이해하는데에 무리는 없을 것 같다.

하드웨어에 가까운 수준에서 설명하다보니 어셈블리언어도 보이는게 놀라웠다.

아래 내용은 운영체제 전공책에 항상 등장하는 '식사하는 철학자' 문제에 대해 다룬 내용이다.

책의 장단점을 소개해야하는데 내가 어려워하던 병렬처리에 대해 전공책보다 더 깊이있게 다루고 있다보니 쉽지 않다.

그래서 병렬처리 경험이 있다면 한 번쯤은 보았을 내용을 다룬 부분을 사진으로 첨부했다.

책의 마지막장은 최종 심화 내용이다.

컴퓨터가 병렬(동시성) 작업을 어떻게 처리할지 그 기준이 되는 처리 모델에 대해 다루고 있다.

내가 업무에 사용하는 자바 언어 구현을 쫓아가면 마지막엔 네이티브(native) 코드를 만난다.

업무를 하면서도 '컴퓨터가 알아서 잘 처리해주겠지'라는 안일한 생각으로 넘겼지만 이 책의 내용을 하나 하나 읽다보니  네이티브 코드는 어떻게 구현되는지 궁금증이 다시 떠올랐다.  

깊이 있는 내용을 다루다보니 아직 다 읽지는 못했다.

조금씩 읽고 익히다보면 읽겠지?

병렬 처리에 대해 막연하게 이론과 그 구성 원리까지 깊이있게 다루는 책이기 때문에 두고두고 볼 생각이다.

만약 이 책을 읽다가 포기할 것 같다면 《7가지 동시성 모델》 부터 읽어보면 좋을것 같다.

내가 읽었던 기억이 맞다면 《동시성 프로그래밍》에 비해 약간 더 넓은 주제를다루고 있지만 난도는 낮기 때문이다.

물론 두 권을 같이 읽으며 부족한 부분을 보충하면 읽으면 좋을것 같다.

"한빛미디어 <나는 리뷰어다> 활동을 위해서 책을 제공받아 작성된 서평입니다."

리뷰를 위해 한빛미디어에서 책을 제공받았지만 주관적인 생각을 그대로 적었습니다.

출처: https://erinyees.tistory.com/120 [Erinyees의 블로그]

사실 프론트엔드 개발자로서 JS같은 고수준의 언어를 주로 다뤄왔기에, 프로세스나 스레드 수준의 여러 일들에 대해서는 제대로 이해하지 못한 채 개발을 하고있다는 생각이 자주 들었었는데요. 그 와중에 이 책을 읽게 되었습니다.

고수준의 영역에서는 아주 당연하게 비동기, 논블로킹 로직을 작성하면서 너무 당연해 간과하기 쉬웠던 부분이었는데 책을 읽으며 태스크의 동시성과 비동기성을 보장하기 위해 더 낮은 수준 단에서는 무슨 일이 일어나야 하는지 좀 더 이해해보는 계기가 되었던 것 같습니다. 컴퓨터 구조나 운영체제 시간에 배웠었던 CPU 자원의 문제나, 병렬적으로 스레드나 프로세스의 일을 처리할때 고려해야하는 여러 고민들을 흥미롭게 소개하고 있는 책입니다.

C, 어셈블리, Rust언어로 코드 예제가 제시되는데, 이를 위해 책의 앞선 부분에서 자세한 설명이 나오는 부분이 인상깊었습니다. 특히 Rust는 웹 생태계에 점점 들어오고 있는 언어이기도 한데요, 이번에 Rust에 대한 설명을 읽으면서 확실히 관심이 더 깊어진 것 같습니다. 소유권이나 차용 등 엄격한 GC와 메모리 관리를 위한 언어적 장치들이 확실히 인상 깊었던 것 같아요.

동시성 프로그래밍. Rust, C, 어셈블리어로 구현하며 배우는 동시성 프로그래밍 A부터 Z까지를 학습할 수 있는 책. 이 책을 읽기 위해서 필요한 사전 지식은 C, Rust를 습득한 대학교 3,4학년 또는 대학원생 이상이며 포인터를 이해하지 못했다면 이 책을 읽기 어려울 수 있다. 아 그리고 멀티 코어를 다루는 내용을 생각한다면 이 책은 해당 내용에 대해선 많은 설명이 없으니 다른 책을 찾아보길 바란다.

이 책은 스레드를 처음으로 사용해 보고 싶은 분들이나, 스레드를 사용하고 있으나 이렇게 사용하는 것이 맞는지 의심이 드는 분들 혹은 느낌적인 느낌으로 사용하고 있었던 부분들을 좀 더 자세하게 설명해 준다.

먼저 동시성과 병렬성을 설명하는 부분을 보면 비슷하지만 다른 것, 본인도 이 책을 읽기 전엔 동시성과 병렬성이 같은 의미인 줄 알았다. 책에는 자세히 적혀 있지만 동시성의 경우 하나의 프로세스로 동시에 여러 가지 일을 처리하는 것을 의미하고, 병렬성은 동시에 여러 개의 프로세스로 하나 또는 여러 가지 일을 처리하는 방식을 의미한다. 이론적인 설명 부분들을 지나가면 스레드의 기초부터 설명을 한다. C언어를 사용하여 스레드를 생성하는 방법. 그리고 해당 소스 코드가 어떻게 동작하는지 등 아래 그림처럼 소스코드를 자세히 설명을 해준다.

이 책을 읽다가 보면 스레드를 사용하면서 그동안 궁금했던 것들을 알 수가 있다. 예를 들면 Intel CPU의 명령어 중에 AVX 명령어에 관한 설명이다. 이 책에서 알려주려 하는 것은 스레드를 사용하면 프로그램이 더 빨라지는지 느려지는지 같은 스레드를 좀 더 잘 사용하고 활용할 수 있도록 도와주는 책이다. 이 책에서 설명하는 내용들은 뮤텍스, 스핀락, 세마포어, 데드락, 재귀락, 코루틴, async 등 프로그래밍을 하면서 한 번씩 들어보거나 사용해 본 것들을 다르고 있다.

IOCP는 한 번쯤은 들어 봤을 것이다. 하지만 이 책에서는 async를 설명해 주고 있다.

그리고 각 스레드의 락을 사용하는 방법과 효율들에 대해서도 설명이 되어 있다. 스레드를 사용하면서 의문이 남거나 스레드를 공부해 보고 싶은 사람에게 추천한다.

동시성 프로그래밍에 대한 책이 많지 않아 그와 관련된 지식을 많이 쌓을 수 없었지만, 이번에 만난 다카노 유키님의 펴낸 '동시성 프로그래밍'이란 책을 만나 조금 어려운 내용이었어도 동시성 프로그래밍에 대해 어느 정도 지식을 쌓을 수 있었다.

동시성 프로그래밍이란 의미를 구글링해서 찾아보면 여러개의 작업 또는 쓰레드를 효율적으로 사용하도록 만드는 프로그래밍을 뜻한다. 이는 하드웨어, OS, 라이브러리와 많은 관련이 있는데, 대부분 저수준 언어로 구현되므로 추상화된 고수준 언어에서는 신경쓰지 않는 부분이 있기는 하다.

하지만 저자는 '동시성 프로그래밍'이 무엇인가?에 대한 질문에는 쉽게 답할 수 없다고 한다. 그것은 추상적인 이미지를 떠올릴 수는 있지만, 구체적으로 '이런 것이 동시성'이다라 표현하기는 쉽지 않다고 한다.

그래서 이 책은 동시성 프로그래밍의 구조를 이해하고 이를 통해 동시성 프로그래밍의 본질적인 어려움에 도전할 수 있도록 쓰였다고 한다. 이 책을 통해 동시성 개념을 이해하고, 동시성 프로그래밍이 갖는 독특한 특징(동기 처리, 레이스 컨디션, 락, 비동기 처리, IO 다중화, 멀티태스킹 등), 어셈블리 언어와 알고리즘, 계산 모델 등 광범위한 주제를 접할 수 있게 한다.

이 책에 사용된 예제는 주로 Rush라는 언어로 작성되었고, 간혹 C언어나 어셈블리 언어로 작성되었다. Rust는 동시성 프로그래밍 관점에서 심사숙고해 만들어진 프로그래밍 언어이며, 저자가 예제의 언어로 선택한 이유를 책을 읽으면서 이해하게 될 것이라고 한다. 아무래도 Rust는 처음 접하는 언어이다보니 주로 사용하는 C언어와는 이해하는데 시간이 많이 걸렸다. 그리고 로우 레벨의 소스코드와 그와 관련된 기술이다보니, 오래전 배운 내용들을 다시 꺼내는데도 오래 걸렸다. 업무에 사용하지 않는 기술들이긴 하지만, 너무 모르고 살았다는 자책감이 들기도 했다. 하지만 동시성 프로그래밍을 이해하면서 이 책을 읽으니 예전에 배웠던 지식이 조금씩 살아나는 것 같았다.

​책 속에서도 동시성 프로그래밍에 대한 기술적인 설명뿐만 아니라 그 기술을 구현한 소스 코드에 대해 설명하는 공간을 많이 할애한 것 같다. 긴 설명보다는 다이어그램이나 소스 코드에 대한 설명이 독자들에게 더 이해를 높여주기 때문일 것이다. 이 책의 대상독자도 초보자가 아닌 소프트웨어 구현 단계의 대학생, 대학원생, 사회인이다. 그러기 떄문에 어느정도 지식을 갖추고 이 책을 임해야 할 것이다.

책에서 사용된 코드는 역자의 깃허브를 통해 다운로드 받을 수 있다.

https://github.com/mosekim/concurrent_programming

​시스템의 안정 및 하드웨어의 성능 및 OS의 최적화를 위해서 동시성 프로그래밍을 꼭 공부해보는 것을 추천한다.

​한빛미디어 <나는 리뷰어다> 활동을 위해서 책을 제공받아 작성된 서평입니다.

​#동시성프로그래밍 #동시성 #병렬성 #비동기 #멀티태스크 #한빛미디어 #OREILLY

학부 시절 운영체제 수업에서 세마포어나 뮤텍스에 대해 배우며 동기적으로 로직을 처리하는 것의 방법을 익히고 스레드/프로세스 컨텍스트 스위칭을 통해 프로그램이 비동기적으로 효율적으로 작동했던 것을 배웠던 기억이 있다. 현재 모두가 매우 일상적으로 사용하고 있는 노래를 들으면서 문서 작업을 한다거나 화면을 나눠 서로 다른 인터넷 창을 띄우고 하는 등과 같은 작업은 동시성 프로그래밍이 없다면 불가능한 것들이다. 현업에서는 저수준 언어를 사용할 일이 거의 없고 대부분 이미 검증이 끝난 동시성 관련 라이브러리를 활용해 비즈니스 로직 구현 자체에 집중하기 때문에 동시성 프로그래밍이 내부적으로 어떻게 구현될 지 깊게 생각해볼 기회가 거의 없다. 따라서 이번 서평 목록에서 해당 책의 제목을 보고 학부 이후로 내 기억 뒷편에 있던 동시성 관련 개념인 락, 비동기 처리, I/O 다중화 등을 이번 기회에 저레벨로 탐색하고 복기하고자 선정하게 되었다.

이 책이 가장 흥미로웠던 점은 비교적 최신의 저수준 언어인 Rust의 특유의 장점이나 특징 등을 설명해주고 이를 활용해 비동기 프로그래밍, 멀티태스크 등의 구현 예제를 구성헀던 것이다. 최근 Rust에 관심을 가지고 있던 중이라 매우 반가웠다.

7장까지의 내용들은 기존 OS 수업을 들었던 개발자라면 어렵지 않게 따라갈 수 있게 구성되었다. 대부분의 예제들이 Rust로 구현되어서 Rust 학습 겸 재미있게 동시성 관련 개념들을 복습했다. 8장의 동시 계산 모델의 경우 어디서 많이 들어보던 용어들이지만 개인적으로 생소한 개념들이 많아서 여러번 반복해서 읽었지만 내 지식의 깊이를 한층 더 확장시켜주었다.

단순 언어 사용이나 작은 서비스 만들어보기 같은 팔로우업 형식의 책들도 좋지만 개인적으로는 깊은 개발을 위해 스스로 생각해볼 수 있는 기반을 만들어주는 이런 유형의 책들도 자주 나오면 좋을 것 같다.

​

​

"한빛미디어 <나는 리뷰어다> 활동을 위해서 책을 제공받아 작성된 서평입니다."

업무로 분석하는 프로그램들이 주로 실시간, 동시에 돌아가야 하는 기능들이 많다보니

내부적인 소스코드도 병렬로 동시에 동작하는 코드들이 많이 포함되어 있는데요.

하지만... 어떤 원리와 흐름으로 짜여진 코드인지를 잘 파악을 못하다 보니 코드리딩과 분석에 어려움이 많았습니다.

그러던 차에 읽게된 "동시성 프로그래밍" 책!

동시성 프로그래밍이란, 쉽게 이해하자면 스마트폰을 예시로 들어 스마트폰애서 음악을 들으면서 인터넷을 하고, 분할 화면에서 카카오톡을 보내고 사진도 찍고, 유투브도 보고... 이 모든 것을 동시에 실행시켜서 할 수 있다는 것입니다. 

처음부터 나오는 개념은 동시성과 병렬성이 차이가 있다는 것이었습니다. 저는 여태 같은 개념으로 알고 있어서 혼용해서 쓰고 있었는데요...

동시성은 2개 이상의 프로세스가 동시에 계산을 진행하는 상태를 나타내는 용어이고,

병렬성은 같은 시각에 여러 프로세스가 동시에 계산을 실행하는 상태를 의미한다고 합니다.

얼핏 보면 정의를 봐도 같은 개념인 것 같지만, 이 책에서는 그림으로 프로세스 A와 B의 상태를 놓고 구분을 합니다.

즉, A 프로세스 실행상태 + B 프로세스 실행상태 = 동시성 (O) 병렬성(O) 둘다 가짐

    A 프로세스 실행상태 + B 프로세스 대기상태  = 동시성 (O) 병렬성(X) 으로 보고,

"병렬성" 은 대기상태를 제외하고 두 개 이상의 프로세스들이 같이 "실행상태" 일 때만 병렬 실행으로 봅니다.

그렇게 놓고 보면 동시성은 병렬성을 포함하면서 조금 더 큰 개념이라고 할 수 있습니다.

이 책은 동시성 프로그래밍을 다루고 있으니 같은 시간에 여러 프로세스가 같이 실행되거나(병렬성), 대기 중에도 다른 일을 할 수 있는(동시성) 처리가 가능해지면서 보다 효율적인 리소스 활용과 여러 프로세스의 공평한 실행, 편리함을 누릴 수 있습니다. 반면에 실행 패턴이 복잡해지기 때문에 동시성 프로그래밍을 잘 이해하여 설계, 구현하는 것이 중요합니다. 

이 책에서는 동시성 프로그래밍의 원리를 어셈블리 언어, C 언어, Rust 언어를 구현하면서 설명합니다. 

어셈블리 언어를 통해 주로 동시성 프로그래밍의 개념이 구현되는 저수준 언어에서 동시성 프로그래밍의 동작원리를 보다 심층적으로 이해할 수 있어서 어셈블리 언어를 구현 예시로 들었고, C언어는 운영체제(OS)의 구현 언어이기도 하고 하나의 프로세스 내에서 여러 개의 스레드가 동작하는 멀티스레드용 라이브러리(Pthread) 등 다양한 라이브러리들이 C언어로 구현되어 있기 때문에 C언어도 동시성 프로그래밍의 원리를 이해하는 하나의 언어로써 이 책에서의 구현 언어 예시로 선정하였다고 합니다. 또, Rust는 동시성 프로그래밍에서 안정성을 제공하고 메모리를 고려하여 코드 작성도 가능하고 async, wait 등의 고급 개념도 적용하고 있기 때문에 예시를 들었다고 합니다. Rust는 저도 잘 모르는 언어인데, 동시성 프로그래밍 관점으로 더 고려해서 만들어진 언어라고 합니다.

이 책에서는 컴퓨터 학과 전공이라면 운영체제 시간에 배우는 동기 처리 알고리즘과 관련된 기본적인 설명 뿐만 아니라 동시성 프로그래밍의 버그 혹은 문제점/특징(데드락, 라이브락, 재귀락, 의사 각성, 시그널), 관련 회피 방법(은행원 알고리즘, 메모리 배리어) 등도 설명합니다. 

그리고 비동기 프로그래밍과 IO 다중화, async/await 사용 방법과 구조, 멀티태스크와 공평한 동기처리, 소프트웨어 트랜잭셔널 메모리(STM, Software transactional memory), lock-free data 구조 등 고도화된 동기 처리 기술도 다룹니다. 

이 책의 좋은 점은 샘플 코드와 샘플코드의 설명이 구체적인 점, 용어의 정의를 명확하게 제시하는 점, 어려운 원리를 도식화하여 설명하고 있는 점, 특정 방법의 구현 방법만 제시한 것이 아니라 문제점과 대안까지 잘 제시하고 있는 점입니다.

그래서 동시성 프로그래밍을 구현하는 다양한 기법들과 그 방법들이 빠질 수 있는 버그 혹은 문제점, 그리고 방안까지 잘 습득할 수 있는 전문서적이라고 할 수 있습니다. 

동시성 프로그래밍을 이렇게 기초부터 전문적으로, 말그대로 A-Z를 다루는 책은 처음 본 것 같은데요.

그래서 컴퓨터 전공자로서는 (물론, 지금은 프로그래밍/구현/개발과는 조금 관련성이 떨어진 (분석) 일을 하지만...) 어려운 주제이지만 관심이 많이 갑니다. 

이 책은 C언어를 어느 정도 알고(문법을 아는 정도), 메모리 구조를 간단하게 알고 있으면 읽기가 좀더 편해집니다.

컴퓨터 알못이 읽기에는 난이도가 꽤 높은 책이고, 워낙 동시성 프로그래밍 자체가 개념부터 용어, 구조들이 일단, 그냥... 어렵습니다. 그래서 저도... 이 책을 읽고 이해하기까지 진도가 빨리 나가지 않더라고요.

그럼에도 불구하고 동시성 프로그래밍을 전반적으로 이해하기에 제일 좋은 책이라는 점에서 프로그래머라면 한번쯤은 꼭 읽어보거나 옆에 둘 만한 좋은 IT 서적이라는 생각이 듭니다. 

"이 책은 한빛미디어 <나는 리뷰어다> 활동을 위해서 책을 제공받아 작성한 서평입니다 "

한빛미디어 <나는 리뷰어다> 활동을 위해서 책을 제공받아 작성된 서평입니다.

동시성 프로그래밍은 개념 혹은 기본 원리인지라
우리가 보고 배웠던 운영체제 교재에서 동시성과 병렬성을 함께 엮어 알려주고 있다.

운영체제 수업이 참 그렇다..
강의실에서 배울때는 그 중요성을 모른다.
그저 학점 채우기 위해서, 좋은 성적을 받기 위한 동기로
교재의 활자 그대로를 두뇌에 입력하고 잊어버리기 일쑤 이다.
하지만 막상 프로그래밍을 하다보면 이 운영체제가 본인의 내공을 결정하는데 많은 역할을 한다.

나는 이 운영체제 부분 중 동시성부분을 똑 떼내어 '동시성프로그래밍'이라는 한권의 책으로 나왔다고 생각한다.
운영체제라는게 학교를 졸업했다고 해서 끝이 아니다.
쿨타임이 돌면 한번씩 업데이트가 필요하다.

특히나 이렇게 한권의 책으로 운영체제 책에서는 가볍게 지나갔던 내용들을 시간을 들여 깊고 자세하게 설명해 있기에
주말에 시간을 들여 한번 읽어보기를 권하고 싶다.

그리고 아직 학교에 있는 분들이라면 꼭 한번 동시성 부분을 읽어보길 바란다.
구지 이책이 아니더라도 운영체제 책에서라도.

업무적으로 만든 프로그램에서 동시성 문제로 '때때로' 나오는 문제때문에 시달리고 싶지 않다면. 부디.

동시성은 정말 어렵다. 나는 여전히 어려움을 느끼고 있고, 그것을 해소하고자 4월 서평 도서로 이 책을 선택했다.

## 기록

동시성 → 2개 이상의 프로세스가 동시에 계산 중인 상태 (실행 상태 + 대기 상태)  

병렬성 → 여러 프로세스가 동시에 계산을 실행하는 상태 (Only 실행 상태)

병렬화를 통한 고속화  

→ 병렬화를 함으로써 수반되는 오버헤드가 있음. 이를 포함한 수행시간이 순차 실행보다 빠른 경우에 병렬화를 고려(적용) 해야 한다.

병렬 처리 → 성능 향상을 위해 필요함

동시 처리

  - 장점

    1. 효율적인 계산 리소스 활용: A라는 일 수행 중에 B 수행

    2. 공평성 (공정성): 동시에 수행하지 못하는 것은 한쪽 처리에 치우쳐진 것

    3. 편리성: 공평성과 비슷한 맥락에 존재

  - 단점

    - 복잡성: 계산 경로 수의 급증

Rust 에서 `if`, `match`(switch 와 유사함) 는 식이어서 값을 반환해야 한다. → 엄청 신기하다.

> 비동기 프로그래밍은 콜백을 이용해서도 기술된다고 설명했다. 하지만 콜백을 이용하는 방법은 가독성이 낮아진다. 특히 콜백을 연속해서 호출하면 매우 읽기 어려운 코드가 되어 콜백 지옥이라 불리기도 한다. 

완전 공감.

## 좋았던 점

- 도식이 있어서 (비교적) 이해하기 쉽다. 처음에 동시성과 병렬성 설명을 보면서 뭐가 다른지 이해하기 어려웠는데, 그림을 보니까 훨씬 이해하기 쉬웠다.

- 코드에 번호를 붙여 설명이 기술되어 있는데, 설명이 자세해서 Rust를 몰라도 전체적인 흐름을 이해하는 데 무리가 없었다. (그래도 여전히 어렵다.)

## 아쉬웠던 점

- 어렵다!  

내가 기대한 것보다 더 깊이가 깊어서 어려웠다. 정신 놓고 읽기에 마냥 쉬운 책은 아니었다. 어영부영 읽는 걸 많이 미루기도 했다. 게다가 이름은 익히 들었지만, 자주 접한 언어도 아닐뿐더러 익숙한 언어가 아니다 보니 언어적인 측면에서도 수월하게 읽을 수 없는 어려움도 있었다. 더 얕고 쉬운 책을 원한 나에게는 적합하지 못했다.

---

한빛미디어 \<나는 리뷰어다> 활동을 위해서 책을 제공받아 작성된 서평입니다.

그렇다. 이 책은 초보자나 주니어 프로그래머들 보다는 프로그램 성능을 담당하고 있는 시니어 프로그래머 이상급이 봐야되는 책이다.

저자의 말에서 이 책이 다른 책과 다른 점이 무엇이냐 묻는 질문에 저자는 다음과 같이 답했다.

"어셈블리에서 알고리즘, 계산 모델에 이르는 광범위한 주제를 총체적으로 다룬 세계 최초의 책입니다."

책의 대부분의 예제 코드는 Rust를 이용한다.

Rust 언어를 사용한 이유는 동시성 프로그래밍에서 안정성을 제공하고,

메모리를 고려해 코드를 작성할 수 있으며 async/await 등의 고급 개념을 적용하고 있기 떄문이라고 한다.

저자는 책의 대상 독자를 '대학교 3,4학년 또는 대학원생 및 사회인'을 대상으로 삼았다고 한다.

그러나 프로그래밍 비기너인 내 관점에서는 적어도 시니어급 이상의 프로그래머들이 대상이 되는 책이다.

왜냐하면 한국에서 어셈블리어까지 생각하는 C언어 프로그래머는 별로 없다고 생각하기 때문이다.

해외쪽은 모르겠으나 한국에서는 점점 더 C 언어를 배울려고 하지 않는다.

22년 4월 기준 어느 학원 홈페이지에서 C++ 강의는 단 1개가 있으며, 수강 후기는 2개가 고작이다. 반면에 자바스크립트 등은 수강 후기가 비교가 안될 정도로 많다.

최신 언어에서는 GC와 언어단에서 알아서 잘 해주는데 그걸 왜 프로그래머가 고민하면서 구현해야되느냐고 질문한다.

OS부터 대부분 언어에서 속도와 성능을 중요시 여기는 부분을 어떤 언어로 구현했는지 모르는건가...

이 책에서는 프로그래밍 기본 문법 지식을 설명하긴 한다

약 30페이지 가량 설명하는데 어느 쓰레기 책들 처럼 처음부터 자세히 설명하는 것이 아니다.

동시성 프로그래밍을 하기 위해서 C언어에서는 어떤 키워드와 라이브러리가 쓰이는지(volatile와 Pthreads 등) 설명하고, Rust 언어에서는 C언어와 어떻게 다른지에 초점을 둔다.

Rust 언어를 사용해본 사람이 그렇게 많지 않은데다가 어떤 점이 다르고,

그렇기에 어떻게 사용해야 되는지, 이 책에서 왜 Rust 언어를 선택했는지를 볼 수 있었다.

이 책의 핵심은 6장이다. 멀티태스크에 대해 설명한 장이지만, 가장 중요한 부분은 Rust 언어를 이용해 액터 모델(Actor model)을 사용자 공간에서 구현한 것이다.

단순히 개념이 이러이러하다는 것을 직접 구현하여 보여준다는 점은 멋진 일이다.

이 챕터뿐만 아니라 여러 부분에서 도움되는 내용이 많았다.

다만 내 프로그래밍 실력이 매우 부족하여 제대로 따라가지 못하는 점이 한탄스러웠다.

책 페이지 수에 비해 가격이 좀 비싸다고 느낄 수 있지만, 충분히 그 값을 한다고 생각한다.

나는 프로그래밍 성능을 생각하기 이전에 구현부터 똑바로 해야하는 비기너 단계이므로,

어떠한 개념이 있고 어떠한 느낌으로 동작한다는 느낌만 가지고 책을 읽었다.

현재 맡은 업무에서도 성능을 중요시 여기고 있지만, 아직까지는 내가 손댈 부분이 아니라고 판단된다. 

리 속에 있는 개념들을 전부 어느 정도 구현할 줄 아는 단계가 오고

시간/공간 복잡도가 아닌 프로그램 성능을 고려해봐야될 때가 오면 이 책을 다시 펼쳐서 볼 것이다.

마지막으로 어느 고수분이 책의 후기를 기술한 트위터 글을 찾았기에 링크를 추가하며 리뷰를 마친다.

https://twitter.com/codingdodobird/status/1516029738367991808

오늘 리뷰할 책은 "동시성 프로그래밍" 책이다.

오레일리(OREILLY) 책은 전문성이 높아 좋아하는 분야 중 하나라서 왠만하면 책을 사서 보는 편이다.

우리가 아는 동시성 이라고 하면 java 기준으로는 Thread  javascript로는 ajax 나 async/await를 생각을 많이 할 것이다.

Spring5에서는 webflux라는 기능이 추가되며 성능이 최적화가 필요한 지금 개발환경에서는 굉장히 중요한 기술이다.

동기를 어려워 하는 이유중 하나가 락처리나 멀티태스킹, 예외 처리를 관리하기 힘들기 떄문에 집입 장벽이 높으면 편이며, 엄청난 데이터를 한번에 처리하는 곳이 아니면 잘 사용하지 않아 노하우가 쌓이기 어려운 것이다.

이 책은 그러한 개발자들을 위해 동시성의 개념들과 사용법을 해소하는과 한편 프로젝트 도입 전에 읽는 입문서 같은 느낌의 책이다.

하지만 이 책의 아쉬운 점은 C언어나 Rust 같은 비주류의 언어를 사용하는 예제로 되어 있어 다른 언어를 불편함을 느끼면 거부감이 들 수 도 있다.

하지만, Rust 언어 자체가 현대적으로 만들어진 언어라 어셈블리어 같은 언어보다는 더 쉽게 느껴질 수 도 있는 매력적인 언어를 배울 기회라고 생각이다.

또한, Rust 언어를 중심으로 선택한 이유는 Rust가 동시성 프로그래밍에서 안정성을 제공하고, 메모리를 고려해 코드를 작성할 수 있으며 async/await 등의 고급 개념을 적용하고 있기 때문입니다. 

구성

Chapter 1: 동시성과 병렬성

Chapter 2: 프로그래밍 기본

Chapter 3: 동기 처리1

Chapter 4: 동시성 프로그래밍 특유의 버그와 문제점

Chapter 5: 비동기 프로그래밍

Chapter 6: 멀티태스크

Chapter 7: 동기 처리2

Chapter 8: 동시 계산 모델

APPENDIX A: AArch64 아키텍쳐

APPENDIX B: x86-64 아키텍쳐

파트별로 봐도 처음에는 동기식을 한 번 보고, 비동기를 진행하는 만큼 그렇게 어려운 내용은 다루기 않는다는걸 알 수 있다.

비동기에 관련하여 관심있는 분들은 한번 보는 것이 좋을 것같다.

"한빛미디어 <나는 리뷰어다> 활동을 위해서 책을 제공받아 작성된 서평입니다."



사진 삭제

Concurrent Programming, 428 page

 



국내에 러스트(Rust)관련 서적이 2권밖에 출간되지 않은 상황에서 '동시성 프로그래밍 - Rust, C, 어셈블리어로 구현하며 배우는 동시성 프로그래밍 A to Z'의 출간 소식은 반가움을 넘어선 무언가 설레임을 가져다 주었다. 일본어를 하나도 모르기에 오레일리 재팬에서 이 책의 원서(https://www.oreilly.co.jp/books/9784873119595/)가 출간된지도 몰랐었다. 역자 '김모세'님의 발빠른 번역으로 원서 출간일(21년 8월)과 큰 차이 없이 한국어 번역판이 출간하였고 그 책이 지금 내 손에 쥐어지게 되었다.

 <국내 출간된 러스트 서적>

 * 러스트 핵심 노트(한빛미디어) https://www.hanbit.co.kr/store/books/look.php?p_code=E2088508957

 * 러스트 프로그래밍 공식 가이드(The Rust Programmming Language, 제이펍) https://jpub.tistory.com/987

이 책은 책의 부제목에서 명시한 것처럼 동시성 프로그래밍의 A부터 Z까지를 알려주는 것이 목적이다. 타 언어에 비해서 러스트(Rust)는 러닝 커브가 높아 초보자가 배우기에 쉽지 않은 언어이다. 여타의 다른 러스트 서적에서도 어느 정도의 C, C++, Python, Java 등의 언어 경험이 있는 상태에서의 학습을 요구하는 것이 일반적이다. 그리고 다른 러스트 서적에서는 하나의 챕터(절)만을 할애해서 동시성 프로그래밍에 대해서 짧은 소개만을 할 뿐이지만 이 책은 동시성 프로그래밍의 정의에서 부터 필요성 그리고 어셈블리와 C에서의 경험을 바탕으로 차근차근 동시성 프로그래밍에 대해서 접근을 한다.

한빛미디어의 '7가지 동시성 모델 - 프로그래머라면 알아야 할 미래를 품은 7가지 동시성 모델'

https://www.hanbit.co.kr/store/books/look.php?p_code=B3745244799

에서의 접근과는 사뭇 다른 방식으로 동시성 프로그래밍을 설명한다.

저자는 이 책을 올바르게 이해하기 위해서는 어셈블리, 러스트에 대한 경험은 없더라도 C언어는 어느 정도 익숙함을 전제로 하고 있다.

어셈블리와 C로 저수준에서 설명하고 똑같은 내용을 러스트로 간결하고 편리하게 구현할 수 방법을 설명해 주고 있다.

1장>

동시성 프로그래밍에 한 챕터만을 할애할 경우 동시성과 병렬성을 명확히 구분하지 않고 하나로 간주하고 설명을 진행하는 경우가 많은데, 이 책에서는 동시성과 병렬성을 명확히 구분지으는 것으로 시작한다.

동시성 : 2개 이상의 프로세스가 동시에 계산을 진행하는 상태

병렬성 : 같은 시각에서 여러 프로세스가 동시에 계산을 실행하는 상태

동시 처리와 병렬 처리가 중요한 이유는 성능 향상에 있고 효율적인 계산 리소스 활용, 공평성(공정성), 편리성을 내세우며 동시 처리가 필요함을 설명하며, 이는 복잡성을 안고 있음을 설명하며 챕터를 마무리 한다.

2장>

군더더기 없이 어셈블리 언어의 기초에 대해 짧지만 최대한 쉽게 설명을 해주고 있다.

레지스터를 다루는 방법, volatile 그리고 POSIX Pthreads 라이브러리를 이용한 스레드의 생성/종료 그리고 스택과 힙을 구분지어 상세히 설명하고 있다. C언어는 이미 익숙한 독자를 대상으로 하고 있으므로 복습하는 차원에서 무리 없이 읽을 수 있다.

러스트 언어에 약 30페이지를 할애하고 있다. 러스트 미경험자도 독자 대상에 두고 있으므로 상대적으로 할애한 분량이 많다. 타 러스트 서적에 비교하여 꼭 필요한 부분을 잘 간추려 최대한 간단히 설명한다. 소유권, 클로저, 참조, 라이프타임, 차용, 트레이트 등 굵직굵직한 내용들을 간결히 설명하고 있다. 짧은 설명에 러스트에 매료되었길 바란다.

3장>

동기 처리가 필요한 이유(레이스 컨디션)를 설명하고 CPU 지원의 아토믹(Atomic) 명령을 이용한 처리를 학습한다.

동기 처리의 기본인 뮤텍스, 세마포터, 조건 변수를 설명하고 이어서 배리어 동기(Barrier Sync), Readers-Writer락, Pthread(러스트의 동기 처리 라이브러리 내부에서 사용)를 설명한다.

설명이 간결할 뿐만 아니라 여러 용어들을 설명하기 위해 일상 생활에서의 예를 적절히 사용하여, 동기 처리 관련 용어에 익숙하지 않은 독자에게 쉬운 이해를 돕는 것이 인상적이다.

앞서와 마찬가지로 이러한 것들을 C와 어셈블리로 설명하고 이어서 러스트로 전환시켜 모던 동기화 라이브러리를 사용한 모던 동기 처리 기법을 다시한번 살펴본다.

단순히 라이브러리로의 전환히 아닌 원천적으로 실수를 방지하기 위해 러스트에서 제공하는 타입 시스템을 이용하도록 안내한다.

마무리는 CPU에서 아토믹 명령을 지원하지 않을 경우 활용 가능한 베이커리 알고리즘으로 마무리 하고 있는데, 단순히 아모믹(Atomic) 명령으로 일일히 처리하지 않고 알고리즘 차원에서의 지원에 대해 살펴본다.

4장>

익숙한 동시성 프로그래밍에서의 문제점인 데드락으로 시작한다. 특히, RwLock을 러스트에서 사용할 경우 발생할 수 있는 데드락을 피하기 위해 러스트의 _(언더바)를 사용하여 손쉽게 변수를 파기 시켜 데드락 발생을 피할 수 있는 방법을 설명한다.

3장에 이어 고급 주제를 다룬다. 재귀 락(Recusive Lock), 의사 각성(Spurious Wakeup), 시그널(멀티스레드와 궁합이 좋지 않지만 필요하면 사용이 용이한 signal_hook 크레이트에 대한 안내를 해주고 있다) 등은 당장에는 필요가 없어 보일지 몰라도 나중에 필요에 의해 쉽게 찾아서 도움이 될 수 있을 것 같다.

마지막으로 러스트에서 atomic을 사용할 때 Ordering 타입을 왜 지정하고 어떻게 사용할 수 있는지를 어셈블리 레벨에서 메모리 배리어(또는 메모리 펜스) 명령 부터 차근 차근 설명해 주고 있다. 어셈블리 레벨에서의 설명으로 명확히 Ordering 타입 지정에 대한 상세한 내용을 알 수 있다.

5장>

다른 모던 언어를 사용해보았을 경우 익숙한 Future 및 async/awit를 설명한다. 러스트에서는 언어차원에서 코루틴을 지원하지 않지만 Futures 트레이트를 사용하여 좀 더 추상적인 비동기 프로그래밍이 가능함을 확인하고 함수의 중단과 재개를 수행할 수 있는 코루틴을 구현할 수 있음을 소개 한다.

이어서 러스트에서 실질적으로 표준이 되버린 Tokio 크레이트를 사용하여 await를 추가하여 일반적으로 사용하던 라이브러리와 유사한 형태로 비동기 프로그래밍이 가능함을 보여준다. Tokio에 대해 자세히 알 수 있는 기회는 아니지만 Tokio의 편리함과 강력함을 알 수 있게 해주며, 여기서의 맛(?)을 기억하여 좀 더 다양하게 이용할 수 있도록 공식 문서를 참고하도록 안내하고 있다.

6장>

비선점적 멀티태스킹과 선점적 멀티태스킹을 명확히 구분하고, 비선점적 멀티태스킹에서 무한 루프가능성이 있음을 알려준다. 애플리케이션 구현입장에서는 크게 신경을 쓰지 않아도 될 수 있지만 선점적 멀티태스킹에 비해 비선점적 멀티태스킹은 컨텍스트 스위칭을 덜 일어나므로 성능에서 약간의 이득을 얻을 수 있다.

(3절의 액터 모델(Actor Model)은 모든 것을 액터로 다루고 멀티 프로세스끼리 메시지를 교환하는 동시 계산 모델로 필요한 경우 별도로 찾아 이용할 수 있을 것이다.)

7장>

챕터의 제목 '동기 처리2'에서 알 수 있듯이 3장 '동기 처리1'에 이어 공평성이나 데드락 같은 문제를 해결하기 위한 좀 더 발전된 동기 처리 주제를 다룬다. STM(Software Transactional Memory)은 기존 락 기법과 달리 데드락이 발생하지 않는 동기 처리 기법이다. 마지막으로 여러 프로세스에서 동시에 접근 가능한 데이터 구조인 락프리(Lockfree, 배타락을 이용하지 않고 처리를 수행하는 데이터 구조 및 그에 대한 조작 알고리즘을 총칭) 데이터 구조를 설명하고 있다.

8장>

1장에서 '동시성과 병렬성'에 대해 정의하였고 저자는 그것이 매우 추상적이었다고 간주하며, 대표적인 동시 계산 모델인 액터 모델(채널을 이용하지 않고 모든 것을 액터(프로세스)를 사용해 직접 통신을 수행)과 ∏ 계산(프로세스 사이의 데이터 교환을 채널을 이용해서 수행)을 사용하여 동시 처리에 관해 형식적으로 정의한다. 수식이 많아 다소 거부감이 들 수 있을 수 있지만 ML에 익숙해 져야 하는 시점(?)에서 좀더 수학적, 학문적으로 접근해 볼 수 있는 기회를 주고 있다.

요약>

쉽게 발견되는 오타가 간간히 눈에 띄지만 학습에 있어 크게 방해가 될 정도는 아니다. 다만 아직 러스트 관련 용어가 확실히 자리잡지 않은 상태에서 몇몇 용어가 '영어 -> 일본어 -> 한국어'로 전환되는 과정에서 어색한 부분이 있는 점은 다소 아쉬운 점이다.

원저자가 대학 교수여서 그런지 강의 경험이 많아서인지 몰라도 매 챕터의 시작마다 적절한 비유를 통한 설명이 인상적이었다.

이 책을 통해서, 동시성 프로그래밍의 깊이 있는 이해 그리고 동시성, 비동기 프로그래밍에서의 러스트의 강력함을 경험하고 국내 러스트 사용자이 많아지는 계기가 되었으면 한다.

"한빛미디어 <나는 리뷰어다> 활동을 위해서 책을 제공받아 작성된 서평입니다."

동시성 프로그래밍이 갖는 독특한 특징 (동기 처리, 레이스 컨디션, 락, 비동기 처리, IO 다중화, 멀티태스킹 등), 어셈블리 언어와 알고리즘, 계산 모델에 이르는 광범위한 주제를 담고 있으므로 오랫동안 옆에 두고 동시성 프로그래밍에 도전해볼 수 있을 것입니다. (p. 6) - 옮긴이의 말

• 컴퓨터 아키텍처 : 특히 프로세스, 스레드, 메모리에 대한 이해
• 어셈블리, C, Rust 언어에 대한 기초적인 이해 : 코드 보고 대충 이런 뜻이겠구나 유추할 수 있는 정도
• C 언어의 포인터, Rust의 소유권 이해 : C와 Rust를 포기하는 이유라고 하던데...
• 자료구조 : 큐(queue), 스택(stack), 리스트(list), HashMap 등의 기초 개념

개발을 할 때, 

저는 고수준 언어를 주로 사용하기 때문에, 

원리를 모른 채 돌아가게만 구현하는게 아닐까?? 하는 의구심에서 책을 접하게 되었어요.

지식의 깊이도 깊어지는 것 같아서 만족합니다 :)   

O'REILLY 의 Concurrent Programming 책은,

동시성 프로그래밍에서의 동시성이라는 것의 의미 그리고 필요성 등에 대해서 설명하고 있으며,

동시성 프로그리밍에 대한 이론과 Rust, C, Assembler 언어를 이용한 예시를 통하여 동시성 프로그래밍에 대해 쉽게 접근하고 실제 프로젝트에 응용할 수 있도록 기반을 다져주는 책이라는 생각이 듭니다.

* 대상 독자

책에서 제시하는 대상 독자는 프로그래밍을 할 줄 아는 사람을 대상으로 하고 있습니다.

실제, C나 Rust 언어에 대해서 프로그래밍을 할 줄 알아야 합니다.

대부분 예제는 Rust 언어로 되어 있으며, 일부 시스템 관련 부분 및 시스템 API 관련 부분을 설명하고자 할때 C 언어를 사용하고 있습니다.

C나 Rust 언어를 이용하여 구현 까지는 아니더라도 구현된 내용을 읽을 줄 알면 이 책을 학습하는데 크게 무리는 없을 것 같습니다.

* 각 CHAPTER 리뷰

CHAPTER 1 에서는 동시성이라는 것이 나오게된 이유와 그에 대한 필요성 등 개론 적인 부분을 주로 다루고 있습니다.

여기에서 동시성과 병렬성이 의미하는 바와 혼용해서 사용하는 부분에서 실제 동시성과 병렬성은 다른 의미라는 것을 

설명하고 있습니다.

      동시성 : 2개 이상의 프로세스가 동시에 계산을 진행하는 상태를 의미

      병렬성 : 같은 시각에서 여러 프로세스가 동시에 계산을 실행하는 상태를 의미

또한, 동시성과 병렬성에 대해 각각의 정의와,

동시성 관련해서는 OS 와 프로세스 그리고 스레드 각각의 관계에서의 동시성 그리고 그 특징들에 대한 설명이 주로 있으며,

병렬성 관련해서는 하드웨어 (컴퓨터 아키텍처) 측면에서의 병렬성의 3가지 종류를 나열하고 ("테스크 병렬성", "데이터 병렬성", "인스트럭션 레벨 병렬성") 각각 의미와 그 구현 방법 등에 대해 주로 설명하고 있습니다.

동시 처리와 병렬 처리의 필요성 섹션에서는,

병렬 처리의 필요성 관련하여 하드웨어 측면에서의 한계점을 기반으로 소프트웨어 측면에서의 필요성을 설명 하고 있으며,

동시처리의 필요성 관련하여서는 동시 처리가 필요한 이유와 처리할 때의 문제점에 대해서 설명하고 있습니다.

여기에서, 동시 처리는 복잡성 (계산 경로 수의 급증 이라는 문제) 의 문제를 안고 있기 때문에, 기반 지식, 즉 동시성 프로그래밍의 작동 원리와 이론 모델에 대한 학습을 통하여 편리성을 유지하면서 문제점을 줄이고 병렬로 고속 작동하는 소프트웨어 구현하는 기술을 익혀야 한다고 기술하고 있습니다.

동시 처리, 병렬 처리에 대해 무조건 적인 적용은 예상하지 못한 결과를 가져올 수 있다는 것에 공감하며, 책에서 얘기하는데로 기반 기술에 대해 많은 공부가 필요 할 것 같습니다.

이는, 동시성 프로그래밍에 대한 구조적인 부분과 본질에 대한 이해도가 있어야 함을 의미 한다고 생각됩니다.

기본 적으로 이 책을 보려면 C 언어와 Rust 언어를 최소한 읽을 줄 알아야 합니다.

그래서, 책에서 제시하는 대상 동자 및 필요한 사전 지식 관련 (p9) 블럭에서도 명시하고 있듯이

       * C나 Rust 의 기본을 습득하고 본격적으로 소프트웨어 구현하는 단계에 있는 사람

       * 프로그래밍 경험이 어느 정도 있으며 동시성 프로그래밍에 대해 체계적으로 학습하고자 하는 사람

이렇게 정리되어 있으며, 프로그래밍 경험이 많지 않은 경우 C나 Rust 언어 관련 입문서를 먼저 학습한 뒤 이 책을 읽기를 권장하고 있습니다.

C나 Rust 언어에 대한 기반 지식을 학습 하였다면, 이 책을 시작 할 수 있습니다.

이 책에서는 기반 지식을 가지고 있다고 하여도, 동시성 프로그래밍을 할 시에 기본 적으로 필요한 언어적인 내용에 대해 정리하고 있습니다.

CHAPTER 2 에서는 "프로그래밍 기본" 이라는 제목에서 나타내는 것처럼 프로그래밍 언어에 대한 전반적인 부분을 다루지는 않습니다.

주로, 동시성 프로그래밍과 관련된 C , Rust, Assembly 언어에 대한 설명을 다루고 있습니다.

책에서는 C 언어와 Rust 언어에 대해 알고 있다면 넘어가도 된다고 되어 있지만, 한번 리프레쉬 하는 생각으로 읽어 보면 좋을 것 같습니다.

책에서는 Rust 와 Assembly 언어를 사용하고 있지만, OS와의 인터페이스나 표준 API를 설명하기 위해 C 언어를 이용한다고 합니다.

책에서 명시된 것 처럼 C 언어와 Rust 언어에 대한 모든 문법 및 기능을 설명하지 않기 때문에 다른 서적이나 공식 문서를 참고 하여야 합니다.

C 언어에 대해서는 thread, volatile, memory (stack, heap) 에 대해서만 일부 정리되어 있고,

Rust 언어에 대해서는 책 예제 대부분이 Rust 언어를 사용하고 있어서 인지, 기본 문법부터 좀 많은 페이지를 할애하여 설명 하고 있습니다. (문법에 대해서 정리되어 있지만 따로 Rust 언어에 대한 학습은 필요할 것 같습니다.)

Assembly 언어를 설명하는 이유는 동시성 프로그래밍 원리를 알고 컴퓨터의 본질을 이해하는데 도움이 되기 때문이라고 설명하고 있으며 AArch64와 x86-64 Assembly 를 이용합니다.

     cf) AArch64 (Arm 64bit Architecture CPU), x86-64 (AMD or Intel Architecture CPU)

Assembly 에 대한 명령 구조에 대한 기초 설명이며, 자세한 내용은 명령어를 사용할 때 정리되어 있습니다.

Appendix 섹션을 할당하여 각 Architecture 에 대해서 추가로 설명 하고 있습니다.

  (Appendix A : AArch64, Appendix B : x86-64)

CHAPTER 3 에서는 동기 처리에 대해 다루고 있습니다.

흔히 C 언어로 프로그래밍 공부할 때 Process 및 Thread 동기에 처리 관련한 내용에 늘 포함되어 있는 Atomic, Mutex, Semaphore, 조건 변수, barrier sync, readers-writer lock 에 대해 설명하고 있으며, C 언어 와 Rust 언어 구분하여 설명 하고 있습니다.

그리고, 여러 동기처리 알고리즘 중에서 레슬리 램포트의 "베이커리 알고리즘"에 대해 설명 하고 있는데,

CPU에서 Atomic 명령을 이용한 동기처리 방식을 지원하지 않는 경우를 위한 알고리즘으로 알아두면 좋을 것 같습니다.

CHAPTER 4 에서는 동시성 프로그래밍의 특유의 버그와 문제점에 대해서 다루고 있습니다.

흔히 들어 봄 직한 "deadlock, livelock, starvation" 등 동기 처리에서의 기본적인 문제점 및 재귀락, 의사 각성과 같은 고급 동기 처리에 관한 문제를 설명하고 있습니다.

각각에 대한 문제점이 발생하는 코드 예시와 함께 그림을 이용한 설명 그리고, 문제가 발생하지 않는 코드를 보여주며 비교 설명 하고 있습니다.

코드에 대한 설명은 모든 라인에 대해서 하는 것은 아니며, 각각에 대해 필요한 부분에 대해서만 숫자 태그를 붙여서 설명 하고 있습니다.

CHAPTER 4는 필히 숙지하고 넘어가야할 부분이라 생각됩니다.

관련 문제점들에 대해서 고려하지 않고 프로그래밍 하게 되면 논리적 오류 뿐만 아니라 프로그램 동작시에 심각한 버그를 생산하게 될 수도 있습니다.

CHAPTER 5 에서는 비동기 프로그래밍에 대해서 다루고 있습니다.

비동기 프로그래밍에 대한 간략한 소개와 함께 구현 방법에 대해 Rust 를 이용하여 실제 예제와 함께 설명하고 있습니다.

Rust 의 async/await 를 이용한 비동기 프로그래밍 예제를 보여주고 Rust 의 비동기 라이브러리인 Tokio를 이용한 비동기 프로그래밍에 대해서 설명하고 있습니다.

CHAPTER 6 에서는 멀티태스크에 대해서 다루고 있습니다.

멀티태스크와 멀티태스킹의 개념적인 의미를 설명하고 멀티태스크 관련 용어에 대해 설명하고 있습니다.

책에서는 단일 CPU상에서 여러 프로세스를 동시에 작동시키기 위한 기술을 나타내는 것으로 설명하고 있으며,

그와 관련하여 6.1.1 서브 섹션에서 "지킬 박사와 하이드"라는 소설을 예로 들어서 멀티태스크에 대해서 설명하고 있습니다.

그리고 멀티태스크의 종류와 각각의 장단점을 설명하며 각각에 대한 구현 예시를 보여주고 있습니다.

CHAPTER 7 에서는 이전에 다루었던 "CHAPTER 3 동기처리"에서의 확장하여 좀더 향상된 동기 기법에 대해서 다룹니다.

"공평성을 보장하는 락, 소프트웨어 트랜잭셔널 메모리" 에 대해서 다루고 실제 구현한 소스와 알고리즘에 대해서 설명하고 있습니다. (공평성이나 데드락 같은 문제를 해결하는 발전적 동기 처리 기법)

CHAPTER 8 에서는 동시성 프로그래밍에 대해 계산 모델 측면에서 다루고 있습니다.

여기서 제시하는 "액터모델" 과 "∏ 계산" 의 두 가지의 계산 모델을 제시하고 있습니다.

음, 해당 CHAPTER 는 수학 기호로 대부분 표기 되어 있고 각 수식 및 변환 등에 대해서는 자세한 설명이 부족 하기 때문에 수식을 읽어 가는데 좀 많은 시간이 소요될 것 같습니다.

수식 읽는 것에 익숙 하지 않더라도 천천히 본다면 무리 없이 학습할 수 있을 것 같습니다.

* 결론

책 구성이나 전체적인 내용으로 보면 많은 것을 알려주고자 노력한 것 같습니다.

다만, 간혹 이미 알고 있다는 전제를 두어서 인지 설명에 대한 할애가 부족한 부분들이 있긴 합니다.

소스코드에 대해서도 설명을 보기전에 코드를 하나씩 읽으면서 구성 및 의미하는 바를 우선 파악 해본 후 설명을 읽어 보는것이 좋은 것 같습니다.

전체적인 구성에서는 예제 위주로 설명이 되어 있기에 하나씩 따라가며 학습하면 충분히 이해하는데 무리는 없을 것으로 보여집니다.

어려운 부분들에 대해서도 최대한 풀어서 설명을 하고 이해를 돕기위한 노력이 보입니다.

동시성 프로그래밍에 대해서 실제 많은 프로그래머들이 자신도 모르게 사용하고 있는 경우가 많을 것이라 생각됩니다.

이 책은 동시성 프로그래밍에 대해 이미 익숙한 사람이거나 프로그래밍을 시작한지 얼마되지 않은 분들 모두 정독 해보면 많은 도움이 될 것 같습니다.

그리고, 예제로 되어 있는 코드들에 대해서 자신이 자신있는 언어로 변경하면서 공부 해보면 좋을 것 같습니다.

현 시대를 살고 있는 사람들은 남녀노소 누구나 핸드폰을 사용하고 있습니다. 2000년대 처럼 단순 통화, 문자뿐만 아니라 핸드폰으로 인터넷 방송이나 동영상을 시청하거나 게임, 웹 서핑등도 즐기고 있게 되었습니다. 특히 2014년부터 게임을 하면서 문자나 통화를 하거나, DMB 또는 유튜브를 시청하면서 그림을 그리는 등의 동시성 작업이 가능해지게 되었습니다.

동시성 프로그램밍은 쉽게 말하자면 스마트폰으로 스트리밍 음원(혹은 장치에 저장된 음원)을 들으면서 모바일 브라우저를 열어 웹 브라우징을 하고, 화면을 분할해 한쪽에 메모를 하거나 메신저 애플리케이션으로 메세지를 보내는 등의 네트워크로 연결된 모든 시스템에서 동시적으로 작업이 가능하게끔 하는 프로그래밍입니다.

동시성 프로그래밍의 개념은 대부분 저수준 언어(어셈블리 등)에서 구현되므로 추상화된 고수준 언어에서는 크게 신경을 쓰지 않는 경향이 있으며 고수준 언어와 저수준 언어의 소통을 담당하는 가상 머신 등에 그 역할을 모두 맡기면 된다고 말하기도 합니다. 그러나 런타임, 즉 프로그램이 작동하는 하드웨어, OS, 라이브러리 등에 관한 이해가 높을수록 실행속도가 높고 메모리 효율(성능)이 좋은 설계와 구현을 할 수 있습니다. 성능 향샹은 물론 구조적인 허점을 피해 보다 안전하고 유지보수성이 높은 소프트웨어를 만들 수도 있을 것입니다.

제가 이 책을 선택한 이유는 이 책이 동시성 프로그래밍의 구조를 이해하고 이를 통해 동시성 프로그래밍의 본질적인 어려움에 도전할 수 있도록 쓰였으며 동시성 개념에서 시작해 동시성 프로그래밍이 갖는 독특한 특징(동기 처리, 레이스 컨디션, 락, 비동기 처리, IO 다중화, 멀티태스킹 등), 어셈블리 언어와 알고리즘, 계산 모델에 이르는 광범위한 주제를 담고 있기 때문에 동시성 프로그램에 대한 기초를 탄탄히 학습할 수 있기 때문입니다.

이 책의 특성은 동시성 프로그래밍과 관련된 주제를 전반적으로 다루고 있고 흔히들 동시성 프로그래밍은 동시성 프로그램의 구조를 이해하지 못하는 데서 느끼는 어려움과 동시성 프로그래밍의 본질적 어려움때문에 개발자들이 많이 어렵다고 말을 하는데 이 책은 전자의 어려움을 해소하고 후자의 어려움에 본격적으로 도전할 수 있도록 해주는 입문서같은 책으로 다른 책과 다르게 어셈블리에서 알고리즘, 계산 모델에 이르는 광범위한 주제를 총체적으로 다룬 세계 최초의 책입니다. 또한 이 책은 C언어와 어셈블리 언어도 절반정도 사용하고 있지만 Rust언어를 주로 이용해서 설명하고 있는데 Rust 언어를 중심으로 선택한 이유는 Rust가 동시성 프로그래밍에서 안정성을 제공하고, 메모리를 고려해 코드를 작성할 수 있으며 async/await 등의 고급 개념을 적용하고 있기 때문입니다. 

구성

Chapter 1: 동시성과 병렬성

Chapter 2: 프로그래밍 기본

Chapter 3: 동기 처리1

Chapter 4: 동시성 프로그래밍 특유의 버그와 문제점

Chapter 5: 비동기 프로그래밍

Chapter 6: 멀티태스크

Chapter 7: 동기 처리2

Chapter 8: 동시 계산 모델

APPENDIX A: AArch64 아키텍쳐

APPENDIX B: x86-64 아키텍쳐

파트별로 나누어 봤을때 1장은 동시성의 개념과 주변 기술을 설명하고 동시성 프로그래밍이 중요한 이유에 대해 나오는데 대부분 컴퓨터 기술에 대해 설명하고 있고 2장은 어셈블리 언어, C 언어, Rust 언어 및 프로그래밍 언어의 기본 개념과 구문 등에 대해, 3~4장은 동시성 프로그래밍의 필수 사전 지식인 동기 처리 알고리즘과 동시성 프로그래밍 특유의 버그에 대해, 5장은 비동기 프로그래밍, 특히 IO다중화와 Rust 언어의 async/await에 관해 설명하는데 async/await를 구현하기 위한 기반 기술, 코루틴 및 IO다중화에 대해, 6장은 Rust 언어를 이용해 액터 모델을 사용자 공간에서 구현하는 멀티태스크에 대해, 7장은 공평한 동기 처리, 소프트웨어 트랜잭셔널 메모리(동기 처리 기법), 락프리 데이터 구조(알고리즘)와 문제점 등 보다 고도의 동기 처리 기술에 대해, 8장은 동시성 프로그래밍을 계산 모델의 측면에서 보았을 때에 대해 설명하고 있습니다.

개인적인 생각으로 학습은 프로그램 개발자로 취업을 희망하시거나 다른언어를 사용하여 취업한지 얼마 되시지 않는 이제 막 개발자로 시작한 초보자이신 분들께서는 C언어와 Rust 언어 둘 다 관련 입문서를 먼저 학습하시고, C 언어나 Rust 언어를 사용하시는 개발자분들은 C 언어 또는 Rust 언어 관련 입문서를 먼저 학습하시고 난 뒤 1장부터 시작하시면 좋을 것 같고 어느정도 경험이 있으신 분들(프로그램 개발자 2년차~)부터는 2장까지는 쭉 보시면서 동시성의 개념과 주변 기술, 어셈블리 언어, C 언어, Rust 언어의 기본 구문 등에 대해 숙지한다는 방식으로 보시고 3장부터 학습하시는 것이 좋을것 같습니다. 그리고 이책에서는 코드를 테스팅하는 환경의 OS로 리눅스를 사용하기 때문에 리눅스를 사용한 경험이 없으신 분들은 리눅스 기본 사용방법에 대해 알아두셔야 합니다

개인적으로 약간의 단점이 어쩌면 욕심일수도 있는게 좀더 많은 실습 예제가 담겨있으면 더 좋았지 않았을까라는 아쉬움이 있습니다.

저의 리뷰를 읽어주셔서 감사합니다. 다음에는 좀더 유용하고 좋은 책을 소개하면서 더 나은 리뷰를 통해 여러분께 책을 소개시켜드릴 수 있도록 더 노력하겠습니다.

"한빛미디어 <나는 리뷰어다> 활동을 위해서 책을 제공받아 작성된 서평입니다."

일반 서버 개발자라면 한번쯤은 concurrent programming을 해본 경험이 있을 것이다. C 언어를 사용하든 Java 언어를 사용하든 Python 언어를  사용하든 multi-process 또는 multi-thread 개념을 지원하기 때문에 이를 이용해서 concurrent programming에 대한 개념과 동작에 대해 어느 정도 이해하고 있는 사람이 많을 것 같다. 하지만 thread나 process를 생성하고 실행하는 함수를 활용해서 프로그래밍하는 것과 그 개념을 제대로 이해하고 프로그래밍하는 것에는 큰 차이가 있다. 이 책은 이런 관점에서 제대로 된 concurrent programming에 대한 개념을 설명하고 다양한 언어로 된 샘플 코드를 제시하고 설명하고 있다.

이 책은 총 8장으로 구성되어 있다. 먼저 concurrent programming에 대한 개념과 기술을 소개하고 concurrent programming이 중요한 이유에 대해 설명한다. 또한 concurrent programming을 위한 어셈블리, C, Rust 언어에 대한 기본 개념과 문법 등을 설명한다. 개인적으로 Rust 언어에 대한 개발 경험은 없지만 대략 문법적인 구조를 이해하고 샘플 코드에 설명되어 있는 설명만 읽어도 대략적인 코드에 대해 이해할 수 있었던 것 같다. 따라서 Rust 언어에 대해 잘 모르더라도 큰 부담을 가지지 말고 책을 계속 읽어나가면 될 것 같다.

그 다음부터는 동기화 처리에 대한 주요 알고리즘 및 기술에 구조에 대해 설명한다. 특히 atomic 연산과 mutex, semaphore 등 동기화 처리에 필수적인 개념에 대해 자세히 설명하고 있다. 이 동기화는 기본적으로 race condition이라고 하는 concurrent programming에서 할상 발생할 수 있는 현상을 제어하기 위해 필요하며 추가적으로 deadlock에 대한 개념과 이를 회피하기 위한 알고리즘에 대해 설명한다.

그 다음 장 부터는 세부적인 주제별로 자세히 설명한다. 비동기 프로그램을 구현하기 위한 다양한 방법을 설명하고, 멀티태스크의 개념과 전략, STM(Software Transactional Memory)에 대한 설명과 공평성을 보장하는 lock에 대해 설명한다. 마지막 장에서는 동시 계산 모델에 대해 설명하면서 액터 모델과 파이 계산, 람다 계산 등의 개념을 소개하면서 자유변수 및 변환, 간략화에 대한 소개를 한다. 가장 어려웠던 부분 중의 하나였던 것 같고 아직도 그 개념을 정확히 이해하기는 어려웠던 것 같다. concurrent programming에 대한 개념을 이해하고 활용하고자 할때 8장은 건너뛰어도 괜찮지 않을까 생각한다.

전반적으로 개념 소개 및 필요한 이유, 그리고 샘플 예제가 잘 소개되어 있어서 이해하는 데 별 문제는 없었다고 생각한다. concurrent programming에 대해 이 정도로 다양한 기술과 개념이 한권에 담겨 있는 책은 잘 보지 못한 것 같다. 또한 샘플도 잘 설명되어 있어서 실제 실행시켜 보면서 그 개념을 파악할 수 있도록 구성되어 더 좋았던 것 같다.

한편으로는 몇가지 아쉬움이 있는 부분도 존재한다. 일단 각 예제에 대해 설명까지만 하고 실제 실행 결과를 보여주지 않아 실제 실행해 보기전까지는 그 결과를 예측하기 어렵다는 것이다. 책에 충분히 설명이 있긴 하지만 그래도 실행 결과를 보여줬더라면 조금 더 이해하기 좋지 않았을까 생각한다. 다른 한편으로는 번역에 대한 아쉬움이다. 거의 같은 페이지에서 일부는 한글로 일부는 영문으로 번역된 부분이 있다. 좀 더 일관성있게 번역되었더라면 더 좋지 않았을까 생각한다(이 책의 원 저자가 일본인이기 때문에 원본이 그랬을 수도 있다. 하지만 번역하면서 그런 부분까지 손봤더라면 하는 아쉬움은 있다). 이 부분은 120 페이지의 "다음 그림은 RW락의 읽기락과 뮤텍스락의 실행속도를 비교한 것이다"와 121 페이지의 "다음 그림은 RW락의 Write락과 mutex락의 실행속도를 비교한 것이다"이다.

추가적으로 몇몇 오타가 있는 것 같다.

54 페이지 : 중간 예제에서 "enum Rule" 은 "enum Role"로 수정되어야 한다.

58 페이지 : 코드 설명하는 부분 3에서 "뒤에 기술한 -> 32"는 "뒤에 기술한 -> u32"로 수정되어야 할 것 같다.

120 페이지는 위에 언급한 부분 참조

178 페이지 : 반복서버(interactive server)는 그냥 인터렉티브 서버로 그대로 적는 것이 좋을 것 같다.

하지만 전반적으로 책을 읽고 이해하는 데에는 문제가 없기 때문에 concurrent programming에 대한 개념을 이해하고 활용하고자 한다면 충분히 기본 도서로 사용할 수 있을 것 같다.

"한빛미디어 <나는 리뷰어다> 활동을 위해서 책을 제공받아 작성된 서평입니다."

실제로 동시성 프로그래밍의 구현과 이룬을 포함해 매우 폭넓은 범위를 다루고 있으며

요즘 매우 인기 있는 언어인 Rust 언어를 중심으로 진행되고 있으므로 Rust의 동시성 프로그래밍 기법에 관심이 있는 사람이라면 꼭 읽어보기를 추천한다

실제 동시성 프로그래밍 테스트를 위해 Intel CPU외에 Arm 기반의 CPU에서 테스트 해보고 싶다면 아마존 EC2에서 Arm CPU를 선택한 인스턴스에서 충분히 테스트해볼 수도 있다

이 책에서 매우 유용했던 부분은 동시성 프로그래밍의 용어에 대한 명확한 의미와 구조 그리고 구체적인 구현 방법들에 대해 설명하고 다른 방법이나 동기식 처리와 어떠한 차이점이 있는지 그리고 동시성 프로그래밍에서 발생할 수 있는 문제점을 어떻게 해결해나갈 수 있는지 과정을 보여주고 다양한 기법들을 설명해주는 부분들이 매우 좋았다

개인적으로 동시성 프로그래밍에 대해 깊이 알고 싶다면 이 책을 여러번 정독하면서 개념들을 명확히 이해하는 것이 매우 도움이 될 것이라는 생각이 들었다

# 다른 책과의 차별성

요즘은 너무 좋은 고수준 프로그래밍 언어들이 아주 많이 발전했을뿐더러, 책도 시대에 맞춰 좀 더 실용적이거나 인기가 많은 언어나 분야들을 다룬다. 한창 성장해야 할 귀여운 경력을 가지고 있는 C 개발자인 나는 좀 더 나은 개발자가 되기 위해서 서점에서 책을 찾아보지만, 보통 C언어와 관련된 서적이라면 내 나이보다 오래된 서적들을 만나거나, 그게 아니면 겉표지와 내용은 깔끔하지만, 너무 기초적인 내용이 담긴 서적들이어서 아쉬워하기 마련이다. 그러던 중 만난 '동시성 프로그래밍'은 한 마디로 적당했다. 발매일이 일주일도 채 지나지 않았다. 신선하고, 깔끔하면서도 실용적이다. 다소 크게 신선한 주제나 새로운 분야는 아니지만, 어느 정도의 지식수준과 똑같은 개발 일상에 지쳐있는 나에게는 신선하고 새로운 지식이 되어준다. 어셈블리와 알고리즘도 접할 수 있다. 광범위한 주제를 가지고 있기는 하지만 아주 적당한 정도로 잘 정리되어 있다. 또한, Rust를 다루며 설명한 내용이 많다 보니, 자연스레 Rust라는 언어에 흥미가 생긴다. 물론 혼자 구현하고 고민해보는 개발도 좋지만, 다른 사람의 코드와 알고리즘을 접해보고 문제점을 살펴본다는 것은 꽤 빠른 발전 방법인 듯 하다.

추가로 코드 예제를 다운로드 할 수 있다고 한다.

(지금은 페이지를 찾을 수 없다고 나오는데.. 깃헙 확인 해주시면 좋을 것 같다 ...)

# 이 책에서 다루지 않는 언어의 개발자라면?

C나 Rust를 다루지 않더라도 추천해주고싶다. 위에서 말했던 것처럼 요즘은 너무 발전하고 개발하기도 좋은 세상이지만, 그렇기 때문에 더 알고 있어야한다고 생각한다. '다양한 장치가 네트워크로 연결되면서 프로그래밍 기술을 요하는 소프트웨어가 폭발적으로 늘어났음에도 불구하고 동시성 프로그래밍에 관한 전반적인 학습을 할 수 없다는 점은 매우 걱정된다.' 책 도입부에서 확인할 수 있는 말인데, 깊게 공감한다. C를 왜 배워야 하냐는 동기의 질문에 교수님이 답변해주셨던 적이 있다. 우리가 사용하는 프로그래밍의 기초이자 근본이 되는 것이니까. 결국은 이해하고 있어야 어떤 프로그래밍을 하는 사람이 되더라도 좀 더 효율적인, 좀 더 적합한 코드를 만들어 낼 수 있을 거라는 말씀을 하셨었다. 동시성 프로그램의 개념도 비슷하지 않을까? 단순 코더가 되지 않기 위해 오늘도 공부하는 사람들을 위해 한 권쯤 가지고 있으면 도움이 될거라고 감히 추천해본다.

* 한빛미디어 <나는 리뷰어다> 활동을 위해서 책을 제공받아 작성된 서평입니다.