Jaybon 의 지식창고

문제

-- 박지성이 구매한 도서의 출판사와 같은 출판사에서 도서를 구매한 고객의 이름
SELECT DISTINCT C.NAME
FROM customer C, ORDERS O, BOOK B
WHERE c.custid = o.custid 
        AND o.bookid = b.bookid 
        AND b.publisher IN (
                            SELECT b.publisher
                            FROM customer C, ORDERS O, BOOK B
                            WHERE c.custid = o.custid AND o.bookid = b.bookid AND C.NAME = '박지성')
        AND C.NAME NOT LIKE '박지성';


-- 두 개 이상의 서로 다른 출판사에서 도서를 구매한 고객의 이름
SELECT C.NAME, COUNT(DISTINCT b.publisher)
FROM customer C, ORDERS O, BOOK B
WHERE c.custid = o.custid AND o.bookid = b.bookid
GROUP BY C.NAME
HAVING COUNT(DISTINCT b.publisher) >= 2;


-- 두 개 이상의 서로 다른 출판사에서 도서를 구매한 고객의 이름 - 상관쿼리
-- GROUP BY 를 사용한 쿼리는 상관쿼리로 바꿀 수 있다
    SELECT C1.NAME
    FROM customer C1 -- 하위쿼리에 C.NAME LIKE C1.NAME 이렇게 연결하면 GROUP BY를 안쓰고도 그룹함수를 쓸 수 있다.
    WHERE 2 <= (SELECT COUNT(DISTINCT B.PUBLISHER)
                FROM customer C, ORDERS O, BOOK B
                WHERE c.custid = o.custid AND o.bookid = b.bookid AND C.NAME = C1.NAME);


-- 전체 고객의 30% 이상이 구매한 도서
SELECT b.bookname, COUNT(b.bookname)
FROM ORDERS O, BOOK B
WHERE o.bookid = b.bookid
GROUP BY b.bookname
HAVING COUNT(b.bookname) >= (
                            SELECT (COUNT(*) * 0.3)
                            FROM customer
                            );
                        
                        
-- 전체 고객의 30% 이상이 구매한 도서 - 상관쿼리
SELECT B1.BOOKNAME
FROM BOOK B1
WHERE (SELECT COUNT(b.bookname)
        FROM ORDERS O, BOOK B
        WHERE o.bookid = b.bookid AND B.BOOKID = B1.BOOKID) >= ( SELECT (COUNT(*) * 0.3) FROM customer);


--새로운 도서 ('스포츠 세계', '대한미디어', 10000원)이 마당서점에 입고되었다. 삽입이 안될 경우 필요한 데이터가 더 있는지 찾아보자
-- PRIMARY KEY 가 필요함 31로 임의 삽입
INSERT INTO book(BOOKID, BOOKNAME, PUBLISHER, PRICE)
VALUES(31, '스포츠 세계', '대한미디어', 10000);


-- '삼성당'에서 출판한 도서를 삭제해야 한다
DELETE FROM BOOK
WHERE publisher = '삼성당';


-- '이상미디어'에서 출판한 도서를 삭제해야 한다. 삭제가 안 될 경우 원인을 생각해보자
DELETE FROM BOOK
WHERE publisher LIKE '이상미디어'; -- 자식 레코드가 있어서 삭제불가


--출판사 '대한미디어'가 '대한출판사'로 이름을 바꾸었다.
UPDATE book
SET publisher = '대한출판사' -- 값을 넣는것이기 때문에 LIKE쓰면 안된다
WHERE publisher LIKE '대한미디어'; -- 비교하는 것이기 때문에 LIKE써도 된다

기본키 - 개체 무결성

자바에서 DB에 데이터 전송할 때는 속성명을 모두 적어줘야한다

쿼리를 실행하고 F10을 누르면 COST가 나온다

---------------------

데이터베이스

릴레이션 - 테이블

릴레이션쉽 - 테이블 연결

인스턴스 - 테이블의 모든 튜플들 모음

넓은 의미의 스키마 - 데이터베이스의 모든객체

좁은 의미의 스키마 - 테이블

도메인 - 값의 범위 제한 (1~100)

원자성 - 한 속성에 한가지 데이터만 넣는.. 느낌

관계대수 - 쿼리를 수식으로 만들어 놓음

제약조건 - constraints

기본키 - 유일해야한다, 테이블에 있는 후보키들 중에 선택된 1개

복합키 - 속성을 묶은 쌍을 키로 사용

후보키 -  alternate key, 대체키, 기본키가 되지 않은 속성이나 속성을 묶은 쌍

슈퍼키 - 중복되지 않은 속성 뿐만 아니라 속성과 속성을 묶은 쌍도 슈퍼키다

대리키 - surrogate key, artificial key , 긴급할 때 기본키 대용으로 쓰는 것  - rownum 같은 것

외래키 - 다른테이블이나 같은테이블(멘토의 경우)에서 참조하는 키

관계대수

프로젝션 - SELECT

셀렉션 - WHERE

데이터베이스 용어

출처

https://cafe.naver.com/busanit2018db

프로시저와 함수의 차이

프로시저 - 리턴값이 없는 함수

함수 - 리턴값이 없는 함수 (SELECT 와 FROM사이에 있는 모든 것)

DATE - 날짜계산 등 편하기 때문에 (+연산) 3월31일 +1일 = 4월 1일

SYSDATE - 시스템 시간을 가져옴

SYSTIMESTAMP - 더 정밀한 시스템 시간을 가져옴

-----------------------------

gpt 타입일 경우 기본적으로 컴퓨터 부팅하면 인식 못하는 경우가 있다

그럴 때 바이오스로 들어가서 windows boot manager를 1순위로 하여 해결 가능

-

package ch15;

class MyOuterClass {
	int outerNum = 10;
	
	public MyOuterClass() {
		MyInnerClass mc = new MyInnerClass();
		System.out.println(mc.innerNum);
	}

	class MyInnerClass {
		int innerNum = 20;
	}
}

public class InnerEx01 {
	public static void main(String[] args) {
		MyOuterClass moc = new MyOuterClass();
		MyOuterClass.MyInnerClass d = moc.new MyInnerClass();
	}
}

package Chat;

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

public class MySocketServer {

	ServerSocket serverSocket;
	Vector<NewSocketThread> vt; // 어레이리스트와 비슷하지만 여러곳에서 동시접근 시 queue를 이용하여 순서대로 처리한다

	public MySocketServer() throws Exception {
		vt = new Vector<>(); // 새 벡터 객체 생성

		serverSocket = new ServerSocket(3000);

		while (true) {

			// socket 을 보관해놔야한다 - 메시지 보내야할 소켓을 기억해야 하기 때문
			// 요청을 대기 - 연결이 되면 소켓을 리턴하고 서버소켓에 연결된 선을 끊는다
			Socket socket = serverSocket.accept();
			System.out.println("요청이 들어옴");

			// 스레드를 돌리기 위한 객체 생성(socket을 받는다)
			// 각각 스레드는 자기가 연결해야할 socket을 객체 안에 들고 있게 된다
			NewSocketThread nt = new NewSocketThread(socket);

			// 새 스레드에 nt객체(타겟)을 넣는다
			Thread newWorker = new Thread(nt);

			// 스레드를 실행한다
			newWorker.start();

			// 벡터배열에 nt객체를 추가한다
			vt.add(nt);

		}
	}

	// 딴곳에 쓸일이없이 클래스 내부에서만 쓸거라면 내부클래스 생성
	// 새로운 스레드에게 버퍼를 연결할 수 있게 socket을 전달
	class NewSocketThread implements Runnable {

		Socket socket; // MySocketServer()에서 서버소켓이 받은 소켓을 저장
		BufferedReader br;
		BufferedWriter bw;

		public NewSocketThread(Socket socket) {
			this.socket = socket; // 받은 소켓을 저장
		}

		@Override
		public void run() {
			try {

				// 소켓에서 데이터를 받기 위한 버퍼
				br = new BufferedReader(new InputStreamReader(socket.getInputStream()));

				// 소켓에 데이터를 쓰기 위한 버퍼
				bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

				String msg = "";

				// 버퍼에서 받은 데이터를 msg로 넣고 msg가 null이 아니면 내용을 실행한다
				while ((msg = br.readLine()) != null) {
					System.out.println("클라이언트 : " + msg);

					// 클라이언트들에게 누군가가 보낸 메시지를 다시 보낸다
					for (NewSocketThread newSocketThread : vt) {

						// 메시지를 보낸 당사자를 제외하고 나머지 클라이언트들에게 보낸다
						if (newSocketThread != this) {
							newSocketThread.bw.write(msg + "\n");
							newSocketThread.bw.flush(); // 버퍼를 비우는 것
						}
					}
				}

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

	public static void main(String[] args) {

		try {
			new MySocketServer(); // 소켓 서버 가동
		} catch (Exception e) {
			e.printStackTrace();
		}

	}
}

package Chat;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;

public class MySocketClient {
	
	// 소켓 통신을 위한 변수 생성
	Socket socket;

	public MySocketClient() throws Exception {
		
		// 소켓 객체 생성 - ip주소와 포트를 입력한다
		socket = new Socket("192.168.0.85", 3000);
		
		// 서버에서 보낸 데이터를 읽어들이는 쓰레드의 타겟을 생성한다
		ReadThread rt = new ReadThread();
		
		// 타겟을 쓰레드에 넣는다
		Thread newWorker = new Thread(rt);
		
		// 쓰레드 실행
		newWorker.start();
		
		// 소켓에 데이터를 보낼 bw 객체 생성
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

		// 키보드로 받은 데이터를 읽어들일 버퍼 keyboardIn 생성
		BufferedReader keyboardIn = new BufferedReader(new InputStreamReader(System.in));

		String outPutMsg = "";

		// 메인쓰레드는 여기서 무한루프
		while ((outPutMsg = keyboardIn.readLine()) != null) {
			bw.write(outPutMsg + "\n");
			bw.flush();
		}

	}
	
	// 쓰레드 실행을 위한 런 메서드를 포함한 러너블 클래스
	class ReadThread implements Runnable {
		
		@Override
		public void run() {
			try {
				
				BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
				
				String inputMsg = "";
				
				// 상대방이 보낸 데이터를 서버가 이 클라이언트로 보내면 br로 읽어서 실행
				while ((inputMsg = br.readLine()) != null) {
					System.out.println("상대방 : " + inputMsg);
				}
			} catch (Exception e) {
				e.printStackTrace();
			}

		}
	}

	public static void main(String[] args) {
		try {
			new MySocketClient(); // 클라이언트 메서드 실행
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

-

finally

package Chat;

interface StarUnit {
	int getHp();
}

abstract class Protoss implements StarUnit{
	abstract int getSh();
}

abstract class Zerg implements StarUnit {}

class Zealot extends Protoss {
	int sh = 100;
	int hp = 100;
	
	@Override
	public int getSh() {
		return sh;
	}
	
	@Override
	public int getHp() {
		return hp;
	}
}

class Ultra extends Zerg {
	int hp = 100;
	
	@Override
	public int getHp() {
		return hp;
	}
	
}

public class FinallyEx01 {
	
	// 상태체크 (hp, sh)
	static void check(StarUnit unit) {
		try {
			Zealot z = (Zealot)unit;
			System.out.println("쉴드" + z.getSh());			
			System.out.println("체력" + z.getHp());			
		} catch (Exception e) {
			// 저그
			Ultra u = (Ultra)unit;
			System.out.println("저그는 쉴드가 없습니다.");
			System.out.println("남은 체력은 : " + u.getHp());
		} finally { // try 들어가면 무조건 실행된다
			System.out.println("나는 무조건 실행돼");
		}
	}
	
	public static void main(String[] args) {
		check(new Ultra());
	}
}

-

서버소켓 클래스

- 이름만 서버소켓이지 단순한 소켓이다
- 가장 중요한 기능 
0. accept요청을 대기하다가 연결을 받게 된다
1. 새로운 소켓 생성
2. 서버 소켓과 연결된 선을 끊는다 (기존 소켓을 없애는게 아니다?)
3. 새로운 클라이언트 소켓에 연결
4. 다시 accept 요청을 대기

소켓이 만들어 질 때 마다 새로운 스레드가 필요하다

package ch15;

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

public class MySocketServer {
	
	ServerSocket serverSocket;
	Socket socket;
	
	public MySocketServer() {
		try {
			
			serverSocket = new ServerSocket(15000); // 서버 소켓 생성 (연결을 받는)
			socket = serverSocket.accept(); // 요청을 대기 - 연결이 되면 소켓을 리턴하고 서버소켓에 연결된 선을 끊는다

			BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
			
			String msg = "";
			while ((msg = br.readLine()) != null) {
				System.out.println("sender : " + msg);
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		
	}
}

package ch15;

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

public class MySocketServer {
	
	ServerSocket serverSocket;
	Socket socket;
	BufferedReader br;
	
	public MySocketServer() {
		try {
			
			serverSocket = new ServerSocket(15000); // 서버 소켓 생성 (연결을 받는)
			socket = serverSocket.accept(); // 요청을 대기 - 연결이 되면 소켓을 리턴하고 서버소켓에 연결된 선을 끊는다

			br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
			
			String msg = "";
			while ((msg = br.readLine()) != null) {
				System.out.println("sender : " + msg);
			}
			
		} catch (Exception e) { // 소켓연결이 끊기면 catch로 와지면서 while을 벗어나게 된다 
			e.printStackTrace();
		}

		try {
			br.close();
			socket.close();
			serverSocket.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		
	}
}

package ch15;

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

public class MySocketServer {

	ServerSocket serverSocket;
	Socket socket;
	BufferedReader br;

	// throws는 함수의 모든 내용이 try catch가 필요한 경우 사용하면 된다
	public MySocketServer() throws Exception { // throws 는 함수를 호출한 자에게 던지는 것이다

		serverSocket = new ServerSocket(15000); // 서버 소켓 생성 (연결을 받는)
		socket = serverSocket.accept(); // 요청을 대기 - 연결이 되면 소켓을 리턴하고 서버소켓에 연결된 선을 끊는다

		br = new BufferedReader(new InputStreamReader(socket.getInputStream()));

		String msg = "";
		while ((msg = br.readLine()) != null) {
			System.out.println("sender : " + msg);
		}

		br.close();
		socket.close();
		serverSocket.close();
	}

	public static void main(String[] args) {
		
		try { // main이 함수를 호출 했기 때문에 여기서 트라이캐치를 사용
			new MySocketServer();
		} catch (Exception e) {
			// TODO: handle exception
		}
	}
}

package ch15;

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

public class MySocketServer {

	ServerSocket serverSocket;
	Socket socket;
	BufferedReader br;

	// throws는 함수의 모든 내용이 try catch가 필요한 경우 사용하면 된다
	public MySocketServer() throws Exception { // throws 는 함수를 호출한 자에게 던지는 것이다

		serverSocket = new ServerSocket(15000); // 서버 소켓 생성 (연결을 받는)
		socket = serverSocket.accept(); // 요청을 대기 - 연결이 되면 소켓을 리턴하고 서버소켓에 연결된 선을 끊는다
		System.out.println("요청이 들어옴");
		br = new BufferedReader(new InputStreamReader(socket.getInputStream()));

		String msg = "";
		while ((msg = br.readLine()) != null) {
			System.out.println("sender : " + msg);
		}

		br.close();
		socket.close();
		serverSocket.close();
	}

	public static void main(String[] args) {
		
		try { // main이 함수를 호출 했기 때문에 여기서 트라이캐치를 사용
			new MySocketServer();
		} catch (Exception e) {
			// TODO: handle exception
		}
	}
}

package ch15;

import java.io.PrintWriter;
import java.net.Socket;

public class MySocketClient {
	
	Socket socket;
	
	public MySocketClient() throws Exception {
		socket = new Socket("localhost", 15000); // 서버소켓의 accept() 함수를 호출
		//"localhost" 또는 127.0.0.1 는 약속된 내용
		
		PrintWriter pw = new PrintWriter(socket.getOutputStream(), true); // autoFlush기능이 있다
		
	}
	
	public static void main(String[] args) {
		try {
			new MySocketClient();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

package ch15;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class MySocketServer {

	ServerSocket serverSocket; // 서버소켓은 연결요청을 대기하다가 연결이 되면 소켓을 리턴하고 서버소켓에 연결된 선을 끊는다
	Socket socket; // 서버소켓이 리턴한 소켓을 받는 역할
	BufferedReader br; // 스트림이 연결되면 BufferedReader로 데이터를 받는다

	// throws는 함수의 모든 내용이 try catch가 필요한 경우 사용하면 된다
	public MySocketServer() throws Exception { // throws 는 함수를 호출한 자(여기서는 main)에게 던지는 것이다

		serverSocket = new ServerSocket(15000); // 서버 소켓 생성 (연결을 받는)
		socket = serverSocket.accept(); // 요청을 대기 - 연결이 되면 소켓을 리턴하고 서버소켓에 연결된 선을 끊는다
		System.out.println("요청이 들어옴");
		br = new BufferedReader(new InputStreamReader(socket.getInputStream()));

		String msg = "";
		while ((msg = br.readLine()) != null) { // br로 데이터를 받고 msg에 넣은 후 null값인지 확인한다
			System.out.println("상대방 : " + msg); // 받은 메시지를 출력한다
		}

		// 사용이 끝난 인스턴스를 닫는다
		br.close();
		socket.close();
		serverSocket.close();
	}

	public static void main(String[] args) {
		
		try { // main이 함수를 호출 했기 때문에 여기서 트라이캐치를 사용
			new MySocketServer(); // 소켓서버 가동 메서드 실행;
		} catch (Exception e) {}
	}
}

package ch15;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;

public class MySocketClient {
	
	Socket socket; // 소켓 생성
	BufferedReader br; // 키보드로 내가 입력한 메시지를 받기위한 br
	BufferedWriter bw; // 내가 입력한 메시지를 소켓으로 보내기 위한 bw 
	
	public MySocketClient() throws Exception {
		
		//스트림
		//"localhost" 또는 127.0.0.1 는 약속된 내용 - 내 컴퓨터의 내부 주소
		socket = new Socket("192.168.0.115", 15000); // 서버소켓의 accept() 함수를 호출
		
		// 소켓 - 버퍼드라이터 연결
		bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
		
		// 키보드 - 버퍼드리더 연결
		br = new BufferedReader(new InputStreamReader(System.in));
		
		String msg = "";
		
		// 키보드로 입력한 메시지를 확인하여 null이 아니면 bw에 적고 flush
		while ((msg = br.readLine()) != null) {
			bw.write(msg + "\n"); // "\n"은 상대방 소켓에서 읽어들이기 위해서 필요한 것이라 넣은 것
			System.out.println("내 메시지 : " + msg);
			bw.flush(); // 버퍼는 꽉차지 않으면 플러시 되지 않기 때문에 수동으로 플러시 시켜준다
		}
		
		// 인스턴스 닫기
		bw.close();
		br.close();
		socket.close();
		
	}
	
	public static void main(String[] args) {
		try {
			new MySocketClient(); // 클라이언트 메서드 실행
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

ArrayList - 동시접근해서 데이터가 꼬일 수 있다

Vector - 동시접속자를 큐에 저장하고 임계구역으로 만들어 여러사람이 동시에 들어오면 순서대로 처리한다 

-----------------------------

모스키토 통신

mqtt

유튜브 퍼블리셔를 구독자가 구독하면

퍼블리셔와 구독자가 통신을 하는데

퍼블리셔는 업로드만 하면 구독자에게 메시지가 가게 된다

구독+업로드 만으로 통신이 연결되는 방식

유튜브에서 유래된 방식

우리나라 표준 통신으로 바뀔 예정 (국제적으로도 유행)

-----------------------------

브로드 캐스트 통신

와이파이와 같이 모든 곳에 뿌리고 받는사람이 선택해서 받는 방식

------------------------------

블루투스 통신

기본적으로 1:1방식 

메시 네트워크라는 방식으로 브로드 캐스트 통신처럼 사용가능
- 페어링을 위한 브로드캐스트인데 그것에 메시지를 담는 것 (페어링 없이 다대다 통신)

-----------------------------

소켓통신

프로토콜이 없다.(약속이 없다)

*만약 소켓통신에 약속을 달면 (지그비, HTTP) 등의 통신을 할 수 있다

Socket -> OS가 들고 있다

OS가 들고 있는 것을 빌려 쓰는 것을 시스템콜이라고 한다

클라이언트와 서버는 포트를 가지고 있다 - 이 포트를 소켓이라고 한다 - 0~65536

(클라이언트, 서버) 서로 포트번호가 같을 필요는 없다

스트림을 연결하고 버퍼드리더, 버퍼드라이터만 이용하면 통신가능하다

멀티프로세싱 - 프로세스 여러개가 동시에 작동해서 작업을 빨리 수행 하는 것
(1개의 프로세스가 3가지 작업을 15초에 할 수 있는데 3개의 프로세스로 나누어 작업하여 5초만에 할 수 있다)

멀티프로세싱 할 경우 cpu가 여러개 있으면 좋다 (병렬처리 가능)

프로그램이 멀티코어를 지원 할 경우에만 멀티프로세싱을 사용 할 수 있다

--------------------------------------

쓰레드

일을 실행하는 단위

일종의 스택

멀티스레드 - 라운드로빈 - 타임슬라이싱 -  일을 시간을 쪼개서 돌아가면서 함

스레드(thread)는 어떠한 프로그램 내에서, 특히 프로세스 내에서 실행되는 흐름의 단위를 말한다. 일반적으로 한 프로그램은 하나의 스레드를 가지고 있지만, 프로그램 환경에 따라 둘 이상의 스레드를 동시에 실행할 수 있다. 이러한 실행 방식을 멀티스레드(multithread)라고 한다.

https://ko.wikipedia.org/wiki/%EC%8A%A4%EB%A0%88%EB%93%9C_(%EC%BB%B4%ED%93%A8%ED%8C%85)

문맥교환(컨텍스트 스위칭 context swiching)

여러가지 일을 시간을 쪼개서 돌아가면서 계속 하는 것

장점

1. 사람의 눈에 동시에 일을 하는 것 처럼 보임
2. 서버에서 그림 등의 데이터를 받는 등의 대기시간에 cpu가 다른 일을 할 수 있다

단점

1. 순서와 위치를 기억해야하기 때문에 느려짐 (컨텍스트 스위칭)

자바에는 기본적으로 main스택이라는 스레드를 가지고 있다

main스레드 이외의 스레드를 Target

Runnable 타입의 클래스 안에 run()메서드가 있고 그 스레드는 Target이 될 수 있다

스레드는 OS가 들고 있다 (윈도우 등)

OS에 스레드를 더 실행해달라고 요청해야 한다. (Runnable타입으로)

OS는 램에서 Runnable 타입의 힙을 찾고 run() 메서드를 실행한다 - 콜백

--------------------------------------

OS가 들고 있는 기능을 사용하는 것을 시스템 콜이라고 한다

--------------------------------------

IPC

데이터 통신을 할려면 시리얼라이즈를 해야한다 - 데이터 직렬화 - 직렬화는 마샬링의 일부

마샬링 - 프로세스간 데이터 통신할 때 데이터를 다른 프로세스가 읽을 수 있게 직렬화 하는 것
(클래스를 다른 곳으로 전송하면 String타입으로 전송되는데 그것을 다시 클래스로 만드는 등)

------------------------------------

콜백

스레드가 메인 스레드에 이벤트를 전송

다른스레드가 종료 된것을 메인 스레드에 보냄

-----------------------------------

데이터베이스에서 동기화

데이터가 일치

------------------------------------

프로세스에서 동기화

동기적 - 일의 순서가 일치해서 순서대로 실행됨

비동기적 - 일의 순서가 나뉘어서 여러개 실행됨

비동기 처리 - promise

비동기에서는 나중시간에 약속된 기능이 있다면

그 시간과 겹치는 앞쪽에 기능이 새로 추가 된다면 앞쪽기능이 실행되다가

약속된 기능이 실행된 뒤 나머지 앞쪽 기능이 실행된다

-------------------------------------

자바에서는 매개변수에 함수를 못넘기기 때문에
클래스를 만들어서 오브젝트를 매개변수로 넘겨서 그 안에 생성했던 함수를 이용한다
-> 익명클래스의 사용 이유

----------------------------------

익명클래스

익명클래스로 스레드 추가도 가능

야매

해결