说起java多线程编程，大家都不陌生，下面我就总结下java里实现多线程的集中方法：继承Thread类,实现Runnable接口,使用Callable和Future创建线程,使用线程池创建（使用java.util.concurrent.Executor接口）
1.继承Thread类创建线程
通过继承Thread类来创建并启动多线程的一般步骤如下：
- 定义Tread类的子类MyThread，并重写run()方法.run()方法的方法体（线程执行体）就是线程要执行的任务。
- 创建MyThread类的实例
- 调用子类实例的start()方法来启动线程
示例代码:
public class Mythread extends Thread {
private int i;
public void run(){//run()是线程类的核心方法
for(int i=0;i<10;i++){
System.out.println(this.getName()+":"+i);
}
}
public static void main(String[] args) {
Mythread t1=new Mythread();
Mythread t2=new Mythread();
Mythread t3=new Mythread();
t1.start();
t2.start();
t3.start();
}
}
2.实现Runnable接口创建线程
通过实现Runnable接口创建并启动线程的一般步骤如下：
1.定义Runnable接口的实现类，必须重写run(）方法，这个run()方法和Thread中的run()方法一样，是线程的执行体
2.创建Runnable实现类的实例，并用这个实例作为Thread的target来创建Thread对象，这个Thread对象才是真正的线程对象
3.调用start()方法
示例代码:
public class MyThread implements Runnable{
@Override
public void run() {
for(int i=0;i<10;i++){
System.out.println(Thread.currentThread().getName()+" : "+i);
}
}
public static void main(String[] args) {
MyThread myThread=new MyThread();
Thread thread1=new Thread(myThread,"线程1");
Thread thread2=new Thread(myThread,"线程2");
Thread thread3=new Thread(myThread,"线程3");
thread1.start();
thread2.start();
thread3.start();
}
}
3.覆写Callable接口实现多线程
它虽然也是接口,但和Runnable接口不一样，Callable接口提供了一个call()方法作为线程执行体，call()方法比run()方法功能要强大:
1.call方法可以有返回值
2.call()方法可以声明抛出异常
创建并启动有返回值的线程的步骤如下：
1.创建Callable接口的实现类，并实现call()方法，然后创建该实现类的实例（从java8开始可以直接使用Lambda表达式创建Callable对象）。
2.使用FutureTask类来包装Callable对象，该FutureTask对象封装了Callable对象的call()方法的返回值
3.使用FutureTask对象作为Thread对象的target创建并启动线程（因为FutureTask实现了Runnable接口）
4.调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
示例代码:
public class MyThread implements Callable<String>{//Callable是一个泛型接口
@Override
public String call() throws Exception {//返回的类型就是传递过来的V类型
for(int i=0;i<10;i++){
System.out.println(Thread.currentThread().getName()+" : "+i);
}
return "Hello DengFengZi";
}
public static void main(String[] args) throws Exception {
MyThread myThread=new MyThread();
FutureTask<String> futureTask=new FutureTask<>(myThread);
Thread t1=new Thread(futureTask,"线程1");
Thread t2=new Thread(futureTask,"线程2");
Thread t3=new Thread(futureTask,"线程3");
t1.start();
t2.start();
t3.start();
System.out.println(futureTask.get());
}
}
FutureTask非常适合用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果。 FutureTask可以确保即使调用了多次run方法，它都只会执行一次Runnable或者Callable任务，或者通过cancel取消FutureTask的执行等。
疑问:
同时实现Runnable和Callable接口会怎么样？
结论:使用Runnable接口实现类做target创建的的线程和FutureTask的线程交叉着运行，但是由于FutureTask只执行一次Callable任务，在一次运行结束后就终止了程序。
4.使用线程池例如用Executor框架
什么是Executor框架?
Executor框架包括：线程池，Executor，Executors，ExecutorService，CompletionService，Future，Callable等。
具体内容可以到我这篇博客查看
Executor执行Runnable任务
通过Executors的以上四个静态工厂方法获得 ExecutorService实例，而后调用该实例的execute（Runnable command）方法即可。一旦Runnable任务传递到execute（）方法，该方法便会自动在一个线程上
示例代码:
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestCachedThreadPool{
public static void main(String[] args){
ExecutorService executorService = Executors.newCachedThreadPool();
for (int i = 0; i < 3; i++){ //执行三个任务，那么线程池中最多创建三个线程
executorService.execute(new TestRunnable());
System.out.println("************* a" + i + " *************");
}
executorService.shutdown();
}
}
class TestRunnable implements Runnable{
public void run(){
for(int i=0;i<5;i++){
System.out.println(Thread.currentThread().getName() + "线程被调用了。");
}
}
}
当通过实现Callable接口创建线程时，调用了Future接口的实现类FutureTask,该类还实现了Runnable接口，所以可以让实例化对象作为Thread对象的Target。并且每次只执行一个线程的任务，当执行完线程的主任务后，返回值。
示例代码:
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class RunNewFixedThreadPool {
public static void main(String[] args) {
RunNewFixedThreadPool run = new RunNewFixedThreadPool();
ExecutorService executorService = Executors.newFixedThreadPool(6);
for (int i = 0; i < 5; i++) {//创建五个线程
executorService.execute(run.new MyRunnable(" "+(i+1)));
}
for (int i = 5; i < 10; i++) {//再创建五个线程，如果当前线程池中有线程可以使用，则复用，否则创建新的线程，但是线程池中最多只能有6个线程
executorService.execute(run.new MyRunnable(" "+(i+1)));
}
}
public class MyRunnable implements Runnable{
private String username;
public MyRunnable(String username) {
this.username = username;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+" username="+username+" begin "+System.currentTimeMillis());
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+" username="+username+" end "+System.currentTimeMillis());
}
}
}
这里面每次创建的线程数可以设定，上面设为了5，所以一次性开启了五个线程。如果设为3，那么一次最多开三个进程，并且只有当一些进程关闭时，才会开启相同数目的进程。
总结四种创建线程的方法
实现Runnable和实现Callable接口的方式基本相同，不过是后者执行call()方法有返回值，前者线程执行体run()方法无返回值，并且如果使用FutureTask类的话，只执行一次Callable任务。因此可以把这两种方式归为一种这种方式与继承Thread类的方法之间的差别如下：
1、线程只是实现Runnable或实现Callable接口，还可以继承其他类。
2、这种方式下，多个线程可以共享一个target对象，非常适合多线程处理同一份资源的情形。
3.继承Thread类只需要this就能获取当前线程。不需要使用Thread.currentThread()方法
4、继承Thread类的线程类不能再继承其他父类（Java单继承决定）。
5、前三种的线程如果创建关闭频繁会消耗系统资源影响性能，而使用线程池可以不用线程的时候放回线程池，用的时候再从线程池取，项目开发中主要使用线程池的方式创建多个线程。
6.实现接口的创建线程的方式必须实现方法（run() call()）。