執行緒，行程，并行，并發（區別，聯系，應用）

并行與并發

理解：
并發是單核處理，并行是多核處理
并發是輪流執行，并行使同時執行

并行可用于：大資料、分布式、多執行緒等等
并不是任何任務都適合并發處理（例如某些任務必須要根據其他任務的資料才能執行的程式）
并行大多通過分治法實作，分治法也要有下限

并行：多個執行緒可以同時執行，每一個時間段，可以有多個執行緒同時執行，

并發：多個執行緒同時競爭一個位置，競爭到的才可以執行，每一個時間段只有一個執行緒在執行，

行程和執行緒:

(看圖，真的比較全面了QAQ)

行程

是指一個記憶體中運行中的應用程式，每個行程都有自己獨立的一塊記憶體空間，一個應用程式可以同時啟動多個行程， 行程是系統進行資源分配的最小單位，
有獨立的記憶體空間，行程中的資料存放空間（堆空間和堆疊空間）是獨立的，至少有一個執行緒，

執行緒

是指行程中的一個執行任務(控制單元)，一個行程可以同時并發運行多個執行緒，及任務的分塊處理
一個行程至少有一個執行緒，為了提高效率，可以在一個行程中開啟多個執行任務,即多執行緒，
堆空間是共享的，堆疊空間是獨立的，執行緒消耗的資源也比行程小，相互之間可以影響的，又稱為輕型行程或行程元，

創建和啟動執行緒:（轉載自鏈接: link.https://blog.csdn.net/qq_44705164/article/details/112058091）

啟動執行緒一共有三種方法：繼承類，實作介面，匿名內部類，
一、啟動執行緒的第一種方法：繼承Thread類
二、啟動執行緒的第二種方式：實作Runnable介面
三、啟動執行緒的第三種方式：實作Callable介面

這個很詳細，清楚

多執行緒

多執行緒出現的原因:

為了解決負載均衡問題,充分利用CPU資源.為了提高CPU的使用率,采用多執行緒的方式去同時完成幾件事情而不互相干擾，

多執行緒的好處:

1.使用執行緒可以把占據時間長的程式中的任務放到后臺去處理

2.程式運行效率提高

3.在一些等待的任務實作上如用戶輸入,檔案讀取和網路收發資料等,執行緒就比較有用了.

多執行緒的缺點:

1.如果有大量的執行緒,會影響性能,因為作業系統需要在它們之間切換.

2.更多的執行緒需要更多的記憶體空間

3.執行緒中止需要考慮對程式運行的影響.

4.通常塊模型資料是在多個執行緒間共享的,需要防止執行緒死鎖情況的發生

多執行緒與并行

因為涉及的知識太多，在此就不一一說明，請參考大佬的文章,寫得很詳細很贊，
linkhttps://blog.csdn.net/ftell/article/details/79353571

如果有多個任務，最好用執行緒池，否則就要為逐個任務創建執行緒，這種做法會導致低吞吐量和低性能，

執行緒池

優勢

（1）降低資源消耗，通過重復利用已創建的執行緒降低執行緒創建和銷毀造成的消耗，
（2）提高回應速度，當任務到達時，任務可以不需要等到執行緒創建就能立即執行，
（3）提高執行緒的可管理性，執行緒是稀缺資源，如果無限制的創建，不僅會消耗系統資源，還會降低系統的穩定性，使用執行緒池可以進行統一的分配，調優和監控，

功能執行緒池

Executors封裝好了 4 種常見的功能執行緒池，如下：

定長執行緒池（FixedThreadPool）

特點：只有核心執行緒，執行緒數量固定，執行完立即回收，任務佇列為鏈表結構的有界佇列，
應用場景：控制執行緒最大并發數，

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


public class Demo {
    public static void main(String[] args) {
        //1.創建可固定長度的執行緒池
        ExecutorService newExecutorService = Executors.newFixedThreadPool(3);
        //創建了10個執行緒
        for (int i = 0; i < 10; i++) {
            int temp = i;
            newExecutorService.execute(new Runnable() {
                @Override
                public void run() {
                 System.out.println("threadName;"+Thread.currentThread().getName()+",i"+temp);
                }
            });
        }
    }
}

定時執行緒池（ScheduledThreadPool ）

特點：核心執行緒數量固定，非核心執行緒數量無限，執行完閑置 10ms 后回收，任務佇列為延時阻塞佇列，
應用場景：執行定時或周期性的任務，

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

import static java.util.concurrent.TimeUnit.*;

public class Demo {
    public static void main(String[] args) {
        //1.創建可定時執行緒池
        ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(5);
        for (int i = 0; i < 10; i++) {
            final int temp = i;
            newScheduledThreadPool.schedule(new Runnable() {
                public void run() {
                    System.out.println("i:" + temp);
                }
            }, 3, TimeUnit.SECONDS);
        }

    }
}

可快取執行緒池（CachedThreadPool）

特點：無核心執行緒，非核心執行緒數量無限，執行完閑置 60s 后回收，任務佇列為不存盤元素的阻塞佇列，如果執行緒池長度超過處理需要，可靈活回收空閑執行緒，若無可回收，則新建執行緒，
應用場景：執行大量、耗時少的任務，

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


public class Demo1 {
    public static void main(String[] args) {
        //1.創建可快取的執行緒池，可重復利用
        ExecutorService newExecutorService = Executors.newCachedThreadPool();
        //創建了10個執行緒
        for (int i = 0; i < 10; i++) {
            int temp = i;
            newExecutorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("threadName;"+Thread.currentThread().getName()+",i"+temp);
                }
            });
        }
    }
}

單執行緒化執行緒池（SingleThreadExecutor）

特點：創建一個單執行緒化的執行緒池，它只會用唯一的作業執行緒來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先級)執行，只有 1 個核心執行緒，無非核心執行緒，執行完立即回收，任務佇列為鏈表結構的有界佇列，
應用場景：不適合并發但可能引起 IO 阻塞性及影響 UI 執行緒回應的操作，如資料庫操作、檔案操作等，

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

import static java.util.concurrent.TimeUnit.*;


public class Demo {
    public static void main(String[] args) {
        //1.創建單執行緒
        ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            newSingleThreadExecutor.execute(new Runnable() {

                @Override
                public void run() {
                    System.out.println("index:" + index);
                    try {
                        Thread.sleep(200);
                    } catch (Exception e) {
                        // TODO: handle exception
                    }
                }
            });
        }
        newSingleThreadExecutor.shutdown();
    }
}