线程的四种创建方法

继承Thread

       调用线程对象的start方法启动线程，不能直接调用run方法，否则是单线程Java采用的是单根继承体系，所以一旦继承于Thread类，则不能继承其它类，启动线程的唯一方法就是通过Thread类的start()实例方法，不能直接调用run()方法。从语法上来说没有错误，但是不是多线程。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程很简单，通过自己的类直接extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。

new Thread的弊端
1、每次new Thread新建对象性能差。
2、线程缺乏统一管理，可能无限制新建线程，相互之间竞争及可能占用过多系统资源导致死机或oom。
3、缺乏更多功能，如定时执行、定期执行、线程中断。

public class Test1 {
public static void main(String[] args) {
	System.out.println(Thread.currentThread()); //获取当前线程对象
	//方法1.2
	Thread t2=new Thread() {
		@Override
		public void run() {
			for(int i=0;i<50;i++) {
				System.out.println("右手"+Thread.currentThread());
				try {
					Thread.sleep(150);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	};
//	t2.run();
	Thread t1=new MyThread3();
	t1.start();
	t2.start();
}
}

//方法1.1
class MyThread3 extends Thread{
	@Override
	public void run() {
		for(int i=0;i<50;i++) {
			System.out.println("左手"+Thread.currentThread());
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

实现Runnable接口

源代码
@FunctionalInterface   注解声明是函数式接口
 public interface Runnable {
     public abstract void run();
 }
 问题：定义run()方法没有返回值
 

public class Test2 {
	public static void main(String[] args) {
		Thread t1 = new Thread(new MyRunnable());
		t1.start();
		// 方法2.2
		new Thread(new Runnable() {
			public void run() {
				for (int i = 0; i < 10; i++) {
					System.out.println("中间手...."+Thread.currentThread());
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}).start();
		// 方法2.3
		new Thread(() -> {
			for (int i = 0; i < 10; i++) {
				System.out.println("右手...."+Thread.currentThread());
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}).start();
	}
}

//方法2.1
class MyRunnable implements Runnable {
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println("左手...."+Thread.currentThread());
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

}

使用Callable和Future接口创建线程

具体是创建Callable接口的实现类，并实现call()方法。并使用FutureTask类来包装Callable实现类的对象，且以此FutureTask对象作为Thread对象的target来创建线程

java.util.concurrent.Callable ：有时java.util.concurrent包可以称为juc包

@FunctionalInterface  //注解用于声明当前接口是一个函数式接口
public interface Callable<V> {  //这里<>中用于声明返回值的类型
   V call() throws Exception;  //真正执行的方法，有返回值，允许抛出异常
 }

线程的构造器为

public Thread(Runnable target) {
     this(null, target, "Thread-" + nextThreadNum(), 0);
}

 Future接口
    public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);  可以取消正在运行的线程
    boolean isCancelled(); 判断是否取消
    boolean isDone(); 判断线程是否在运行中
    V get() throws InterruptedException, ExecutionException; 获取线程执行的结果
    V get(long timeout, TimeUnit unit)throws InterruptedException, ExecutionException,TimeoutException;

Java针对Future接口提供的具体实现类FutureTask

//源代码:
	public class FutureTask<V> implements RunnableFuture<V>
	
	public interface RunnableFuture<V> extends Runnable, Future<V>
//构造器
	  public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }
	
	public void run() {
            Callable<V> c = callable;
            ...
                    result = c.call();
    }

注意:FutureTask实现了Future和Runnable接口，所以new Thread(futureTask),当执行thread.start()方法时会自动调用Callable接口实现中的call方法。当调用futureTask.get()方法时可以获取对应的线程对象的执行结果，如果线程并没有返 回时，当前线程阻塞等待 。

public class Test3 {
	public static void main(String[] args) throws Exception {
		// 为了获取返回值，所以需要使用FutureTask中提供的get方法
		FutureTask<Integer>[] arr = new FutureTask[10];
		for (int i = 1; i <= 10; i++) {
			int begin = (i - 1) * 100 + 1;
			int end = i * 100;
			// 定义Callable的实现
			Callable<Integer> c = new Callable<Integer>() {
				public Integer call() throws Exception {
					int res = 0;
					for (int k = begin; k <= end; k++)
						res += k;
					return res;
				}
			};
			// 构建FutureTask对象，其中包含Callable对象
			FutureTask<Integer> ft = new FutureTask<>(c);
			// 不是必须的，只是证明FutureTask实现了Runnable接口
			Runnable r = ft;
			arr[i - 1] = ft;
			// 启动线程，构建Thread对象时，要求参数类型为Runnable接口类型
			// 线程执行时会自动调用run方法，而FutureTask中提供的run方法会调用Callable对象的call方法
			new Thread(r).start();
		}
		int res = 0;
		for (FutureTask<Integer> tmp : arr)
			res += tmp.get(); // main线程执行到这里时，会自动阻塞等待子线程tmp执行结束，
                              //执行结束后获取call方法的返回值
		System.out.println(res);
	}
}

使用线程池创建线程

享元模式Flyweight Pattern主要用于减少创建对象的数量，以减少内存占用和提高性能 。这种类型的设计模式属于结构型模式，它提供了减少对象数量从而改善应用所需的对象结构的方式。

共享所有的IShape类型的对象，当需要使用IShape对象时，从对象池中获取一个即可，不是临时创建；当不需要使用对象时，不是直接释放对象，而是归还对象池 。
优点：大大减少对象的创建，降低系统内存的使用，以提高程序的执行效率。
缺点：提高了系统的复杂度，需要分离出外部状态和内部状态，而且外部状态具有固有化的性质，不应该随着内部状态的变化而变化，否则会造成系统的混乱。

public class Test4 {
public static void main(String[] args)throws Exception {
	for(int i=0;i<100;i++) {
		IShape tmp=ObjectManager.getInstance();
		System.out.println(tmp);
		ObjectManager.releaseInstance(tmp);
	}
}
}
class ObjectManager {
	private static IShape[] arr = new IShape[20];
	static { // 类加载完毕，则在对象池中已经准备好了20个对象
		for (int i = 0; i < arr.length; i++)
			arr[i] = new Circle();
	}

	// 当需要使用对象时，从对象池中获取一个对象即可
	public static IShape getInstance() {
		IShape res = null;
		for (int i = arr.length - 1; i >= 0; i--) {
			res = arr[i];
			if (res != null) {
				arr[i] = null;
				break;
			}
		}
		return res;
	}

	// 当不使用对象时，需要归还到对象池中，以供下次需要时再次使用
	public static void releaseInstance(IShape obj) {
		for (int i = 0; i < arr.length; i++) {
			IShape tmp = arr[i];
			if (tmp == null) {
				arr[i] = obj;
				break;
			}
		}
	}
}

使用ExecutorService、Callable、Future实现有返回结果的线程，线程池的具体实现实际上是依赖于ThreadPoolExecutor

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 java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
public class Test40 {
	public static void main(String[] args) {
		// 固定大小的线程池，容积为3
//		ExecutorService es = Executors.newFixedThreadPool(3);
		//缓存线程池
		ExecutorService es=Executors.newCachedThreadPool();
		FutureTask<Integer>[] fs = new FutureTask[10];
		for (int i = 1; i <= 10; i++) {
			int begin = (i - 1) * 100 + 1;
			int end = i * 100;
			fs[i-1] = new FutureTask<>(new Callable<Integer>() {
				public Integer call() throws Exception {
					System.out.println(Thread.currentThread());
					int res = 0;
					for (int k = begin; k <= end; k++)
						res += k;
					return res;
				}
			});
			es.submit(fs[i-1]);
		}
		int res = 0;
		for (Future<Integer> f : fs) {
			try {
				res += f.get(1, TimeUnit.SECONDS);
			} catch (InterruptedException | ExecutionException | TimeoutException e) {
				e.printStackTrace();
			}
		}
		System.out.println(res);
	}
}

创建线程要花费昂贵的资源和时间，如果任务来了才创建线程那么响应时间会变长，而且一个进程能创建的线程数有限。为了避免这些问题，在程序启动的时候就创建若干线程来响应处理，它们被称为线程池，里面的线程叫工作线程。
从JDK1.5开始，Java API提供了Executor框架可以创建不同的线程池。比如单线程池，每次处理一个任务；数目固定的线程池或者是缓存线程池（一个适合很多生存期短的任务的程序的可扩展线程池）

线程池的好处
重用存在的线程，减少对象创建、消亡的开销，性能佳
可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞
提供定时执行、定期执行、单线程、并发数控制等功能。

线程池的工作原理

1、线程池判断核心线程池里的线程是否都在执行任务。如果不是，则创建一个新的工作线程来执行任务。如果核心线程池里的线程都在执行任务，则执行第二步。

2、线程池判断工作队列是否已经满。如果工作队列没有满，则将新提交的任务存储在这个工作队列里进行等待。如果工作队列满了，则执行第三步

3、线程池判断线程池的线程是否都处于工作状态。如果没有，则创建一个新的工作线程来执行任务。如果已经满了，则交给饱和策略来处理这个任务

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,  
long keepAliveTime,TimeUnit unit, BlockingQueue<Runnable> workQueue)