在JDK1.4之前,只有两种实现方式,即继承Thread类和实现Runnable接口。在JDK1.5之后,新加入Callable接口,通过继承Callable接口也能实现多线程。值得注意的是前两种实现方式是没有返回值,通过Callable实现是可以获得线程实现的结果。
1、继承Thread类
继承Thread实现的方式比较简单,直接在类上extends Thread就可以了。Thread类本质也是实现了Runnable接口,因此继承Thread类之后需要在子类的内部重写run()方法。启动线程的方式也十分简单,直接通过子类对象调用start()方法。start()方法是一个本地方法,它将异步调用子类的run()方法并开启一个新线程。
public
class
MyThread
extends
Thread
{
@Override
public
void
run
()
{
System
.
out
.
println
(
"一个新的线程被开启!"
);
}
public
static
void
main
(
String
[]
args
)
{
//
TODO
Auto-generated method stub
MyThread
myThread1
=
new
MyThread
();
MyThread
myThread2
=
new
MyThread
();
myThread1
.
start
();
myThread2
.
start
();
}
}
2、实现Runnable接口
与C++不同的是,java只能有一个直接父类,也就是说对于一个java最多只能继承一个类。当该类已经继承一个类之后,就不能再继承Thread类,这时候可以通过实现Runnable接口来实现。下面给出实例。
public class MyRunnable implements Runnable {
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("Runnable线程新建!");
}
public static void main(String[] args) {
// TODO Auto-generated method stub
new Thread(new MyRunnable()).start();
new Thread(new MyRunnable()).start();
}
}
3、实现Callable接口
import java.util.Random;
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 MyCallable {
public static void main(String[] args) {
ExecutorService threadPool = Executors.newSingleThreadExecutor();//新建线程池,只能容单个线程
Future<Integer> future = threadPool.submit(()->{
System.out.println("调用Callable中的call方法");
return new Random().nextInt(100);
});
try {
Thread.sleep(1);// 可能做一些事情
System.out.println(future.get());//通过future的get()方法返回执行结果
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
threadPool.shutdown();
}
}