Java中啓動線程的方式及區別

三種方式

1. 繼承Thread類建立線程類，經過start方法開啓新線程

使用方式：

1. 繼承Thread類，並重寫該類的run方法。
2. new一個實例，經過start方法啓動新線程

示例

package com.thread;  
      
    public class FirstThreadTest extends Thread{  
        int i = 0;  
        //重寫run方法，run方法的方法體就是現場執行體  
        public void run()  
        {  
            for(;i<100;i++){  
            System.out.println(getName()+" "+i);  
              
            }  
        }  
        public static void main(String[] args)  
        {  
            for(int i = 0;i< 100;i++)  
            {  
                System.out.println(Thread.currentThread().getName()+" : "+i);  
                if(i==20)  
                {  
                    new FirstThreadTest().start();  
                    new FirstThreadTest().start();  
                }  
            }  
        }  
      
    }  
複製代碼

擴展

start和run方法的區別： start方法開啓了一個新的線程，使線程處於就緒狀態；run方法只是在當前線程執行實例方法，直接調用run方法並無開啓新的線程。

2. 實現Runnable接口

使用方式：

1. 實現Runnable接口，並重寫該類的run方法。
2. new一個實例，將該實例做爲Thread的target建立Thread對象
3. 調用Thread的start方法

示例

package com.thread;  
      
    public class RunnableThreadTest implements Runnable  
    {  
      
        private int i;  
        public void run()  
        {  
            for(i = 0;i <100;i++)  
            {  
                System.out.println(Thread.currentThread().getName()+" "+i);  
            }  
        }  
        public static void main(String[] args)  
        {  
            for(int i = 0;i < 100;i++)  
            {  
                System.out.println(Thread.currentThread().getName()+" "+i);  
                if(i==20)  
                {  
                    RunnableThreadTest rtt = new RunnableThreadTest();  
                    new Thread(rtt,"新線程1").start();  
                    new Thread(rtt,"新線程2").start();  
                }  
            }  
      
        }  
      
    }  
複製代碼

3. 實現Callable接口

使用方式

1. 建立Callable接口的實現類，並實現call方法
2. 建立Callable實現類的實例，並用FutureTask類來包裝該實例
3. 使用FutureTask實例做爲target建立Thread實例
4. 調用Thread實例的start方法

示例

package com.thread;  
      
    import java.util.concurrent.Callable;  
    import java.util.concurrent.ExecutionException;  
    import java.util.concurrent.FutureTask;  
      
    public class CallableThreadTest implements Callable<Integer>  
    {  
      
        public static void main(String[] args)  
        {  
            CallableThreadTest ctt = new CallableThreadTest();  
            FutureTask<Integer> ft = new FutureTask<>(ctt);  
            for(int i = 0;i < 100;i++)  
            {  
                System.out.println(Thread.currentThread().getName()+" 的循環變量i的值"+i);  
                if(i==20)  
                {  
                    new Thread(ft,"有返回值的線程").start();  
                }  
            }  
            try  
            {  
                System.out.println("子線程的返回值："+ft.get());  
            } catch (InterruptedException e)  
            {  
                e.printStackTrace();  
            } catch (ExecutionException e)  
            {  
                e.printStackTrace();  
            }  
      
        }  
      
        @Override  
        public Integer call() throws Exception  
        {  
            int i = 0;  
            for(;i<100;i++)  
            {  
                System.out.println(Thread.currentThread().getName()+" "+i);  
            }  
            return i;  
        }  
      
    }  
複製代碼

對比

Runnable/Callable和Thread對比

優點

1. 經過實現接口，還能夠繼承其餘類
2. 多個線程能夠共享同一個target，適合資源共享

劣勢

1. 編程稍微複雜，若是要訪問當前線程，則必須使用Thread.currentThread()方法

Runnable和Callable的區別

1. Callable能夠有返回值，Runnable沒有返回值
2. Callable接口的call()方法容許拋出異常；而Runnable接口的run()方法的異常只能在內部消化，不能繼續上拋

擴展：

Callable接口支持返回執行結果，此時須要調用FutureTask.get()方法實現，此方法會阻塞主線程直到獲取‘未來’結果；當不調用此方法時，主線程不會阻塞
複製代碼