개발새발, 써놓기

현재 주문과 동시에 포인트를 넣어주고 있음...(소스에서)

 나중에 배송이 완료된 이후(지금은 이것까지는 안했긴 함...) 배송일을 입력 한 후에 포인트를 넣던가 방식을 바꿔야 될 것 같다.

>> 후기작성의 경우 도착일이 생긴 후에 작성하게끔 하려면 어떻게 해야될까 ?

후기작성할 때 빵코드를 입력받지 않고 후기작성하려면 ? >> 주문번호를 받아서 먼저 주문번호에 해당하는 결과를 받은 후에 별점 내용을 거기에 넣어서 해줘야될 듯 ..

아직 상품준비중인데 포인트가 쌓였음. 이부분도 나중에는 생각해봐야할 문제

아까 민트초코마카롱을 5개를 주문했는데 10개가 사라져있었다. 소스를 뜯어보니, 

재고를 변경하는 곳에 문제가 있었다.

빵코드를 입력받아 재고는 빵코드로 합쳐서 보여지는데, 

재고 업데이트를 빵코드를 받아서 하다보니까 빵코드에 해당하는 재고는 입고번호에 따라 계속 넣어지는데, (즉 빵코드에 해당하는 자료가 입고받을 때마다 넣어지므로 여러개) 재고를 2번을 입고 받았었기 때문에 해당 빵코드의 qty에서 -5가 다 들어가기 때문에 2번의 입고 정보에 다 -5가 되어서 -10이 되었던 것이다.

납품업체 리스트 확인.

납품업체 하나에 (부모테이블) 입고(자식테이블) 이 여러개가 존재할 수 있다. 참조키로 납품업체 코드를 해놨다. 그래서 납품업체 삭제는 거의 사용하지 않을 듯. 입고를 한번이라도 했으면 삭제해도 자식 레코드는 재고를 위해서 사용해야되서.

입고날짜를 넣어줄때는 매개변수가 없는 메소드를 통해 현재 날짜를 넣어주고,

데이터베이스에서 가져올 때는 매개변수가 있는 메소드를 통해 데이터베이스에서 가져온 날짜로 set할 수 있도록 overloading 을 통해 구현했다. 

입고번호도 overloading을 통해서 입고에서 넣어줄 때는 오늘날짜+랜덤번호 를 통해 넣었다.

데이터베이스에서 가져와서 데이터를 출력할 때는 가져온 값을 매개변수로 해서 넣어준다.

폐기가 고구마케익만 되었다. 소스를 보고 해당 재고를 다 없애도록 고쳐야 할듯...

하나씩 만 폐기되도록 되어있음. 한번 더 실행하니까 이번엔 뉴욕치즈케익이 사라졌음.

싹 다 사라지도록 변경해야될 것 같다.

주문총금액부분은 없애야함.

해당 주문번호에 배송일자를 추가한다.

총 주문리스트 말고 새로운 주문만 확인하는 리스트도 있다.

배송등록 후에는 주문 확인 리스트가 뜨지 않도록 설정했다.

총팔린금액에 개당 금액이 들어가있다. 고쳐야함!

여기도 총금액에 개당금액이 들어가있다.

package netEx;

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;

public class ChatForm extends JFrame implements ActionListener, Runnable {
	private static final long serialVersionUID = 1L;

	private JTextField tf = new JTextField();
	private JTextArea ta = new JTextArea();

	public ChatForm() {
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

		ta.setEditable(false);
		JScrollPane sp = new JScrollPane(ta);
		add(sp, BorderLayout.CENTER);
		
		// JtextField에서 엔터를 누르면 ActionEvent가 발생되므로
		// 		ActionEvent를 등록하여 ActionEvent 처리
		tf.addActionListener(this);
		add(tf, BorderLayout.SOUTH);

		setTitle("채팅");
		setSize(500, 550);
		setVisible(true);

		tf.requestFocus();

	}

	public static void main(String[] args) {
		new ChatForm();
	}

	@Override
	public void actionPerformed(ActionEvent e) {
		if (e.getSource() == tf) {
			String s = tf.getText().trim();
			if (s.length() == 0)
				return;

			try {

				ta.append("보냄] " + s + "\n");

				tf.setText("");
				tf.requestFocus(); // 포커스를 JTextField 에
			} catch (Exception e2) {
				e2.printStackTrace();
			}
		}

	}

	@Override
	public void run() {
		// TODO Auto-generated method stub

	}
}

package netEx;

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;

public class ChatClient extends JFrame implements ActionListener, Runnable {
	private static final long serialVersionUID = 1L;

	private JTextField tf = new JTextField();
	private JTextArea ta = new JTextArea();

	private Socket sc = null;
	private String host = "127.0.0.1";
	private int port = 8000;
	private String nickName = "자바";

	public ChatClient() {
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

		ta.setEditable(false);
		JScrollPane sp = new JScrollPane(ta);
		add(sp, BorderLayout.CENTER);

		// JtextField에서 엔터를 누르면 ActionEvent가 발생되므로
		// ActionEvent를 등록하여 ActionEvent 처리
		tf.addActionListener(this);
		add(tf, BorderLayout.SOUTH);

		setTitle("채팅-클라이언트");
		setSize(500, 550);
		setVisible(true);

		tf.requestFocus();

	}

	public void connect() {
		// 서버에 연결
		try {
			sc = new Socket(host, port);
			ta.setText("서버에 접속...\n");

			Thread t = new Thread(this);
			t.start();

		} catch (IOException e) {
			// 서버가 실행되지 않은 경우
			sc = null;
			e.printStackTrace();
		}
	}

	public static void main(String[] args) {
		new ChatClient().connect();
	}

	@Override
	public void actionPerformed(ActionEvent e) {
		if (e.getSource() == tf) {
			String s = tf.getText().trim();
			if (s.length() == 0)
				return;

			try {
				if (sc == null) {
					return;
				}

				// 서버에 정보를 전송하기 위한 출력 스트림
				PrintStream out = new PrintStream(sc.getOutputStream());
				out.println(nickName + "] " + s); // 서버에게 문자열 전송

				ta.append("보냄] " + s + "\n");
				ta.setCaretPosition(ta.getDocument().getLength());;
				
				tf.setText("");
				tf.requestFocus(); // 포커스를 JTextField 에
			} catch (IOException e2) {
				ta.append("서버가 종료 됨 !!!\n");
				sc = null;
				// e2.printStackTrace();
			}
		}

	}

	@Override
	public void run() {
		String s;

		try {
			if (sc == null) {
				return;
			}

			// 서버가 보낸 정보를 받기 위한 입력 스트림
			BufferedReader br = new BufferedReader(new InputStreamReader(sc.getInputStream()));

			while((s = br.readLine())!=null) {
				ta.append(s+"\n");
				ta.setCaretPosition(ta.getDocument().getLength());;
			}
		} catch (IOException e) {
			s = "서버가 종료 되었습니다.\n";
			ta.append(s);
			sc = null;
			// e.printStackTrace();
		}

	}
}

package netEx;

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;

// 1:1 채팅
public class ChatServer extends JFrame implements ActionListener, Runnable {
	private static final long serialVersionUID = 1L;

	private JTextField tf = new JTextField();
	private JTextArea ta = new JTextArea();

	private ServerSocket ss = null;
	private int port = 8000;
	private Socket sc = null;

	public ChatServer() {
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

		ta.setEditable(false);
		JScrollPane sp = new JScrollPane(ta);
		add(sp, BorderLayout.CENTER);

		tf.addActionListener(this);
		add(tf, BorderLayout.SOUTH);

		setTitle("채팅-서버");
		setSize(500, 550);
		setVisible(true);

		tf.requestFocus();
	}

	public void serverStart() {
		try {
			ss = new ServerSocket(port);
			ta.setText("서버 시작 !!!\n");
			sc = ss.accept(); // 클라이언트의 접속을 기다린다.
			// 클라이언트가 접속하면 클라이언트와 통신을 할 수 있는 Socket 객체를 반환 받는다.

			Thread t = new Thread(this);
			t.start();

		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static void main(String[] args) {
		new ChatServer().serverStart();
	}

	@Override
	public void actionPerformed(ActionEvent e) {
		if (e.getSource() == tf) {
			String s = tf.getText().trim();
			if (s.length() == 0)
				return;

			try {
				if (sc == null) {
					return;
				}

				// 클라이언트에게 정보를 전송 한다.
				PrintStream out = new PrintStream(sc.getOutputStream());
				// OutputStream을 PrintStream으로 변환
				out.println("서버] " + s);

				ta.append("보냄] " + s + "\n");
				ta.setCaretPosition(ta.getDocument().getLength());;

				tf.setText("");
				tf.requestFocus(); // 포커스를 JTextField 에
			} catch (IOException e2) {
				// e2.printStackTrace();
				ta.append("클라이언트가 접속을 해제 했습니다.\n");
				sc = null;
			}
		}

	}

	@Override
	public void run() {
		String str;
		String ip = "";

		if (sc == null) {
			return;
		}

		try {
			// 접속한 클라이언트가 보낸 정보를 입력 스트림으로 받는다.
			BufferedReader br = new BufferedReader(new InputStreamReader(sc.getInputStream()));
			
			// 접속한 클라이언트의 ip 주소
			ip = sc.getInetAddress().getHostAddress();
			ta.append("["+ip+"] 접속 ...\n");
			
			// 클라이언트가 보낸 정보를 받는다.
			while((str = br.readLine()) !=null ) {
				ta.append(str+"\n");
				ta.setCaretPosition(ta.getDocument().getLength());;
			}
			
		} catch (IOException e) {
			str = "["+ip+"] 접속 해제 !!!";
			ta.append(str+"\n");
			sc = null;
		}
	}
}

package netEx;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Vector;

// 1:다 채팅 프로그램
public class ChatServer2 {
	// 접속한 클라이언트를 저장하기 위한 벡터 객체
	private Vector<Socket> client = new Vector<>();
	private ServerSocket ss = null;
	private int port = 8000;

	// 내부 스레드 클래스
	class WorkerThread extends Thread {
		private Socket sc = null;

		public WorkerThread(Socket sc) {
			this.sc = sc;
		}

		@Override
		public void run() {
			String ip= null;
			String msg;
			
			try {
				// 클라이언트가 보낸 정보를 받기 위한 입력 스트림
				BufferedReader br = new BufferedReader(new InputStreamReader(sc.getInputStream()));
				ip = sc.getInetAddress().getHostAddress();
				
				// 접속한 클라이언트 소켓을 벡터에 저장
				client.add(sc);
				
				// 다른 클라이언트에게 접속 사실을 알림
				msg = "["+ip+"] 에서 접속 !!!";
				sendMsg(msg);
				
				System.out.println(msg);
				
				// 클라이언트가 보낸 정보를 받아 다른 클라이언트에게 보냄
				while((msg = br.readLine()) != null) {
					sendMsg(msg);
				}
				
			} catch (IOException e) {
				// 클라이언트가 채팅방을 나간 경우
				msg = "["+ip+"] 퇴장...";
				sendMsg(msg);
				
				client.remove(sc);
				sc = null;
				System.out.println(msg);
			}
		}
		
		// 다른 모든 클라이언트에게 메세지 전송
		public void sendMsg(String msg) {
			for(Socket s : client) {
				try {
					if( s == sc) {
						continue; // 자기 자신
					}
					
					PrintStream out = new PrintStream(s.getOutputStream());
					out.println(msg);
				} catch (Exception e) {
				}
			}
		}
	}

	public void serverStart() {
		try {
			ss = new ServerSocket(port);
			System.out.println("서버 시작 !!!");

			while (true) {
				// 클라이언트 접속을 기다린다.
				Socket sc = ss.accept();

				// 클라이언트가 접속하면 클라이언트가 보낸 정보를 받을 스레드 객체를 생성하고 스레드를 실행한다.
				WorkerThread t = new WorkerThread(sc);
				t.start();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static void main(String[] args) {
		ChatServer2 obj = new ChatServer2();
		obj.serverStart();
	}

}

package netEx;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.InetAddress;

public class Ex001_InetAddress {

	public static void main(String[] args) {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String host = null;
		
		try {
			System.out.print("호스트명[www.naver.com 또는 컴이름] ? ");
			host = br.readLine();
			
			InetAddress ia = InetAddress.getByName(host);
			
			String str = ia.getHostName();
			String ip = ia.getHostAddress();
			
			System.out.println("호스트명 : "+str);
			System.out.println("아이디 : "+ip);
			
		} catch (Exception e) {
			e.printStackTrace();
		} 

	}

}

위 예제를 통해 InetAddress 클래스로 해당 주소의 호스트명과 ip를 가져올 수 있었다.

package netEx;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;

public class Ex002_URL {

	public static void main(String[] args) {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String webUrl, s;

		BufferedReader nbr = null;

		try {
			System.out.print("웹주소[https://www.naver.com] ? ");
			webUrl = br.readLine();
			
			// URL : 웹(World Wide Web)상의 리소스에 대한 포인터를 나타냄
			URL url = new URL(webUrl);
			InputStream is = url.openStream();
			
			nbr = new BufferedReader(new InputStreamReader(is, "UTF-8"));
			
			while( (s = nbr.readLine()) !=null) {
				System.out.println(s);
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (nbr != null) {
				try {
					nbr.close();
				} catch (Exception e2) {
				}
			}
		}

	}

}

아직 뭔지 모르는 소스들을 가져왔다.

package netEx;

import java.net.URLDecoder;
import java.net.URLEncoder;

public class Ex003_URLEncoder {

	public static void main(String[] args) {
		String s1, s2;
		s1 = "자바 java";
		
		try {
			// 인터넷에서 데이터를 전송할 수 있는 상태로 변환(application/x-www-form-urlencoded)
			s2 = URLEncoder.encode(s1, "UTF-8");
			System.out.println(s2); // %EC%9E%90%EB%B0%94+java

			// 주소형식으로 변환된 문자열을 다시 원래대로 변환
			s1 = URLDecoder.decode(s2, "UTF-8");
			System.out.println(s1);
			
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

}

URLEncoder 와 URLDecoder 클래스로 문자열을 인터넷에서 주고받을 수 있는 형태로 변환해보고 다시 변환된 것을 우리가 볼 수 있도록 바꾸어보았다.

동기화란?

- 멀티 스레드(Multi Thread) 환경에서는 여러 스레드가 동일한 프로세스 내의 자원을 공유해서 사용하기 때문에 문제점이 발생할 수 있다.

- 따라서 공유 자원에 여러 개의 스레드가 동시에 접근하지 못하도록 설정하여야 하는데 이를 동기화라 한다.

- 즉, 한 스레드가 동기화된 객체를 사용하는 경우 오직 그 스레드 만이 그 객체에 접근할 수 있도록 한다.

크리티컬 섹션(Critical Section, 임계 영역)

공유 데이터나 리소스(메모리나 파일)에 대한 접근을 하나의 스레드로 제한한다. 즉, 동일한 프로세스 내의 스레드 간 동기화에 사용한다.

뮤텍스(Mutex) 

크리티컬 섹션과 동일한 기능을 가지지만 차이가 있다면 다른 프로세스에 속한 스레드를 제어할 수 있다.

세마포어(Semaphore) 

뮤텍스와 유사하지만 동시에 수행할 수 있는 스레드를 여러 개로 제한할 수 있다.

모니터(Monitors) 

두 개의 스레드에 의해 공유되고 그 값이 참조될 때 반드시 동기화되어야 하는 공유 데이터와 같은 객체를 상태변수(condition variables)라고 한다. 자바 언어에서는 상태 변수에 대한 모니터를 사용할 수 있도록 함으로써 스레드를 동기화 한다. 모니터는 자신이 소유한 스레드를 제외한 다른 스레드의 접근을 막는다.

교착 상태(DeadLock)

두 개 이상의 작업이 서로 상대방의 작업이 끝나기만을 기다리고 있기 때문에 결과적으로 아무 것도 완료되지 못하는 상태를 가리킨다.

Synchronized 키워드

- Synchronized 키워드를 통해 해당 작업과 관련된 공유 데이터에 lock을 걸어서 먼저 작업 중이던 스레드가 작업을 완전히 마칠 때까지는 다른 스레드에게 제어권이 넘어가더라도 데이터가 변경되지 않도록 보호함으로써 스레드의 동기화를 가능하게 한다.

package threadEx2;

public class Ex001_Synchronized {
	public static void main(String[] args) {
		MyBank1 b = new MyBank1();
				
		Thread t1 = new Thread(b);
		Thread t2 = new Thread(b);
		
		t1.start();
		t2.start();
	}
}

// 동기화 하지 않은 경우
class MyBank1 implements Runnable {
	private int money = 10000;
	
	
	@Override
	public void run() {
		int need = 6000;
		int n = 0;
		String msg = null;
		
		try {
			if(getMoney()>=need) {
				Thread.sleep(200);
				n = drawMoney(need);
				msg = "인출 성공";
			} else {
				n = 0;
				msg = "인증 실패";
			}
			
			System.out.println(msg + ", 인출금액:"+n+", 잔고:"+getMoney());
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}


	public int getMoney() {
		return money;
	}


	private int drawMoney(int m) {
		money -= m;
		return m;
	}
}

package threadEx2;

public class Ex003_Synchronized {
	public static void main(String[] args) {
		ShareData1 share = new ShareData1();
		
		UpThread1 t1 = new UpThread1(share, "up");
		DownThread1 t2 = new DownThread1(share, "down");
		
		t1.start();
		t2.start();
		
	}
}

// 동기화 하지 않은 경우
class ShareData1 {
	private int num = 100;
	
	public void up(String title) {
		System.out.print(title+":"+num);
		num++;
		System.out.println(", 증가->"+num);
	}
	public void down(String title) {
		System.out.print(title+":"+num);
		num--;
		System.out.println(", 감소->"+num);
	}
}

class UpThread1 extends Thread {
	private ShareData1 share;
	private String title;
	
	public UpThread1(ShareData1 share, String title) {
		this.share = share;
		this.title = title;
	}
	
	public void run() {
		for(int i=0; i<5; i++) {
			try {
				sleep(500);
				share.up(title);
			} catch (Exception e) {
			}
		}
	}
}

class DownThread1 extends Thread {
	private ShareData1 share;
	private String title;
	
	public DownThread1(ShareData1 share, String title) {
		this.share = share;
		this.title = title;
	}
	
	public void run() {
		for(int i=0; i<5; i++) {
			try {
				sleep(500);
				share.down(title);
			} catch (Exception e) {
			}
		}
	}
}

package threadEx2;

public class Ex002_Synchronized {
	public static void main(String[] args) {
		MyBank2 b = new MyBank2();
				
		Thread t1 = new Thread(b);
		Thread t2 = new Thread(b);
		
		t1.start();
		t2.start();
	}
}

// 동기화 한 경우
class MyBank2 implements Runnable {
	private int money = 10000;
	
	
	@Override
	public void run() {
		int need = 6000;
		int n = 0;
		String msg = null;
		
		try {
			synchronized (this) { // 동기화 블럭
				if(getMoney()>=need) {
					Thread.sleep(200);
					n = drawMoney(need);
					msg = "인출 성공";
				} else {
					n = 0;
					msg = "인증 실패";
				}				
			}
			
			System.out.println(msg + ", 인출금액:"+n+", 잔고:"+getMoney());
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}


	public int getMoney() {
		return money;
	}


	private int drawMoney(int m) {
		money -= m;
		return m;
	}
}

package threadEx2;

public class Ex005_wait {
	public static void main(String[] args) {
		MyBank3 atm = new MyBank3();
		
		Thread t1 = new Thread(atm, "t1");
		Thread t2 = new Thread(atm, "t2");
		
		t1.start();
		t2.start();
		
	}
}

class MyBank3 implements Runnable {
	private long money = 10000;
	
	public void run() {
		synchronized (this) {
			for(int i = 0; i < 10; i++) {
				if(getMoney() <= 0) {
					// wait()에 의해 대기하고 있는 모든 스레드를 깨운다.
					this.notifyAll();
					break;
				}
				
				drawMoney(1000);
				
				if(getMoney()>=2000 && getMoney() % 2000 == 0) {
					try {
						// wait()를 만나면 해당 쓰레드는 해당 객체의 모니터링 락에 대한 권한을 가지고 있으면
						// 모니터링 락의 권한을 놓고 대기한다.
						// synchronized 블록에서만 사용
						this.wait();
					} catch (Exception e) {
					}
				} else {
					// wait()에 의해 대기하고 있는 해당 스레드를 깨운다.
					// 아래 notify()를 주석 처리하면 무한 대기(deadlock)상태가 된다.
					this.notify();
				}
				
			}
			
		}
	}

	public long getMoney() {
		return money;
	}
	
	public void drawMoney(long m) {
		System.out.print(Thread.currentThread().getName()+", "); // 현재 쓰레드명 출력
		
		if(getMoney()>=m) {
			money -= m;
			System.out.printf("잔액 :  %,d원\n", getMoney());
		} else {
			System.out.println("잔액이 부족 합니다.");
		}
	}
}

- 자바의 스레드 스케쥴링은 우선순위(Priority)방식과 라운드 로빈(Round-robin) 방식을 사용한다.

1) 우선순위(Priority) 방식

- 우선순위가 높은 스레드가 실행 상태를 더 많이 가지도록 스케쥴링 하는 것

- 우선순위를 부여하여 코드로 제어가 가능하다.

2) 라운드 로빈(Round-robin) 방식

- 시간 할당량(Time Slice)을 정해서 스레드를 정해진 시간만큼 실행시키고 다른 스레드를 실행하는 방식

- JVM에 의해 정해지므로 코드로 제어할 수 없다.

- 스레드는 우선순위를 나타내는 필드(priority)를 가지고 있다. 1~10 사이의 값을 갖는다. (10: 가장 높음)

- 자바 런타임 스케줄러는 현재 실행 가능한 스레드들 중에서 우선순위가 가장 높은 스레드를 실행시켜 주는데, 현재 실행중인 스레드보다 더 높은 우선순위를 갖는 스레드가 실행가능 상태가 되면 자바 런타임 스케줄러는 우선순위가 더 높은 스레드를 실행시켜 준다.

- 스레드 우선 순위는 스레드를 생성한 스레드로부터 상속 받는다. main() 메소드에서 스레드를 생성하면 main() 메소드의 우선 순위가 5이므로 자동으로 5를 갖는다.

package threadEx;

public class Ex007_Priority {
	public static void main(String[] args) {
		MyThread7 t1 = new MyThread7("A");
		MyThread7 t2 = new MyThread7("B");
		MyThread7 t3 = new MyThread7("C");

		t1.setPriority(Thread.MIN_PRIORITY); // 1
		t2.setPriority(Thread.MAX_PRIORITY); // 10
		
		t1.start();
		t2.start();
		t3.start();
		
	}
}

class MyThread7 extends Thread {
	public MyThread7(String name) {
		super(name);
	}

	@Override
	public void run() {
		for (int i = 1; i <= 20; i++) {
			// System.out.println(getName() + " -> " + i);
			System.out.println(this); // [스레드명, 우선순위, 그룹]
		}

	}
}

몇 번 실행시켜보면 우선순위가 높은 B부터 일처리를 하는 것을 알 수 있다.

package threadEx;

/*
 - 독립 스레드
 	메인은 프로그램의 시작점이지 종료점은 아니다. 
 	메인 스레드가 종료되어도 독립 스레드의 작업이 완료될 때까지 프로그램은 종료되지 않는다.
 - 데몬 스레드
 	다른 스레드에게 도움을 주기 위한 스레드
 	메인 스레드가 종료되면 데몬 스레기의 작업이 완료되지 않아도 프로그램은 종료됨.
 */
public class Ex006_Daemon {
	public static void main(String[] args) {
		MyThread6 t1 = new MyThread6();
		MyThread6 t2 = new MyThread6();
		MyThread6 t3 = new MyThread6();

		// 스레드들 데몬으로 만듦
		t1.setDaemon(true);
		t2.setDaemon(true);
		t3.setDaemon(true);
		
		t1.start();
		t2.start();
		t3.start();
		
		try {
			t1.join(); // 스레드가 종료될 때 까지 대기
			t2.join();
			t3.join();
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		System.out.println("메인 종료...");
	}
}

class MyThread6 extends Thread {
	@Override
	public void run() {
		for (int i = 1; i <= 20; i++) {
			System.out.println(getName() + " -> " + i);
			
			try {
				Thread.sleep(500);
			} catch (Exception e) {
			}
		}
		
	}
}

메인이 종료되면 같이 종료된다.

package threadEx;

import java.util.Calendar;

public class Ex005_Runnable {

	public static void main(String[] args) {
		Thread t = new Thread(new MyThread5());
		t.start();

	}

}

class MyThread5 implements Runnable {

	@Override
	public void run() {
		String str;

		while (true) {
			Calendar cal = Calendar.getInstance();

			str = String.format("%tF %tT", cal, cal);
			System.out.println(str);

			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

	}

}

Thread.sleep(1000); 괄호 안에는 millisecond 단위이므로 1000이면 1초를 뜻한다.

terminate를 누르지 않으면 계속 시간이 찍힌다.

package threadEx;

import java.awt.BorderLayout;
import java.util.Calendar;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;

public class Ex006_Runnable {
	public static void main(String[] args) {
		ChatForm cf = new ChatForm();
		Thread t = new Thread(cf);
		t.start();
	}
}

class ChatForm extends JFrame implements Runnable {
	private static final long serialVersionUID = -5166274042184939576L;
	
	private JTextField tf = new JTextField();
	private JTextArea ta = new JTextArea();
	
	public ChatForm() {
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		JScrollPane sp = new JScrollPane(ta);
		add(sp, BorderLayout.CENTER);
		
		add(tf, BorderLayout.SOUTH);
		
		setTitle("채팅...");
		setSize(500,500);
		setVisible(true);
		
		
	}

	@Override
	public void run() {
		String s;
		while(true) {
			try {
				Calendar cal = Calendar.getInstance();
				s = String.format("%tF %tT", cal, cal);
				setTitle(s);
			} catch (Exception e) {
			}
		}
		
	}
	
}

위 코드를 실행하면 이렇게 따로 윈도우창이 뜨고 창 제목이 시스템 시간에 따라 1초씩 찍히는 것을 확인할 수 있다. 

프로세스 Process

- 운영체제로부터 자원을 할당받은 작업의 단위로, 실행중인 하나의 프로그램을 의미한다.

- 리소스(resource)와 스레드(thread)로 구성된다.

- Code, Data, Heap, Stack영역으로 이루어지며, 각각의 메모리 공간을 차지한다.

- 동시에 두 개 이상의 프로그램을 특정 기법으로 동시에 실행시키는 기능을 멀티 태스킹(multitasking) 이라 한다. 특정 기법에는 대표적으로 시분할(Time-Shared)기법이 있다.

스레드 Thread

- 프로세스 내에서 실행되는 흐름의 단위이다. 즉, 프로세스가 할당 받은 자원을 이용하는 실행 단위(흐름)이다. 

- 스레드는 프로세스 내에 존재하며, 모든 프로세스는 적어도 하나이상의 스레드를 가지고 있다.

- 프로세스는 자신만의 메모리 공간과 자원을 할당받아 사용하지만, 스레드는 다른 스레드와 메모리와 자원을 공유한다.

Code, Data, Heap 영역은 공유하고 별도의 Stack영역만 가지고 있다.

- 둘 이상의 스레드를 가진 프로세스를 멀티 스레드 프로세스(multi-thread process)라 한다.

멀티 스레드 

장점

- 시스템의 자원소모가 줄어든다.

- CPU의 사용률을 향상시킨다.

- 프로그램의 응답 시간이 단축된다.

단점

- 자원 공유를 위해 전역변수를 이용하므로 동기화 관련된 문제가 발생할 수 있다.

- 잘못된 변수를 사용하거나 미묘한 시간차로 인해 프로그램에 오류가 발생할 수도 있다.

- 디버깅이 어렵다.

자바 메인 스레드

- 자바는 프로그램(process)이 시작되면 기본적으로 main() 메소드를 진입점(Entry Point)으로 하는 메인 스레드(Main Thread)가 생성되며, 사용자가 정의한 스레드를 생성함으로써 멀티 스레드를 구현할 수 있다.

- main()메소드는 프로그램의 진입점이지 종료점이 아니므로, 멀티 스레드 환경에서는 모든 스레드가 종료되야 프로세스가 종료된다.

java.lang.Thread 클래스

- 스레드 생성 및 시작, 관리를 위한 클래스이다.

- Thread 클래스를 상속 받은 하위 클래스에서 run() 메소드를 재정의하여 스레드를 구현한다.

java.lang.Runnable 인터페이스

- 스레드에서 실행할 코드를 가지는 run() 메소드가 선언되어 있다.

- 자바는 단일 상속만 구현 가능하므로 스레드를 구현할 클래스가 다른 클래스를 상속 받은 경우 Runnable 인터페이스를 구현한다.

- Runnable 인터페이스를 implements 한 클래스는 run() 메소드를 재정의하여 스레드를 구현한다.

스레드 시작

- 스레드를 실행하기 위해서는 Thread 클래스의 start() 메소드를 호출하면 스레드를 시작한다. start() 메소드에 의해 스레드가 시작되면, 자바 가상 머신은 이 스레드의 run() 메소드를 호출한다.

- 스레드 시작 방법

　1) Thread 클래스를 상속받는 하위 클래스 만든 경우 : 해당 클래스의 객체를 생성한 후 Thread 클래스의 start() 메소드를 호출한다.

　2) Runnable 인터페이스를 구현하여 클래스를 만든 경우 : Thread(Runnable target) 생성자에 Runnable 인터페이스 구현 클래스 객체를 인수로 넘겨 Thread 클래스의 객체를 생성하여 Thread 클래스의 start() 메소드를 호출한다.

스레드 종료

- 스레드의 종료는 run() 메소드가 종료되는 시점이다.

- Thread 클래스의 stop() 메소드를 이용하여 강제로 스레드를 종료할 수 있지만 사용을 권장하지 않는다.

package threadEx;

public class Ex001_Thread {

	public static void main(String[] args) {
		MyThread1 t = new MyThread1();

		t.start(); // 스레드 시작
		// t.run(); // 유저가 부르면 Tread가 아님.
		
		try {
			for (int i = 1; i <= 10; i++) {
				System.out.println("main -> " + i);
				Thread.sleep(100);
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		System.out.println("main 종료 !!!");
		// main은 프로그램의 시작점이지만 종료점은 아니다.
		// main이 종료되어도 프로그램은 종료되지 않을 수 있다.
		// 프로그램의 종료 시점은 모든 독립스레드가 종료되는 시점이다.
	}
}

// 스레드 구현방법 - 1
//	1) Thread 클래스를 상속 받아 run() 메소드를 override한다.
//	2) Thread 클래스를 상속 받은 클래스의 객체를 생성하여 start() 메소드를 호출한다.
class MyThread1 extends Thread {

	@Override
	public void run() {
		int n = 0;

		try {
			while (n < 20) {
				n++;
				System.out.println(getName() + " -> " + n);

				sleep(500); // 지정 시간(단위:ms)동안 스레드 실행이 일시 중지됨.
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

	}
}

스레드클래스를 상속받아 run() 메소드를 override 해서 클래스의 객체를 생성해서 start()메소드로 멀티 스레드를 구현했다. main 에서도 이미 Thread가 (main() 메소드를 진입점으로 하는 메인 스레드가 존재) 있기 때문에 둘을 비교해보았다.

main()이 종료되어도 프로그램 종료는 모든 독립 스레드가 종료된 후에 일어난다.

package threadEx;

public class Ex002_Runnable {
	public static void main(String[] args) {
		MyThread2 th = new MyThread2();
		Thread t = new Thread(th);
		t.start();
		
		try {
			for (int i = 1; i <= 10; i++) {
				System.out.println("main -> " + i);
				Thread.sleep(100);
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		System.out.println("main 종료 !!!");
	}
}

// 스레드 구현방법 - 2
//	1) Runnable 인터페이스를 구현하는 클래스를 만들어 run() 메소드를 override 한다.
//	2) Runnable 인터페이스 구현 클래스 객체를 생성한다.
//	3) Thread 클래스를 객체를 생성하며, Thread 객체를 생성할 때 생성자의 인자에 2)번에서 생성한 객체를 넘긴다.
//	4) 
class MyThread2 implements Runnable {

	@Override
	public void run() {
		int n = 0;

		try {
			while (n < 20) {
				n++;
				System.out.println(Thread.currentThread().getName() + " -> " + n);
				Thread.sleep(500);
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

}

Runnable 인터페이스를 구현하는 클래스를 만들어 run() 메소드를 override한 후 Runnable 인터페이스 구현 클래스 객체를 생성한다. Thread 클래스 객체를 생성하여 생성자의 인자에 Runnable 구현 클래스 객체를 넘겨준다.

package threadEx;

public class Ex003_Runnable {

	public static void main(String[] args) {
		// 스레드 구현방법 - 3 : 익명 클래스를 이용한 스레드 구현
		Thread t = new Thread(new Runnable() {

			@Override
			public void run() {
				try {
					for (int n = 1; n <= 20; n++) {
						System.out.println("스레드 -> " + n);
						Thread.sleep(500);
					}
				} catch (InterruptedException e) {
					e.printStackTrace();
				}

			}
		});

		t.start();

		try {
			for (int i = 1; i <= 10; i++) {
				System.out.println("메인 -> " + i);
				Thread.sleep(100);
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		System.out.println("메인 종료 !!!");
		
	}

}

익명클래스는 전에 수업시간에 한 번 보고 나서 너무 오랫만에 보는 클래스라 너무 낯설었다.

package threadEx;

public class Ex004_Runnable {

	public static void main(String[] args) {
		// 스레드 구현 방법 - 4 : 람다를 이용한 스레드 구현
		Thread t = new Thread( () -> {
			try {
				for (int n = 1; n <= 20; n++) {
					System.out.println("스레드 -> " + n);
					Thread.sleep(500);
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		});

		t.start();

		try {
			for (int i = 1; i <= 10; i++) {
				System.out.println("메인 -> " + i);
				Thread.sleep(100);
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		System.out.println("메인 종료 !!!");

	}

}

람다는 아직 배우지 않았으므로 그냥 이렇게 구현할 수 있구나~ 정도만 알면 된다고 하셨다.