Java 创建线程的3种方法及各自优势

1. 继承 Thread 类，然后调用 start 方法。

 1 class MyThread extends Thread {
 2     //重写run方法，线程运行后，跑的就是run方法 
 3     public void run(){
 4        //System.out.println("");
 5     }
 6  
 7     public static void main(String[] args){
 8        Thread t1 = new MyThread();10        
          t1.start();  //线程运行,调用的 run()方法.
12     }
13 } 

2. 实现 Runnable 接口的 run 方法, 然后再用 Thread 类包裹后，调用 start 方法。

 1 class TestThread implements Runnable{
 2  
 3     @Override
 4     public void run() {
 5         // implement run method here 
 6        //System.out.println("");
 7     }
 8  
 9     public static void main() {
10         final TestThread obj = new TestThread();
12         Thread t1 = new Thread(obj);
14         t1.start();
15     }
16  
17 }

3. 实现 Callable 接口的 call 方法，用 FutureTask 类包裹 Callable 对象。然后再用 Thread 类包裹 FutureTask 类，并调用 start 方法。call() 方法可以有返回值。

 1 class MyCallable implements Callable {
 2     @Override
 3     public Integer call() throws Exception {
 4         int sum = 0;
 5         for (int i = 1; i <= 100; i++) {
 6             sum += i;
 7         }
 8         return sum;
 9     }
10  
11     public static void main(String[] args) throws Exception {
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<Integer> task=new FutureTask<Integer>(()->{
    throw new Exception("自定义异常");
});
 
new Thread(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 = <your runnable here>;
3 es.execute(r);

 

实现Runnable接口相对于继承Thread类的优势:

   (1) 适合多个相同程序代码的线程去处理同一资源的情况

   (2) 可以避免由于java单一继承带来的局限性

   (3) 用接口的方式将你的代码和线程实现分离，更加清晰。

   (4) 通过继承Thread类，每个线程都有一个相关联的唯一对象，而实现Runnable接口，多线程可以共享同一个Runnable实例。

  (5) 增强了程序的健壮性,代码能够被多个线程共享,代码与数据是独立的。

转载于:https://www.cnblogs.com/zhaosq/p/11422888.html