public class Task implements Runnable{

    public void run(){
        // 스레드가 실행할 코드;
    }

}

Runnable task = new Task();
Thread thread = new Thread(task);

Thread thread = new Thread(new Runnable(){
    public void run(){
        // 스레드가 실행할 코드;
    }
});

Thread thread = new Thread(()->{
    // 스레드가 실행할 코드;
});

thread.start();

public class myThread extends Thread{
    @Override
    public void run(){
        // 스레드가 실행할 코드
    }
}

Thread thread = new Thread(){
    @Override
    public void run(){
        // 스레드가 실행할 코드
    }
}

thread.setName("스레드 이름");   // 스레드 이름 설정
thread.getName();             // 스레드의 이름 가져오기

Thread thread = Thread.currentThread();

// main
public class MainThreadExample{
    public static void main(String[] args){
        
        Calculator calculator = new Calculator();   // 공유하게 되는 객체
        
        User1 user1 = new User1();
        user1.setCalculator(calculator);
        user1.start();
        
        User2 user2 = new User2();
        user2.setCalculator(calculator);
        user2.start();
        
    }
}

// 공유 객체
public class Calculator{
    private int memory;
    
    public int getMemory(){
        return memory;
    }
    
    public void setMemory(int memory){
        this.memory = memory;
        
        try{
            Thread.sleep(2000);
        }catch(InterruptedException e){
            System.out.println(Thread.currentThread().getName() + " : " + this.memory);
        }
    }
}

// User1
public class User1 extends Thread{
    private Calculator calculator;
    
    public void setCalculator(Calculator calculator){
        this.setName("CalculatorUser1");
        this.calculator = calculator;
    }
    
    public void run(){
        calculator.setMemory(100);  // 공유 객체에 100 저장
    }
    
}


// User2
public class User2 extends Thread{
    private Calculator calculator;
    
    public void setCalculator(Calculator calculator){
        this.setName("CalculatorUser2");
        this.calculator = calculator;
    }
    
    public void run(){
        calculator.setMemory(50);   // 공유 객체에 50 저장
    }
    
}

public Synchronized void method(){
    // 단 하나의 스레드만 실행 가능
}

public void method(){
    
    // 여러 스레드가 실행 가능
    
    Synchronized(공유객체){
        // 단 하나의 스레드만 실행 가능
    }
    
    // 여러 스레드가 실행 가능
    
}

try{
    Thread.sleep(3*1000);   // 3초 동안 일시 정지 상태로 있는다.
}catch(InterruptedException e){
    // interrupt() 메소드가 호출되면 실행 된다.
}

public class YieldExample{
    public static void main(String[] args){
        ThreadA threadA = new ThreadA();
        ThreadB threadB = new ThreadB();
        
        // ThreadA, ThreadB 모두 실행
        threadA.start();
        threadB.start();
        
        try{
            Thread.sleep(3000);
        }catch(InterruptedException e){
            // ...    
        }
        threadA.work = false;       // ThreadB만 실행
        
        try{
            Thread.sleep(3000);
        }catch(InterruptedException e){
            // ...    
        }
        threadA.work = true;        // ThreadA, ThreadB 모두 실행
        
        try{
            Thread.sleep(3000);
        }catch(InterruptedException e){
            // ...    
        }
        threadA.stop = true;        // ThreadA, ThreadB 모두 종료
        threadB.stop = true;
        
    }
}

public class ThreadA extends Thread{
    public boolean stop = false;    // 종료 플래그
    public boolean work = true; // 작업 진행 여부 플래그
    
    public void run(){
        while(!stop){
            if(work){
                // 작업 내용
            }else{
                Thread.yield(); // work가 false가 되면, 다른 스레드에게 실행을 양보
            }
        }
        System.out.println("ThreadA 종료");
    }
}

public class ThreadB extends Thread{
    public boolean stop = false;    // 종료 플래그
    public boolean work = true; // 작업 진행 여부 플래그
    
    public void run(){
        while(!stop){
            if(work){
                // 작업 내용
            }else{
                Thread.yield(); // work가 false가 되면, 다른 스레드에게 실행을 양보
            }
        }
        System.out.println("ThreadB 종료");
    }
}

public class JoinExample{
    public static void main(String[] args){
        SumThread sumThread = new SumThread();
        sumThread.start();
        
        try{
            sumThread.join();   // sumThread가 종료할 때까지 main스레드를 일시 정지시킨다.
        }catch(InterruptedException e){
        
        }
        
        System.out.println("결과 : " + sumThread.getSum(); 
    }
}

public class DataBox{
    private String data;
    
    public Synchronized String getData(){
        if(this.data == null){
            try{
                wait();     // data가 null인 경우, 스레드를 일시 정지 상태로 만든다.
            }catch(InterruptedExcetion e){
                // ...
            }
        }
            
        String returnValue = data;
        System.out.println("ConsumerThread가 읽은 데이터 : " + returnValue);
        
        data = null;
        notify();       // ProducerThread를 실행 대기 상태로 만듬
        return returnValue;
        }
    }
    
    public Synchronized String setData(String data){
        if(this.data != null){
            try{
                wait();     // data가 null이 아니면, 스레드를 일시 정지 상태로 만든다.
            }catch(InterruptedExcetion e){
                // ...
            }
        }
            
        this.data = data;
        System.out.println("ProducerThread가 생성한 데이터 : " + data);
        notify();       // wait()에 의해서 일시 정지된 Thread를 실행 대기 상태로 만듬
        
        }
    }
}

public class ProducerThread extends Thread{
    private DataBox dataBox;
    
    public ProducerThread(DataBox dataBox){
        this.dataBox = dataBox;
    }
    
    @Override
    public void run(){
        for(int i=1; i<=3; i++){
            String data = "Data - "+ i;
            dataBox.setData(data);
        }
    }
}

public class ConsumerThread extends Thread{
    private DataBox dataBox;
    
    public ConsumerThread(DataBox dataBox){
        this.dataBox = dataBox;
    }
    
    @Override
    public void run(){
        for(int i=1; i<=3; i++){
            String data = dataBox.getData();
        }
    }
}

public class WaitNotifyExample{
    public static void main(String[] args){
        DataBox dataBox = new DataBox();
        
        ProucerThread producerThread = new ProducerThread(dataBox);
        ConsumerThread consumerThread = new ConsumerThread(dataBox);
        
        producerThread.start();
        consumerThread.start();
        
    }
}

public class StopFlagExample{
    public static void main(String[] args){
        PrintThread1 printThread = new PrintThread1();
        printThread.start();
        
        try{ 
            Thread.sleep(1000);
        }catch(InterruptedException e){
            // ...
        }
        
        printThread.setStop(true);  // 스레드를 종료시키기 위해 stop 필드를 true로 변경
        
    }
}

public class PrintThread1 extends Thread{
    private boolean stop;
    
    public void setStop(boolean stop){
        this.stop = stop;
    }
    
    public void run(){
        while(!stop){
            System.out.println("실행 중");
        }
        
        System.out.println("자원 정리");
        System.out.println("실행 종료");
    }
    
}

public class InterruptExample{
    public static void main(String[] args){
        Thread thread = new PrintThread2();
        thread.start();
        
        try{
            Thread.sleep(1000);
        }catch(InterruptedException e){
            // ...
        }
        
        thread.interrupt();     // PrintThread2를 종료시키기 위해 InterruptedException을 발생 시킨다.
        
    }
}

 public class PrintThread2 extends Thread{
    public void run(){
        while(true){
            System.out.println("실행 중");
            if(Thread.interrupted()){
                break;
            }
        }
        
        System.out.println("자원 정리");
        System.out.println("실행 종료");
        
    }
 }

public class AutoSaveThread extends Thread{
    public void save(){
        System.out.println("자동 저장 합니다.");
    }
    
    @Override
    public void run(){
        while(true){
            try{
                Thread.sleep(1000);
            }catch(InterruptedException e){
                break;
            }
            save();
            
        }
    }
}

public class DaemonExample{
    public static void main(String[] args){
        AutoSaveThread autoSaveThread = new AutoSaveThread();
        autoSaveThread.setDaemon(true);     // AutoSaveThread를 데몬 스레드로 만든다.
        autoSaveThread.start();
        
        try{
            Thread.sleep(3000);
        }catch(InterruptedException e){
        
        }
        
        System.out.println("메인 스레드 종료");
    }
}

ThreadGroup group = Thread.currentThread.getThreadGroup();
String groupName = group.getName();

Map<Thread, StackTraceElement[]> map = Thread.getAllStackTraces();
Set<Thread> threads = map.keySet();
for(Thread thread : threads){
    System.out.println("Name : " + thread.getName() + ((thread.isDaemon()) ? "데몬" : "주"));
    System.out.println("스레드 그룹 : thread.getThreadGroup().getName());
}

ThreadGroup tg = new ThreadGroup(String name);  // 현재 스레드가 속한 그룹의 하위 그룹으로 생성됨.
ThreadGroup tg = new ThreadGroup(ThreadGroup parent, String name);  // 지정해준 스레드 그룹의 하위 스레드 그룹으로 생성됨

Thread t = new Thread(ThreadGroup group, Runnable target, target());
Thread t = new Thread(ThreadGroup group, Runnable target, String name);  // name : 스레드의 이름
Thread t = new Thread(ThreadGroup group, String name);

ExecutorService executorService = Excutors.newCachedThreadPool(); 

ExecutorService executorService = Executors.newFixedThreadPool(
    // CPU 코어의 수만큼 최대 스레드를 사용하는 스레드풀을 생성
    Runtime.getRuntime().availableProcessors() 
);

ExecutorService threadPool = new ThreadPoolExecutor(
    3,      // 코어 스레드 개수
    100,    // 최대 스레드 개수
    120L,   // 놀고 있는 시간
    TimeUnit.SECONDS,   // 놀고 있는 시간 단위
    new SynchronousQueue<Runnable>()    // 작업 큐
);

Runnable task = new Runnable(){
    @Override
    public void run(){
        // 스레드가 처리할 작업 내용
    }
}

Callable<T> task = new Callable<T>{
    @Override
    public T call() throws Exception{
        // 스레드가 처리할 작업 내용
        return T;
    }
}

Future future = executorService.submit(task);

try{
    future.get();
}catch(InterruptedException e){
    // 작업 처리 도중 스레드가 interrupt 될 경우 실행할 코드
}catch(ExecutionException e){
    // 작업 처리 도중 예외가 발생된 경우 실행할 코드
}

public class NoResultExample{
    public static void main(String[] args){
        
        ExecutorService executorService = Executors.newFixedThreadPool(
            Runtime.getRuntime().availableProcessors()
        );
        
        System.out.println("[작업 처리 요청]");
        
        Runnable runnable = new Runnable(){
            @Override
            public void run(){
                int sum = 0;
                for(int i=1; i<=10; i++){
                    sum += i;
                }
                System.out.println("[처리 결과] " + sum);
            }
        };
        
        Future future = executorService.submit(runnable);
        
        try{
            future.get();
            System.out.println("[작업 처리 완료]");
        }catch(Exception e){
            System.out.println("[실행 예외 발생] " + e.getMessage());
        }
        
        executorService.shutdown(); // 작업 큐에 대기하고 있는 모든 작업을 처리한 뒤에 스레드풀을 종료
        
    }
}

public class ResultByCallableExample{
    public static void main(String[] args){
        
        // 스레드풀 생성
        ExecutorService executorService = Executors.newFixedThreadPool(
            Runtime.getRuntime().availableProcessors()
        );
        
        System.out.println("[작업 처리 요청]");
                
        Callable callable = new Callable<Integer>(){
            @Override
            public Integer call() throws Exception{
                int sum = 0;
                for(int i=1; i<=10; i++){
                    sum += i;
                }
                
                return sum;
            }
        };
        
        Future<Integer> future = executorService.submit(runnable);
        
        try{
            int sum = future.get();
            System.out.println("[처리 결과] " + sum);
            System.out.println("[작업 처리 완료]");
        }catch(Exception e){
            System.out.println("[실행 예외 발생] " + e.getMessage());
        }
        
        executorService.shutdown(); // 작업 큐에 대기하고 있는 모든 작업을 처리한 뒤에 스레드풀을 종료
        
    }
}

public class ResultByRunnableExample{
    public static void main(String[] args){
        // 스레드풀 생성
        ExecutorService executorService = Executors.newFixedThreadPool(
            Runtime.getRuntime().availableProcessors()
        );
        
        System.out.println("[작업 처리 요청]");
        
        Result result = new Result();
        Runnable task1 = new Task(result);
        Runnable task2 = new Task(result);
        
        // 스레드풀의 작업 큐에 저장
        Future<Result> future1 = executorService.submit(task1, result);
        Future<Result> future2 = executorService.submit(task2, result);
        
        try{
            result = future1.get();
            result = future2.get();
            System.out.println("[처리 결과] " + result.accumValue);
            System.out.println("[작업 처리 완료]");
        }catch(Exception e){
            e.printStackTrace();
            System.out.println("[실행 예외 발생] " + e.getMessage());
        }
            
        executorService.shutdown(); // 작업 큐에 대기하고 있는 모든 작업을 처리한 뒤에 스레드풀을 종료
        
    }
}

public class Task implements Runnable{
    Result result;
    public Task(Result result){
        this.result = result;
    }
    
    @Override
    public void run(){
        int sum = 0;
        for(int i=0; i<=10; i++){
            sum += i;
        }
        result.addValue(sum);       // Result 객체에 작업 결과 저장
    }
}

public class Result{
    int accumValue;
    Synchronized void addValue(int value){
        accumValue += value;
    }
}

public class CompletionServiceExample extends Thread{
    public static void main(String[] args){
        // 스레드풀 생성
        ExecutorService executorService = Executors.newFixedThreadPool(
            Runtime.getRuntime().availableProcessors()
        );
        
        // CompletionService 생성
        CompletionService<Integer> completionService =
            new ExecutorCompletionService<Integer>(executorService);
        
        System.out.println("[작업 처리 요청]");
        
        for(int i=0; i<3; i++){
            // 스레드풀에게 작업 처리 요청
            completionService.submit(new Callable<Integer>(){
                @Override
                public Integer call() throws Exception{
                    int sum = 0;
                    for( int i=0; i<=10; i++){
                        sum += i;
                    }
                    return sum;
                }
            });
        }
        
        System.out.println("[처리 완료된 작업 확인]");
        
        // 스레드풀의 스레드에서 실행하도록 함
        executorService.submit(new Runnable(){
            @Override
            public void run(){
                while(true){
                    try{
                        Future<Integer> future = completionService.take();  // 완료된 작업 가져오기
                        int value = future.get();
                        System.out.println("[처리 결과] " + value);
                    }catch(Exception e){
                        break;
                    }
                }
            }
        });
        
        
        try{
            Thread.sleep(3000);
        }catch(InterruptedException e){
        
        }
        
        executorService.shutdownNow();  // 3초 뒤에 take()에서 InterruptedException이 발생하고 catch 절에서 break가 되어 while문을 종료함.
        
    }
}

// V : 결과값 타입, A : 결과값 이외에 추가적으로 전달하는 객체, 필요 없다면 Void로 지정가능하다.
CompletionHandler<V, A> callback = new CompletionHandler<V, A>(){
    @Override
    public void completed(V result, A attachment){
        // 작업을 정상 처리 완료했을 때
    }
    
    @Override
    public void failed(Throwable exc, A attachment){
        // 작업 처리 도중 예외가 발생했을 때
    }
}

Runnable task = new Runnable(){
    @Override
    public void run(){
        try{
            // 작업 처리
            V result = ...;
            callback.completed(result, null);
        }catch(Exception e){
            callback.failed(e, null);
        }
            
    }
}

public class CallbackExample{
    private ExecutorService executorService;
    
    public CallbackExample(){
        executorService = Executors.newFixedThreadPool(
            Runtime.getRuntime().availableProcessors();
        );
    }
    
    // 콜백 메소드를 가진 CompletionHandler 객체 생성. Integer : 결과 타입, Void : 첨부 타입
    private CompletionHandler<Integer, Void> callback = new CompletionHandler<Integer, Void>(){
        @Override
        public void completed(Integer result, Void attachment){
            System.out.println("completed() 실행 : " + result);
        }
        
        @Override
        public void failed(Throwable exc, Void attachment){
            System.out.println("failed() 실행 : " + exc.toString());
        }
    
    };
    
     public void doWork(final String x, final String y){
        
        // 작업을 정의
        Runnable task = new Runnable(){
            @Override
            public void run(){
                try{
                    int intX = Integer.parseInt(x);
                    int intY = Integer.parseInt(y);
                    int result = intX + intY;
                    callback.completed(result, null);
                }catch(NumberFormatException e){
                    callback.failed(e, null);
                }
            }
        };
        
        // 스레드풀에게 작업 요청
        executorService.submit(task);
        
    }
    
    public void finish(){
        executorService.shutdown(); // 스레드풀 종료
    }
    
    public static void main(String[] args){
        CallbackExample example = new CallbackExample();
        example.doWork("3", "3");
        example.doWork("3", "삼");
        example.finish();
    }
    
}