Top 44 Node Js 멀티 쓰레드 The 143 Correct Answer

You are looking for information, articles, knowledge about the topic nail salons open on sunday near me node js 멀티 쓰레드 on Google, you do not find the information you need! Here are the best content compiled and compiled by the https://chewathai27.com/to team, along with other related topics such as: node js 멀티 쓰레드 node.js 멀티프로세싱, node.js worker thread, node.js worker thread pool, Worker_threads, Node 쓰레드, nodejs 멀티코어, Node worker thread example, Js worker thread

Node.js의 멀티 스레딩

nodejs의 멀티쓰레딩과 worker threads – yceffort

Article author: yceffort.kr
Reviews from users: 1617 Ratings
Top rated: 3.2
Lowest rated: 1
Summary of article content: Articles about nodejs의 멀티쓰레딩과 worker threads – yceffort nodejs는 싱글스레드 인가? 그래서, nodejs 애플리케이션은 단일 스레드일까? 어느정도는 그렇다. 사실 우리는 병렬로 실행할 수 있지만, 우리는 스레드를 … …
Most searched keywords: Whether you are looking for nodejs의 멀티쓰레딩과 worker threads – yceffort nodejs는 싱글스레드 인가? 그래서, nodejs 애플리케이션은 단일 스레드일까? 어느정도는 그렇다. 사실 우리는 병렬로 실행할 수 있지만, 우리는 스레드를 … 그 놈의 싱글스레드그 놈의 싱글스레드
Table of Contents:

싱글스레드 세상

nodejs는 싱글스레드 인가

CPU 집약적인 작업

자바스크립트에서 스레드가 없는 이유

일단 간단한 해결책

백그라운드 프로세스

문제 해결

Worker Thread 예제

웹 워커

결론

nodejs의 멀티쓰레딩과 worker threads

nodejs 10.5.0 버전 이후에서 부터는 worker_threads 가 가능해졌고, 12 LTS 부터 stable로 자리잡았다. 이 worker_threads 는 무엇이고 어떤 역할을 하는 것일까?

싱글스레드 세상

자바스크립트는 브라우저에서 실행되는 단일 스레드 프로그래밍 언어로 설계되었다. 단일 스레드 라는 것은, 하나의 프로세스 (브라우저 또는 모던 브라우저의 경우 하나의 탭)에서 하나의 명령어 집합만 실행된다는 것을 의미한다.

이러한 설계는 개발자들이 언어를 사용하는데 있어서 더 쉽게 할 수 있는 요소가 되었다. 자바스크립트는 처음에 웹 페이지, 폼 유효성 검사 등의 상호작용을 추가하는데만 사용되었었는데, 이 정도 작업으로는 멀티스레딩의 복잡함이 전혀 필요하지 않았다.

그러나 nodejs의 창시자(Ryan Dahl)는 이러한 한계를 기회로 보았다. 그는 비동기 IO 를 기반으로 서버측 플랫폼을 구현하고 싶어했다. 즉, 스레드가 필요하지 않았다. 동시성은 매우 풀기 어려운 문제가 될 수 있다. 동일한 메모리에 접근하려고 하는 스레드가 많아지면 재현 및 수정이 매우 어려운 race condition 문제가 발생할 수 있다.

nodejs는 싱글스레드 인가?

그래서, nodejs 애플리케이션은 단일 스레드일까? 어느정도는 그렇다.

사실 우리는 병렬로 실행할 수 있지만, 우리는 스레드를 만들지도 않고 이를 동기화 하지도 않는다. 가상머신과 운영체재가 IO를 병렬로 실행하며, 자바스크립트 코드로 데이터를 다시 전송해야 할 때, 자바스크립트 부분은 단일 스레드로 실행된다.

즉, 자바스크립트 코드를 제외한 모든 것이 병결로 실행된다. 자바스크립트 코드의 동시식 블록은 항상 한번에 하나씩 실행된다.

let flag = false function doSomething ( ) { flag = true // flag를 수정하지 않는 더 많은 코드… // 우리는 flag가 true라는 것은 확신할 수 있다. // 이 코드 블록이 동기로 실행되는 이상, // 이 코드블록이 flag 값을 바꿀일이 없다. }

우리가 처리하는 것이 모두 비동기 IO로 이루어져있다면 이러한 방식은 매우 훌륭하다고 볼 수 있다. 코드는 빠르게 실행되고, 데이터를 파일과 스트림에 전달하는 동기 블록은 작은 부분으로 구성된다. 자바스크립트 코드는 너무 빨라서, 다른 자바스크립트의 실행을 막지 못한다. 자바스크립트 코드가 실행될 때 보다, IO 이벤트가 발생할 때 까지 기다리는 시간이 훨씬 더 많다. 아래 예를 살펴보자.

// 2 db . findOne ( ‘SELECT … LIMIT 1’ , function ( err , result ) { if ( err ) return console . error ( err ) console . log ( result ) } ) // 1 console . log ( ‘Running query’ ) // 3 setTimeout ( function ( ) { console . log ( ‘Hey there’ ) } , 1000 )

데이터베이스로 실행한 이 쿼리는 몇 분 정도 걸릴 수 있지만, Running query 메시지는 쿼리를 호출한 후 즉시 표시된다. 그리고 잠시 후 쿼리가 여전히 실행중인지 아닌지를 확인 한후, 잠시후에 Hey there 메시지를 볼 수 있다.

nodejs 애플리케이션은 함수를 호출할 뿐, 다른 코드의 실행을 차단하지 않는다. 조회가 완료되면 콜백을 통해 알림을 받고, 결과를 받는다.

CPU 집약적인 작업

만일 큰 데이터를 가지고 메모리에서 복잡한 계산을 수행하는 것 과 같이, 동기 집약적인 작업을 수행해야하는 경우엔 어떻게 될까? 그렇게 되면 많은 시간이 걸리게되고, 나머지 코드를 차단하는 동기 코드블록이 생길 수도 있다.

동기 코드 실행에 10초가 걸린다고 상상해보자. 웹서버를 실행중이면, 이 작업 때문에 다른 요청이 최소 10초동안 차단된다. 100ms이상 걸리는 작업은 문제를 유발할 수 있다.

자바스크립트와 nodejs는 CPU 바인딩 작업에 사용할 수 없었다. 자바스크립트는 단일 스레드이기 때문에, 브라우저의 UI는 멈추게되고, Nodejs의 IO 이벤트를 넣게 된다.

db . findAll ( ‘SELECT …’ , function ( err , results ) { if ( err ) return console . error ( err ) // 겁나 오래 걸리는 작업 for ( const encrypted of results ) { const plainText = decrypt ( encrypted ) console . log ( plainText ) } } )

조회가 완료되면 콜백이 실행된다. 콜백이 실행 끝날 때 까지 자바스크립트 코드가 실행되지 않는다.

일반적으로, 앞서 이야기 한 것 처럼 코드는 일반적으로 매우 작고 빠르다. 그러나 위의 예제 코드에서는, 많은 결과가 나오고, 이에 따른 많은 계산이 필요하다. 이는 몇 초 정도 걸릴 수 있으며, 이 기간 동안은 다른 자바스크립트 실행이 대기 중이 기 때문에, 동일한 애플리케이션에서 서버를 실행하는 경우 해당 시간 동안 모든 사용자가 블로킹 될 수 있다.

자바스크립트에서 스레드가 없는 이유

그래서, 많은 사람들이 nodejs 코어에 새 모듈을 추가하여 스레드를 만들고 동기화 할 수 있어야 한다고 생각한다.

만약, nodejs에서 스레드가 추가된다면, 이는 언어의 본질을 바꿔버리는 것이다. 단순히 클래스 또는 함수 추가 만으로 스레드를 만들 수는 없다. 언어를 바꿀 필요가 있다. 멀티스레딩을 지원하는 언어에는 스레드간 협력이 가능하도록 synchronized 와 같은 키워드가 있다.

예를 들어, 자바에서는 일부 숫자 유형의 경우 원자형이 아니다. 액세스를 동기화 하지 않는다면, 두개의 스레드가 변수의 값을 변경할 수 있다. 결과적으로 두개의 스레드가 변수에 액세스하고, 하나의 스레드에 의해 몇 바이트가 변경되고, 다른 스레드에 의해 몇 바이트가 변경되므로 유효한 값을 얻지 못할 것이다.

일단 간단한 해결책

nodejs는 이벤트 큐의 다음 코드블록을, 이전 코드블록의 실행이 완료될 때까지 평가하지 않는다. 그래서 할 수 있는 간단한 방법 중 하나는, 코드를 작은 동기식 코드로 나누고, nodejs에 이 작업이 끝났다고 전달한 이후에 큐에서 보류 중인 것들을 계속해서 실행할 수 있도록 하는 것이다.

const arr = [ /*겁나 큰 배열*/ ] for ( const item of arr ) { // 무거운 작업 } // 저 포문이 끝날 때 까지 여기는 오지 못함

이를 작은 청크로 나눠서 실행해보자.

const crypto = require ( ‘crypto’ ) const arr = new Array ( 200 ) . fill ( ‘something’ ) function processChunk ( ) { if ( arr . length === 0 ) { // code that runs after the whole array is executed // 모든 배열이 실행이 끝난 뒤에 실행됨 } else { console . log ( ‘processing chunk’ ) /// 10개만 추출 const subarr = arr . splice ( 0 , 10 ) for ( const item of subarr ) { // 오래 걸리는 작업 doHeavyStuff ( item ) } // 다음 큐로 작업을 밀어넣음 setImmediate ( processChunk ) } } processChunk ( ) function doHeavyStuff ( item ) { crypto . createHmac ( ‘sha256’ , ‘secret’ ) . update ( new Array ( 10000 ) . fill ( item ) . join ( ‘.’ ) ) . digest ( ‘hex’ ) } // 다른 작업도 가능한지 확인하기 위한 함수 let interval = setInterval ( ( ) => { console . log ( ‘tick!’ ) if ( arr . length === 0 ) clearInterval ( interval ) } , 0 )

이제 setImmediate(callback) 가 실행될 때마다 10개씩 작업을 처리하게 되며, 이외에 무언가 작업할게 생기게 되면 이 작업 사이에 처리하게 된다.

그러나 보다시피 코드가 더 복잡해졌다. 또한 알고리즘은 이보다 더 복잡하기 때문에 어디서 적절히 setImmediate() 를 배치해야 할지 알 수 없다. 게다가 이제 코드는 비동기 식이며, 다른 외부 라이브러리에 의존하게 되면 실행을 더 작은 청크로 분할해서 실행하기 어려워 질 수도 있다.

백그라운드 프로세스

setImmediate() 는 간단한 시나리오에서는 쓸만했지만, 아주 적당한 해결책이라 보기 어렵다.

스레드 없이 프로세스를 병렬로 처리하는 것이 가능할까? 그렇다. 우리에게 필요한 것은 충분한 CPU와 시간을 활용해서 결과를 애플리케이션으로 되돌 릴 수 있는 일종의 백그라운드 처리이다.

// `script.js`를 별도의 환경에서 실행하여 메모리를 공유하지 않는다. const service = createService ( ‘script.js’ ) // 여기에 데이터를 넘기고 결과를 받는다. service . compute ( data , function ( err , result ) { // 결과 } )

사실 우리는 이미 nodejs에서 백그라운드 처리를 할 수 있다. 프로세스를 fork 하여 메시지를 전달하는 방식으로 구현이 가능하다. 메인 프로세스에서 하위 프로세스로 이벤트를 주고 받는 방식으로 통신이 가능하다.

메모리 공유는 없다. 서로 교환되는 데이터는 모두 복제된 데이터이며, 한쪽 데이터를 변경한다고 다른 쪽에 변경이 일어나지는 않는다.

그러나 이는 해결책이긴 하지만, 이상적인 해결책은 아니다. 프로세스를 만드는 것은 리소스 측면에서 많은 비용이 든다. 그리고 느리다. 프로세스가 메모리를 공유하지 않기 때문에, 많은 메모리를 사용하여 새 가상 시스템을 처음부터 실행해야 한다.

물론 동일한 포크 프로세스를 재사용할 수 있다. 그러나 포킹된 프로세스 내에서 동시에 실행되는 서로 다른 과중한 워크로드를 전송하면 두가지 문제가 발생한다.

먼저, 메인 애플리케이션은 차단하지 않을 수 도 있지만, 포크된 프로세스는 한번에 하나의 작업만 처리할 수 있다. 10초가 걸리는 작업과 1초가 걸리는 작업이 순서대로 대기하는 경우, 두번째 작업을 실행하기 위해 10초를 기다리는 것은 이상적이지 않다.

또 다른 문제로, 한작업이 프로세스가 중단되면 동일하나 프로세스에 전송되는 모든 작업이 완료되지 않은 채로 남아있게 된다. 이러한 문제를 해결하기 위해서는 포크가 한 개가 아니고 여러개가 있어야 한다. 그러나 각 프로세스마다 모든 가상 시스템 코드가 메모리에 중복되므로, 프로세스당 몇 MBs의 처리시간과 부팅시간을 계산해서 포크되는 프로세스의 개수를 제한해야 한다.

따라서 데이터베이스 연결과 마찬가지로, 사용할 수 있는 일종의 프로세스 풀이 필요하고, 각 프로세스마다 한번에 작업을 실행하고, 작업이 완료된 후 프로세스를 다시 사용해야 한다. 구현이 매우 복잡해보인다. worker-farm이라는 것을 사용해보자.

// main app const workerFarm = require ( ‘worker-farm’ ) const service = workerFarm ( require . resolve ( ‘./script’ ) ) service ( ‘hello’ , function ( err , output ) { console . log ( output ) } ) // script.js // 여기는 포크 프로세스에서 실행됨 module . exports = ( input , callback ) => { callback ( null , input + ‘ ‘ + world ) }

문제 해결?

뭐, 문제는 해결되었지만 멀티스레드 솔루션보다 훨씬 더 많은 메모리를 쓰고 있다. 스레드들은 포크 프로세스에 비해 리소스 측면에서 매우 가볍다. 이러한 이유 때문에 Worker Thread가 탄생하게 되었다.

Worker Thread에는 분리된 컨텍스트가 있다. 메시지 패싱을 활용하여 메인 프로세스와 정보를 교환하기 때문에 레이스 컨디션 문제를 해결할 수 있다. 또한 이들은 같은 프로세스에 존재하기 때문에 더 적은 메모리를 쓴다.

Worker Thread와 메모리도 공유할 수 있다. 이러한 용도로 많이 사용되는 객체 SharedArrayBuffer 를 활용하여 객체를 전달할 수 있다. 많은 양의 데이터를 활용하여 CPU 집약적인 작업을 수행할 때만 이 기능을 사용해야 한다.

Worker Thread 예제

노드 10버전 이상을 사용하고 있다면 worker_threads 를 쓸 수 있다. 그러나 11.7버전 이하에서는 –experimental-worker 를 추가해야 사용이 가능하다.

한가지 명심해야할 것은, 아무리 프로세스 포킹보다 저렴하다 하더라도 너무 많이 워커를 생성하면 리소스를 많이 사용할 수도 있다는 것이다. 이 경우에는, 워커 풀을 만들기를 권장한다. 이 워커 풀도 마찬가지로 직접 구현하는대신, 워커 풀을 구현한 다른 패키지를 npm에서 찾을 수 있다.

간단한 예제에서 시작해보자. 먼저 Worker thread를 만드는 메인 파일을 구현하고, 데이터를 넘긴다. API는 이벤트 드리븐이지만 Promise로 감싸서 워커로부터 첫번째 메시지를 받는다면 resolve 하도록 한다.

// index.js const { Worker } = require ( ‘worker_threads’ ) function runService ( workerData ) { return new Promise ( ( resolve , reject ) => { const worker = new Worker ( ‘./service.js’ , { workerData } ) worker . on ( ‘message’ , resolve ) worker . on ( ‘error’ , reject ) worker . on ( ‘exit’ , ( code ) => { if ( code !== 0 ) reject ( new Error ( ` Worker stopped with exit code ${ code } ` ) ) } ) } ) } async function run ( ) { const result = await runService ( ‘world’ ) console . log ( result ) } run ( ) . catch ( ( err ) => console . error ( err ) )

보시다시피, 파일 이름과 데이터를 argument로 넘기는 것 만으로도 쉽게 구현이 가능하다. 이 데이터는 복제되었다. 그런 다음 메시지 이벤트를 리슨하여 Worker Thread가 메시지를 보낼 때 까지 기다린다.

const { workerData , parentPort } = require ( ‘worker_threads’ ) // 여기에서 무거운 작업을 동기로 메인 스레드를 방해하지 않으면서 처리할 수 있다. parentPort . postMessage ( { hello : workerData } )

여기서는 메인 애플리케이션이 보낸 workerData 와 메인 애플리케이션으로 정보를 돌려보내는 방법 이 두가지가 필요하다. 작업이 끝나면 parentPort.postMessage 를 통해서 결과를 보낼 수 있다.

이게 전부다. 이는 간단한 예제지만, 우리는 더 복잡한 것들을 할 수 있다. 예를 들어 피드백을 보내야 하는 경우, Worker thread에서 실행 상태를 나타내는 메시지를 여러개 보낼 수도 있다. 아니면 일부 결과만 보낼 수 있다. 수천개의 이미지를 처리한다고 가정해보자. 처리된 이미지별로 보낼 수 있지만, 이 모든작업이 처리될 때 까지 기다리는 것은 좋지 않다.

https://nodejs.org/docs/latest-v10.x/api/worker_threads.html

웹 워커?

아마도 Web Worker API에 대해 들어본 적이 있을 것이다.

이는 웹에서 지원하는 api고, 모던 브라우저에서 잘 지원되고 있다. (심지어 IE11에서도?!) API는 요구사항과 기술조건들이 제각각이지만, 브라우저 런타임에서 유사한 문제를 충분히 해결할 수 있다. 웹 애플리케이션에서 암호화, 압축/압축해제, 이미지조작, 컴퓨터 비전(얼굴인식) 등을 수행하는 하는 경우 유용하다.

결론

[NODE] 📚 Worker_Threads 모듈 (멀티 쓰레드 구현)

Worker Thread 이해하기

Node.js가 시작되면, 다음이 실행됩니다.

하나의 프로세스 : 어디서든 접근 가능한 전역 객체이자 그 순간 실행되고 있는 것들의 정보를 가지고 있는 프로세스

어디서든 접근 가능한 전역 객체이자 그 순간 실행되고 있는 것들의 정보를 가지고 있는 프로세스 하나의 스레드 : 단일 스레드는 주어진 프로세스에서 오직 한 번에 하나의 명령만이 실행된다는 뜻.

단일 스레드는 주어진 프로세스에서 오직 한 번에 하나의 명령만이 실행된다는 뜻. 하나의 이벤트 루프 : 노드를 이해하기 위해 가장 중요한 부분 중 하나입니다.

이는 자바스크립트가 단일 스레드라는 사실에도 불구하고, 언제든 가능한 callback, promise, async/await 를 통해 시스템 커널에 작업을 offload 하게 합니다. 이로서 노드가 비동기식, 비차단 I/O 의 특성을 가집니다.

노드를 이해하기 위해 가장 중요한 부분 중 하나입니다. 이는 자바스크립트가 단일 스레드라는 사실에도 불구하고, 언제든 가능한 callback, promise, async/await 를 통해 시스템 커널에 작업을 offload 하게 합니다. 이로서 노드가 비동기식, 비차단 I/O 의 특성을 가집니다. 하나의 js 엔진 인스턴스 : js 코드를 실행하는 컴퓨터 프로그램입니다.

js 코드를 실행하는 컴퓨터 프로그램입니다. 하나의 노드js 인스턴스 : 노드js 코드를 실행하는 컴퓨터 프로그램입니다.

즉, 노드는 단일 스레드에서 실행되고, 이벤트 루프에는 한 번에 하나의 프로세스만 발생합니다.

하나의 코드, 하나의 실행, (코드는 병렬로 실행되지 않습니다).

이 점은 매우 유용한데, 왜냐하면 당신이 동시성 문제에 대한 걱정 없이 자바스크립트를 사용하는 방법을 단순하게 만들어주기 때문입니다.

그러나 모든 것과 마찬가지로 단점도 있습니다.

만약 인 메모리에서 발생하는 대규모 데이터 세트의 복잡한 계산같은 CPU 자원을 많이 사용하는 코드가 있으면, 이 코드가 다른 프로세스가 실행되는걸 차단할 수도 있습니다.

마찬가지로, CPU 자원을 많이 사용하는 코드가 있는 서버에 요청하는 경우, 이 코드가 이벤트 루프를 차단하고 다른 요청들이 처리되지 않게 할 수도 있습니다.

CPU 작업과 I/O 작업을 구분하는 게 중요합니다.

앞에서 말했듯이, Node.js 코드는 병렬로 실행되지 않습니다.

오직 I/O 작업만 비동기식으로 실행되므로, 병렬로 실행됩니다.

그래서 워커 스레드는 I/O 집약적인 일에는 별로 효과적이지 못한데, 왜냐하면 비동기적 I/O 작업이 워커가 하는 것보다 더 효율적이기 때문입니다.

워커의 가장 중요한 목표는 I/O 작업이 아닌 CPU 집약적인 작업의 퍼포먼스를 향상 시키는 겁니다.

워커 솔루션

CPU 퍼포먼스를 위한 최고의 솔루션은 워커 스레드입니다.

기존 브라우저 특징

하나의 프로세스

하나의 스레드

하나의 이벤트 루프

하나의 js 엔진 인스턴스

하나의 node.js 인스턴스

대신, 워커 스레드는 아래와 같은 특징을 가집니다.

하나의 프로세스

여러개의 스레드

스레드 별 하나의 이벤트 루프

하나의 이벤트 루프 스레드 별 하나의 js 엔진 인스턴스

하나의 js 엔진 인스턴스 스레드 별 하나의 node.js 인스턴스

아래와 같은 이미지로 표현할 수 있습니다.

Worker Thread 사용

const { worker, parentPort } = require(‘worker_threads’)

-> worker 클래스는 독립적인 자바스크립트 실행 스레드를 의미하고, parentPort는 메세지 포트의 인스턴스입니다.

-> worker 클래스는 독립적인 자바스크립트 실행 스레드를 의미하고, parentPort는 메세지 포트의 인스턴스입니다. new Worker(filename) 이나 new Worker(code, {eval: true})

-> 워커를 시작하는 두 가지 메인 방법입니다(파일명을 넘기거나, 실행하고자 하는 코드를 작성하거나). 실제 제작시 파일명을 사용하는 편이 권장됩니다.

-> 워커를 시작하는 두 가지 메인 방법입니다(파일명을 넘기거나, 실행하고자 하는 코드를 작성하거나). 실제 제작시 파일명을 사용하는 편이 권장됩니다. worker.on(‘message’), worker.postMessage(data)

-> 다른 스레드간 메세지를 주고받을 때 사용합니다.

-> 다른 스레드간 메세지를 주고받을 때 사용합니다. parentPort.on(‘message’), parentPort.postMessage(data)

-> parentPort.postMessage(data) 를 통해 보내진 메세지는 worker.on(‘message’) 를 사용한 부모 스레드에서 사용 가능합니다. 그리고 worker.postMessage(data) 를 사용한 부모 스레드로부터 보내진 메세지는 parentPort.on(‘message’) 를 사용한 스레드에서 사용 가능합니다.

워크 쓰레드 통신 로직은 iframe통신 로직과 유사합니다.

iframe통신을 공부하셨다면 수월하게 익히실수 있습니다.

메인 스레드 와 Worker 스레드

isMainThread : 현재 코드가 메인 스레드에서 실행되는지, 워커 스레드에서 실행되는지 구분

: 현재 코드가 메인 스레드에서 실행되는지, 워커 스레드에서 실행되는지 구분 메인 스레드에서는 new Worker를 통해 현재 파일(__filename)을 워커 스레드에서 실행시킴

const { Worker, isMainThread, parentPort } = require(‘worker_threads’); if (isMainThread) { // 메인 스레드 const worker = new Worker(__filename); // 같은 dir폴더에 워커를 생성 } else { // 워커스레드 // 위에서 생성한 worker는 여기서 동작 }

메인 스레드 <-> Worker 데이터 송수신

worker.postMessage 로 부모에서 워커로 데이터를 보냄

로 부모에서 워커로 데이터를 보냄 parentPort.on(‘message’) 로 부모로부터 데이터를 받고, postMessage로 데이터를 보냄

const { Worker, isMainThread, parentPort } = require(‘worker_threads’); if (isMainThread) { // 메인 스레드 const worker = new Worker(__filename); worker.on(‘message’, (value) => { console.log(‘워커로부터’, value) }) worker.on(‘exit’, (value) => { // parentPort.close()가 일어나면 이벤트 발생 console.log(‘워커 끝~’); }) worker.postMessage(‘ping’); // 워커스레드에게 메세지를 보낸다. } else { // 워커스레드 parentPort.on(‘message’, (value) => { console.log(“부모로부터”, value); parentPort.postMessage(‘pong’); parentPort.close(); // 워커스레드 종료라고 메인스레드에 알려줘야 exit이벤트 발생 }) }

Worker를 모듈로 관리

new Worker(경로)를 통해 모듈 적으로 워커들을 관리할 수도 있습니다.

// main.js const { Worker } = require(‘worker_threads’) const worker = new Worker(‘./worker.js’) worker.on(‘message’, (value) => { console.log(‘워커로부터’, value) }) worker.on(‘exit’, (value) => { console.log(‘워커 끝~’); }) worker.postMessage(‘ping’); // 워커스레드에게 메세지를 보낸다.

// worker.js const { parentPort } = require(‘worker_threads’) parentPort.on(‘message’, (value) => { console.log(“부모로부터”, value); parentPort.postMessage(‘pong’); parentPort.close(); // 워커스레드 종료라고 메인스레드에 알려줘야 exit이벤트 발생 })

MessageChannel 을 사용한 Worker 간 데이터 송수신

위의 예시에선 메인 스레드가 메시지를 중계합니다.

이 방법으로 Worker 간 데이터 송수신을 구현했습니다.

Worker 간에서 데이터 송수신하는 다른 방법으론 MessageChannel 활용이 있습니다.

메인 측에서 MessageChannel 을 만들 때 MessagePort 2개가 생성됩니다. 각각을 각 Worker 에 전달하도록 합니다.

// main.js const {Worker, MessageChannel} = require(‘worker_threads’) const {port1, port2} = new MessageChannel() const worker1 = new Worker(‘./worker1.js’) const worker2 = new Worker(‘./worker2.js’) worker1.postMessage({worker2: port1}, [port1]) worker2.postMessage({worker1: port2}, [port2])

MessagePort 를 받은 Worker 는 이후 MessagePort 를 통해 Worker 간 데이터 송수신을 할 수 있게 됩니다.

// worker1.js const assert = require(‘assert’) const {parentPort, MessagePort} = require(‘worker_threads’) parentPort.once(‘message’, ({worker2}) => { assert(worker2 instanceof MessagePort) worker2.postMessage(‘message from worker1’) })

// worker2.js const assert = require(‘assert’); // 값을 비교하여 프로그램이 제대로 동작하는지 테스트 하는데 사용하는 모듈 const {parentPort, MessagePort} = require(‘worker_threads’) parentPort.once(‘message’, ({worker1}) => { assert(worker1 instanceof MessagePort) worker1.on(‘message’, message => { console.log(‘worker2 received message: %o’, message) }) })

여러개의 Worker 스레드

WorkerData : startup 데이터를 전달하기 위해 사용됩니다. 워커 생성자에게 전달된 데이터의 복제본이 포함된 임의의 js 값입니다. postMessage()를 사용하는 것처럼 데이터가 복제됩니다.

const { Worker, isMainThread, parentPort , workerData} = require(‘worker_threads’); if (isMainThread) { // 메인 스레드 const threads = new Set(); // 자료형 set threads.add(new Worker(__filename, { // Worker객체를 생성하고 workerData객체를 주어 초기 데이터를 전송 workerData: { start: 1 }, // 초기 데이터 })); threads.add(new Worker(__filename, { workerData: { start: 2 }, })); // Woker가 들어있는 set을 순회하여 각 Worker에 이벤트를 등록 for(let worker of threads) { worker.on(‘message’, (value) => { console.log(‘워커로부터’, value) }) worker.on(‘exit’, (value) => { threads.delete(worker); // set에서 쓰레드 삭제 if(threads.size === 0 ){ // set이 모두 비웠졌을 경우, 워커쓰레드가 모두 끝난거니까 console.log(‘워커 끝~’); } }) } } else { // 워커스레드 const data = workerData; parentPort.postMessage(data.start + 100); }

Worker 스레드 성능

다음은 2에서 10000000 까지 소수를 구하는 예제 입니다.

알고리즘은 아리토스테네스의 체 소수 구하기 를 사용하였습니다.

let min = 2, max = 10_000_000, primes = []; // 아리토스테네스의 체 소수구하기 function generatePrimes(start, range) { let isPrime = true; const end = start + range; for (let i = start; i < end; i++) { for (let j = min; j < Math.sqrt(end); j++) { if (i !== j && i % j === 0) { isPrime = false; break; } } if (isPrime) { primes.push(i) } isPrime = true; } } console.time('prime'); generatePrimes(min, max) console.timeEnd('prime'); console.log(primes.length); 총 소수가 663479개가 나왔고 걸린 시간은 7.5초나 걸렸습니다. 하나의 쓰레드에서 하드한 cpu작업을 돌려서 그렇습니다. 워커를 이용해서 하드한 작업을 분배해 봅시다. const { Worker, isMainThread, parentPort, workerData } = require('worker_threads'); let min = 2, max = 10_000_000, primes = []; // 아리토스테네스의 체 소수구하기 function generatePrimes(start, range) { let isPrime = true; const end = start + range; for (let i = start; i < end; i++) { for (let j = min; j < Math.sqrt(end); j++) { if (i !== j && i % j === 0) { isPrime = false; break; } } if (isPrime) { primes.push(i) } isPrime = true; } } if (isMainThread) { const threadCount = 8; const threads = new Set() const range = Math.ceil((max - min) / threadCount); // 10_000_000 max를 8개의 쓰레드에 분배를 해서 처리하기 위해서 let start = min; console.time('prime2'); // 우리가 워커가 일을 할수있게 분배하고 직접 짜야 한다. 여간 복잡한게 아니다.. for (let i = 0; i < threadCount - 1; i++) { const wStart = start; threads.add(new Worker(__filename, { workerData: { start: wStart, range: range } })) start += range; } // 7개만 for돌고 마지막 워커는 특별해서 따로 지정 threads.add(new Worker(__filename, { workerData: { start: start, range: range + ((max - min + 1) % threadCount) } })); // 워커들 이벤트 등록 for (let worker of threads) { worker.on('error', (err) => { throw err; }) worker.on(‘exit’, () => { threads.delete(worker); if (threads.size ===0){ console.timeEnd(‘prime2’) console.log(primes.length); } }); // 워커들이 일한 결과를 메시지 받아서 정리해주는 동작도 직접 구현 worker.on(‘message’, (msg) => { primes = primes.concat(msg); }) } } else { // 워커들 일 등록 generatePrimes(workerData.start, workerData.range); parentPort.postMessage(primes); }

워커 작업의 핵심은 무언가 하드한 코드가 있으면,

이를 개발자가 이 코드를 잘 쪼개서 나뉘어 할당하는 로직을 구현하여 나누는 능력이 필요하고, 워커에서 돌리고 나온 결과나 설정 등등 하나하나 개발자가 세세하게 직접 코딩해야 한다는 특징이 있습니다.

Cách thực hiện đa luồng – Multithreading với Node.js

20 tháng 05, 2021 – 5810 lượt xem

Hot: Node.js có khả năng thực hiện đa luồng từ phiên bản 13.

Giới thiệu

Hầu hết các nhà phát triển JavaScript trước nay vẫn cho rằng Node.js là luồng đơn – single thread, xử lý nhiều hoạt động bằng các quy trình không đồng bộ và không hỗ trợ đa luồng. Giờ thì điều đó xưa rồi, vì trên phiên bản 13 của Node.js, có một mô-đun mới được gọi là “worker thread” để triển khai đa luồng.

Mặc dù lệnh gọi không đồng bộ, không chặn có thể xử lý nhiều hoạt động rất hiệu quả, nhưng các chức năng yêu cầu sử dụng dung lượng CPU lớn – ví dụ như encryption (mã hóa) sẽ làm chậm các quy trình khác, hiệu suất của Node.js là yếu đối với trường hợp như vậy. Mô-đun “worker thread” khắc phục điểm yếu đó bằng cách cô lập chức năng sử dụng CPU dung lượng cao thành một luồng riêng biệt, xử lý nó ở chế độ nền và như vậy sẽ không làm nghẽn bất kỳ quy trình nào khác.

Thực hiện

Thông thường trong Node.js, luồng chính xử lý tất cả các hoạt động. Ví dụ dưới đây sẽ trình bày cách tạo thêm một luồng khác để xử lý. Ví dụ này có hai API, API đầu tiên sẽ xử lý chức năng trên luồng chính và API thứ 2 sẽ xử lý chức năng trên một luồng riêng biệt. Đoạn mã dưới đây hiển thị cấu trúc cơ bản của ví dụ.

/* * File Name: index.js * Description: This is the main thread */ const express = require(“express”); const app = express(); const port = 3000; app.get(“/”, (req, res) => { res.send(“Process function on main thread.”); }); app.get(“/seprate-thread”, (req, res) => { res.send(“Process function on seprate thread.”); }); app.listen(port, () => { console.log(`Example app listening at http://localhost:${port}`); });

Bước đầu tiên, ta thêm một function trên luồng chính. Tiếp theo, ta thêm function tương tự trên một luồng khác. Function được sử dụng sẽ là getSum, function này sẽ trả về tổng tích lũy thành giá trị giới hạn được đưa ra dưới dạng đối số. Sau khi thêm hàm getSum vào luồng chính, đoạn mã sẽ giống như bên dưới.

/* * File Name: index.js * Description: This is the main thread */ const express = require(“express”); const app = express(); const port = 3000; const getSum = (limit) => { let sum = 0; for (let i = 0; i < limit; i++) { sum += i; } return sum; }; app.get("/", (req, res) => { const result = getSum(1000); res.send(`Processed function getSum on main thread and result: ${result}`); }); app.get(“/seprate-thread”, (req, res) => { res.send(“Process function getSum on seprate thread.”); }); app.listen(port, () => { console.log(`Example app listening at http://localhost:${port}`); });

Bước tiếp theo là thêm chức năng tương tự trên một luồng khác và nó có thể thực hiện như sau.

Nhập mô-đun worker thread vào luồng chính.

const { Worker } = require(“worker_threads”);

Tạo một tệp khác, seprateThread.js, để xác định hàm getSum sẽ chạy trên một luồng khác.

Tạo một phiên bản của mô-đun worker thread và cung cấp tên đường dẫn đến tệp mới được tạo

const seprateThread = new Worker(__dirname + “/seprateThread.js”);

Bắt đầu một luồng mới

seprateThread.on(“message”, (result) => { res.send(`Processed function getSum on seprate thread: ${result}`); });

Gửi dữ liệu đến luồng mới

seprateThread.postMessage(1000);

Cuối cùng, luồng chính sẽ giống như đoạn mã dưới đây

/* * File Name: index.js * Description: This is the main thread */ const express = require(“express”); const { Worker } = require(“worker_threads”); const app = express(); const port = 3000; const getSum = (limit) => { let sum = 0; for (let i = 0; i < limit; i++) { sum += i; } return sum; }; app.get("/", (req, res) => { const result = getSum(1000); res.send(`Processed function getSum on main thread and result: ${result}`); }); app.get(“/seprate-thread”, (req, res) => { const seprateThread = new Worker(__dirname + “/seprateThread.js”); seprateThread.on(“message”, (result) => { res.send(`Processed function getSum on seprate thread: ${result}`); }); seprateThread.postMessage(1000); }); app.listen(port, () => { console.log(`Example app listening at http://localhost:${port}`); });

Do đó, một luồng mới được tạo ra từ luồng chính. Chúng ta hãy đặt hàm getSum trên luồng mới được tạo, vì vậy hãy xác định hàm đó trên tệp seprateThread.js. Sau khi xác định, luồng mới sẽ gửi kết quả trở lại luồng chính; kiểm tra mã dưới đây để tham khảo.

/* * File Name: seprateThread.js * Description: This is another thread */ const { parentPort } = require(“worker_threads”); const getSum = (limit) => { let sum = 0; for (let i = 0; i < limit; i++) { sum += i; } return sum; }; parentPort.on("message", (limit) => { const result = getSum(limit); parentPort.postMessage(result); });

Trong ví dụ trên, bạn có thể thấy hàm seprateThread.postMessage () được sử dụng bởi luồng chính để giao tiếp với luồng con. Tương tự như vậy, parentPort.postMessage () được sử dụng bởi luồng con để giao tiếp với luồng chính. Hình dưới đây minh họa giao tiếp giữa con và luồng chính

Đặc trưng

Mỗi luồng có các V8 engine riêng biệt.

Các luồng con có thể giao tiếp với nhau.

Các chủ đề con có thể chia sẻ cùng một bộ nhớ.

Giá trị ban đầu có thể được chuyển như một tùy chọn trong khi bắt đầu luồng mới.

Kết luận

Động cơ của bài viết này là đưa ra một ý tưởng ngắn gọn về cách triển khai cơ bản của đa luồng trên Node.js. Đa luồng trong Node.js hơi khác một chút so với đa luồng truyền thống. Người ta khuyên rằng đối với hoạt động I / O lớn, luồng chính có thể hoạt động tốt hơn nhiều so với worker thread. Để hiểu thêm về đa luồng, hãy tham khảo tài liệu chính thức của Node.js và mã nguồn của ví dụ có sẵn tại đây.

Bài dịch từ PlainEnglish

Tham khảo khoá Lộ trình Node.js 4.5 tháng của Techmaster

So you have finished reading the node js 멀티 쓰레드 topic article, if you find this article useful, please share it. Thank you very much. See more: node.js 멀티프로세싱, node.js worker thread, node.js worker thread pool, Worker_threads, Node 쓰레드, nodejs 멀티코어, Node worker thread example, Js worker thread

Top 44 Node Js 멀티 쓰레드 The 143 Correct Answer

nodejs의 멀티쓰레딩과 worker threads – yceffort

[NODE] 📚 Worker_Threads 모듈 (멀티 쓰레드 구현)

Techmaster Việt Nam – Học là có việc

Multi-Thread in Node.js: What are Worker Threads?

Node.js multithreading: Worker threads and why they matter – LogRocket Blog

Node.js – 기본 개념 (2): 멀티스레드 · ASSU BLOG.

node.js는 single thread일까?

node.js는 single-thread 인가요?

Node.js의 스레드 | devlog.akasai

[NodeJS] NodeJS 는 Single Thread 일까? Multi Thread 일까?

nodejs의 멀티쓰레딩과 worker threads

[NODE] 📚 Worker_Threads 모듈 (멀티 쓰레드 구현)

Cách thực hiện đa luồng – Multithreading với Node.js

Leave a Comment Cancel reply