Java粗淺認識-併發編程（一）-線程簡介

線程簡介

進程，操作系統中分配資源的基本單元，線程，操作系統中運行的基本單元，在一個進程中可以包含一個或多個線程，進程間通信，資源共享效率低，在同一個進程中，所有線程共享資源。

線程在使用時，也存在各種問題，線程安全性，線程活躍性，線程性能

線程安全性

在多線程環境中，能夠正確地處理多個線程之間的共享變量，使程序功能正確完成，這裏的正確完成，就是每個線程得到預期值。

示例代碼中，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），這也就是加速比的上限。（阿姆達爾定律）

總結，這章節講了線程簡介，以及線程安全性問題，線程活躍性問題，以及線程性能問題，下一章節講解線程的狀態，線程的創建，線程同步器。