Java中创建线程主要有三种方式:
- 继承Thread;
- 实现Runnable接口;
- 使用ExecutorService、Callable、Future实现由返回结果的多线程。
继承Thread类创建线程类
重写父类run( )方法
package moreline;
//针对一个线程,顺序执行,体现不出来多线程的概念
public class threadTest1 extends Thread{
public static void main(String[] args) {
threadTest1 tr1=new threadTest1();
threadTest1 tr2=new threadTest1 ();
tr1.run();
tr2.run();
}
public void run() {
for(int i=0;i<10000;i++){
System.out.println("线程-"+i);
}
}
}
run( )方法只是普通的方法,是顺序执行的,虽然我们是写了一个线程,但是并没有体现出多线程的意义。为了体现多线程,应该使用start( )方法来启动线程,start()方法会自动调用run( )方法。所以上面的代码改为:
package moreline;
public class threadTest2 extends Thread {
public static void main(String[] args) {
threadTest2 tr1=new threadTest2();
threadTest2 tr2=new threadTest2();
tr1.start();
tr2.start();
}
public void run() {
for(int i=0;i<10000;i++){
System.out.println("线程-"+i);
}
}
}
通过start( )方法启动的线程。不管th1.start( )调用的run( )方法是否执行完,都继续执行th2.start( )。如果下面有别的代码也同样不需要等待th2.start( )执行完而继续执行。
实现Runnable接口创建线程类
package moreline;
public class threadTest3 implements Runnable{
public String ThreadName;
public threadTest3(String ThreadName) {
this.ThreadName=ThreadName;
}
@Override
public void run() {
for(int i=0;i<10000;i++){
System.out.println(ThreadName);
}
}
public static void main(String[] args) {
threadTest3 th1=new threadTest3("线程A");
threadTest3 th2=new threadTest3("线程B");
Thread myth1=new Thread(th1);
Thread myth2=new Thread(th2);
myth1.start();
myth2.start();
}
}
其实Thread类也是实现了Runnable接口,代表了一个线程的实例,并且启动线程唯一的方法就是通过Thread类的start( )方法。所以第二种实现多线程的方法必须要提拔个工艺new一个Thread类去启动线程。同样的,也不能只是运行run( )方法,因为这样只是一个线程。
使用ExecutorService、Callable、Future实现由返回结果的多线程
ExecutorService、Callable、Future这个对象实际上都是属于Executor框架中的功能类。想要详细了解Executor框架的可以访问:http://www.javaeye.com/topic/366591 ,这里面对该框架做了很详细的解释。返回结果的线程是在JDK1.5中引入的新特征,确实很实用,有了这种特征我就不需要再为了得到返回值而大费周折了。
可返回值的任务必须实现Callable接口,类似的,无返回值的任务必须Runnable接口。执行Callable任务后,可以获取一个Future的对象,在该对象上调用get就可以获取到Callable任务返回的Object了,再结合线程池接口ExecutorService就可以实现传说中有返回结果的多线程了。下面提供了一个完整的有返回结果的多线程测试例子,在JDK1.5下验证过没问题可以直接使用。代码如下:
threadTest.java
package morelinedemo;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
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 threadTest {
public static void main(String[] args) throws
ExecutionException,InterruptedException{
System.out.println("---程序开始执行!---");
Date date1=new Date();
int taskSize=5;
//创建一个线程池
ExecutorService pool=Executors.newFixedThreadPool(taskSize);
//创建多个有返回值的任务
List<Future> list=new ArrayList<Future>();
for(int i=0;i<taskSize;i++){
Callable c=new MyCallable(i+"");
//执行任务并获取Future对象
Future f=pool.submit(c);
list.add(f);
}
//关闭线程池
pool.shutdown();
//获取所有并发任务的运行结果
for(Future f:list){
//从Future对象上获取任务的返回值,并输出到控制台
System.out.println("》》》"+f.get().toString());
}
Date date2=new Date();
System.out.println("---程序结束运行---,程序运行时间{"+(date2.getTime()-
date1.getTime())+"毫秒}");
}
}
MyCallable.java
package morelinedemo;
import java.util.Date;
import java.util.concurrent.Callable;
public class MyCallable implements Callable<Object> {
private String taskNum;
MyCallable(String taskNum){
this.taskNum=taskNum;
}
public Object call() throws Exception{
System.out.println("》》》"+taskNum+"任务启动");
Date dateTmp1=new Date();
Thread.sleep(1000);
Date dateTmp2=new Date();
long time =dateTmp2.getTime()-dateTmp1.getTime();
System.out.println("》》》"+taskNum+"任务终止");
return taskNum+"任务返回运行结果,当前任务时间{"+time+"毫秒}";
}
}
返回结果:
代码说明:
上述代码中Executors类,提供了一系列工厂方法用于创先线程池,返回的线程池都实现了ExecutorService接口。
public static ExecutorService newFixedThreadPool(int nThreads)
创建固定数目线程的线程池。
public static ExecutorService newCachedThreadPool()
创建一个可缓存的线程池,调用execute 将重用以前构造的线程(如果线程可用)。如果现有线程没有可用的,则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。
public static ExecutorService newSingleThreadExecutor()
创建一个单线程化的Executor。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
创建一个支持定时及周期性的任务执行的线程池,多数情况下可用来替代Timer类。
ExecutoreService提供了submit()方法,传递一个Callable,或Runnable,返回Future。如果Executor后台线程池还没有完成Callable的计算,这调用返回Future对象的get()方法,会阻塞直到计算完成。
总结:
实现多线程的几种方式,建议使用runable实现,不管如何最终都需要thread.start( )来启动线程。