Thread thread = new Thread(Runnable target);

Runnable taskrun = new Task();
Thread thread = new Thread(taskrun);
Thread threadanony = new Thread( new Runnable(){
	public void run(){
    	//쓰레드가 실행할 코드흐름	
    }
});

import java.awt.Toolkit;

public class BeepThread extends Thread{
	@Override
	public void run() {
		Toolkit toolkit = Toolkit.getDefaultToolkit();
		for(int i =0; i<5; i++) {
			toolkit.beep();
			try {Thread.sleep(500);} catch(Exception e) {}
		}
	}
}

import java.awt.Toolkit;

public class BeepPrintExample3 {
	public static void main(String[] args) {
		Thread thread = new BeepThread();
		
		//2. ㅇ익명객체
		Thread thread2 = new Thread() {
			@Override
			public void run() {
				Toolkit toolkit = Toolkit.getDefaultToolkit();
				for(int i =0; i<5; i++) {
					toolkit.beep();
					try {Thread.sleep(500);} catch(Exception e) {}
				}
			}
		};
		
		
		thread2.start();
		
		for(int i =0; i<5; i++) {
			System.out.println("띵");
			try {Thread.sleep(500);} catch(Exception e) {}
		}
	}
}

thread.setName("쓰레드명");
thread.getName(); // 쓰레드명 반환

Thread thread = Thread.currentThread();

public class ThreadNameExample {
	public static void main(String[] args) {
		Thread mainThread = Thread.currentThread();
		System.out.println("프로그램 시작 쓰레드 이름: "+mainThread.getName());
		
		ThreadA threadA = new ThreadA();
		System.out.println("작업 쓰레드 이름 : "+threadA.getName());
		threadA.start();
		
		ThreadB threadB = new ThreadB();
		System.out.println("작업 쓰레드 이름 : "+threadB.getName());
		threadB.start();
		
	}
}
//-----------------------------------
public class ThreadA extends Thread{
	public ThreadA() {
		setName("ThreadA");
	}
	
	@Override
	public void run() {
		for(int i =0; i<2; i++) {
			System.out.println(getName()+"가 출력한 내용");
		}
	}
}
//-----------------------------------
public class ThreadB extends Thread{
	@Override
	public void run() {
		for(int i =0; i<2; i++) {
			System.out.println(getName()+"가 출력한 내용");
		}
	}
}

thread.setPriority(우선순위);

public class PriorityExample {
	public static void main(String[] args) {
		for(int i =1; i<=10; i++) {
			Thread thread = new ClacThread("thread"+i);
			if(i == 10) {
				//가장 낮은 우선순위
				thread.setPriority(Thread.MAX_PRIORITY);
			}else {
				//가장 높은 우선순위
				thread.setPriority(Thread.MIN_PRIORITY);
			}
			thread.start();
		}
	}
}
//---------------------------------------------------------
public class ClacThread extends Thread{
	public ClacThread(String name) {
		setName(name);
	}
	
	public void run() {
		for(int i =0; i<2000000000; i++) {}
		System.out.println(getName());
	}
}

public synchronized void method(){
	//임계영역; 단하나의 쓰레드만 실행가능.
}

package sync;

public class Calculator {
	private int memory;
	
	public int getMemory() {
		return memory;
	}
	//동기화 메소드로 선언하는 방법
	public synchronized void setMemory(int memory) { 
		this.memory = memory;
		try {
			Thread.sleep(2000);
		}catch(InterruptedException e) {}
		System.out.println(Thread.currentThread().getName()+" : "+this.memory);
	}
}

public void method(){
	synchronized (공유객체){
    	//임계영역(단 하나의 쓰레드만 실행 가능)
    }
    //여러 쓰레드가 실행 가능한 영역.
}

package sync;

public class Calculator {
	private int memory;
	
	public int getMemory() {
		return memory;
	}
	
	// 이렇게 동기화 블럭을 사용해서 처리할 수 있다.
	public void setMemory(int memory) {
		synchronized (this) {
			this.memory = memory;
			try {
				Thread.sleep(2000);
			}catch(InterruptedException e) {}
			System.out.println(Thread.currentThread().getName()+" : "+this.memory);
		}
	}
}

try{
	Thread.sleep(1000); //1초간 일시정지(밀리초 : 1000 -> 1초)
}catch(InterruptedException){
	//interrupt() 메소드가 호출되면 실행.
}

public void run(){
	while(true){
    	if(work){
        	System.out.println("ThreadA 작업 내용");
        }
    }
}

public class ThreadA extends Thread{
	public boolean stop = false; //종료 플래그
	public boolean work = true; // 작업진행여부
	
	public void run() {
		while(!stop) {
			if(work) {
				System.out.println("ThreadA 작업 내용");
			}else {
				Thread.yield();
			}
		}
		System.out.println("ThreadA 종료");
	}
}

public class SumThread extends Thread{
	private long sum;

	public long getSum() {
		return sum;
	}

	public void setSum(long sum) {
		this.sum = sum;
	}

	public void run() {
		for(int i =1; i<=100; i++) {
			sum+=i;
		}
	}
	
	@Override
	public String toString() {
		return "SumThread [sum=" + sum + "]";
	}
}

public class JoinExample {
	public static void main(String[] args) {
		SumThread sumThread = new SumThread();
		sumThread.start();
		
		try {
			sumThread.join();//현재 쓰레드 기준 (이부분을 주석처리해서 결과를 비교해보세요)
		} catch (Exception e) {
		}
		System.out.println("1~100 합 : "+sumThread.getSum());
	}
}

//공유객체
public class WorkObject {
	public synchronized void methodA() {
		System.out.println("ThreadA의 methodA() 작업 실행");
		notify(); //일시정지 상태에 있는 ThreadB를 실행대기 상태로 만듬.
		try {
			wait();//ThreadA를 일시정지 상태로 만듬.
		} catch (Exception e) {
		}
	}
	
	public synchronized void methodB() {
		System.out.println("ThreadB의 methodB() 작업 실행");
		notify(); //일시정지 상태에 있는 ThreadA를 실행대기 상태로 만듬.
		try {
			wait();//ThreadB를 일시정지 상태로 만듬.
		} catch (Exception e) {
		}
	}
}

//Thread A
public class ThreadA extends Thread{
	private WorkObject workObject;
	
	public ThreadA(WorkObject workObject) {
		this.workObject = workObject;
	}
	
	@Override
	public void run() {
		for(int i =0; i<10; i++) {
			workObject.methodA();
		}
	}
}

//ThreadB
public class ThreadB extends Thread{
	private WorkObject workObject;
	
	public ThreadB(WorkObject workObject) {
		this.workObject = workObject;
	}
	
	@Override
	public void run() {
		for(int i =0; i<10; i++) {
			workObject.methodB();
		}
	}
}

//main 쓰레드
public class WaitNotifyExample {
	public static void main(String[] args) {
		WorkObject shareObject = new WorkObject(); //공유객체 생성
		
		ThreadA threadA = new ThreadA(shareObject);
		ThreadB threadB = new ThreadB(shareObject);//ThreadA와 ThreadB 생성
		
		threadA.start();
		threadB.start();
				
	}
}

public class PrintThread2 extends Thread{
	public void run() {
		try {
			while(true) {
				System.out.println("실행 중");
				Thread.sleep(1);
				//if(Thread.interrupted()) {
				//if(Thread.currentThread().isInterrupted()) {
					//break;
				//}
			}
		} catch (InterruptedException e) {
			System.out.println("interrupt() 실행");
		}
		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 (Exception e) {
			
		}
		thread.interrupt();
	}
}

public class AutoSaveThread extends Thread{
	public void save() {
		System.out.println("작업 내용을 저장함");
	}
	
	@Override
	public void run() {
		while(true) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				System.out.println("1");//여기실행안됨. exception 발생은 아님
				e.printStackTrace();
				break;
			}
			save();
		}
	}
}

//메인 쓰레드
public class DaemonExample {
	public static void main(String[] args) {
		AutoSaveThread autoSaveThread = new AutoSaveThread();
		autoSaveThread.setDaemon(true);
		autoSaveThread.start();
		
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {

		}
		System.out.println("메인 쓰레드 종료");
	}
}

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

public static void main(String[] args) {
	ThreadGroup group = Thread.currentThread().getThreadGroup();
	//System.out.println(group.getName());
		
	AutoSaveThread autoSaveThread = new AutoSaveThread();
	autoSaveThread.setName("AutoSaveThread");
	autoSaveThread.setDaemon(true);
	autoSaveThread.start();
		
	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("\t"+"소속그룹 : "+thread.getThreadGroup().getName());
		System.out.println();
	}
}

public class WorkThread extends Thread{
	public WorkThread(ThreadGroup threadGroup, String threadName) {
		super(threadGroup, threadName);
	}
	
	@Override
	public void run() {
		while(true) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				System.out.println(getName()+" interrupted");
				break;
			}
		}
		System.out.println(getName()+ " 종료됨");
	}
}

public class Main{
	public static void main(String[] args) {
		ThreadGroup myGroup = new ThreadGroup("myGroup");
		WorkThread workThreadA = new WorkThread(myGroup, "workThreadA");
		WorkThread workThreadB = new WorkThread(myGroup, "workThreadB");
		
		workThreadA.start();
		workThreadB.start();
		
		System.out.println("[main 쓰레드 그룹의 list() 메소드 출력 내용]");
		ThreadGroup mainGroup = Thread.currentThread().getThreadGroup(); //현재쓰레드의 그룹
		mainGroup.list();
		
		System.out.println();
		
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {}
		
		System.out.println("[myGroup 쓰레드 그룹의 interrupted() 메소드 호출]");
		myGroup.interrupt();
	}
}

ExecutorService executorService = Executors.newCachedThreadPool();

ExecutorService executorService2 = Executors.newFixedThreadPool(
	Runtime.getRuntime().availableProcessors();
); //cpu의 코어수만큼 최대쓰레드풀 생성

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

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

public static void main(String[] args) throws Exception{
		ExecutorService executorService = Executors.newFixedThreadPool(2); //최대쓰레드 개수가 2인 쓰레드풀 생성
		
		for(int i =0; i<10; i++) {
			Runnable runnable = new Runnable() {

				@Override
				public void run() {
					ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) executorService;
					int poolSize = threadPoolExecutor.getPoolSize();
					String threadName = Thread.currentThread().getName();
					System.out.println("[총 쓰레드 개수 : "+poolSize+"] 작업 쓰레드 이름 :"+threadName);
					
					//예외 발생시킴
					int value = Integer.parseInt("삼");
				}
			};	
            //이 두개를 번갈아가면서 실행해보세요.
			//executorService.execute(runnable);
			executorService.submit(runnable);
			
			Thread.sleep(10);//콘솔 출력시간을 위해 0.01초 일시정지
		}
		executorService.shutdown();
	}