class MyThread extends Thread{
	public void run() {
		//작업내용 // Thread클래스의 run()을 오버라이딩 해서 사용한다.
	}
}

class myTread implements Runnable{
	public void run(){
		// 작업내용 // Runnable 인터페이스의 run()을 구현
	}
}

static Thread currentThread() //현재 실행중인 쓰레드의 참조를 반환한다.
String getName() // 쓰레드의 이름을 반환한다.

// 따라서 다음과 같이 사용해서 현재 실행중인 쓰래드의 이름을 파악한다.
Thread.currentTread().getName();

class ThreadEx1_1 extends Thread{
	public void run(){
		for(int i=0; i<5; i++){
			System.out.println(getName());
		}
	}
}

class ThreadEx1_2 implements Runnable{
	public void run(){
		for(int i=0; i<5; i++){
			//Thread.currentThread() - 현재 실행중인 Thread를 반환한다.
			System.out.println(Thread.currentTread().getName());
		}
	}
}

import javax.swing.*;

public class ThreadEx2 {
    public static void main(String[] args) throws Exception{
        ThreadEx22 th1 = new ThreadEx22();
        th1.start();

        String input = JOptionPane.showInputDialog("아무값이나 입력하세요.");
        System.out.println("입력하신 값은: " + input + "입니다.");
    }
}

class ThreadEx22 extends Thread{
    public void run(){
        for(int i=10; i>0; i--){
            System.out.println(i);;
            try{
              sleep(1000);
            }
            catch(Exception e){}
        }
    }
}

void setPriority(int newPriority) // 쓰레드의 우선순의를 지정한 값으로 변경한다.
int getPriority() // 쓰레드의 우선순위를 반환한다.

public static final int MAX_PRIORITY = 10;
public static final int MIN_PRIORITY = 1;
public static final int NORM_PRIORITY = 5;

public class ThreadEx3 {
    public static void main(String[] args) throws Exception{
        ThreadGroup main = Thread.currentThread().getThreadGroup();
        ThreadGroup grp1 = new ThreadGroup("Group1");
        ThreadGroup grp2 = new ThreadGroup("Group2");

        //ThreadGroup(ThreadGroup parent, String name);
        ThreadGroup subGrp1 = new ThreadGroup(grp1, "SubGroup1");

        grp1.setMaxPriority(3); //쓰레드 그룹 grp1의 최대우선순의를 3으로 변경

        Runnable r = new Runnable() {
            @Override
            public void run() {
                try{
                    Thread.sleep(1000);
                } catch (InterruptedException e) {}
            }
        };

        // Thread(ThreadGroup tg, Runnable r, String name);
        new Thread(grp1, r, "th1").start();
        new Thread(subGrp1, r, "th2").start();
        new Thread(grp2, r, "th3").start();

        System.out.println(">>List of ThreadGroup : " + main.getName() + "" +
                ", Active Thread Group: " + main.activeGroupCount() + ", Active Thread: " + main.activeCount());
        main.list();
    }
}

boolean isDaemon() // 쓰레드가 데몬 쓰레드인지 확인한다. 데몬쓰레드이면 true를 반환한다.
void setDaemon(boolean on)
// 쓰레드를 데몬쓰레드로 또는 사용자 쓰레드로 변경이 가능하다. on을 true로하면 데몬 쓰레드가 된다.
// start()를 호출하기 전에 실행되어야만 한다.

public class ThreadEx4 implements Runnable{
    static boolean autoSave = false;
    public static void main(String[] args){
        Thread t = new Thread(new ThreadEx4());
        t.setDaemon(true);
        t.start();

        for(int i=1; i<=10; i++){
            try{
                Thread.sleep(1000);
            }catch(InterruptedException e){}
            System.out.println(i);
            if(i == 5) autoSave = true;
        }
    }
    public void run(){
        while(true){
            try{
                Thread.sleep(3 * 1000); //3초마다
            }catch (InterruptedException e ){}
            // autoSave가 true이면 해당 함수를 호출
            if(autoSave){
                autoSave();
            }
        }
    }
    public void autoSave(){
        System.out.println("작업파일이 자동저장되었습니다.");
    }
}

1.쓰레드를 생성하고 start()를 호출하면 바로 실행되는 것이 아니라 실행 대기열에 저장되어 자신의 차례가
될 때 까지 기다려야한다. 실행대기열은 큐와 같은 구조로 먼저 실행대기 열에 들어온 쓰레드가 먼저 실행된다.

2.실행대기상태에 있다가 자신의 차례가 되면 실행 상태가 된다.

3.주어진 실행시간이 다되거나 yield()를 만나면 다시 실행대기상태가 되고 다음 차례의 쓰레드가 실행상태가 된다.

4.실행중에 suspend(), sleep(), wait(), join(), I/O block에 의해 일시정지상태가 될 수 있다.
I/O block은 입출력작업에서 발생하는 지연상태를 말한다. 사용자의 입력을 기다리는 경우를 예로 들 수 있는데,
이런 경우 일시정지 상태에 있다가 사용자가 입력을 마치면 다시 실행대기 상태가 된다.

5.지정된 일시정지시간이 다되거나 notify(), resume(), interrupt()가 호출되면 일시 정지상태를 벗어나
다시 실행대기열에 저장되어 자신의 차례를 기다리게 된다.

6.실행을 모두 마치거나 stop()이 호출되면 쓰레드는 소멸된다.

static void sleep(long millis)
static void sleep(long millis, int nanos)

void delay(long millis){
	try{
		Thread.sleep(millis);
	} catch(InterruptedException e){}
}

void interrupt() // 쓰레드의 interrupted 상태를 false에서 true로 변경
void isInterrupted() // 쓰레드의 interrupted 상태를 반환
static boolean interrupted() // 현재 쓰레드의 interrupted상태를 반환 후, false로 변경

import javax.swing.*;

public class ThreadEx5 {
    public static void main(String[] args) throws Exception{
        ThreadEx14_1 th1 = new ThreadEx14_1();
        th1.start();

        String input = JOptionPane.showInputDialog("아무값이나 입력하세요.");
        System.out.println("입력하신 값은 " + input + "입니다.");;
        th1.interrupt(); // interrupt()를 호출하면, interrupted상태가 true가 된다.
        System.out.println("isInterrupted(): " + th1.isInterrupted());
    }
}
class ThreadEx14_1 extends Thread{
    public void run(){
        int i= 10;
        while(i !=0 && !isInterrupted()){
            System.out.println(i--);
            try{
                Thread.sleep(1000); //1초 지연
            }catch (InterruptedException e) {
                // sleep함수가 돌고있는 tryCatch문에 interrupt가 발생하면
				// InterruptedException이 발생하여 쓰레드의
				// Interrupt 상태는 false로 자동 초기화 된다. 따라서 이를 막기위해 아래에 interrupt를 추가

				interrupt();
				// interrupt함수를 발생시켜서 다시 interrupted의 상태를 true로 바꿔주어야한다.
            }
        }
        System.out.println("카운트가 종료되었습니다.");
    }
}

public class ThreadEx6 {
    public static void main(String[] args){
        ThreadEx17_1 th1 = new ThreadEx17_1("*");
        ThreadEx17_1 th2 = new ThreadEx17_1("**");
        ThreadEx17_1 th3 = new ThreadEx17_1("***");
        th1.start();
        th2.start();
        th3.start();

        try{
            Thread.sleep(2000);
            th1.suspend();
            Thread.sleep(2000);
            th2.suspend();
            Thread.sleep(3000);
            th1.resume();
            Thread.sleep(3000);
            th1.stop();
            th2.stop();
            Thread.sleep(2000);
            th3.stop();
        }catch (InterruptedException e){}
    }
}
class ThreadEx17_1 implements Runnable{
    boolean suspended = false;
    boolean stopped = false;

    Thread th;

    ThreadEx17_1(String name){
        th = new Thread(this, name); // Thread(Runnable r, String name);
    }

    public void run(){
        while(!stopped){ // stopped 값이 false인 동안 반복한다
            if(!suspended){ // suspended의 값이 false일 떄만 작업을 수행한다.
                System.out.println(Thread.currentThread().getName());
                try{
                    Thread.sleep(1000);
                }catch(InterruptedException e){}
            }
        }
        System.out.println(Thread.currentThread().getName() + " - stopped");
    }
    // 이렇게 오버라이딩해서 사용하기
    public void suspend() {suspended = true; }
    public void resume() {suspended = false; }
    public void stop() {stopped = true; }
	//  suspend, stop에 th.interrupt()를 넣어주면 sleep(1000)에 걸려있던 상태에서 바로 탈출할 수 있다.
    public void start() {th.start();}
}

while(!stopped){
            if(!suspended){
                System.out.println(Thread.currentThread().getName());
                try{
                    Thread.sleep(1000);
                }catch(InterruptedException e){}
            }
        }
// 위의 코드를 yield를 추가하면 의미없이 while문을 도는 낭비(busy-waiting)를 없앨 수 있다.

while(!stopped){
            if(!suspended){
                System.out.println(Thread.currentThread().getName());
                try{
                    Thread.sleep(1000);
                }catch(InterruptedException e){}
            }
			else{
				Thread.yeild(); //해당 쓰레드가 쓰도록 할당된 시간을 양보하기 떄문이다.
			}
        }

void join()
void join(long millis)
void join(long millis, int nanos)

public class ThreadEx7 {
    public static void main(String[] args){
        ThreadEx20_1 gc = new ThreadEx20_1();
        gc.setDaemon(true);
        gc.start();

        int requiredMemory = 0;
        for(int i=0; i<20; i++){
            requiredMemory = (int)(Math.random() * 10) * 20;
            // 필요한 메모리가 사용할 수 있는 양보다 크거나 전체메모리의 60%이상을 사용했을 경우 gc를 꺠운다.
            if(gc.freeMemory() < requiredMemory || gc.freeMemory() < gc.totalMemory() * 0.4){
                gc.interrupt();
                // gc 가 작업할 시간을 기다리는 것
                try{
                    gc.join(100);
					// join을 이용해서 gc가 작업을 할 시간을 0.1초 정도 주는 것
					// 이를 통해 데이터가 꼬이는 것을 방지할 수 있다.
                }catch(InterruptedException e){}
            }
            gc.usedMemory += requiredMemory;
            System.out.println("usedMemory: "+ gc.usedMemory);
        }
    }
}
class ThreadEx20_1 extends Thread{
    final static int MAX_MEMORY = 1000;
    int usedMemory = 0;
    public void run(){
        while(true){
            try{
                Thread.sleep(10 * 1000); //10초를 기다린다.
            }catch (InterruptedException e){
                System.out.println("Awaken by Interrupt().");
            }
            gc();//garbage collection을 수행한다.
            System.out.println("Garbage Collected. Free Memory :" + freeMemory());
        }
    }
    public void gc(){
        usedMemory -= 300;
        if(usedMemory < 0) usedMemory = 0;
    }
    public int totalMemory() { return MAX_MEMORY; }
    public int freeMemory() { return MAX_MEMORY - usedMemory; }
}

public synchronized void caclSum(){
	//...
}

synchronized(객체의 참조변수 (ex: this)){
	//...
}

ReentrantLock  : 재진입이 가능한 lock. 가장 일반적인 배타 lock
ReentrantReadWriteLock : 읽기에는 공유적이고, 쓰기에는 배타적인 lock
StampedLock : ReentrantReadWriteLock에 낙관적인 lock의 기능을 추가

ReentrantLock() //ReentrantLock의 생성자
ReentrantLock(boolean fair) // lock이 풀렸을 때 가장 오래 기다린 쓰레드가 lock 획득

void lock() // lock을 잠근다
void unlock() // lock을 해지한다
boolean isLocked() // lock이 잠겼는지 확인한다

synchronized(lock){
    //임계영역
}

/// 위의 코드는 아래와 기능은 같다
lock.lock();
    // 임계영역
lock.unlock();

lock.lock(); // ReentrantLock lock = new ReentrantLock();
try{
    // 임계영역
} finally{
    lock.unlock();
}

boolean tryLock() // 다른 쓰레드에 의해 lock이 걸려있으면 lock을 얻으려고 기다리지 않는다
boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException
// lock을 얻기위해 지정된 시간만큼만 기다린다.

public  void add(String dish){
    lock.lock();

    try{
        while(dishes.size() >= MAX_FOOD){
            String name = Thread.currentThread().getName();
            System.out.println(name+ " is waiting.");
            try{
                forCook.await(); // wait() ; Cook쓰레드를 기다리게 한다.
            }catch(InterruptedException e){}
        }

        dishes.add(dish);
        forCust.signal(); // notify(); 기다리고 있는 CUST를 꺠움
        System.out.println("Dishes:)" + dishes.toSTring());
    } finally{
        lock.unlock();
    }
}

RecursiveAction 반환값이 없는 작업을 구현할 때 사용
RecursiveTask 반환값이 있는 작업을 구현할 때 사용

ForkJoinPool pool = new ForkJoinPool(); //쓰레드 풀을 생성
SumTask task = new SumTask(from, to); // 수행할 작업을 생성

Long result = pool.invoke(task); // invoke()를 호출해서 작업을 시작

import java.util.concurrent.*;
public class ForkJoinEx1 {
    static final ForkJoinPool pool = new ForkJoinPool();
    public static void main(String[] args){
        long from = 1L, to = 100_000_000L;

        SumTask task = new SumTask(from, to);

        Long result = pool.invoke(task);
        System.out.printf("sum of %d~%d=%d%n",from, to, result);
        System.out.println();
    }
}
class SumTask extends RecursiveTask<Long>{
    long from, to;
    SumTask(long from, long to){
        this.from = from;
        this.to = to;
    }
    public Long compute(){
        long size = to - from + 1;

        if(size <= 5) return sum();

        long half = (from + to) / 2;

        // 범위를 반으로 나눠서 두개의 작업을 생성
        SumTask leftSum = new SumTask(from, half);
        SumTask rightSum = new SumTask(half+1, to);

        leftSum.fork();

        return rightSum.compute() + leftSum.join();
    }
    long sum(){
        long tmp = 0L;
        for(long i =from; i<=to; i++) tmp+=i;
        return tmp;
    }
}

}