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;
}

}

未完待续…