Java创建线程方式总结

创建线程的方式

1.继承Thread类
2.实现Runnable接口
3.实现Callable接口
4.通过线程池来创建线程

创建线程方式之间的比较：

1. Thread和Runnable的比较

Thread和Runnable是实现java多线程的2种方式，Runnable是接口，Thread是类，建议使用Runnable实现 java多线程，不管如何，最终都需要通过thread.start()来使线程处于可运行状态。
start（）和run（）方法:
调用start方法方可启动线程，而run方法只是thread的一个普通方法调用，还是在主线程里执行。把需要并行处理的代码放在run()方法中，start()方法启动线程将自动调用 run()方法，这是由jvm的内存机制规定的。并且run()方法必须是public访问权限，返回值类型为void.

2. Runnable接口和Callable接口的区别

a.Callable是个泛型参数化接口.
b.实现Callable接口需要重写的方法是call(),实现Runnable接口需要重写的方法是run().
c.Callable的任务执行后可返回值，而Runnable的任务是不能返回值的
d.call方法可以抛出异常，run方法不可以
e.运行Callable任务需要一个FutureTask对象，通过FutureTask对象的get方法来阻塞主进程。

package com.callable.runnable;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * 实现Callable接口
 */
public class CallableImpl implements Callable<String> {

    public CallableImpl(String acceptStr) {
        this.acceptStr = acceptStr;
    }

    private String acceptStr;

    @Override
    public String call() throws Exception {
        // 任务阻塞 1 秒
        Thread.sleep(1000);
        return this.acceptStr + " append some chars and return it!";
    }


    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<String> callable = new CallableImpl("my callable test!");
        FutureTask<String> task = new FutureTask<>(callable);
        long beginTime = System.currentTimeMillis();
        // 创建线程
        new Thread(task).start();
        // 调用get()阻塞主线程，反之，线程不会阻塞
        String result = task.get();
        long endTime = System.currentTimeMillis();
        System.out.println("hello : " + result);
        System.out.println("cast : " + (endTime - beginTime) / 1000 + " second!");
    }
}

这是一个主函数中的创建线程池的方式,具有缓冲功能的线程池，系统根据需要创建线程,线程会被缓冲到线程池中,如果线程池大小超过了处理任务所需要的线程,线程池就会回收空闲的线程池，当处理任务增加时，线程池可以增加线程来处理任务,线程池不会对线程的大小进行限制,线程池的大小依赖于操作系统

//这是一个线程类
public class ThreadChi implements Runnable{
    public void run(){
        for(int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

ExecutorService es=Executors.newCachedThreadPool();
        for(int i=0;i<10;i++){
            ThreadChi tc=new ThreadChi();
            es.execute(tc);
        }
        es.shutdown();

下面来举个栗子，应用一下刚才上面讲到的不易理解的创建线程的方式，加深一下理解：
要计算出1-10000之间的所有数字的和，为了提升计算速度，我们使用两个线程，第一个线程计算1-5000的和，另外有一个线程计算5001-10000之间的数字的和。

import java.util.ArrayList;  
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;  

public class TestMain{  
    public static void main(String[] args) throws InterruptedException, ExecutionException {  
        ExecutorService executor = Executors.newCachedThreadPool();  
        ArrayList<Future<Integer>> resultList = new ArrayList<>();  

        //创建并提交任务1  
        AddNumberTask task1 = new AddNumberTask(1, 5000);  
        Future<Integer> future1 = executor.submit(task1);  
        resultList.add(future1);  

        //创建并提交任务2  
        AddNumberTask task2 = new AddNumberTask(5001, 10000);  
        Future<Integer> future2 = executor.submit(task2);  
        resultList.add(future2);  

        executor.shutdown();  

        int total = 0;  

        for(Future<Integer> future : resultList){  
            while(true){  
                if(future.isDone() && !future.isCancelled()){  
                    int sum = future.get();  
                    total += sum;  
                    break;  
                }  
                else{  
                    Thread.sleep(100);  
                }  
            }  
        }  

        System.out.println("total sum is " + total);  
    }  

}  

class AddNumberTask implements Callable<Integer>{  
    private int start;  
    private int end;  

    public AddNumberTask(int start, int end) {  
        // TODO Auto-generated constructor stub  
        this.start = start;  
        this.end = end;  
    }  

    @Override  
    public Integer call() throws Exception {  
        // TODO Auto-generated method stub  
        int totalSum = 0;  

        for(int i = start; i <= end; i++){  
            totalSum += i;  
        }  
          Thread.sleep(5000); 
        return totalSum;  
    }  

}  

未完待续…