詳解Java多線程如何實現(xiàn)

小編這次要給大家分享的是詳解Java多線程如何實現(xiàn)，文章內容豐富，感興趣的小伙伴可以來了解一下，希望大家閱讀完這篇文章之后能夠有所收獲。

1.繼承Thread類，重寫run方法

2.實現(xiàn)Runnable接口，重寫run方法，實現(xiàn)Runnable接口的實現(xiàn)類的實例對象作為Thread構造函數(shù)的target

3.通過Callable和FutureTask創(chuàng)建線程

4.通過線程池創(chuàng)建線程

前面兩種可以歸結為一類：無返回值，原因很簡單，通過重寫run方法，run方式的返回值是void，所以沒有辦法返回結果

后面兩種可以歸結成一類：有返回值，通過Callable接口，就要實現(xiàn)call方法，這個方法的返回值是Object，所以返回的結果可以放在Object對象中

1. 繼承Thread類

public class ThreadDemo01 extends Thread{
  public ThreadDemo01(){
    //編寫子類的構造方法，可缺省
  }
  public void run(){
    //編寫自己的線程代碼
    System.out.println(Thread.currentThread().getName());
  }
  public static void main(String[] args){ 
    ThreadDemo01 threadDemo01 = new ThreadDemo01(); 
    threadDemo01.setName("我是自定義的線程1");
    threadDemo01.start();    
    System.out.println(Thread.currentThread().toString()); 
  }
}

程序結果：

Thread[main,5,main]
我是自定義的線程1

2. 實現(xiàn)Runnable接口

重寫run方法，接口的實現(xiàn)類的實例作為Thread的target作為參數(shù)傳入帶參的Thread構造函數(shù)，通過調用start()方法啟動線程

public class ThreadDemo02 {
  public static void main(String[] args){ 
    System.out.println(Thread.currentThread().getName());
    Thread t1 = new Thread(new MyThread());
    t1.start(); 
  }
}

class MyThread implements Runnable{
  @Override
  public void run() {
    // TODO Auto-generated method stub
    System.out.println(Thread.currentThread().getName()+"-->我是通過實現(xiàn)接口的線程實現(xiàn)方式！");
  }  
}

程序運行結果：

main
Thread-0–>我是通過實現(xiàn)接口的線程實現(xiàn)方式！

3. 通過Callable和FutureTask創(chuàng)建線程

• 創(chuàng)建Callable接口的實現(xiàn)類 ，并實現(xiàn)Call方法
• 創(chuàng)建Callable實現(xiàn)類的實現(xiàn)，使用FutureTask類包裝Callable對象，該FutureTask對象封裝了Callable對象的Call方法的返回值
• 使用FutureTask對象作為Thread對象的target創(chuàng)建并啟動線程
• 調用FutureTask對象的get()來獲取子線程執(zhí)行結束的返回值

public class ThreadDemo03 {
  /**
   * @param args
   */
  public static void main(String[] args) {
    // TODO Auto-generated method stub
    Callable<Object> oneCallable = new Tickets<Object>();
    FutureTask<Object> oneTask = new FutureTask<Object>(oneCallable);
    Thread t = new Thread(oneTask);
    System.out.println(Thread.currentThread().getName());
    t.start();
  }
}
class Tickets<Object> implements Callable<Object>{

  //重寫call方法
  @Override
  public Object call() throws Exception {
    // TODO Auto-generated method stub
    System.out.println(Thread.currentThread().getName()+"-->我是通過實現(xiàn)Callable接口通過FutureTask包裝器來實現(xiàn)的線程");
    return null;
  }  
}

程序運行結果：

main
Thread-0–>我是通過實現(xiàn)Callable接口通過FutureTask包裝器來實現(xiàn)的線程

4. 通過線程池創(chuàng)建線程

public class ThreadDemo05{
  private static int POOL_NUM = 10;   //線程池數(shù)量

  /**
   * @param args
   * @throws InterruptedException 
   */
  public static void main(String[] args) throws InterruptedException {
    // TODO Auto-generated method stub
    ExecutorService executorService = Executors.newFixedThreadPool(5); 
    for(int i = 0; i<POOL_NUM; i++) { 
      RunnableThread thread = new RunnableThread();
      //Thread.sleep(1000);
      executorService.execute(thread); 
    }
    //關閉線程池
    executorService.shutdown(); 
  }  
}

class RunnableThread implements Runnable {   
  @Override
  public void run() { 
    System.out.println("通過線程池方式創(chuàng)建的線程：" + Thread.currentThread().getName() + " "); 
  } 
} 

程序運行結果：

通過線程池方式創(chuàng)建的線程：pool-1-thread-3
通過線程池方式創(chuàng)建的線程：pool-1-thread-4
通過線程池方式創(chuàng)建的線程：pool-1-thread-1
通過線程池方式創(chuàng)建的線程：pool-1-thread-5
通過線程池方式創(chuàng)建的線程：pool-1-thread-2
通過線程池方式創(chuàng)建的線程：pool-1-thread-5
通過線程池方式創(chuàng)建的線程：pool-1-thread-1
通過線程池方式創(chuàng)建的線程：pool-1-thread-4
通過線程池方式創(chuàng)建的線程：pool-1-thread-3
通過線程池方式創(chuàng)建的線程：pool-1-thread-2

ExecutorService、Callable都是屬于Executor框架。還有Future接口也是屬于這個框架，有了這種特征得到返回值就很方便了。
通過分析可以知道，他同樣也是實現(xiàn)了Callable接口，實現(xiàn)了Call方法，所以有返回值。這也就是正好符合了前面所說的兩種分類
執(zhí)行Callable任務后，可以獲取一個Future的對象，在該對象上調用get就可以獲取到Callable任務返回的Object了。get方法是阻塞的，即：線程無返回結果，get方法會一直等待。

Executors類：提供了一系列工廠方法用于創(chuàng)建線程池，返回的線程池都實現(xiàn)了ExecutorService接口。

// 創(chuàng)建固定數(shù)目線程的線程池
public static ExecutorService newFixedThreadPool(int nThreads)

// 創(chuàng)建一個可緩存的線程池，調用execute 將重用以前構造的線程（如果線程可用）。如果現(xiàn)有線程沒有可用的，則創(chuàng)建一個新線程并添加到池中。終止并從緩存中移除那些已有 60 秒鐘未被使用的線程
public static ExecutorService newCachedThreadPool()

// 創(chuàng)建一個單線程化的Executor
public static ExecutorService newSingleThreadExecutor()

// 創(chuàng)建一個支持定時及周期性的任務執(zhí)行的線程池，多數(shù)情況下可用來替代Timer類
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)

ExecutoreService提供了submit()方法，傳遞一個Callable，或Runnable，返回Future。

如果Executor后臺線程池還沒有完成Callable的計算，這調用返回Future對象的get()方法，會阻塞直到計算完成。

看完這篇關于詳解Java多線程如何實現(xiàn)的文章，如果覺得文章內容寫得不錯的話，可以把它分享出去給更多人看到。