[코딩] Circle Square

14. Thread

    1) Thread 클래스

        1. 쓰레드 프로그래밍을 적용하고 싶은 클래스를 작성시 Thread라는 클래스를 상속하도록 작성.(extends Thread)
        2. 쓰레드가 실행될때 run메소드가 호출되므로 실제 쓰레드 구현하고 싶은 처리흐름을 run에 작성.
        => void run()을 오버라이딩
        3. run메소드를 직접 호출하지않고 Thread클래스이 내부에서 제공하는 start메소드를 호출하여 run을 실행.

        (t1.start())

        => start 메소드를 호출하면 JVM내부의 스케쥴러에 의해서 적절한 시점에 run이 호출.

        (정확한 호출시점 알 수 없음)

class ThreadClass extends Thread{
	public void run() {
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}
//main
ThreadClass t1 = new ThreadClass("t1");
t1.start();

    2) Runnable : 이미 다른 상위클래스를 상속하는 클래스를 쓰레드 프로그래밍을 적용하기 위해서 Runnable타입으로

    클래스를 작성.

        1. Runnable 인터페이스를 상속.(implements Runnable)
        2. run 메소드를 오버라이딩해서 쓰레드 프로그래밍으로 처리하고 싶은 내용을 구현.
        3. Runnable 객체를 이용해서 Thread클래스를 생성.

        (Thread t1 = new Thread(new Runnable을 상속한 클래스명()))
        4. 생성한 Thread객체의 start를 호출
        => Thread클래스에 오버라이딩한 run이 있으면 run을 실행. 
        => target객체(Runnable타입의 객체)의 run을 실행.

class Parent{
}
class 클래스명 extends Parent implements Runnable{
	public void run() {
		
			System.out.print(i+"("+Thread.currentThread().getName()+")");
			// 현재 실행중인 쓰레드의 getName()을 호출
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
	}
}
// main
// 1. Runnable을 상속해서 작성한 객체를 생성
Runnable obj1 = new RunnableDemo01();
// 2. 생성한 Runnable 객체를 이용해서 Thread객체를 생성
Thread t1 = new Thread(obj1);
Thread t2 = new Thread(new RunnableDemo01());

//3. 생성한 Thread객체의 start를 호출
t1.start();
t2.start();

    3) priority : JVM의 스케쥴러에 의해서 실행시킬 쓰레드가 여러 개 있다면 우선순위가 높은 쓰레드 부터 먼저 실행.

    1부터 10까지 우선수위를 지정가능 (default : 5)

t1.setPriority(6); // 우선순위 set
t1.getPriority(); // 우선순위 get
Thread.MAX_PRIORITY; // 10 return
Thread.MIN_PRIORITY; // 1 return

    4) yeild : yield 우선권이 동일한 쓰레드에게 실행을 양보하여 start()부터 재시작.

Thread.yield();

    5) join : 연결된 쓰레드 종료 후 메인 쓰레드가 종료하도록 하는 메소드.

try {
	t5.join();
} catch (InterruptedException e) {
	e.printStackTrace();
}

    6) thread 종료
        1. 임의의 변수(flag 변수)를 선언해서 종료하는 방법
        - 변수값에 따라서 작업을 처리할 수 있도록 구현

class testClass extends Thread{
	private boolean state = true;// 현재 상태값을 저장할 수 있는 변수
	
	public void run() {
		while(state) {
			// 실행문
		}
	}
	
	//쓰레드의 상태를 조절할 수 있도록 변수를 변경하는 메소드
	public void stopThread() {
		state = false;
	}
}
public class StopThreadTest01{
	public static void main(String[] args) {
		testClass t1 = new testClass();
		t1.start();
		t1.stopThread();
	}
}

        2. 인터럽트를 발생시키고 현재상태를 확인한 후 작업

class StopThread02 extends Thread{
	public void run() {
		try { // interupt이 발생해도 sleep문의 예외처리에 걸리지 않도록 try로 묶어준다.
		while(false == Thread.currentThread().isInterrupted()) { 
		// 현재상태가 인터럽트 상태면 종료하도록 구현.
			// 실행문
			Thread.sleep(500);
		}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		finally {
		}
	}
}

StopThread02 t1 = new StopThread02();
t1.start();
System.out.println("쓰레드 이름 : "+t1.getName());
System.out.println("인터럽트 상태 : "+t1.isInterrupted());
try {
	Thread.sleep(3000);
} catch (InterruptedException e) {
	e.printStackTrace();
}
t1.interrupt();
System.out.println("쓰레드 이름 : "+t1.getName());
System.out.println("인터럽트 상태 : "+t1.isInterrupted());

    7) 동기화

        1. synchronized 지정자

public class Shared {
	public synchronized void method() {
	// 한 쓰레드가 method 사용이 끝나기 전까지 다른 쓰레드가 method를 사용하지 못하도록 lock
	}
}
public class threadClass extends Thread{ // Thread
	Shared sh;
	threadClass(Shared sh){
		this.sh = sh
	}
	public void run() {
		Shared.method();
	}
}
// main
//쓰레드에서 공유할 객체 생성
Shared sh = new Shared();

//공유객체를 사용하는 쓰레드 생성
threadClass t1 = new threadClass(sh);
threadClass t2 = new threadClass(sh);

//쓰레드
t1.start(); // 한 쓰레드가 synchronized된 메소드를 사용중이면 사용이 끝난 후 사용할 수 있다.
t2.start();

        2. synchronized 블록

//공유객체
public class SharedObj {
	Account acc1;
	Account acc2;
}

// 기능1의 쓰레드
public class Thread1 extends Thread{
	SharedObj obj;
	public AccountSumThread(SharedObj obj) {
		this.obj = obj;
	}
	public void run() {
		for(int i=1;i<=5;i++) {
			long total = obj.acc1.getBalance()+obj.acc2.getBalance();
		}
	}
}

//기능2의 쓰레드
public class Thread2 extends Thread{
	SharedObj obj;
	public AccountTransferThread(SharedObj obj) {
		this.obj = obj;
	}
	public void run() {
		for(int i=1;i<=20;i++) {
			synchronized (obj) { // 메소드 전체가 아니라 명령문 일부에 lock을 적용할때 사용하는 synchronized블럭
								// ()안에 공유객체 명시.
				obj.acc1.withdraw(1000000);
				obj.acc2.deposit(1000000);
				
			}
		}
	}
}
// main
// 공유객체 생성
SharedObj obj = new SharedObj();
obj.acc1 = new Account();
obj.acc2 = new Account();

//쓰레드 생성
Thread1 t1 = new Thread1(obj); 
Thread2 t2 = new Thread2(obj);// 기능 2의 쓰레드의 동기화 블록이 실행 중에는 다른 쓰레드를 실행할 수 없다.

//쓰레드 start
t1.start();
t2.start();

15. Network

    1) InetAddress클래스 : IP주소를 모델링한 클래스. 로컬, 호스트네임을 통해서 IP주소를 가져올 수 있는 기능제공.

try {
	//InetAddress ia = InetAddress.getByName("www.naver.com");
	InetAddress ia = InetAddress.getByName(args[0]);
	ia.getHostName(); // Name 리턴
	ia.getHostAddress(); // ip주소 리턴
	InetAddress.getLocalHost(); // 로컬 ip 리턴
	
	InetAddress[] iaArr = InetAddress.getAllByName(args[0]); // 연결된 모든 ip 리턴
	for(int i=0;i<iaArr.length;i++) {
		iaArr[i].getHostName();
		iaArr[i].getHostAddress();
	}
} catch (UnknownHostException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
}

    2) URL클래스 : 웹상의 주소를 나타내는 클래스고 이를 통해서 네트워크 연결도 가능.
    웹상의 리소스를 가져올 수 있다. 웹페이지, 이미지, 동영상..

try {
	URL url = new URL("https://www.naver.com/");
	url.toString();
	url.getHost();
	url.getPath();
	url.getPort(); // 프로토콜에 등록되어 있는 기본 port로 접속 할 경우 -1 return
					// http프로토콜의 기본포트는 80번
	url.getProtocol(); // https
	url.getFile();
	
	// URL에 접속해서 자원정보를 읽는 작업을 수행
	InputStream is = url.openStream();
	InputStreamReader isr = new InputStreamReader(is);
	BufferedReader br = new BufferedReader(isr); 
	
	while(true) {
		String data = br.readLine();
		if(data == null) {
			break;
		}
		System.out.println(data);
	}
}catch (MalformedURLException e) {
	e.printStackTrace();
}catch (IOException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
}

    3) URL 이미지 출력
    - BufferedInputStream : byte단위 입력
    - FileOutputStream : byte단위 파일 출력

BufferedInputStream bis =null;
FileOutputStream fos=null;

try {
	URL url = new URL("url 경로");
	bis = new BufferedInputStream(url.openStream());
	fos = new FileOutputStream("src/data/image.jpg");
	while(true) {
		int data = bis.read();
		if(-1 == data) {
			break;
		}
		fos.write(data);
	}
} catch (MalformedURLException e) {
	e.printStackTrace();
} catch (IOException e) {
	e.printStackTrace();
}
finally {
	try {
		if(bis != null)
			bis.close();
		if(fos != null)
			fos.close();
	} catch (IOException e) {
		e.printStackTrace();
	}
}

    4) Socket 통신 - Server

try {
	
	ServerSocket server = new ServerSocket(50000);
	// 클라이언트와 통신하기 위해서 ServerSocket을 생성
	while(true) {
		Socket client = server.accept();
		// 클라이언트가 접속할때까지 대기하다가 (Litsen) 클라이언트가 접속하면 클라이언트와 통신
        // 할 수 있도록 클라이언트의 정보를 Socket객체로 만들어서 리턴
		InetAddress clientIp = client.getInetAddress();
		System.out.println("접속한 클라이언트 => "+clientIp.getHostAddress());
	}
	
} catch (UnknownHostException e){
	e.printStackTrace();
} catch (IOException e) {
	e.printStackTrace();
}

    5) Socket 통신

try {
	//서버와 통신할 수 있는 소켓객체 생성
	//Socket 객체를 생성하면 서버에 접속한다.
	Socket serverInfo = new Socket("192.168.0.3",50000); // 서버 ip 및 port
} catch (IOException e) {
	e.printStackTrace();
}

    6) DataInputStream : 파일의 데이터를 읽는 클래스

DataInputStream dis = new DataInputStream(new FileInputStream("src/data/dos.txt"));
// IO작업 직접하는 것이 아니라 추가된 기능을 표현해 놓은 스트림 클래스로
// 직접 원시데이터와 연결하지 못한다.
int data1 = dis.readInt();
double data2 = dis.readDouble();
String data3 = dis.readUTF();
System.out.println(data1);
System.out.println(data2);
System.out.println(data3);
dis.close();

    7) DataOutputStream : 파일의 데이터를 쓰는 클래스

FileOutputStream fos = new FileOutputStream("src/data/dos.txt");
DataOutputStream dos = new DataOutputStream(fos);
// FileOutputStream과 같은 스트림객체를 먼저 생성한 후 작업해야한다.
dos.writeInt(100);
dos.writeDouble(10.5);
dos.writeUTF("문자열");
fos.close();
dos.close();

    8) Echo Server : 클라이언트가 전송한 데이터를 받아서 그대로 클라이언트에게 전송

public static void main(String[] args) {
Socket client = null;
BufferedReader in = null;
PrintWriter out = null;
// InputStream is =null; // 클라이언트와 input통신을 할 수 있는 스트림
// DataInputStream dis = null; // 최종적으로 클라이언트와 DataInputStream을 통해서 통신
// OutputStream os =null; // 클라이언트와 output통신을 할 수 있는 스트림
// DataOutputStream dos = null; // 최종적으로 클라이언트와 DataOutputStream을 통해서 통신
try {
	ServerSocket server = new ServerSocket(7777);//서버소켓을 열고 대기
	while (true) { // 클라이언트와 통신할 수 있는 input/output스트림을 소켓으로 부터 생성
		client = server.accept(); // 클라이언트 접속을 기다리다가 클라이언트가 접속하면 이용해서 Socket객체를 생성
		
		// 클라이언트와 통신할 수 있는 input/output스트림을 소켓으로 부터 생성
		in = new BufferedReader(new InputStreamReader(client.getInputStream()));
		out = new PrintWriter(client.getOutputStream(), true);
		// autoflush속성을 true로 설정하면 println메소드가 호출될때 자동으로 flush호출.
		out.println("문자열");
		String msg = in.readLine();
		
		//클라이언트가 전송하는 데이터를 읽기 위한 스트림 객체를 소켓으로 부터 생성한다.(accept 했을 때 만든 소켓)
		//is = client.getInputStream();
		//dis = new DataInputStream(is);
		// 클라이언트로 전송할 데이터를 출력하기 위한 스트림 객체를 소켓으로 부터 생성
		//os = client.getOutputStream();
		//dos = new DataOutputStream(os);
		//dos.writeUTF("문자열");
		//dos.writeInt(20000);
		//dis.readUTF()
		//dis.readint()
		
		/*
		out = new PrintWriter(client.getOutputStream());
		out.println("문자열");
		out.flush();// flush는 버퍼를 비우는 명령 - 출력버퍼의 내용을 실제로 출력하라는 의미
		// 출력버퍼에 임시로 보관되어 스트림으로 출력될때까지 대기중인 데이터를 스트릠으로 내보내는 작업을 하는 것이 flush
		*/
		
		//클라이언트가 보내오는 데이터를 지속적으로 읽어서 클라이언트로 다시 보내주는 작업 - 예측불가
		String reMsg = "";
		while(true) {//한 클라이언트와 지속으로 대화하기 위해서 사용하는 while
			//1. 서버<-클라이언트(클라이언트가 보내는 데이터를 지속적으로 읽기)
			reMsg = in.readLine();
			if(reMsg == null) {
				break;
			}
			//2. 서버 -> 클라이언트
			out.println(reMsg");
		}
	}
} catch (IOException e) {
	e.printStackTrace();
}

    9) Echo Client

Socket server = null;
BufferedReader in =null;//소켓통신
PrintWriter out =null;//소켓통신
BufferedReader keyin = null; // 서버에게 데이터를 내보내기 위해서 키로브로 입력하는 것을 읽기 위한 입력 스트림

try {
	server = new Socket("192.168.0.3",7777);
	System.out.println("Client Accept to server.");
	while(true) {
		in = new BufferedReader(new InputStreamReader(server.getInputStream()));
		keyin = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(server.getOutputStream(), true);
		
		//키보드로 입력하는 내용이 지속적으로 서버에 전달되도록 구현
		String sendMsg=""; // 서버로 보낼 메시지
		String reMsg=""; // 서버에서 받는 메시지
		while(true){
			//1. 클라이언트 -> 서버 (키보드로 입력하는 데이터 서버로 보내기)
			sendMsg = keyin.readLine();
			out.println(sendMsg);
			//2. 클라이언트 <- 서버
			reMsg = in.readLine(); // 네트워크로 입력되어 들어오는 데이터 읽기
			System.out.println("서버에서 전송된 메시지 : "+reMsg);
		}
	}
} catch (UnknownHostException e) {
	e.printStackTrace();
} catch (IOException e) {
	e.printStackTrace();
}