Java - Thread Pool, Thread Pool Blocking

< Thread Pool >

// Thread pool은 대여소 같은 역할을 수행 한다.

// 대여할 Thread가 없다면 대기해야 한다.

// Thread pool은 ExecutorService 객체를 통해 생성 된다.

// 생성시에는 초기/코어/최대 스레드 수를 명시해 준다.

// 코어 스레드 수 - 최소한으로 유지되어야 하는 수

// 동시 수행 - 실시간(Real Time), 병렬 처리

// 프로그램상 스레드는 실제 스레드에서 남는 부분에서 수행한다.

// 그래서 여러 스레드를 만들 수 있다.

// Thread Pool의 작업은 Runnable과 Callable로 생성 한다.

// 두 방법의 차이는 return 값의 유무 이다.

// Runnable은 return값이 없고 Callable은 있다.

// 생성된 작업은 execute()와 submit()으로 실행한다

// execute는 return 타입이 void이기때문에 Runnable에서 사용

// submit은 Future타입으로 반환한다 Callable에서 사용

// execute는 예외상황에 스레드 종료, submit()은 스레드를 종료하지 않고 재사용

// Runnable객체로 생성 되지않거나 Thread를 재사용 하려면 submit()

// Runnable객체로 생성되고, *예외상황*에 Thread를 죽이려면 execute()

// 둘다 예외상황이 아니면 정상적으로 스레드를 반환 한다.

// Runnable로 submit()을 사용할 수도 있다.

// Runnable은 무조건 스레드를 죽이는 것은 아니다. -> 둘 다 사용가능

< Execute >

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class ExecuteMain {

    public static void main(String[] args) {

        

        // 1. 풀을 만들어 준다.

        int n = Runtime.getRuntime().availableProcessors();

        ExecutorService pool = Executors.newFixedThreadPool(n);

        

        // 2. 작업 내용을 정한다.

        Runnable runnable = new Runnable() {

            

            @Override

            public void run() {

                System.out.println("runnable로 처리 한다.");

            }

        };

        

        // 3. 실행을 요청한다.

        pool.execute(runnable); // 처리 후 pool에 스레드 반환

// 4. 스레드 종료

pool.shutdown();

        

    }

}

< Submit >

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

public class SubmitMain {

    public static void main(String[] args) throws Exception {

        

        // 1. pool 생성

        ExecutorService pool = Executors.newFixedThreadPool(2);

        

        // 2. 해야할 일

        Callable<String> call = new Callable<String>() {

            @Override

            public String call() {

                System.out.println("callable 처리");

                return "완료";

            }

        };

        

        

        // 3. 실행

        Future<String> result = pool.submit(call); // Future객체에 반환 값 저장

        System.out.println(result.get());

// 4. 스레드 종료

pool.shutdown(); // 처리를 마무리하고 pool 종료

pool.shutdownNow(); // 처리여부 상관없이 바로 pool종료

pool.awaitTermination(10L, TimeUnit.SECONDS); // 시간여부에 따라 pool 종료

        

        

    }

}

// Pool은 다쓰고 나면 반드시 닫아야 한다.

// shutdown - 처리 작업을 마무리하고 thread pool 종료

// shutdownNow - 처리 작업 여부에 상관없이 thread pool 종료

// awaitTermination - 시간 여부에 따라 thread pool 종료

< Thread Pool Blocking >

// Thread Pool에서는 rnnable과 callable 관계없이 작업 완료 후, Future객체를 반환한다.

// Future객체를 가져 오는 get()메서드는 syncronized와 같은 역할을 수행 한다.

// 이것을 Blocking이라고 한다. Future의 get() = join()과 같은 개념

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

public class NoResult {

    public static void main(String[] args) throws Exception {

        

        // 1. 스레드 풀 생성

        int n = Runtime.getRuntime().availableProcessors();

        ExecutorService pool = Executors.newFixedThreadPool(n);

        

        // 2. 작업 내용 작성

        Runnable run = new Runnable() {

            @Override

            public void run() {

                for(int i=1;i<=5;i++) {

                    System.out.println("작업 처리 : "+i );

                }

            }

        };

        

        // 3. 작업 내용 실행 요청

        Future result = pool.submit(run);

        result.get();

        System.out.println("작업 완료");

        

        // 4. 스레드 풀 종료

        pool.shutdown();

        

    }

}

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

public class Result {

    public static void main(String[] args) throws Exception {

        

        int n = Runtime.getRuntime().availableProcessors();

        ExecutorService pool = Executors.newFixedThreadPool(n);

        

        Callable<String> call = new Callable<String>() {

            @Override

            public String call() throws Exception {

                for(int i=1;i<=5;i++) {

                    System.out.println("Data : "+i);

                }

                return "완료";

            }

        };

        

        Future result = pool.submit(call);

        System.out.println(result.get());

        

        pool.shutdown();

    }

}