執行緒簡介

程序，作業系統中分配資源的基本單元，執行緒，作業系統中執行的基本單元，在一個程序中可以包含一個或多個執行緒，程序間通訊，資源共享效率低，在同一個程序中，所有執行緒共享資源。

執行緒在使用時，也存在各種問題，執行緒安全性，執行緒活躍性，執行緒效能

執行緒安全性

在多執行緒環境中，能夠正確地處理多個執行緒之間的共享變數，使程式功能正確完成，這裡的正確完成，就是每個執行緒得到預期值。

示例程式碼中，thread1和thread2共享資源ArrayList，而ArrayList本身並不是執行緒安全的容器,在每個執行緒中都各自取出list中第一個元素加50次，我們期望的值是100，經過執行後，值可能不是100，就存線上程安全性問題

public static void count() {
        List<Integer> list = new ArrayList<>();
        list.add(0);
        Thread thread1 = new Thread(new Task(list));
        Thread thread2 = new Thread(new Task(list));
        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.get(0));
    }

    public static class Task implements Runnable {
        List<Integer> list;

        public Task(List<Integer> list) {
            this.list = list;
        }

        @Override
        public void run() {
            for (int i = 0; i < 50; i++) {
                int value = list.get(0);
                list.set(0, ++value);
            }
        }
    }
 

執行緒活躍性問題

執行緒活躍性問題，死鎖，弱響應性，飢餓，活鎖，丟失的訊號等

死鎖

當兩個以上的運算單元，雙方都在等待對方停止執行，以獲取系統資源，但是沒有一方提前退出時，就稱為死鎖。

死鎖例項

public static void deadlock() {
        String sourceA = "A";
        String sourceB = "B";

        Thread thread1 = new Thread(new DeadlockTask(sourceA,sourceB));
        Thread thread2 = new Thread(new DeadlockTask(sourceB,sourceA));

        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static  class DeadlockTask implements Runnable{
        private String first;
        private String sec;
        public DeadlockTask(String first,String sec){
            this.first = first;
            this.sec = sec;
        }

        @Override
        public void run() {
            synchronized (first){
                System.out.println(Thread.currentThread().getName()+"獲取到資源:"+ first);
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (sec){
                    System.out.println(Thread.currentThread().getName()+"獲取到資源:"+ sec);
                }
            }
        }
    }
 

造成死鎖有幾個因素，禁止搶佔、持有和等待、互斥、迴圈等待，只要打破其中一個條件就不會產生死鎖，java中減少在鎖巢狀，超時等待獲取鎖等。

死鎖檢測手段

1.用 jstack <pid>工具轉存stack資訊，進行檢測

2.用jvisualvm 圖形化工具檢視

飢餓

在多執行緒環境中，執行緒永遠輪不到cpu時間片，一直處於等待狀態，這個不好演示，也不好檢測，以下程式演示了設定執行緒優先順序，避免飢餓就是儘量減少執行緒優先順序設定。

public static void lockHunger(){
        Thread thread1 = new Thread(new Runnable(){
            @Override
            public void run() {
                System.out.println("A");
            }
        });
        thread1.setPriority(Thread.MIN_PRIORITY);
        Thread thread2 = new Thread(()->{
            System.out.println("B");
        });
        thread2.setPriority(Thread.MAX_PRIORITY);
        
        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

弱響應性

cpu大量時間在處理其他任務，而對某些執行緒排程時間較少，導致響應緩慢，緩解辦法，就是把響應較慢的執行緒優先順序設定高些。

活鎖

執行緒並沒有阻塞，而是不斷重試相同的操作，但是總是失敗，一直處於這種尷尬的狀態，避免的操作，增加重試次數限制機制。

例項程式碼中，執行緒嘗試去對狀態值經行修改，然後做一次db互動。 

    private static void livelock() {
        final AtomicInteger status = new AtomicInteger();
            Thread thread = new Thread(()->{
                while(status.getAndAdd(0)==0){
                    System.out.println("嘗試修改狀態.");
                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("做一次DB互動，儲存狀態值。");
            },"活鎖測試.");
        thread.start();
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

丟失的訊號

給執行緒一個可預期的訊號值，然後讓這個執行緒繼續下面的，但是沒有得到這個訊號，導致的問題。

測試例項，thread1設定訊號，thread2根據訊號執行任務，由於訊號執行緒的執行無法預知，雖然thread1先呼叫start()，但是很可能thread2得不到預期的值，避免程式，在thread2中while等待，將不會產生這個問題。

    private static void lostSemaphore() {
        final AtomicBoolean semaphore = new AtomicBoolean();
        Thread thread1 = new Thread(() -> {
            System.out.println("設定訊號量");
            semaphore.set(true);
        }, "設定訊號量。");

        Thread thread2 = new Thread(() -> {
            if (semaphore.get()) {
                System.out.println("繼續我的任務。");
            }
        }, "接受訊號量。");
        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

 執行緒效能

多執行緒比單線提高了效能，但是也會帶來一定開銷，當這個開銷非常大時，就會出現執行緒新能問題，具體只對多執行緒的管理，執行緒建立，執行緒排程，執行緒銷燬，上下文切換（執行緒在執行和阻塞狀態相互切換時），自旋等待，記憶體同步等。

1.採用多執行緒，是多大限度的讓cpu做有用的事情（而不是在上下文切換這種任務消耗），一個任務需要多少執行緒同時處理才能達到達到最佳效能呢？設定一個非常大的值對不對呢？

這個值需要不斷的測試才能得出，在Netty中NioEventLoopGroup中預設值是cup核數*2。

2.阿姆達爾定律（英語：Amdahl's law，Amdahl's argument），一個電腦科學界的經驗法則，因吉恩·阿姆達爾而得名。它代表了處理器並行運算之後效率提升的能力。

S=1/(1-a+a/n)，a為平行計算部分所佔比例，n為並行處理結點個數。這樣，當1-a=0時，(即沒有序列，只有並行)最大加速比s=n；當a=0時（即只有序列，沒有並行），最小加速比s=1；當n→∞時，極限加速比s→ 1/（1-a），這也就是加速比的上限。（阿姆達爾定律）

總結，這章節講了執行緒簡介，以及執行緒安全性問題，執行緒活躍性問題，以及執行緒效能問題，下一章節講解執行緒的狀態，執行緒的建立，執行緒同步器。