Java多线程之建立线程的三种方式比较

一：继承Thread类建立线程

        1：继承Thread类定义线程子类；

        2：重写run()方法，定义线程的操做；

        3：经过建立的线程子类对象.start() 启动线程。

package com.thread;   
public class FirstThreadTest extends Thread{   
    public void run()  
    {    
        System.out.println(Thread.currentThread().getName());  
    }  
    public static void main(String[] args)  
    {  
                new FirstThreadTest().start();    
    }  
  
} 

 

    二：实现Runnable接口建立线程

        1：实现Runnable接口定义线程类；

        2：重写run()方法；

        3：建立Thread对象：把上面 实现runnable接口的线程类 的对象做为构造参数，建立出线程对象；

        4：由thread对象的start()方法启动线程；

public class RunnableThreadTest implements Runnable  
{  
    public void run()  
    {     
            System.out.println(Thread.currentThread().getName()）
    }  
    public static void main(String[] args)  
    {  
                new Thread(new RunnableThreadTest()).start();  
    }  
  
} 

 

    三：经过Callable接口和Future建立线程

       1：建立Callable接口的实现类，并指明返回值类型；

       2：在实现类中重写call()方法，并返回结果；

       3：建立Future<V>类型的list接收线程的预期结果： List<Future<String>> results = new ArrayList<Future<String>>();

       4：经过线程池启动线程，而且把线程返回结果add到list中；

       5：遍历list时，经过每一个元素的 get() 方法获取每一个线程的实际运行结果值；

//实现callable接口，定义线程类
class TaskWithResult implements Callable<String>{  
    private int id;  
    public TaskWithResult(int id){  
        this.id = id;  
    }  
   //重写call()方法，切记抛出异常，并返回值
    public String call() throws Exception {  
        return "result of task:" + id;  
    }  

public class TestCallable {      
    public static void main(String[] args) {  
        //建立线程池
        ExecutorService es = Executors.newCachedThreadPool();
       //建立预期结果集合  
        List<Future<String>> results = new ArrayList<Future<String>>();  

        for(int i=0;i<5;i++){  
            //经过线程池启动线程，把线程结果保存到预期结果集合
            results.add(es.submit(new TaskWithResult(i)));  
        }  
        //遍历结果集合
        for(Future<String> fs : results){  
            try {  
                //经过 结果.get() 方法获取每一个线程运行结束后的返回值。并处理异常
                System.out.println(fs.get());  
            } catch (InterruptedException | ExecutionException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
}  

另外一种启动callable实现类线程的办法：

Callable<Result> ca = new Callable<Result>() {
             public Result call() throws Exception {
                 System.out.println("当前线程名称是:" + Thread.currentThread().getName());
                 Thread.sleep(2000L);
                return new Result("callable 执行完毕");
             }
         };
         //包装对象
         FutureTask<Result> ft = new FutureTask<Result>(ca);
         try {            
          //启动线程执行
            new Thread(ft).start();
            //获取结果
             System.out.println(ft.get().getMsg());
          } catch (Exception e) {
             e.printStackTrace();
         }
     }

 

    四：对比

        1：继承Thread类建立线程：其run()方法没有返回值；经过start方法启动；因为Java不能容许多继承，一个类若是须要继承其余类就不能再定义为线程类了；run方法中的异常必须捕获并处理；

        2：实现runnable接口建立线程：其run()方法没有返回值；经过做为thread类的构造函数的参数被包装成thread类对象，再经过start方法启动（由此，能够同一个任务对象交给多个thread对象来运行，实现资源的共享以及并行处理）；因为接口能够多实现，一个类能够继承其余类的同时实现runnable接口成为线程类；run方法中的异常必须捕获并处理；

        3：实现Callable接口建立线程：其call()方法有返回值；通常经过线程池来启动线程，也能够先包装成为FutureTask对象，而后再由futuretask对象包装成Thread对象经过start方法启动；call()方法能够抛出异常，直到在结果处经过get()方法获取结果时再处理异常；在主线程启动实现callable建立的线程时能够得到一个Future对象做为异步处理的预期结果，在经过future.get()方法时检测启动的线程是否已完成并返回结果，是则获得结果，不然阻塞主线程等待任务线程完成并返回结果；