네트워크 1 (Socket)

참고자료

김영한의 실전 자바 - 고급 2편, I/O, 네트워크, 리플렉션 강의 | 김영한 - 인프런

 

자바 네트워크 프로그램에 대해 공부해보자. 여기서는 TCP/IP로 개발할 예정이다.

프로그램을 작성하기 전에 스레드 정보와 현재 시간을 출력하는 간단한 로깅 유틸리티를 만들자.

package cwchoiit.util;

import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

public class MyLogger {

    private static final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm:ss.SSS");

    public static void log(Object object) {
        String time = LocalTime.now().format(formatter);
        System.out.printf("%s [%9s] %s\n", time, Thread.currentThread().getName(), object);
    }
}

• 앞으로 대부분의 출력은 이 로깅 클래스를 사용하겠다.

이번에 만들 프로그램은 아주 간단한 네트워크 클라이언트, 서버 프로그램이다. 클라이언트가 "Hello"라는 문자를 서버에 전달하면 서버는 클라이언트의 요청에 " World!"라는 단어를 더해서 "Hello World!"라는 문장을 클라이언트에 응답한다.

• 클라이언트 → 서버: "Hello"
• 클라이언트 ← 서버: "Hello World!"

네트워크 프로그램 1

ClientV1

package cwchoiit.network.tcp.v1;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;

import static cwchoiit.util.MyLogger.log;

public class ClientV1 {

    private static final int PORT = 12345;

    public static void main(String[] args) throws IOException {
        log("클라이언트 시작");

        Socket socket = new Socket("localhost", PORT);

        DataInputStream input = new DataInputStream(socket.getInputStream());
        DataOutputStream output = new DataOutputStream(socket.getOutputStream());
        log("소켓 연결: " + socket);

        // 서버에게 문자 보내기
        String toSend = "Hello";
        output.writeUTF(toSend);
        log("client -> server: " + toSend);

        // 서버로부터 문자 받기
        String received = input.readUTF();
        log("client <- server: " + received);

        // 자원 정리
        log("연결 종료: " + socket);
        input.close();
        output.close();
        socket.close();
    }
}

• 클라이언트 소스이다.

ServerV1

package cwchoiit.network.tcp.v1;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

import static cwchoiit.util.MyLogger.log;

public class ServerV1 {

    private static final int PORT = 12345;

    public static void main(String[] args) throws IOException {
        log("서버 시작");

        ServerSocket serverSocket = new ServerSocket(PORT);
        log("서버 소켓 시작 - 리스닝 포트: " + PORT);

        Socket socket = serverSocket.accept();
        log("소켓 연결: " + socket);

        DataInputStream input = new DataInputStream(socket.getInputStream());
        DataOutputStream output = new DataOutputStream(socket.getOutputStream());

        // 클라이언트로부터 문자 받기
        String received = input.readUTF();
        log("client -> server: " + received);

        // 클라이언트에게 문자 보내기
        String toSend = received + " World!";
        output.writeUTF(toSend);
        log("client <- server: " + toSend);

        // 자원 정리
        log("연결 종료: " + socket);
        input.close();
        output.close();
        socket.close();
        serverSocket.close();
    }
}

• 서버 소스이다.

서버를 먼저 실행하고, 그 다음에 클라이언트를 실행해야 한다.

 

실행 결과 - 클라이언트

13:48:52.354 [     main] 클라이언트 시작
13:48:52.373 [     main] 소켓 연결: Socket[addr=localhost/127.0.0.1,port=12345,localport=51146]
13:48:52.373 [     main] client -> server: Hello
13:48:52.376 [     main] client <- server: Hello World!
13:48:52.376 [     main] 연결 종료: Socket[addr=localhost/127.0.0.1,port=12345,localport=51146]

참고로, 클라이언트의 localport는 랜덤으로 생성되므로, 다른 숫자가 나올 수 있다. 이 부분은 뒤에서 설명한다.

 

실행 결과 - 서버

13:48:37.708 [     main] 서버 시작
13:48:37.720 [     main] 서버 소켓 시작 - 리스닝 포트: 12345
13:48:52.373 [     main] 소켓 연결: Socket[addr=/127.0.0.1,port=51146,localport=12345]
13:48:52.375 [     main] client -> server: Hello
13:48:52.376 [     main] client <- server: Hello World!
13:48:52.376 [     main] 연결 종료: Socket[addr=/127.0.0.1,port=51146,localport=12345]

 

• localhost (127.0.0.1)
  • localhost는 현재 사용중인 컴퓨터 자체를 가리키는 특별한 호스트 이름이다. google.com, naver.com과 같은 호스트 이름이지만, 자기 자신의 컴퓨터를 뜻하는 이름이다.
  • localhost는 127.0.0.1이라는 IP로 매핑된다.
  • 127.0.0.1은 IP 주소 체계에서 루프백 주소(loopback address)로 지정된 특별한 IP 주소이다. 이 주소는 컴퓨터가 스스로를 가리킬 때 사용되며, localhost와 동일하게 취급된다.
  • 127.0.0.1은 컴퓨터가 네트워크 인터페이스를 통해 외부로 나가지 않고, 자신에게 직접 네트워크 패킷을 보낼 수 있도록 한다.

주의! - 서버 연결 불가

java.net.ConnectException: Connection refused

• 서버를 시작하지 않고, 클라이언트만 실행하면 해당 예외가 발생한다.
• 커넥션 및 소켓과 관련된 다양한 예외들이 있는데, 이런 예외들은 뒤에서 한번에 정리하겠다.

주의 - BindException

Exception in thread "main" java.net.BindException: Address already in use

• 만약, 이런 예외가 발생했다면 이미 12345라는 포트를 다른 프로세스가 사용하고 있다는 뜻이다. 포트를 다른 숫자로 변경해서 사용하자. 
• 우리가 작성한 서버 프로그램을 아직 종료하지 않은 상태로 다시 실행하는 경우에도 12345 포트를 이미 점유하고 있으므로 같은 예외가 발생할 수 있다.

위 코드 분석하기

TCP/IP 통신에서는 통신할 대상 서버를 찾을 때 호스트 이름이 아니라, IP 주소가 필요하다. 네트워크 프로그램을 분석하기 전에 먼저 호스트 이름으로 IP를 어떻게 찾는지 확인해보자.

 

DNS 탐색

package cwchoiit.network.tcp.v1;

import java.net.InetAddress;
import java.net.UnknownHostException;

public class InetAddressMain {
    public static void main(String[] args) throws UnknownHostException {
        InetAddress localhost = InetAddress.getByName("localhost");
        System.out.println(localhost);

        InetAddress google = InetAddress.getByName("google.com");
        System.out.println(google);
    }
}

실행 결과

localhost/127.0.0.1
google.com/142.250.199.110

 

자바의 InetAddress 클래스를 사용하면, 호스트 이름으로 대상 IP를 찾을 수 있다. 찾는 과정은 다음과 같다.

• 자바는 InetAddress.getByName("호스트명") 메서드를 사용해서 해당하는 IP 주소를 조회한다.
• 이 과정에서 시스템의 호스트 파일을 먼저 확인한다.
  • /etc/hosts (Linux, Mac)
  • C:\Windows\System32\drivers\etc\hosts (Windows)
• 호스트 파일에 정의되어 있지 않다면, DNS 서버에 요청해서 IP 주소를 얻는다.

호스트 파일 예시

127.0.0.1 localhost
255.255.255.255 broadcasthost
::1 localhost

 

만약, 호스트 파일에 localhost가 없다면, 127.0.0.1 localhost를 추가하거나, 127.0.0.1과 같은 IP를 직접 사용하면 된다.

 

클라이언트 코드 분석

클라이언트와 서버의 연결은 Socket을 사용한다.

Socket socket = new Socket("localhost", PORT)

• (지금은 서버도 클라이언트도 동일한 PC이므로) localhost를 통해, 자신의 컴퓨터에 있는 12345 포트에 TCP 접속을 시도한다. 
  • localhost는 IP가 아니므로 해당하는 IP를 먼저 찾는다. 내부에서 InetAddress를 사용한다.
  • localhost는 127.0.0.1 이라는 IP에 매핑되어 있다.
  • 127.0.0.1:12345에 TCP 접속을 시도한다.
• 연결이 성공적으로 완료되면, Socket 객체를 반환한다.
• Socket은 서버와 연결되어 있는 연결점이라고 생각하면 된다.
• Socket 객체를 통해서 서버와 통신할 수 있다.

클라이언트와 서버간의 데이터 통신은 Socket이 제공하는 스트림을 사용한다.

DataInputStream input = new DataInputStream(socket.getInputStream());
DataOutputStream output = new DataOutputStream(socket.getOutputStream());

• Socket은 서버와 데이터를 주고 받기 위한 스트림을 제공한다.
• 클라이언트 입장에서는,
  • InputStream: 서버에서 전달한 데이터를 클라이언트가 받을 때 사용한다.
  • OutputStream: 클라이언트에서 서버에 데이터를 전달할 때 사용한다.
  • InputStream, OutputStream을 그대로 사용하면 모든 데이터를 byte로 변환해서 전달해야 하기 때문에 번거롭다. 여기서는 DataInputStream, DataOutputStream이라는 보조 스트림을 사용해서, 자바 타입의 메시지를 편리하게 주고 받을 수 있도록 했다.

// 서버에게 문자 보내기 
String toSend = "Hello";
output.writeUTF(toSend);

• OutputStream을 통해 서버에 "Hello" 메시지를 전송한다.

// 서버로부터 문자 받기
String received = input.readUTF();

• InputStream을 통해 서버가 전달한 메시지를 받을 수 있다.
• 클라이언트가 "Hello"를 전송하면 서버는 " World!"라는 문자를 붙여서 반환하므로 "Hello World!"라는 문자를 반환받는다.

사용한 자원은 반드시 정리해야 한다.

// 자원 정리
log("연결 종료: " + socket);
input.close(); 
output.close(); 
socket.close();

사용이 끝나면 사용한 자원은 반드시 반납해야 한다. 지금은 간단하고 허술하게 자원 정리를 했지만, 뒤에서 자원 정리를 매우 자세히 다루겠다.

 

서버 코드 분석

서버 소켓

서버는 특정 포트를 열어두어야 한다. 그래야 클라이언트가 해당 포트를 지정해서 접속할 수 있다.

ServerSocket serverSocket = new ServerSocket(PORT);

• 서버는 서버 소켓(ServerSocket)이라는 특별한 소켓을 사용한다.
• 지정한 포트를 사용해서 서버 소켓을 생성하면, 클라이언트는 해당 포트로 서버에 연결할 수 있다.

 

클라이언트와 서버의 연결 과정을 그림으로 자세히 알아보자.

• 서버가 12345 포트로 서버 소켓을 열어둔다. 클라이언트는 이제 12345 포트로 서버에 접속할 수 있다.
• 클라이언트가 12345 포트에 연결을 시도한다.
• 이때 OS 계층에서 TCP 3 way handshake가 발생하고, TCP 연결이 완료된다.
• TCP 연결이 완료되면 서버는 OS backlog queue라는 곳에 클라이언트와 서버의 TCP 연결 정보를 보관한다.
  • 이 연결 정보를 보면 클라이언트의 IP, PORT 서버의 IP, PORT 정보가 모두 들어있다.

클라이언트와 랜덤 포트

TCP 연결시에는 클라이언트, 서버 모두 IP와 PORT 정보가 필요하다. 예제에서 사용된 IP 포트는 다음과 같다.

• 클라이언트 → localhost(127.0.0.1), 50000(랜덤 생성)
• 서버 → localhost(127.0.0.1), 12345

그런데 생각해보면, 클라이언트는 자신의 포트를 지정한 적이 없다. 서버의 경우 포트가 명확하게 지정되어 있어야 한다. 그래야 클라이언트에서 서버에 어떤 포트에 접속할지 알 수 있다. 반면에 서버에 접속하는 클라이언트의 경우에는 자신의 포트가 명확하게 지정되어 있지 않아도 된다. 클라이언트는 보통 포트를 생략하는데, 생략할 경우 클라이언트 PC에 남아있는 포트 중 하나가 랜덤으로 할당된다. 참고로 클라이언트의 포트도 명시적으로 할당할 수 있지만, 잘 사용하지 않는다.

 

accept() 

Socket socket = serverSocket.accept();

• 서버 소켓은 단지 클라이언트와 서버의 TCP 연결만 지원하는 특별한 소켓이다.
• 실제 클라이언트와 서버가 정보를 주고 받으려면 Socket 객체가 필요하다. (서버 소켓이 아니다! 소켓이다!)
• serverSocket.accept() 메서드를 호출하면 TCP 연결 정보를 기반으로, Socket 객체를 만들어서 반환한다.

accept() 호출 과정을 그림으로 자세히 알아보자.

• accept()를 호출하면 backlog queue에서 TCP 연결 정보를 조회한다.
  • 만약, TCP 연결 정보가 없다면, 연결 정보가 생성될 때까지 대기한다. (블로킹)
• 해당 정보를 기반으로 Socket 객체를 생성한다.
• 사용한 TCP 연결 정보는 backlog queue에서 제거된다.

Socket 생성 후 그림

• 클라이언트와 서버의 Socket은 TCP로 연결되어 있고, 스트림을 통해 메시지를 주고 받을 수 있다.

DataInputStream input = new DataInputStream(socket.getInputStream());
DataOutputStream output = new DataOutputStream(socket.getOutputStream());

• Socket은 클라이언트와 서버가 데이터를 주고 받기 위한 스트림을 제공한다.
• InputStream: 서버 입장에서 보면 클라이언트가 전달한 데이터를 서버가 받을 때 사용한다.
• OutputStream: 서버에서 클라이언트에 데이터를 전달할 때 사용된다.

// 클라이언트로부터 문자 받기
String received = input.readUTF();

• 클라이언트가 전달한 "Hello" 메시지를 전달 받는다.

// 클라이언트에게 문자 보내기
String toSend = received + " World!";
output.writeUTF(toSend);

• 클라이언트의 메시지에 " World!" 메시지를 붙여서 반환한다.
• OutputStream을 통해 서버에서 클라이언트로 메시지를 전송한다.

// 자원 정리
log("연결 종료: " + socket);
input.close(); 
output.close();
socket.close();
serverSocket.close();

• 필요한 자원을 사용하고 나면, 꼭! 정리해야 한다.

 

문제

이 프로그램은 메시지를 하나만 주고 받으면 클라이언트와 서버가 모두 종료된다. 메시지를 계속 주고 받고, 원할 때 종료할 수 있도록 변경해보자.

 

네트워크 프로그램 2

이번엔 클라이언트와 서버가 메시지를 계속 주고 받다가, "exit" 라고 입력하면 클라이언트와 서버를 종료해보자.

 

ClientV2

package cwchoiit.network.tcp.v2;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.util.Scanner;

import static cwchoiit.util.MyLogger.log;

public class ClientV2 {

    private static final int PORT = 12345;

    public static void main(String[] args) throws IOException {
        Scanner scanner = new Scanner(System.in);
        log("클라이언트 시작");

        Socket socket = new Socket("localhost", PORT);

        DataInputStream input = new DataInputStream(socket.getInputStream());
        DataOutputStream output = new DataOutputStream(socket.getOutputStream());
        log("소켓 연결: " + socket);

        while (true) {
            System.out.print("서버에게 보낼 문자를 입력하세요:");
            String message = scanner.nextLine();

            output.writeUTF(message);
            log("client -> server: " + message);

            if ("exit".equalsIgnoreCase(message)) {
                break;
            }

            // 서버로부터 문자 받기
            String received = input.readUTF();
            log("client <- server: " + received);
        }

        // 자원 정리
        log("연결 종료: " + socket);
        input.close();
        output.close();
        socket.close();
    }
}

• 클라이언트와 서버가 메시지를 주고 받는 부분만 while로 반복하면 된다.
• exit를 입력하면 클라이언트는 exit 메시지를 서버에 전송하고, 클라이언트는 while 문을 빠져나가면서 연결을 종료한다.

ServerV2

package cwchoiit.network.tcp.v2;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Arrays;
import java.util.Scanner;

import static cwchoiit.util.MyLogger.log;

public class ServerV2 {

    private static final int PORT = 12345;

    public static void main(String[] args) throws IOException {
        log("서버 시작");

        ServerSocket serverSocket = new ServerSocket(PORT);
        log("서버 소켓 시작 - 리스닝 포트: " + PORT);

        Socket socket = serverSocket.accept();
        log("소켓 연결: " + socket);

        DataInputStream input = new DataInputStream(socket.getInputStream());
        DataOutputStream output = new DataOutputStream(socket.getOutputStream());

        while (true) {
            // 클라이언트로부터 문자 받기
            String received = input.readUTF();
            log("client -> server: " + received);

            if (received.equalsIgnoreCase("exit")) {
                break;
            }

            String toSend = received + " World!";
            output.writeUTF(toSend);
            log("client <- server: " + toSend);
        }

        // 자원 정리
        log("연결 종료: " + socket);
        input.close();
        output.close();
        socket.close();
        serverSocket.close();
    }
}

• 클라이언트와 서버가 메시지를 주고 받는 부분만 while로 반복하면 된다.
• 클라이언트로부터 exit 메시지가 전송되면, 서버는 while문을 빠져나가면서 연결을 종료한다.

실행 결과 - 클라이언트

16:03:41.259 [     main] 클라이언트 시작
16:03:41.275 [     main] 소켓 연결: Socket[addr=localhost/127.0.0.1,port=12345,localport=60687]
서버에게 보낼 문자를 입력하세요:hello
16:03:49.077 [     main] client -> server: hello
16:03:49.081 [     main] client <- server: hello World!
서버에게 보낼 문자를 입력하세요:hi
16:03:53.077 [     main] client -> server: hi
16:03:53.078 [     main] client <- server: hi World!
서버에게 보낼 문자를 입력하세요:exit
16:04:03.087 [     main] client -> server: exit
16:04:03.089 [     main] 연결 종료: Socket[addr=localhost/127.0.0.1,port=12345,localport=60687]

 

실행 결과 - 서버

16:03:34.700 [     main] 서버 시작
16:03:34.712 [     main] 서버 소켓 시작 - 리스닝 포트: 12345
16:03:41.275 [     main] 소켓 연결: Socket[addr=/127.0.0.1,port=60687,localport=12345]
16:03:49.077 [     main] client -> server: hello
16:03:49.080 [     main] client <- server: hello World!
16:03:53.077 [     main] client -> server: hi
16:03:53.078 [     main] client <- server: hi World!
16:04:03.088 [     main] client -> server: exit
16:04:03.089 [     main] 연결 종료: Socket[addr=/127.0.0.1,port=60687,localport=12345]

 

덕분에 클라이언트와 서버가 필요할 때까지 계속 매시지를 주고 받을 수 있다.

 

문제

서버는 하나의 클라이언트가 아니라, 여러 클라이언트의 연결을 처리할 수 있어야 한다. 여러 클라이언트가 하나의 서버에 접속하도록 해보자.

 

참고로, IntelliJ에서 같은 클라이언트를 동시에 실행하려면 다음과 같이 하면 된다.

• Edit Configurations... 선택

• Copy Configuration 클릭

• 새로 만든 ClientV2의 Configuration을 저장한다.

• 새로 만든 Configuration을 실행한다.

 

그렇게 실행하면 여러 클라이언트를 실행할 수 있다. 그런데 다음과 같이 정상적으로 수행되지 않는다.

16:12:03.789 [     main] 클라이언트 시작
16:12:03.804 [     main] 소켓 연결: Socket[addr=localhost/127.0.0.1,port=12345,localport=61271]
서버에게 보낼 문자를 입력하세요:hello
16:13:20.652 [     main] client -> server: hello

 

• 처음 접속한 클라이언트는 문제 없이 작동하는데, 두번째부터 새로 연결한 클라이언트는 소켓 연결과 보내는 것만 될 뿐, 돌아오지 않고 있다. 왜 이런 문제가 발생할까?

 

네트워크 프로그램 2 - 문제 분석

서버 소켓과 연결을 더 자세히 알아보자. 이번에는 여러 클라이언트가 서버에 접속한다고 가정해보자.

• 서버는 12345 서버 소켓을 열어둔다.
• 50000번 랜덤 포트를 사용하는 클라이언트가 먼저 12345 포트의 서버에 접속을 시도한다.
• 이때, OS 계층에서 TCP 3 handshake가 발생하고, TCP 연결이 완료된다.
• TCP 연결이 완료되면, 서버는 OS backlog queue라는 곳에 클라이언트와 서버의 TCP 연결 정보를 보관한다.

여기서 중요한 점이 있는데, 이 시점에 TCP 3 handshake가 완료되었기 때문에, 클라이언트와 서버의 TCP 연결은 이미 완료되고, 클라이언트의 소켓 객체도 정상 생성된다. 참고로 이 시점에 아직 서버의 소켓 객체(서버 소켓 아님)는 생성되지 않았다.

 

• 이번에는 60000번 랜덤 포트를 사용하는 클라이언트가 12345 포트의 서버에 접속을 시도하고 연결을 완료한다.
• 50000번 클라이언트와 60000번 클라이언트 모두 서버와 연결이 완료되었고, 클라이언트의 소켓도 정상 생성된다.

• 서버가 클라이언트와 데이터를 주고 받으려면 소켓을 획득해야 한다.
• ServerSocket.accept() 메서드를 호출하면 backlog 큐의 정보를 기반으로 소켓 객체를 하나 생성한다.
• 큐이므로 순서대로 데이터를 꺼낸다. 처음 50000번 클라이언트의 접속 정보를 기반으로 서버에 소켓이 하나 생성된다.
• 50000번 클라이언트와 서버는 소켓의 스트림을 통해 서로 데이터를 주고 받을 수 있다.

• 그림에서 60000번 클라이언트도 이미 서버와 TCP 연결은 되어 있다. OS 계층에서 TCP 3 handshake가 발생하고, TCP 연결이 완료되었다.
• 60000번 클라이언트도 서버와 TCP 연결이 되었기 때문에 서버로 메시지를 보낼 수 있다. 아직 서버에 Socket 객체가 없더라도, 메시지는 보낼 수 있다. 클라이언트는 Socket이 만들어진 상태고 TCP 연결은 이미 완료가 된 상태이니까.

그림을 보자. 소켓을 통해 스트림으로 메시지를 주고 받는다는 것은 이러한 과정을 거친다. 자바 애플리케이션은 소켓 객체의 스트림을 통해 서버와 데이터를 주고 받는다. 데이터를 주고 받는 과정은 다음과 같다.

클라이언트가 "Hello"라는 메시지를 서버에 전송할 때

• 클라이언트: 애플리케이션 → OS TCP 송신 버퍼 → 클라이언트 네트워크 카드

클라이언트가 보낸 메시지가 서버에 도착했을 때

• 서버: 서버 네트워크 카드 → OS TCP 수신 버퍼 → 애플리케이션

여기서, 60000번 클라이언트가 보낸 메시지는 서버 애플리케이션에서 아직 읽지 않았기 때문에, 서버 OS의 TCP 수신 버퍼에서 대기하게 된다. 여기서 핵심적인 내용이 있는데, 소켓 객체 없이 서버 소켓만으로도 TCP 연결은 완료된다는 점이다. (서버 소켓은 연결만 담당한다) 하지만 연결 이후에 서로 메시지를 주고 받으려면 소켓 객체가 필요하다.

 

accept()는 이미 연결된 TCP 연결 정보를 기반으로 서버 측에 소켓 객체를 생성한다. 그리고 이 소켓 객체가 있어야 스트림을 사용해서 메시지를 주고 받을 수 있다.

• 이렇게 소켓을 연결하면 소켓의 스트림을 통해 OS TCP 수신 버퍼에 있는 메시지를 읽을 수 있고, 또 전송할 수도 있다.

• 정상적으로 여러 클라이언트를 처리할 수 있는 서버라면, 이렇게 50000번, 60000번 클라이언트와 통신할 소켓 객체를 각각 만들어 통신할 수 있는 환경이 되면 다시 accept() 메서드가 블로킹 상태로 계속 대기해야 한다. 그래야 다음 클라이언트가 접속 시도를 할 때 정상적으로 소켓 객체를 만들 수 있으니까. 

그럼 지금 겪고 있는 문제의 원인은 이렇다.

• 새로운 클라이언트가 접속하면?
  • 새로운 클라이언트가 접속했을 때, 서버의 main 스레드는 aceept() 메서드를 절대로 호출할 수 없다! 왜냐하면 while 문으로 기존 클라이언트와 메시지를 주고 받는 부분만 반복하기 때문이다.
  • accept()를 호출해야 소켓 객체를 생성하고 새로운 클라이언트와 메시지를 주고 받을 수 있다.
• 2개의 블로킹 작업 - 핵심은 별도의 스레드가 필요하다!
  • accept() → 클라이언트와 서버의 연결을 처리하기 위해 대기
  • readUTF() 등 readXxx() → 클라이언트의 메시지를 받아서 처리하기 위해 대기
• 각각의 블로킹 작업은 별도의 스레드에서 처리해야 한다. 그렇지 않으면 다른 블로킹 메서드 때문에 계속 대기할 수 있다.

즉, 지금 서버의 코드는 다음과 같이 두 부분이 블로킹 메서드이다.

ServerSocket serverSocket = new ServerSocket(PORT);
Socket socket = serverSocket.accept(); // 블로킹

while(true) {
    ...
    String received = input.readUTF(); // 블로킹
    output.writeUTF(toSend);
}

 

네트워크 프로그램 3

이번엔 위 문제를 해결하고자, 클라이언트가 동시에 접속할 수 있는 서버 프로그램을 작성해보자.

• 서버의 main 스레드는 서버 소켓을 생성하고, 서버 소켓의 accept()를 반복해서 호출해야 한다.

• 클라이언트가 서버에 접속하면 서버 소켓의 accept() 메서드가 Socket을 반환한다.
• main 스레드는 이 정보를 기반으로 Runnable을 구현한 Session이라는 별도의 객체를 만들고, 새로운 스레드에서 이 객체를 실행한다. 여기서는 Thread-0이 Session을 실행한다.
• Session 객체와 Thread-0은 연결된 클라이언트와 메시지를 주고 받는다.

• 새로운 TCP 연결이 발생하면 main 스레드는 새로운 Session 객체를 별도의 스레드에서 실행한다. 그리고 이 과정을 반복한다. 
• Session 객체와 Thread-1은 연결된 클라이언트와 메시지를 주고 받는다.

역할의 분리

• main 스레드
  • main 스레드는 새로운 연결이 있을때마다 Session 객체와 별도의 스레드를 생성하고, 별도의 스레드가 Session 객체를 실행하도록 한다.
• Session 담당 스레드
  • Session을 담당하는 스레드는 자신의 소켓이 연결된 클라이언트와 메시지를 반복해서 주고 받는 역할을 담당한다.

 

ClientV3

package cwchoiit.network.tcp.v3;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.util.Scanner;

import static cwchoiit.util.MyLogger.log;

public class ClientV3 {

    private static final int PORT = 12345;

    public static void main(String[] args) throws IOException {
        Scanner scanner = new Scanner(System.in);
        log("클라이언트 시작");

        Socket socket = new Socket("localhost", PORT);

        DataInputStream input = new DataInputStream(socket.getInputStream());
        DataOutputStream output = new DataOutputStream(socket.getOutputStream());
        log("소켓 연결: " + socket);

        while (true) {
            System.out.print("서버에게 보낼 문자를 입력하세요:");
            String message = scanner.nextLine();

            output.writeUTF(message);
            log("client -> server: " + message);

            if ("exit".equalsIgnoreCase(message)) {
                break;
            }

            // 서버로부터 문자 받기
            String received = input.readUTF();
            log("client <- server: " + received);
        }

        // 자원 정리
        log("연결 종료: " + socket);
        input.close();
        output.close();
        socket.close();
    }
}

• 클라이언트 코드는 기존 코드와 완전히 같다. 클래스 이름만 ClientV2 → ClientV3로 변경했다.

SessionV3

package cwchoiit.network.tcp.v3;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;

import static cwchoiit.util.MyLogger.log;

public class SessionV3 implements Runnable {

    private final Socket socket;

    public SessionV3(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            DataInputStream input = new DataInputStream(socket.getInputStream());
            DataOutputStream output = new DataOutputStream(socket.getOutputStream());

            while (true) {
                // 클라이언트로부터 문자 받기
                String received = input.readUTF();
                log("client -> server: " + received);

                if (received.equalsIgnoreCase("exit")) {
                    break;
                }

                String toSend = received + " World!";
                output.writeUTF(toSend);
                log("client <- server: " + toSend);
            }

            input.close();
            output.close();
            socket.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

• Session의 목적은 소켓이 연결된 클라이언트와 메시지를 반복해서 주고받는 것이다.
• 생성자를 통해 Socket 객체를 입력 받는다.
• Runnable을 구현해서 별도의 스레드에서 실행한다.

ServerV3

package cwchoiit.network.tcp.v3;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

import static cwchoiit.util.MyLogger.log;

public class ServerV3 {

    private static final int PORT = 12345;

    public static void main(String[] args) throws IOException {
        log("서버 시작");

        ServerSocket serverSocket = new ServerSocket(PORT);
        log("서버 소켓 시작 - 리스닝 포트: " + PORT);

        while (true) {
            Socket socket = serverSocket.accept();

            SessionV3 session = new SessionV3(socket);
            Thread thread = new Thread(session);
            thread.start();
        }
    }
}

• main 코드는 main 스레드가 작동하는 부분이다.
• main 스레드는 서버 소켓을 생성하고, serverSocket.accept()를 호출해서 연결을 대기한다.
• 새로운 연결이 추가될 때마다 Session 객체를 생성하고 별도의 스레드에서 Session 객체를 실행한다.
• 이 과정을 반복한다.

실행결과 - ClientV3

17:59:18.232 [     main] 클라이언트 시작
17:59:18.248 [     main] 소켓 연결: Socket[addr=localhost/127.0.0.1,port=12345,localport=65101]
서버에게 보낼 문자를 입력하세요:17:59:25.057 [     main] client -> server: hello
17:59:25.067 [     main] client <- server: hello World!
서버에게 보낼 문자를 입력하세요:

 

실행 결과 - ClientV3-2

17:59:34.482 [     main] 클라이언트 시작
17:59:34.498 [     main] 소켓 연결: Socket[addr=localhost/127.0.0.1,port=12345,localport=65103]
서버에게 보낼 문자를 입력하세요:17:59:39.294 [     main] client -> server: hoho
17:59:39.295 [     main] client <- server: hoho World!
서버에게 보낼 문자를 입력하세요:

 

실행 결과 - ServerV3

17:59:14.130 [     main] 서버 시작
17:59:14.143 [     main] 서버 소켓 시작 - 리스닝 포트: 12345
17:59:25.063 [ Thread-0] client -> server: hello
17:59:25.067 [ Thread-0] client <- server: hello World!
17:59:39.294 [ Thread-1] client -> server: hoho
17:59:39.294 [ Thread-1] client <- server: hoho World!

 

이제 여러 서버가 접속해도 문제없이 작동하는 것을 볼 수 있다. 그리고 각각의 연결이 별도의 스레드에서 처리되는 것도 확인할 수 있다. 

서버 소켓을 통해 소켓을 연결하는 부분과 각 클라이언트와 메시지를 주고 받는 부분이 별도의 스레드로 나뉘어 있다. 블로킹 되는 부분은 이렇게 별도의 스레드로 나누어 실행해야 한다.

 

문제

여기서 실행 중인 클라이언트를 IntelliJ의 빨간색 Stop 버튼을 눌러서 직접 종료해보자.

 

 

클라이언트를 직접 종료한 경우 서버 로그

Exception in thread "Thread-0" java.lang.RuntimeException: java.io.EOFException
	at cwchoiit.network.tcp.v3.SessionV3.run(SessionV3.java:42)
	at java.base/java.lang.Thread.run(Thread.java:857)
Caused by: java.io.EOFException
	at java.base/java.io.DataInputStream.readUnsignedShort(DataInputStream.java:337)
	at java.base/java.io.DataInputStream.readUTF(DataInputStream.java:583)
Caused by: java.io.EOFException

	at java.base/java.io.DataInputStream.readUTF(DataInputStream.java:558)
	at cwchoiit.network.tcp.v3.SessionV3.run(SessionV3.java:26)
	... 1 more

다음과 같이 에러가 발생했다. 에러가 어디서 발생했을까? 항상 에러 로그는 가장 아래서부터 봐야한다.

 

클라이언트의 연결을 직접 종료하면, 클라이언트 프로세스가 종료되면서, 클라이언트와 서버의 TCP 연결도 함께 종료된다. 이때 서버에서 readUTF()로 클라이언트가 보낸 메시지를 읽으려고 하면 EOFException이 발생한다. 소켓의 TCP 연결이 종료되었기 때문에 더는 읽을 수 있는 메시지가 없다는 뜻이다. EOF(파일의 끝)가 여기서는 전송의 끝이라는 뜻이다. 그런데 여기서 심각한 문제가 하나 있다. 이렇게 예외가 발생해버리면, 서버에서 자원 정리 코드를 호출하지 못한다는 점이다. 서버 로그를 보면 연결 종료 로그가 없는 것을 확인할 수 있다. 

 

// 자원 정리
input.close();
output.close();
socket.close();

자바 객체는 GC가 되지만, 자바 외부의 자원은 자동으로 GC가 되는게 아니다. 따라서, 꼭! 정리를 해주어야 한다. (TCP 연결의 경우 운영체제가 어느정도 연결을 정리해주지만, 직접 연결을 종료할 때보다 더 많은 시간이 걸릴 수 있다) 결론은, 이 자원 정리 코드가 예외가 발생하면서 catch 구문으로 빠져버리니 자원 정리 코드를 호출하지 못하게 된다는 점이다.

 

자원 정리는 정말 반드시 중요하게 짚고 넘어가야 하는 부분이다. 서버는 한번 키고 끄는 일회성이 아니라, 항시 켜져있어야 한다. 따라서 사용하지 않는 자원은 반드시 정리해야 한다. 그래서 이제부터 자원 정리에 대해 알아보는 시간을 가져보자.

 

 

자원 정리1

자원 정리를 이해하기 위해 간단한 예제 코드를 만들어보자.

 

CallException

package cwchoiit.network.tcp.autocloseable;

public class CallException extends Exception {
    public CallException(String message) {
        super(message);
    }
}

 

CloseException

package cwchoiit.network.tcp.autocloseable;

public class CloseException extends Exception {

    public CloseException(String message) {
        super(message);
    }
}

 

ResourceV1

package cwchoiit.network.tcp.autocloseable;

public class ResourceV1 {
    private String name;

    public ResourceV1(String name) {
        this.name = name;
    }

    public void call() {
        System.out.println(name + " call");
    }

    public void callEx() throws CallException {
        System.out.println(name + " callEx");
        throw new CallException(name + " ex");
    }

    public void close() {
        System.out.println(name + " close");
    }

    public void closeEx() throws CloseException {
        System.out.println(name + " closeEx");
        throw new CloseException(name + " ex");
    }
}

• call(): 정상 로직 호출
• callEx(): 비정상 로직 호출 CallException을 던진다.
• close(): 정상 종료
• closeEx(): 비정상 종료, CloseException을 던진다.

 

ResourceCloseMainV1

package cwchoiit.network.tcp.autocloseable;

public class ResourceCloseMainV1 {
    public static void main(String[] args) {
        try {
            logic();
        } catch (CallException e) {
            System.out.println("Call Exception 예외 처리");
            throw new RuntimeException(e);
        } catch (CloseException e) {
            System.out.println("Close Exception 예외 처리");
            throw new RuntimeException(e);
        }
    }

    private static void logic() throws CallException, CloseException {
        ResourceV1 resource1 = new ResourceV1("resource1");
        ResourceV1 resource2 = new ResourceV1("resource2");

        resource1.call();
        resource2.callEx();

        System.out.println("자원 정리");
        resource2.closeEx();
        resource1.close();
    }
}

• 서로 관련된 자원은 나중에 생성한 자원을 먼저 정리해야 한다.
• 예를 들어서, resource1을 생성하고, resource1의 정보를 활용해서 resource2를 생성한다면, 닫을 때는 그 반대인 resource2를 먼저 닫고, 그 다음에 resource1을 닫아야 한다. 왜냐하면 resource2의 입장에서 resource1의 정보를 아직 참고하고 있기 때문이다.
• 이 예제에서는 두 자원이 서로 연관이 없기 때문에 생성과 종료 순서가 크게 상관이 없지만, resource1의 정보를 기반으로, resource2를 생성한다고 가정하겠다.

실행 결과

resource1 call
resource2 callEx
Call Exception 예외 처리
Exception in thread "main" java.lang.RuntimeException: cwchoiit.network.tcp.autocloseable.CallException: resource2 ex
	at cwchoiit.network.tcp.autocloseable.ResourceCloseMainV1.main(ResourceCloseMainV1.java:9)
Caused by: cwchoiit.network.tcp.autocloseable.CallException: resource2 ex
	at cwchoiit.network.tcp.autocloseable.ResourceV1.callEx(ResourceV1.java:16)
	at cwchoiit.network.tcp.autocloseable.ResourceCloseMainV1.logic(ResourceCloseMainV1.java:21)
Caused by: cwchoiit.network.tcp.autocloseable.CallException: resource2 ex

	at cwchoiit.network.tcp.autocloseable.ResourceCloseMainV1.main(ResourceCloseMainV1.java:6)

• callEx()를 호출하면서 예외가 발생했다. 예외 때문에 자원 정리 코드가 정상 호출되지 않았다. 이 코드는 예외가 발생하면 자원이 정리되지 않는다는 문제가 있다.

 

자원 정리2

이번에는 예외가 발생해도 자원을 정리하도록 해보자.

 

ResourceCloseMainV2

package cwchoiit.network.tcp.autocloseable;

public class ResourceCloseMainV2 {
    public static void main(String[] args) {
        try {
            logic();
        } catch (CallException e) {
            System.out.println("Call Exception 예외 처리");
            throw new RuntimeException(e);
        } catch (CloseException e) {
            System.out.println("Close Exception 예외 처리");
            throw new RuntimeException(e);
        }
    }

    private static void logic() throws CallException, CloseException {

        ResourceV1 resource1 = null;
        ResourceV1 resource2 = null;
        try {
            resource1 = new ResourceV1("resource1");
            resource2 = new ResourceV1("resource2");

            resource1.call();
            resource2.callEx();
        } catch (CallException e) {
            System.out.println("ex " + e);
            throw e;
        } finally {
            System.out.println("자원 정리");
            if (resource2 != null) {
                resource2.closeEx();
            }
            if (resource1 != null) {
                resource1.close();
            }
        }
    }
}

 

실행 결과

resource1 call
resource2 callEx
ex cwchoiit.network.tcp.autocloseable.CallException: resource2 ex
자원 정리
resource2 closeEx
Close Exception 예외 처리
Exception in thread "main" java.lang.RuntimeException: cwchoiit.network.tcp.autocloseable.CloseException: resource2 ex
	at cwchoiit.network.tcp.autocloseable.ResourceCloseMainV2.main(ResourceCloseMainV2.java:12)
Caused by: cwchoiit.network.tcp.autocloseable.CloseException: resource2 ex
	at cwchoiit.network.tcp.autocloseable.ResourceV1.closeEx(ResourceV1.java:25)
Caused by: cwchoiit.network.tcp.autocloseable.CloseException: resource2 ex

	at cwchoiit.network.tcp.autocloseable.ResourceCloseMainV2.logic(ResourceCloseMainV2.java:32)
	at cwchoiit.network.tcp.autocloseable.ResourceCloseMainV2.main(ResourceCloseMainV2.java:6)

 

이 코드는 비즈니스 로직에서 예외가 발생했을 때도 자원을 잘 정리하는 것 같지만(그렇지도 않지만) 다음과 같은 문제들이 있다.

• null 체크
  • 이번에는 finally 코드 블록을 사용해서 자원을 닫는 코드가 항상 호출되도록 했다. 만약, resource2 객체를 생성하기 전에 예외가 발생하면 resource2는 null이 된다. 따라서 null 체크를 해야한다. resource1의 경우에도 resource1을 생성하는 중에 예외가 발생한다면 null 체크가 필요하다.
• 자원 정리 중에 예외가 발생하는 문제
  • finally 코드 블록은 항상 호출되기 때문에 자원이 잘 정리되는 것 같지만, 이번에는 자원을 정리하는 중에 finally 코드 블록 안에서 resource2.closeEx()를 호출하면서 예외가 발생한다. 결과적으로 resource1.close()는 호출되지 않는다.
• 핵심 예외가 바뀌는 문제
  • 이 코드에서 발생한 핵심적인 예외는 CallException이다. 이 예외 때문에 문제가 된 것이다. 그런데 finally 코드 블록에서 자원을 정리하면서 CloseException 예외가 추가로 발생했다. 예외 때문에 자원을 정리하고 있는데, 자원 정리중에 또 예외가 발생한 것이다. 이 경우 logic()을 호출하는 쪽에서는 핵심 예외인 CallException이 아니라 finally 블록에서 새로 생성된 CloseException을 받게 된다. 핵심 예외가 사라진 것이다! 개발자가 원하는 예외는 당연히 핵심 예외다. 이 핵심 예외를 확인해야 제대로 된 문제를 찾을 수 있다. 자원을 닫는 중에 발생한 예외는 부가 예외일 뿐이다. 

정리하면 이 코드는 다음과 같은 문제가 있다.

• close() 시점에서 실수로 예외를 던지면, 이후 다른 자원을 닫을 수 없는 문제 발생
• finally 블럭 안에서 자원을 닫을 때 예외가 발생하면, 핵심 예외가 finally에서 발생한 부가 예외로 바뀌어 버린다. 그리고 핵심 예외가 사라진다.

 

자원 정리3

이번에는 자원 정리의 코드에서 try-catch를 사용해서 자원 정리 중에 발생하는 예외를 잡아서 처리해보자.

package cwchoiit.network.tcp.autocloseable;

public class ResourceCloseMainV3 {
    public static void main(String[] args) {
        try {
            logic();
        } catch (CallException e) {
            System.out.println("Call Exception 예외 처리");
            throw new RuntimeException(e);
        } catch (CloseException e) {
            System.out.println("Close Exception 예외 처리");
            throw new RuntimeException(e);
        }
    }

    private static void logic() throws CallException, CloseException {

        ResourceV1 resource1 = null;
        ResourceV1 resource2 = null;
        try {
            resource1 = new ResourceV1("resource1");
            resource2 = new ResourceV1("resource2");

            resource1.call();
            resource2.callEx();
        } catch (CallException e) {
            System.out.println("ex " + e);
            throw e;
        } finally {
            System.out.println("자원 정리");
            if (resource2 != null) {
                try {
                    resource2.closeEx();
                } catch (CloseException e) {
                    // close()에서 발생한 예외는 버린다. 필요하면 로깅 정도
                    System.out.println("close ex: " + e);
                }
            }
            if (resource1 != null) {
                try {
                    resource1.closeEx();
                } catch (CloseException e) {
                    System.out.println("close ex2: " + e);
                }
            }
        }
    }
}

• finally 블럭에서 각각의 자원을 닫을 때도, 예외가 발생하면 예외를 잡아서 처리하도록 했다.
• 이렇게 하면 자원 정리 시점에 예외가 발생해도, 다음 자원을 닫을 수 있다.
• 자원 정리 시점에 발생한 예외는 잡아서 처리했기 때문에, 자원 정리 시점에 발생한 부가 예외가 핵심 예외를 가리지 않는다.
• 자원 정리 시점에 발생한 예외는 당장 더 처리할 수 있는 부분이 없다. 이 경우 로그를 남겨서 개발자가 인지할 수 있게 하는 정도면 충분하다. 

실행 결과

resource1 call
resource2 callEx
ex cwchoiit.network.tcp.autocloseable.CallException: resource2 ex
자원 정리
resource2 closeEx
close ex: cwchoiit.network.tcp.autocloseable.CloseException: resource2 ex
resource1 closeEx
close ex2: cwchoiit.network.tcp.autocloseable.CloseException: resource1 ex
Call Exception 예외 처리
Exception in thread "main" java.lang.RuntimeException: cwchoiit.network.tcp.autocloseable.CallException: resource2 ex
	at cwchoiit.network.tcp.autocloseable.ResourceCloseMainV3.main(ResourceCloseMainV3.java:9)
Caused by: cwchoiit.network.tcp.autocloseable.CallException: resource2 ex
	at cwchoiit.network.tcp.autocloseable.ResourceV1.callEx(ResourceV1.java:16)
	at cwchoiit.network.tcp.autocloseable.ResourceCloseMainV3.logic(ResourceCloseMainV3.java:25)
Caused by: cwchoiit.network.tcp.autocloseable.CallException: resource2 ex

	at cwchoiit.network.tcp.autocloseable.ResourceCloseMainV3.main(ResourceCloseMainV3.java:6)

이전에 발생했던 2가지 문제를 해결했다.

• close() 시점에 예외가 발생하면, 이후 다른 자원을 닫을 수 없는 문제 발생
• finally 블럭 안에서 자원을 닫을 때 예외가 발생하면, 핵심 예외가 finally에서 발생한 부가 예외로 바뀌어 버린다. 그리고 핵심 예외가 사라지는 현상

 

핵심적인 문제들은 해결되었지만, 코드 부분에서 보면 아쉬운 부분이 많다.

• resource 변수를 선언하면서 동시에 할당할 수 없음(try, finally 코드 블록과 변수 스코프가 다른 문제)
• catch 이후에 finally 호출, 자원 정리가 조금 늦어진다.
• 개발자가 실수로 close()를 호출하지 않을 가능성
• 개발자가 close() 호출 순서를 실수(보통 자원을 생성한 순서와 반대로 닫아야 하는데 순서를 실수할 경우)

지금까지 수많은 자바 개발자들이 자원 정리 때문에 고통을 받아왔다. 이런 문제를 한번에 해결하는 것이 바로 자바 중급1편에서 학습한 try-with-resource 구문이다.

 

자원 정리4

이 try-with-resource를 사용해서 자원 정리를 효율적으로 해보자.

 

ResourceV2

package cwchoiit.network.tcp.autocloseable;

public class ResourceV2 implements AutoCloseable {
    private final String name;

    public ResourceV2(String name) {
        this.name = name;
    }

    public void call() {
        System.out.println(name + " call");
    }

    public void callEx() throws CallException {
        System.out.println(name + " callEx");
        throw new CallException(name + " ex");
    }

    @Override
    public void close() throws CloseException {
        System.out.println(name + " close");
        throw new CloseException(name + " ex");
    }
}

• AutoCloseable을 구현했다.
• close()는 항상 CloseException을 던지도록 구현했다. (AutoCloseable을 구현한 객체가 close()가 호출될 때 예외가 발생하면 어떻게 행동하는지 알아보기 위함)

ResourceCloseMainV4

package cwchoiit.network.tcp.autocloseable;

public class ResourceCloseMainV4 {
    public static void main(String[] args) {
        try {
            logic();
        } catch (CallException e) {
            System.out.println("Call Exception 예외 처리");
            throw new RuntimeException(e);
        } catch (CloseException e) {
            System.out.println("Close Exception 예외 처리");
            throw new RuntimeException(e);
        }
    }

    private static void logic() throws CallException, CloseException {
        try (ResourceV2 resource1 = new ResourceV2("resource1");
             ResourceV2 resource2 = new ResourceV2("resource2")) {

            resource1.call();
            resource2.callEx();
        } catch (CallException e) {
            System.out.println("ex: " + e);
            throw e;
        }
    }
}

 

실행 결과

resource1 call
resource2 callEx
resource2 close
resource1 close
ex: cwchoiit.network.tcp.autocloseable.CallException: resource2 ex
Call Exception 예외 처리
Exception in thread "main" java.lang.RuntimeException: cwchoiit.network.tcp.autocloseable.CallException: resource2 ex
	at cwchoiit.network.tcp.autocloseable.ResourceCloseMainV4.main(ResourceCloseMainV4.java:9)
Caused by: cwchoiit.network.tcp.autocloseable.CallException: resource2 ex
	at cwchoiit.network.tcp.autocloseable.ResourceV2.callEx(ResourceV2.java:16)
	at cwchoiit.network.tcp.autocloseable.ResourceCloseMainV4.logic(ResourceCloseMainV4.java:21)
	at cwchoiit.network.tcp.autocloseable.ResourceCloseMainV4.main(ResourceCloseMainV4.java:6)
	Suppressed: cwchoiit.network.tcp.autocloseable.CloseException: resource2 ex
		at cwchoiit.network.tcp.autocloseable.ResourceV2.close(ResourceV2.java:22)
		at cwchoiit.network.tcp.autocloseable.ResourceCloseMainV4.logic(ResourceCloseMainV4.java:17)
		... 1 more
	Suppressed: cwchoiit.network.tcp.autocloseable.CloseException: resource1 ex
Caused by: cwchoiit.network.tcp.autocloseable.CallException: resource2 ex

		at cwchoiit.network.tcp.autocloseable.ResourceV2.close(ResourceV2.java:22)
		at cwchoiit.network.tcp.autocloseable.ResourceCloseMainV4.logic(ResourceCloseMainV4.java:17)
		... 1 more

• try-with-resource는 단순하게 close()를 자동 호출해준다는 정도의 기능만 제공하는 것이 아니다. 고민한 6가지 문제를 모두 해결하는 장치이다.

2가지 핵심 문제

• close() 시점에 예외가 던져지면, 이후 다른 자원을 닫을 수 없는 문제 발생
• finally 블록 안에서 자원을 닫을 때 예외가 발생하면, 핵심 예외가 finally에서 발생한 부가 예외로 바뀌어 버린다. 그리고 핵심 예외가 사라진다.

4가지 부가 문제

• resource 변수를 선언하면서 동시에 할당할 수 없음 (try, finally 코드 블록과 변수 스코프가 다른 문제)
• catch 이후에 finally 호출, 자원 정리가 조금 늦어진다.
• 개발자가 실수로 close()를 호출하지 않을 가능성
• 개발자가 close() 호출 순서를 실수 (보통 자원을 생성한 순서와 반대로 닫아야 한다)

 

try-with-resource의 장점

• 리소스 누수 방지: 모든 리소스가 제대로 닫히도록 보장한다. 실수로 finally 블록을 적지 않거나, finally 블록 안에서 자원 해제 코드를 누락하는 문제들을 예방할 수 있다.
• 코드 간결성 및 가독성 향상: 명시적인 close() 호출이 필요 없어, 코드가 더 간결하고 읽기 쉬워진다.
• 스코프 범위 한정: 예를 들어, 리소스로 사용되는 resource1, 2 변수의 스코프가 try 블록 안으로 한정된다. 따라서 코드 유지보수가 더 쉬워진다. 
• 조금 더 빠른 자원 해제: 기존에는 try → catch → finally로 catch 이후에 자원을 반납했다. try-with-resource 구문은 try 블럭이 끝나면 즉시 close()를 호출한다.
• 자원 정리 순서: 먼저 선언한 자원을 나중에 정리한다. 
• 부가 예외 포함: 이 내용은 무엇이냐면, 아까 ResourceV2 만들때, AutoCloseable을 구현하게 했고, close() 메서드를 오버라이딩했다. 그리고 그 메서드 안에서 예외를 던지도록 코드를 수정했었다. 그럼 try-with-resource 구문에서 자원이 해제될 때, 해당 예외가 발생할테니까 이 try-with-resource도 과연 핵심 예외가 부가 예외로 변경되어 밖으로 던져질지가 궁금했다. 근데 그게 아니라 정확히 핵심 예외가 밖으로 던져졌고, 자원을 해제하는 중에 터진 예외는 Suppressed로 추가된다. 아래 더 자세히 설명했다.

try-with-resources 예외 처리와 부가 예외 포함

try-with-resources를 사용하는 중에 핵심 로직 예외와 자원을 정리하는 중에 발생하는 부가 예외가 모두 발생하면 어떻게 될까?

• try-with-resources는 핵심 예외를 반환한다.
• 부가 예외는 핵심 예외안에 Suppressed로 담아서 반환한다.
• 개발자는 자원 정리 중에 발생한 부가 예외를 e.getSuppressed()를 통해 활용할 수 있다.
• try-with-resources를 사용하면 핵심 예외를 반환하면서, 동시에 부가 예외도 필요하면 확인할 수 있다. 

참고로 자바 예외는 e.addSuppressed(ex)라는 메서드가 있어서 예외 안에 참고할 예외를 담아둘 수 있다. 참고로 이 기능도 try-with-resources와 함께 등장했다.

 

 

다음 포스팅에서 계속...