1. 继承 Thread 类,然后调用 start 方法。
1 class MyThread extendsThread {2 //重写run方法,线程运行后,跑的就是run方法
3 public voidrun(){4 //System.out.println("");
5 }6
7 public static voidmain(String[] args){8 Thread t1 = newMyThread();10
t1.start(); //线程运行,调用的 run()方法.
12 }13 }
2. 实现 Runnable 接口的 run 方法, 然后再用 Thread 类包裹后,调用 start 方法。
1 class TestThread implementsRunnable{2
3 @Override4 public voidrun() {5 //implement run method here6 //System.out.println("");
7 }8
9 public static voidmain() {10 final TestThread obj = newTestThread();
12 Thread t1 = newThread(obj);
14 t1.start();15 }16
17 }
3. 实现 Callable 接口的 call 方法,用 FutureTask 类包裹 Callable 对象。然后再用 Thread 类包裹 FutureTask 类,并调用 start 方法。call() 方法可以有返回值。
1 class MyCallable implementsCallable {2 @Override3 public Integer call() throwsException {4 int sum = 0;5 for (int i = 1; i <= 100; i++) {6 sum +=i;7 }8 returnsum;9 }10
11 public static void main(String[] args) throwsException {12 MyCallable mc = new MyCallable(); //实例化 callable
13
14 FutureTask oneTask = new FutureTask(mc); //用FutureTask包裹
15 Thread oneThread = new Thread(oneTask); //用Thread包裹
16 oneThread.start();17 System.out.print(oneTask.get()); //获取返回值
18 }19 }
Callable 方法在 Java 8 后,支持拉姆达表达式的写法,可以创建一个 FutureTask 类,语句上不是太罗嗦。 Callable 方式有以下几个优点:
可以捕获线程上的异常。
可以通过 get 方法得到返回值。
get 方法阻塞当前线程,直到调用的线程运行结束。
可以取消线程的运行。
下面代码演示了使用 FutureTask 类运行线程,捕获异常的例子:
FutureTask task=new FutureTask(()->{throw new Exception("自定义异常");
});newThread(task).start();try{
System.out.println(task.get());
}catch(Exception e) {
System.out.println(e.getMessage());
}
Java 6 之后,还可以通过创建线程池来创建线程,使用 ExecutorService 的 execute 方法:
1 ExecutorService es =Executors.newCachedThreadPool();2 Runnable r = ;3 es.execute(r);
实现Runnable接口相对于继承Thread类的优势:
(1) 适合多个相同程序代码的线程去处理同一资源的情况
(2) 可以避免由于java单一继承带来的局限性
(3) 用接口的方式将你的代码和线程实现分离,更加清晰。
(4) 通过继承Thread类,每个线程都有一个相关联的唯一对象,而实现Runnable接口,多线程可以共享同一个Runnable实例。
(5) 增强了程序的健壮性,代码能够被多个线程共享,代码与数据是独立的。