说起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，那么一次最多开三个进程，并且只有当一些进程关闭时，才会开启相同数目的进程。