#8 Java - 3 (쓰레드, IO, 네트워크)

# Thread

java.lang.Thread 클래스를 상속하여 멀티 쓰레드를 구현 할 수 있다.

public class Test extends Thread {
	// 다른 쓰레드로 실행할 코드
    public void run() {
        System.out.println("thread run.");
    }
	
    public static void main(String[] args) {
        Test test = new Test(); // 쓰레드 객체 생성
        test.start(); // 코드 실행
    }
}

모던 자바를 다루며 배우겠지만, Lambda를 이용하면 좀 더 깔끔하게 구현 할 수 있다.

public class RunnableLambdaExample {
 
  public static void main(String[] args) {
    Thread thread = new Thread(() -> {
      String threadName = Thread.currentThread().getName();
      System.out.println(threadName);
    });
    
    thread.setName("Thread #1");
    thread.start();
  }
}

개발을 하다보면 쓰레드가 종료된 후 처리해야하는 작업이 있을 수 있는데, Thread.join() 메서드를 이용하여 모든 쓰레드가 종료될 때 까지 기다리게 만들 수 있다.

public static void main(String[] args) {
    ArrayList<Thread> threads = new ArrayList<Thread>();
    for(int i=0; i<10; i++) {
        Thread t = new Test(i);
        t.start();
        threads.add(t);
    }
 
    for(int i=0; i<threads.size(); i++) {
        Thread t = threads.get(i);
        try {
            t.join();
        }catch(Exception e) {
        }
    }
    // 모든 쓰레드가 종료 된 후 end 출력
    System.out.println("main end.");
}

# Runnable

보통 실제 사용에서 있어 유연하게 프로그래밍하기 위해 Thread 클래스를 직접 상속해서 변경하기보단 아래와 같이 Runnable 인터페이스를 구현하고 이를 Thread 클래스의 생성자로 넘기는 방식으로 사용한다. 이렇게 함으로써 필요한 다른 클래스를 상속받고, Runnable를 구현하여 다중 상속 문제를 해결 할 수 있는 장점도 있다.

//class Test implements Runnable{}
Thread t = new Thread(new Test(i));

import java.util.ArrayList;
 
public class Test implements Runnable {
    int seq;
    public Test(int seq) {
        this.seq = seq;
    }
    public void run() {
        System.out.println(this.seq+" thread start.");
        try {
            Thread.sleep(1000);
        }catch(Exception e) {
        }
        System.out.println(this.seq+" thread end.");
    }
 
    public static void main(String[] args) {
        ArrayList<Thread> threads = new ArrayList<Thread>();
        for(int i=0; i<10; i++) {
            Thread t = new Thread(new Test(i));
            t.start();
            threads.add(t);
        }
 
        for(int i=0; i<threads.size(); i++) {
            Thread t = threads.get(i);
            try {
                t.join();
            }catch(Exception e) {
            }
        }
        System.out.println("main end.");
    }
}

# Console 입출력

자바의 콘솔 입출력 스트림을 제공한다. 기본적으로 System.out , System.in, System.err 스트림이 제공된다.

스트림이 뭐죠?

콘솔출력은 딱히 어려울 것이 없다. 그냥 System.out 안에 있는 출력 객체를 이용하면 된다.

System.out.println()
System.err.println() // err도 콘솔출력이지만, 에러를 출력할 때 사용하는 스트림이다.

콘솔 입력은 System in을 이용하여 입력 스트림을 받아 올 수 있다. 다만 System.in은 InputStream 객체로 반환하므로, 사용하기 위해서 java.io.InputStreamd을 import 해야 한다.

import java.io.InputStream;
 
public class StreamTest {
    public static void main(String[] args) throws Exception {
        InputStream in = System.in;
 
        int a;
        a = in.read(); // 콘솔입력 하나를 받아온다.
        
        byte[] buffer = new byte[3];
        in.read(buffer); // 콘솔입력들을 받아 buffer에 저장한다.
    }
}

이런식으로 받아온 입력값은 이진데이터 (숫자, byte)이므로 콘솔에 사용되는 문자열을 처리하기에는 불편하다. 그래서 문자열을 쉽게 받아오기 위해 java.io.InputStreamReader 같은 객체를 이용한다.

import java.io.InputStream;
import java.io.InputStreamReader;
 
public class StreamTest {
// 당연한거지만, 파일 객체는 예외를 던지므로 실제 사용시에는 예외처리를 해주어야한다.
    public static void main(String[] args) throws Exception {
        InputStreamReader reader = new InputStreamReader(System.in);
        
        // BufferedReader를 사용하면 따로 버퍼용 객체를 만들지 않아도 버퍼링된다.
        BufferedReader bufferReader = new BufferedReader(reader); 
        
        // InputStreamReader를 사용하는 방법
        char[] a = new char[3]; 
        reader.read(a);
 
	// BufferedReader를 사용하는 방법
        String a = bufferReader.readLine();
    }
}

• InputStream - byte
• InputStreamReader - character
• BufferedReader - String

# Scanner

콘솔 입력을 쉽게하기위해 J2SE 5.0부터 java.util.Scanner라는 새로운 객체가 추가되었다. 토큰 단위로 입력을 읽어들여 기존의 방식보다 쉽고 직관적이게 사용 할 수 있다.

import java.util.Scanner;
 
public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println(sc.next());
    }
}

# File 입출력

콘솔입출력에는 JVM에서 스트림(System.in, System.out)을 자동으로 생성해줘서 그냥 사용하면 되었지만, 파일 입출력을 위해서는 직접 스트림 객체를 생성해야 한다. java.io.FileOutputStream을 이용하여 출력할 수 있다.

import java.io.FileOutputStream;
import java.io.IOException;
 
public class FileWrite {
    public static void main(String[] args) throws IOException {
        // FileOutput스트림
        FileOutputStream output = new FileOutputStream("c:/out.txt");
        output.close();
        
        // FileWriter
        FileWriter fw = new FileWriter("c:/out.txt");
        for(int i=1; i<11; i++) {
            String data = i+" 번째 줄입니다.\r\n";
            fw.write(data);
        }
        fw.close();
    }
}

파일 입출력도 마찬가지로 이진데이터를 쉽게 처리하기위해 PrintWrite등 다양한 라이브러리가 제공된다.

import java.io.IOException;
import java.io.PrintWriter;
 
public class FileWrite {
    public static void main(String[] args) throws IOException {
        PrintWriter pw = new PrintWriter("c:/out.txt");
        for(int i=1; i<11; i++) {
            String data = i+" 번째 줄입니다.";
            pw.println(data); // 공백문자를 자동으로 입력해준다.
        }
        pw.close();
    }
}

파일 입력도 스트림을 직접 생성해주는 것을 제외하면, 콘솔 입력이랑 크게 다를 것이 없다.

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
 
public class FileRead {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("c:/out.txt"));
        while(true) {
            String line = br.readLine();
            if (line==null) break;
            System.out.println(line);
        }
        br.close();
    }
}

# Fast IO (코딩테스트용, 멀티스레드)

Java는 Cpp과 달리 콘솔입출력 시간에 여유가 있으므로 그냥 Scanner를 사용하는 것이 제일 편하고 깔끔하다.

import java.util.Scanner;
 
public class Solution {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
 
        System.out.println(a + b);
    }
}

정말 콘솔입출력 데이터가 많아서 최적화가 필요하다면 BufferedReader와 StringTokenize를 사용하는 방법도 있다.

// Working program using BufferedReader
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
 
public class Main {
    public static void main(String[] args)
        throws IOException
    {
 	// BufferedReader 객체를 만들고
        BufferedReader br = new BufferedReader(
            new InputStreamReader(System.in));
 		
        // 한줄에 여러 값을 입력했다면 StringTokenizer를 사용한다.
        StringTokenizer st
            = new StringTokenizer(br.readLine());
        int n = Integer.parseInt(st.nextToken());
        int k = Integer.parseInt(st.nextToken());
        int count = 0;
        
        while (n-- > 0) {
        // 값이 하나라면 아래와 같이 사용하면 된다.
            int x = Integer.parseInt(br.readLine());
            if (x % k == 0)
                count++;
        }
        System.out.println(count);
    }
}

실제 대량의 파일입출력에서 속도가 필요하다면 파일을 여러개로 쪼개 멀티쓰레드를 돌리면 된다. 이때는 PipedInputStream, PipedOutputStream을 이용한다.

• PipedInputStream() : 아직 연결되지 않은 PipedInputStream을 생성.
• PipedInputStream(PipedOutputStream src) : PipedOutputStream에 연결하는 PipedInputStream을 생성.
• void connect(PipedOutputStream src) : PipedInputStream과 연결할 PipedOutputStream src를 지정
• PipedOutputStream() : 아직 연결되지 않은 PipedOutputStream을 생성.
• PipedOutputStream(PipedInputStream src) : PipedInputStream에 연결하는 PipedOutputStream을 생성합니다.
• void connect(PipedInputStream snk) : PipedOutputStream과 연결할 PipedInputStream을 지정.

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
 
public class PipedInputOutputTest extends Thread {
 
    InputStream input;
    OutputStream output;
    
    PipedInputOutputTest(InputStream input, OutputStream output) {
        this.input = input;
        this.output = output;
    }
 
    public void run() {
        byte[] buf = new byte[1024];
        int i = 0;
 
        try {
            while (true) {
                i = input.read(buf);
 
                if (i != -1) 
                    output.write(buf, 0, i);
                 else 
                    return;
            }
        } catch (Exception e) {
            // 파일이 존재하지 않을 때 등등의 예외처리
        }
    }
 
    public static void main(String[] args) throws IOException {
        PipedInputStream pis = new PipedInputStream();
        PipedOutputStream pos = new PipedOutputStream(pis);
        // pis, pos 객체를 따로 만들고 pis.connect(pos)로 연결해주어도 된다.
        
        PipedInputOutputTest p1 = new PipedInputOutputTest(System.in, pos);
        PipedInputOutputTest p2 = new PipedInputOutputTest(pis, System.out);
        
        p1.start();
        p2.start();
    }
}

# 네트워크 소켓 프로그래밍

이 내용은 네트워크에 대한 지식이 있다면 쉽고, 없다면 어렵게 느껴질 것이다.

기본지식

자바에서는 TCP Socket 객체를 활용하여 Client 자바 앱 - Server 자바 앱 간의 네트워크를 구성할 수 있다.

1. Server측에서는 ServerSocket을 생성하고 accept() 메서드를 호출함으로써 Client의 접속을 대기합니다.
2. Client측에서는 Server에 접속을 함으로써 Server와의 통신을 위한 Socket을 생성합니다.
3. 마찬가지로 Server측에서 Client 접속이 이루어지면 해당 Client와 통신 할 수 있는 Socket을 반환받습니다.
4. Clinet와 Server는 생성된 소켓을 통하여 각각 상대에게 데이터를 내보내기 위한 출력 스트림과 데이터를 읽어 들이기 위한 입력 스트림을 생성합니다.
5. 생성된 스트림을 통하여 Server/Client 서로간에 데이터를 송수신합니다.
6. 통신이 끝나면 Client와 Server측에서 각각 socket.close()를 해줌으로써 통신을 종료하게 됩니다.

Server

package Threads;
 
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
 
public class Server {
    public static void main(String arg[]) {
        Socket socket = null;                //Client와 통신하기 위한 Socket
        ServerSocket server_socket = null;  //서버 생성을 위한 ServerSocket 
        BufferedReader in = null;            //Client로부터 데이터를 읽어들이기 위한 입력스트림
        PrintWriter out = null;                //Client로 데이터를 내보내기 위한 출력 스트림
 
        try {
            server_socket = new ServerSocket(8888);
 
        } catch (IOException e) {
            System.out.println("해당 포트가 열려있습니다.");
        }
        try {
            System.out.println("서버 오픈!!");
            socket = server_socket.accept();    //서버 생성 , Client 접속 대기
 
            in = new BufferedReader(new InputStreamReader(socket.getInputStream()));    //입력스트림 생성
            out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()))); //출력스트림 생성
 
            String str = null;
            str = in.readLine();                //Client로부터 데이터를 읽어옴
 
            System.out.println("Client로 부터 온 메세지 : " + str);
 
            out.write(str);
            out.flush();
            socket.close();
        } catch (IOException e) {
        }
    }
}

Client

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
 
public class Client {
    public static void main(String[] arg) {
        Socket socket = null;            //Server와 통신하기 위한 Socket
        BufferedReader in = null;        //Server로부터 데이터를 읽어들이기 위한 입력스트림
        BufferedReader in2 = null;        //키보드로부터 읽어들이기 위한 입력스트림
        PrintWriter out = null;            //서버로 내보내기 위한 출력 스트림
        InetAddress ia = null;
        try {
            ia = InetAddress.getByName("서버 주소 입력");    //서버로 접속
            socket = new Socket(ia, 8888);
            in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            in2 = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())));
 
            System.out.println(socket.toString());
        } catch (IOException e) {
        }
 
        try {
            System.out.print("서버로 보낼 메세제 : ");
            String data = in2.readLine();            //키보드로부터 입력
            out.println(data);                        //서버로 데이터 전송
            out.flush();
 
            String str2 = in.readLine();            //서버로부터 되돌아오는 데이터 읽어들임
            System.out.println("서버로부터 되돌아온 메세지 : " + str2);
            socket.close();
 
        } catch (IOException e) {
        }
    }
}