Java多线程（Thread， Runnable，Callable， Executors）

Java多线程实现方式有4种，继承Thread类，实现Runnable接口，实现Callable接口，使用线程池实现（Executors）
1. 继承Thread类
通过继承Thread类，实现run方法，从而实现多线程。该方式实现简单，但该类不可作为拓展类，因为Java是单继承模式，该类继承了Thread类，便无法继承其他类了。

class ChildThread2 extends Thread{
	// 1.调用start方法
	ChildThread2(){
		System.out.println("Child Thread2:");
		start();
	}
	//2实现run方法
	@Override
	public void run() {
		// TODO Auto-generated method stub
		super.run();
		for(int i=0; i < 5; i++){
			System.out.println("Child Thread2:"+i);
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

public class Demo2 {
	public static void main(String[] args) {
		//new ChildThread1();
		new ChildThread2();
		for(int i = 0; i < 5; i++){
			System.out.println("Main Thread:"+i);
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	
}

2. 实现Runnable接口
该方式实现多线程同样简单，只需重写run方法，此类也可作为拓展类，Java是多接口实现的。

public class Demo2 {
	public static void main(String[] args) {
		new ChildThread1();
		//new ChildThread2();
		for(int i = 0; i < 5; i++){
			System.out.println("Main Thread:"+i);
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	
}

class ChildThread1 implements Runnable{
	// 1.实例化Thread对象
		Thread t;
		ChildThread1(){
			t = new Thread(this,"Demo2 Thread");
			System.out.println("Child Thread:"+t);
			// 2.调用start方法  线程进入就绪状态
			t.start();
		}
		// 3.实现run方法  书写要处理的事务
		@Override
		public void run() {
			
			for(int i = 0; i < 5; i++){
				System.out.println("Child Thread:"+i);
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}

}

3. 实现Callable接口
该方法稍显麻烦，首先要实现Callable接口，然后通过FutureTask包装器实现Thread。

public class Demo5 {

	public static void main(String[] args) {
		//等到实现Callable接口的类的对象
		Callable<Integer> callable = new CallChild<Integer>();
		//等到FutureTask对象，将Callable对象传入参数
		FutureTask ft = new FutureTask<>(callable);
		//得到Thread对象，将FutureTask对象作为参数传入
		Thread thread = new Thread(ft);
		thread.start();
	}
}

class CallChild<V> implements Callable<V>{

	@Override
	public V call() throws Exception {
		System.out.println("线程运行成功。。。");
		return null;
	}
	
}

4. 通过线程池实现
通过线程池实现多线程，可以指定池中的线程个数，避免线程过多而造成效率低下；线程使用完毕不会销毁，而是重新放入池中，省去了创建线程和销毁线程的开销。
工作机制
当前线程数量小于corePoolSize时，即便有空闲线程，仍然会创建一个新的线程
当线程数量大于corePoolSize，小于maximumPoolSize时，而阻塞队列未满时，会将请求放入阻塞队列
当线程数量大于corePoolSize，小于maximumPoolSize时，而阻塞队列已满时，会直接创建新线程执行任务
当线程数量达到maximumPoolSize且阻塞队列已满，将会执行饱和策略。
创建线程的方法
Executors类提供了多种创建线程池的静态方法

1. newFixedThreadPool（int i）：重用指定i数目的线程，背后是无界的工作队列，最多只有i个线程执行任务

ExecutorService threadPool = Executors.newFixedThreadPool(10);
		for(int i = 0; i < 20; i++){
		threadPool.execute(new Runnable() {
			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName()+": 线程执行了");
			}
		});

2. newCacheThreadPool（）：用来处理大量短时工作任务的线程，当无线程可用时就创建新的线程，当线程限制超过60s就会被移除销毁。其内部使用 SynchronousQueue 作为工作队列。
3. newSingleThreadExecutor（）；只有一个线程处于工作状态，背后使用的无界的队列。它可以保证任务按顺序执行
4. newScheduledThreadPool（int corePoolSize）：可以定时或周期性的工作调度

ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(10);
		threadPool.schedule(new Runnable(){

			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName()+": 线程执行了");
				
			}}, 10, TimeUnit.SECONDS);

第三个参数指定时间单位，第二参数指定时间长度。（在10s后执行）

5. newWorkStealingPool(int parallelism)，Java 8 才加入这个创建方法，并行地处理任务，不保证处理顺序。
6. ThreadPoolExecutor（）：最原始的方法，上面的方法都是对该方法的封装