摘要：多線程的實現用多線程只有一個目的更好的利用資源燒水的例子當洗杯子花分鐘線程要停分鐘等待返回結果才能進行后續的燒水操作，新開一個線程執行洗杯子操作。指在并發的情況之下，該代碼經過多線程使用，線程的調度順序不影響任何結果。

Java多線程的實現

用多線程只有一個目的:更好的利用cpu資源.燒水的例子.(當洗杯子花5分鐘,線程要停5分鐘等待返回結果才能進行后續的燒水操作，新開一個線程執行洗杯子操作)。

一、關于線程的一些概念

cpu時間片:我們操作系統看起來可以多個程序同時運行.分時操作系統,將時間分成長短相同的時間區域,分配給一個線程使用,當線程還沒有結束,時間片已經過去,該線程只有先停止,等待下一個時間片.cpu運行很快,中間的停頓感覺不出來.

多線程：指的是這個程序（一個進程）運行時產生了不止一個線程(比如,下載程序,開啟多個線程同時進行.)

并行：多個cpu實例或者多臺機器同時執行一段處理邏輯，是真正的同時。

并發：通過cpu調度算法，讓用戶看上去同時執行，實際上從cpu操作層面不是真正的同時。并發往往在場景中有公用的資源，那么針對這個公用的資源往往產生瓶頸，我們會用TPS或者QPS來反應這個系統的處理能力.

線程安全：經常用來描繪一段代碼。指在并發的情況之下，該代碼經過多線程使用，線程的調度順序不影響任何結果。這個時候使用多線程，我們只需要關注系統的內存，cpu是不是夠用即可。反過來，線程不安全就意味著線程的調度順序會影響最終結果.

Java中的同步指的是通過人為的控制和調度，保證共享資源的多線程訪問成為線程安全，來保證結果的準確。如上面的代碼簡單加入@synchronized關鍵字。在保證結果準確的同時，提高性能，才是優秀的程序。線程安全的優先級高于性能.

二、Java多線程的實現

1、繼承Thread類創建線程

Thread類本質上是實現了Runnable接口，啟動該線程的唯一方法是start()方法，

public class MyThread extends Thread{
    //普通的調用方法,定義任務要完成的工作.
    @Override
    public void run() {
        System.out.println("新線程正在執行,處理相關的邏輯!");
    }
}


public class Test {
    public static void main(String[] args) {
        //實例化對象
        MyThread myThread1 = new MyThread();  
        MyThread myThread2 = new MyThread();    
        //開啟新的線程，分配新的資源
        myThread1.start();
        myThread2.start();
    }
}

2、實現Runnable接口創建線程

java中是單繼承的,如果繼承了一個類,就不能直接繼承Thread類,需要實現Runnable接口的方式達到開啟新線程的目的.

public class MyThread implements Runnable {
    //普通的調用方法,定義任務要完成的工作.
    @Override
    public void run() {
        System.out.println("新線程正在執行,處理相關的邏輯!");
    }    
 }
 
 
 public class Test {
    public static void main(String[] args) {
         MyThread myThread = new MyThread();  
        Thread thread =new Thread(myThread);
        //開啟新的線程，分配新的資源
        thread.start();
    }
}

3、實現Callable接口

Callable接口的call()方法類似run()方法,都是定義任務要完成的工作.主要不同點是call()方法是有返回值的、可以拋出異常。Callable類型的任務可以有兩種方法開啟執行.

方法一：借助FutureTask執行(FutureTask、Callable)

將Callable接口對象放到FutureTask對象中，FutureTask的get()方法,可以獲取返回值.

public class MyCallableTask  implements Callable {
    @Override
    public Integer call() throws Exception {
        System.out.println("新線程正在執行,處理相關的邏輯!");
        Thread.sleep(3000);
        int sum = 0;
        for(int i=0;i<100;i++) {
            sum += i;
        }
        return sum;
    }    
}

    
public class Test {
    public static void main(String[] args) {
        Callable mycallabletask = new MyCallableTask();   
        //由Callable創建一個FutureTask對象：   
        FutureTask futuretask = new FutureTask(mycallabletask);   
        //注釋：FutureTask是一個包裝器，它通過接受Callable來創建，它同時實現了Future            和Runnable接口。 
        //由FutureTask創建一個Thread對象：   
        Thread oneThread = new Thread(futuretask);
        oneThread.start();
        try {
            //通過futuretask中get()方法可以得到MyCallableTask的call()運行結果.
            //需要使用時獲取出來,否則出現堵塞,本線程要等待新線程執行完返回結果才執行
            Integer i = futuretask.get();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

方法二：借助線程池來運行 (ExecutorService、Callable、Future)

ExecutorService、Callable、Future三個接口實際上都是屬于Executor框架。

執行Callable任務后，可以獲取一個Future的對象，在該對象上調用get()就可以獲取到Callable任務返回的Object了。

public class MyCallableTask  implements Callable {    
    @Override
    public Integer call() throws Exception {
        System.out.println("新線程正在執行,處理相關的邏輯!");
        Thread.sleep(3000);
        int sum = 0;
        for(int i=0;i<100;i++) {
            sum += i;
        }
        return sum;
    }
}

public class Test {
    public static void main(String[] args) {
        int taskSize = 5;
        //創建線程池
        ExecutorService threadPool = Executors.newCachedThreadPool(taskSize);
        //提交一個Callable任務,返回一個Future類型
        Future future = threadPool.submit(new MyCallableTask());
         try {
            Thread.sleep(3000);//模擬本線程的一些任務
            //獲取執行結果get方法是阻塞的
            System.out.println(future.get());
        } catch (Exception e) {
            e.printStackTrace();
        }    
    }
}

采用匿名類直接新建Callable接口

public class Test{
    public static void main(String[] args) {
        // 創建線程池
        ExecutorService threadPool = Executors.newCachedThreadPool();
        // 提交一個Callable任務,返回一個Future類型
        Future future = threadPool.submit(new Callable() {
            @Override
            public Integer call() throws Exception {
                System.out.println("新線程正在執行,處理相關的邏輯!");
                Thread.sleep(3000);
                int sum = 0;
                for (int i = 0; i < 100; i++) {
                    sum += i;
                }
                return sum;
            }
        });

        try {
            Thread.sleep(3000);//模擬本線程的一些任務
            //獲取執行結果
            System.out.println(future.get());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

三、使用場景

一、Tomcat內部采用了多線程，上百個用戶同時訪問同一個web應用，都會新開一個線程，調用到Servlet程序。如果不使用多線程，將串行操作，客戶端將等待別人執行完才能訪問。

二、異步請求，有兩個任務Task a和Task b，單線程只能先進行a再進行b。

三、需要知道執行進度，比如說我們常看到的進度條，任務執行到一定進度給new 一個變量，給變量+1.新開一個線程去輪詢這個變量,反饋給客戶端,這樣就可以看到進度情況.

總之,很多地方都用到了多線程,多線程是為了充分利用cpu資源,當你發現一個業務邏輯執行效率特別低,耗時長,可以考慮使用多線程.