談談多線程

前言：

　　一直以來，對於多線程的理解總是趕在前一秒翻書時回憶起，后一秒放下書即忘。甚是可惱！今晚對多線程總結一下，也好有個了斷~

概念引入：

　　首先，我們想了解的是：什么是線程，跟進程有什么關聯？

　　其實是這樣的：線程是程序執行流的最小單元。其一般有3種狀態：就緒，執行和阻塞（因本文注重實例，就不對概念作過多的解釋~）。在計算機中，一個代碼塊（block）運行時產生一個或多個進程（process）,而每一個進程又對應一至多個線程(thread)，每一個線程又可以分為一至多個任務（task）.

　　因此，以上的關系我們可以通過下面一張圖進行理解。

• 1.創建線程的兩種實現方式：

1）繼承Thread類

2）實現Runnable接口

package com.gdufe.thread;

public class ThreadTest {

    public static void main(String[] args) {

        Thread thread1 = new Thread(new TaskA(),"thread1");
        Thread thread2 = new Thread(new TaskB('a',100),"thread2");
        Thread thread3 = new Thread(new TaskB('b',100),"thread3");
        
        thread1.start();;
        thread2.start();
        thread3.start();
        System.out.println("--End--");
        
        
    }
    
    /*
     * 任務A通過實現Runnable接口創建任務
     */
    private static class TaskA implements Runnable{

        @Override
        public void run() {
            for(int i=0;i<100;i++){
                System.out.print(i+" ");
            }
        }
        
    }
    /*
     * 任務B通過繼承Thread類並重寫run()方法來創建任務
     */
    private static class TaskB extends Thread{
        
        private char ch;
        private int times;
        
        public TaskB(char ch,int times){
            this.ch=ch;
            this.times=times;
        }
        @Override
        public void run() {
            for(int i=0;i<times;i++){
                System.out.print(ch+" ");
            }
        }
    }
}

輸出結果：

• 2.線程池thread-pool 

　　線程池指的是不需要每個任務用一個線程來存儲，而是初始就給出一個“池”。線程池首先會初始池的大小，即可供同時進入的“任務”的數量，這樣的話每當來一個新任務就直接往線程池里面扔，不需要再單獨創建一個個線程。

• 3.線程不安全

【不安全實例代碼】

package com.gdufe.thread;

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

public class ThreadNotSafe {
    static Account account = new Account();

    public static void main(String[] args) {

        ExecutorService executor = Executors.newCachedThreadPool();
        for (int i = 0; i < 100; i++) {
            executor.execute(new Deposit());
        }
        executor.shutdown();
        while (!executor.isTerminated()) {
        }
        System.out.println("Finally, the account get the total balance:"
                + account.getBalance());
    }
    /*
     * 存錢操作，每次存入1
     */
    static class Deposit implements Runnable {

        @Override
        public void run() {
            account.deposit(1);
        }
    }

    static class Account {
        private int balance = 0;

        public int getBalance() {
            return balance;
        }

        public void deposit(int value) {
            int newBalance = balance + value;
            try {
                Thread.sleep(5);    //故意將原有的簡單操作拆分兩步，並且中間延遲5毫秒
            } catch (Exception e) {
            }
            balance = newBalance;
        }
    }

}

輸出結果：

Finally, the account get the total balance:3

（注意：執行多次的結果不一樣）

 

分析：

　　上述實例進行100個任務，每個任務都是往賬號里面存“1”，正確的結果應該輸出“100”，那為什么最終的結果好像“不正確”。原因是，當多個任務同時訪問一個資源時，就出現了所謂的資源“競爭”。

解決方法：

1）使用關鍵字“synchronized”對資源進行封鎖，此方式稱作“隱式加鎖”；

2）采用java內部工具類“Lock”進行“顯式加鎖”。

【方式1-代碼修改部分】：

static class Account {
        private int balance = 0;

        public int getBalance() {
            return balance;
        }
        /*
         * 增加關鍵字‘synchronized’,方法未執行完時，僅限一個任務訪問該方法
         */
        public synchronized void deposit(int value) {
            int newBalance = balance + value;
            try {
                Thread.sleep(5);    //故意延遲5毫秒
            } catch (Exception e) {
            }
            balance = newBalance;
        }
    }

【方式2-代碼修改部分】：

static class Account {
        private int balance = 0;
        private static Lock lock = new ReentrantLock();  4 
        public int getBalance() {
            return balance;
        }
        /*
         * 采用顯示加鎖，方法開始執行時加鎖，執行結束前解鎖
         */
        public void deposit(int value) {
            lock.lock();    //加鎖
            int newBalance = balance + value;
            try {
                Thread.sleep(5);    //故意延遲5毫秒
                balance = newBalance;
            } catch (Exception e) {
            
            }finally{
                lock.unlock();     //解鎖
            }
        }
    }

輸出結果：

Finally, the account get the total balance:100

（多次執行，輸出結果總是100）

• 4.線程協作實例：

　　實例情境：

　　假如現在要對一個銀行賬號（Account）進行存(Deposit)取(Withdraw)錢操作。故確定了2個線程，這里的協作需要注意一點的是當銀行賬號的余額不足時，取錢操作必須等待。因此，除了前面設定的鎖之外，我們還得加一個信號量signal。信號量的作用是當取錢的數量大於當前賬號余額時，停止該操作，發出等待的信號量signal；存錢時，有多少即存多少就是了。不過，每進行一次存錢操作，都必須發出信號提醒還在等待的取錢操作，不然取錢操作將一直等下去...

代碼實現：

package com.gdufe.thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ThreadCooperation {
    private static Account account = new Account();

    public static void main(String[] args) {
        //開啟大小為2線程池的，依次加入任務
        ExecutorService executor = Executors.newFixedThreadPool(2);
        executor.execute(new DepositTask());
        executor.execute(new WithdrawTask());
        //關閉線程池入口
        executor.shutdown();
        System.out.println("Operation------Balance");
    }
    //從賬號取出錢
    static class WithdrawTask implements Runnable {
        @Override
        public void run() {
            try {
                while (true) {
                    account.withdraw((int) (Math.random() * 10));
                }
            } catch (Exception e) {
            }
        }
    }
    //往賬號存錢
    static class DepositTask implements Runnable {
        @Override
        public void run() {
            try{
            while (true) {
                account.deposit((int) (Math.random() * 10));
                Thread.sleep(1000);
            }
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
    //內部類，只有‘balance’屬性
    static class Account {
        private int balance = 0;
        private static Lock lock = new ReentrantLock();
        private static Condition signal = lock.newCondition();

        public int getBalance() {
            return balance;
        }
        //前后加鎖，解鎖
        public void deposit(int amount) {
            lock.lock();
            try {
                balance += amount;
                System.out.println("deposit "+amount+"----total:" + account.getBalance());
                signal.signalAll();        //not 'notifyAll()'
            } finally {
                lock.unlock();
            }
        }
        //同樣加鎖，解鎖
        public void withdraw(int amount) {
            lock.lock();
            try {
                while (balance < amount) {
                    signal.await();
                    System.out.println("signal await...");
                }
                balance -= amount;
                System.out.println("whthdraw "+amount+"----total:" + account.getBalance());
            } catch (Exception e) {
                    e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }

}

 

輸出結果：

• 5.經典生產者消費者問題

（抱歉，時間關系！后續補上關於生產者消費者的實例，敬請關注~~）