JAVA 겨울방학 7일차

Thread Scheduler: 공정한 형태로 Thread를 실행 ex)Round Robin 

공정하지 않으면 특정 thread가 starvation에 빠짐

Java10(Stream 기반)

-Stream은 데이터의 연결통로

-입력통로와 출력통로가 따로 존재

(입력스트릠과 출력스트림)
(InputStream, OuyputSream)

데이터가 한쪽 방향으로만 흐른다.

하나의 통로를 이용해서 데이터를 보내고 받을 수 없다

package JavaThread;

//이 클래스로부터는 instance를 우리가 원하는 만큼 외부에서 생성할 수 있다.

//프로그램적으로 해당 클래스로부터 instance를 딱 1개만 생성하도록 제한을 걸 수 있다.->싱글톤

class Exam06_Shared{

private static Exam06_Shared obj=new Exam06_Shared();

public static Exam06_Shared getInstance() {

return obj;

}

private Exam06_Shared() {

}

//method자체를 동기화->효율이 좋지 않다 public synchronized void printName()

//synchronized(this) {

// System.out.println(Thread.currentThread().getName());

//}

//wait():현재 수행하고 있는 thread의 수행 중지, 자기가 가지고 있는 모니터객체(lock)을 풀어버린다. 그렇기 때문에 동기화코드내에서 나와야 한다.

//notify(): wait()에 의해서 정지되어있는 Thread를 runnable상태로 전환

public synchronized void printName() {

for(int i=0;i<10;i++) {

try{

Thread.sleep(1000);//현재 실행되는 thread를 sleep상태로 전환

}catch (InterruptedException e) {

e.printStackTrace();

}

notify();

try {

wait();

}catch(InterruptedException e){

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName());

}

}

}

class Exam06_Runnable implements Runnable{

private Exam06_Shared shared;

public Exam06_Runnable(Exam06_Shared shared) {

this.shared=shared;

}

public Exam06_Runnable() {

// TODO Auto-generated constructor stub

}

@Override

public void run() {

shared.printName();

}

}

public class Exam06_State{

public static void main(String[] args) {

//공용 객체를 생성(singleton으로 처리)

Exam06_Shared obj=Exam06_Shared.getInstance();

//Thread가 공유객체를 이용한다는 말은, Thread에게 공유객체를 injection한다는 말이다

System.out.println("소리없는 아우성!");

Thread t1=new Thread(new Exam06_Runnable(obj));

t1.setName("A");

Thread t2=new Thread(new Exam06_Runnable(obj));

t2.setName("B");

t1.start();//instance상태에서 runnable상태로

t2.start();//instance상태에서 runnable상태로

//Thread Scheduler가 runnable중 선택!

}

}

package JavaThread;

import javafx.application.Application;

import javafx.application.Platform;

import javafx.geometry.Insets;

import javafx.scene.Scene;

import javafx.scene.control.Button;

import javafx.scene.control.TextArea;

import javafx.scene.layout.BorderPane;

import javafx.scene.layout.FlowPane;

import javafx.stage.Stage;

//Application은 javafx를 이용하려고

public class Exam07_Interrupt extends Application{

private TextArea textarea;

private Thread t;

public static void main(String[] args) {

launch();

}

@Override

public void start(Stage primaryStage) throws Exception {

// TODO Auto-generated method stub

BorderPane root=new BorderPane();

//크기 지정(창의 크기로 사용)

root.setPrefSize(700, 500); 

textarea=new TextArea();

textarea.setEditable(false);

root.setCenter(textarea);

FlowPane bottom=new FlowPane();

bottom.setPrefSize(700, 50);

bottom.setPadding(new Insets(20,20,20,20));

Button startBtn=new Button("Thread 시작");

startBtn.setPrefSize(100, 30);

startBtn.setOnAction(event->{

t=new Thread(new Runnable() {

@Override

public void run() {

// TODO Auto-generated method stub

while(true) {

try {

Thread.sleep(1000);

Platform.runLater(()->{

textarea.appendText("안녕하세요\n");

});

}

catch (InterruptedException e) {

break;

}

}

}

});

t.setDaemon(true);

t.start();

});

Button stopBtn=new Button("Thread 중지");

stopBtn.setPrefSize(100, 30);

stopBtn.setOnAction(event->{

//이렇게 안해요! t.stop();

t.interrupt();//t라는 thread에 표시(interrupt걸렸다고)

//만약 interrupt표시된 thread가 block 상태로 들어가면 자동적으로 exception 발생

});

bottom.getChildren().add(startBtn);

bottom.getChildren().add(stopBtn);

//화면 아래부분에 위에서 만든 패널을 붙인다.

root.setBottom(bottom);

Scene scene=new Scene(root);

primaryStage.setScene(scene);

primaryStage.show();

}

}

package JavaThread;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import javafx.application.Application;

import javafx.application.Platform;

import javafx.geometry.Insets;

import javafx.scene.Scene;

import javafx.scene.control.Button;

import javafx.scene.control.TextArea;

import javafx.scene.layout.BorderPane;

import javafx.scene.layout.FlowPane;

import javafx.stage.Stage;

//Application은 javafx를 이용하려고

public class Exam08_ThreadPoolBasic extends Application{

private TextArea textarea;

//java7 이상에서 사용할 수 있는 ThreadPool을 하나 선언

private ExecutorService executorservice;

public static void main(String[] args) {

launch();

}

@Override

public void start(Stage primaryStage) throws Exception {

// TODO Auto-generated method stub

BorderPane root=new BorderPane();

//크기 지정(창의 크기로 사용)

root.setPrefSize(700, 500); 

textarea=new TextArea();

textarea.setEditable(false);

root.setCenter(textarea);

FlowPane bottom=new FlowPane();

bottom.setPrefSize(700, 50);

bottom.setPadding(new Insets(20,20,20,20));

Button createPoolBtn=new Button("Thread Pool 생성");

createPoolBtn.setPrefSize(100, 30);

createPoolBtn.setOnAction(event->{

executorservice=Executors.newCachedThreadPool();

//newCachedThreadPool(): 기본 thread의 수는 0개

//thread를 사용하겠어요라고 하면 하나의 thread를 생성

//만약 또 필요하면 pool안에 또 만든다.

//나중에 사용이 끝나면 60초 대기하다가 사용이 없으면 삭제

//executorservice=Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());//core갯수로!->최적화

//newFixedThreadPool(4): 기본 thread싀 수는 0개

//thread가 필요하면 하나 만들어서 빌려줘서 사용

//이 thread pool 안에는 최대 4개의 thread만 존재

// 60초제한 이런 거 없다. 사용한 Thread는 pool안에 지속적으로 존재

});

Button createThreadBtn=new Button("Thread 시작");

createThreadBtn.setPrefSize(100, 30);

createThreadBtn.setOnAction(event->{

Runnable runnable=new Runnable() {

//Runnable interface를 구현한 객체 생성

//익명 내부 클래스를 이용해서 인스턴스 생성

@Override

public void run() {

Platform.runLater(()->{

textarea.appendText("소리없는 아우성!!");

});

}

};

//Threadpool 이용해서 thread로 실행

executorservice.execute(runnable);

});

Button stopPoolBtn=new Button("ThreadPool 중지");

stopPoolBtn.setPrefSize(100, 30);

stopPoolBtn.setOnAction(event->{

//executorservice.shutdown();

//현재 thread pool안에서 수행되는 모든 thread가 종료된 후에 thread pool을 종료

executorservice.shutdownNow();

//현재 thread pool 안에서 수행되는 모든 thread를 interript()처리

//그 후에 thread pool을 종료

});

bottom.getChildren().add(createPoolBtn);

bottom.getChildren().add(createThreadBtn);

bottom.getChildren().add(stopPoolBtn);

//화면 아래부분에 위에서 만든 패널을 붙인다.

root.setBottom(bottom);

Scene scene=new Scene(root);

primaryStage.setScene(scene);

primaryStage.show();

}

}

package JavaThread;

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

import javafx.application.Application;

import javafx.application.Platform;

import javafx.geometry.Insets;

import javafx.scene.Scene;

import javafx.scene.control.Button;

import javafx.scene.control.TextArea;

import javafx.scene.layout.BorderPane;

import javafx.scene.layout.FlowPane;

import javafx.stage.Stage;

//Application은 javafx를 이용하려고

public class Exam09_Callable extends Application{

private TextArea textarea;

//java7 이상에서 사용할 수 있는 ThreadPool을 하나 선언

private ExecutorService executorservice;

public static void main(String[] args) {

launch();

}

@Override

public void start(Stage primaryStage) throws Exception {

// TODO Auto-generated method stub

BorderPane root=new BorderPane();

//크기 지정(창의 크기로 사용)

root.setPrefSize(700, 500); 

textarea=new TextArea();

textarea.setEditable(false);

root.setCenter(textarea);

FlowPane bottom=new FlowPane();

bottom.setPrefSize(700, 50);

bottom.setPadding(new Insets(20,20,20,20));

Button createPoolBtn=new Button("Thread Pool 생성");

createPoolBtn.setPrefSize(100, 30);

createPoolBtn.setOnAction(event->{

executorservice=Executors.newCachedThreadPool();

//newCachedThreadPool(): 기본 thread의 수는 0개

//thread를 사용하겠어요라고 하면 하나의 thread를 생성

//만약 또 필요하면 pool안에 또 만든다.

//나중에 사용이 끝나면 60초 대기하다가 사용이 없으면 삭제

//executorservice=Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());//core갯수로!->최적화

//newFixedThreadPool(4): 기본 thread의 수는 0개

//thread가 필요하면 하나 만들어서 빌려줘서 사용

//이 thread pool 안에는 최대 4개의 thread만 존재

// 60초제한 이런 거 없다. 사용한 Thread는 pool안에 지속적으로 존재

});

Button createThreadBtn=new Button("Thread 시작");

createThreadBtn.setPrefSize(100, 30);

createThreadBtn.setOnAction(event->{

Runnable runnable=new Runnable() {

//Runnable interface를 구현한 객체 생성

//익명 내부 클래스를 이용해서 인스턴스 생성

@Override

public void run() {

Platform.runLater(()->{

textarea.appendText("소리없는 아우성!!");

});

}

};

Callable callable=new Callable<String>() {

@Override

public String call() throws Exception {

// TODO Auto-generated method stub

return "소리없는 아우성!!";

}

};

//Threadpool 이용해서 thread로 실행

//인자로 callable리 들어가면 결과값이 있다는 뜻이다. method가 execute()가 아닌 submit()

Future<String> future=executorservice.submit(callable);

try {

String result=future.get();//프로그램이 block 

System.out.println(result);

}catch (InterruptedException e) {

// TODO: handle exception

e.printStackTrace();

}catch(ExecutionException e){

e.printStackTrace();

}

});

Button stopPoolBtn=new Button("ThreadPool 중지");

stopPoolBtn.setPrefSize(100, 30);

stopPoolBtn.setOnAction(event->{

//executorservice.shutdown();

//현재 thread pool안에서 수행되는 모든 thread가 종료된 후에 thread pool을 종료

executorservice.shutdownNow();

//현재 thread pool 안에서 수행되는 모든 thread를 interript()처리

//그 후에 thread pool을 종료

});

bottom.getChildren().add(createPoolBtn);

bottom.getChildren().add(createThreadBtn);

bottom.getChildren().add(stopPoolBtn);

//화면 아래부분에 위에서 만든 패널을 붙인다.

root.setBottom(bottom);

Scene scene=new Scene(root);

primaryStage.setScene(scene);

primaryStage.show();

}

}

package JavaThread;

import java.util.Random;

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorCompletionService;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

import javafx.application.Application;

import javafx.geometry.Insets;

import javafx.scene.Scene;

import javafx.scene.control.Button;

import javafx.scene.control.TextArea;

import javafx.scene.layout.BorderPane;

import javafx.scene.layout.FlowPane;

import javafx.stage.Stage;

//Application은 javafx를 이용하려고

public class Exam10_Completeion extends Application{

private TextArea textarea;

//java7 이상에서 사용할 수 있는 ThreadPool을 하나 선언

private ExecutorService executorservice; //일반 thread pool

private ExecutorCompletionService<Integer> executorCompletionService;

public static void main(String[] args) {

launch();

}

@Override

public void start(Stage primaryStage) throws Exception {

// TODO Auto-generated method stub

BorderPane root=new BorderPane();

//크기 지정(창의 크기로 사용)

root.setPrefSize(700, 500); 

textarea=new TextArea();

textarea.setEditable(false);

root.setCenter(textarea);

FlowPane bottom=new FlowPane();

bottom.setPrefSize(700, 50);

bottom.setPadding(new Insets(20,20,20,20));

Button createPoolBtn=new Button("Thread Pool 생성");

createPoolBtn.setPrefSize(100, 30);

createPoolBtn.setOnAction(event->{

executorservice=Executors.newCachedThreadPool();

//newCachedThreadPool(): 기본 thread의 수는 0개

//thread를 사용하겠어요라고 하면 하나의 thread를 생성

//만약 또 필요하면 pool안에 또 만든다.

//나중에 사용이 끝나면 60초 대기하다가 사용이 없으면 삭제

//executorservice=Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());//core갯수로!->최적화

//newFixedThreadPool(4): 기본 thread의 수는 0개

//thread가 필요하면 하나 만들어서 빌려줘서 사용

//이 thread pool 안에는 최대 4개의 thread만 존재

// 60초제한 이런 거 없다. 사용한 Thread는 pool안에 지속적으로 존재

//thread pool(특수한 목적의 thread pool)

executorCompletionService=new ExecutorCompletionService<Integer>(executorservice);

});

Button createThreadBtn=new Button("Thread 시작");

createThreadBtn.setPrefSize(100, 30);

createThreadBtn.setOnAction(event->{

Random random=new Random();

for(int i=0;i<10;i++) {

final int k=i+1;

Callable callable=new Callable<Integer>(){

@Override

public Integer call() throws Exception {

// TODO Auto-generated method stub

Thread.sleep(random.nextInt(3000));

return k;

}

};

executorCompletionService.submit(callable);

}

Runnable runnable=new Runnable() {

@Override

public void run() {

//결과 취합

int sum=0;

for(int i=0;i<10;i++) {

try {

Future<Integer> future=executorCompletionService.take();

//take() thread pool안의 완료된 thread의 future 객체를 가져와요

//만약 완료된게 없다면 완료될때 까지 기다린다

sum+=future.get();

}catch (InterruptedException e) {

    e.printStackTrace();

}catch (ExecutionException e) {

e.printStackTrace();

}

}

System.out.println("결과값: "+sum);

}

};

executorservice.execute(runnable);

});

Button stopPoolBtn=new Button("ThreadPool 중지");

stopPoolBtn.setPrefSize(100, 30);

stopPoolBtn.setOnAction(event->{

//executorservice.shutdown();

//현재 thread pool안에서 수행되는 모든 thread가 종료된 후에 thread pool을 종료

executorservice.shutdownNow();

//현재 thread pool 안에서 수행되는 모든 thread를 interript()처리

//그 후에 thread pool을 종료

});

bottom.getChildren().add(createPoolBtn);

bottom.getChildren().add(createThreadBtn);

bottom.getChildren().add(stopPoolBtn);

//화면 아래부분에 위에서 만든 패널을 붙인다.

root.setBottom(bottom);

Scene scene=new Scene(root);

primaryStage.setScene(scene);

primaryStage.show();

}

}