摘要：的多任務(wù)執(zhí)行框架提供了一套線程框架來幫助開發(fā)者有效的進(jìn)行線程控制，扮演線程工廠的角色，其創(chuàng)建線程的方法如下返回固定數(shù)量的線程池，該方法的線程數(shù)始終不變。

1.Jdk的多任務(wù)執(zhí)行框架

JDK提供了一套線程框架Executor來幫助開發(fā)者有效的進(jìn)行線程控制，Executors扮演線程工廠的角色，其創(chuàng)建線程的方法如下

newFixedThreadPool() 返回固定數(shù)量的線程池，該方法的線程數(shù)始終不變。若線程空閑則立即執(zhí)行 否則暫緩到隊(duì)列中

newSingleThreadPool() 創(chuàng)建一個(gè)線程池，若線程空閑則立即執(zhí)行 否則暫緩到隊(duì)列中

newCachedThreadPool() 返回一個(gè)可根據(jù)實(shí)際情況調(diào)整線程個(gè)數(shù)的線程池 ，若線程空閑則立即執(zhí)行 否則暫緩到隊(duì)列中

newScheduledThreadPool() 返回一個(gè)ScheduledExecutorService對(duì)象，但該線程可以執(zhí)行線程的數(shù)量(schedule 排定/安排/目錄)

        ScheduledExecutorService scheduler = 
        Executors.newScheduledThreadPool(10);
        
        //command 就是一個(gè)Thread
        ScheduledFuture scheduledTask =
         scheduler.scheduleWithFixedDelay(command,5,1, TimeUnit.SECONDS);

若Executors工廠類無法滿足我們的需求，可以自己去創(chuàng)建自定義的線程池。自定義線程池的構(gòu)造方法如下

    
public ThreadPoolExecutor(int corePoolSize,//核心線程數(shù)
                          int maximumPoolSize,//最大線程數(shù)
                          long keepAliveTime,//線程的空閑時(shí)間
                          TimeUnit unit,//給定單元粒度的時(shí)間段 
                          BlockingQueue workQueue,//有界、無界隊(duì)列
                          RejectedExecutoionHandler handler//任務(wù)拒絕策略
                          ){.....}

使用什么隊(duì)列對(duì)該構(gòu)造方法來說比較關(guān)鍵

使用有界隊(duì)列 如有任務(wù)需要執(zhí)行 如果實(shí)際線程數(shù)

    如果實(shí)際線程數(shù)>corePoolSize，則將任務(wù)添加到緩存隊(duì)列
    如果緩存隊(duì)列已滿 ，總線程maximumPoolSize, 則執(zhí)行拒絕策略

使用無界隊(duì)列LinkedBlockingQueue 除非系統(tǒng)資源耗盡 否則不會(huì)出現(xiàn)入隊(duì)失敗

    如有任務(wù)需要執(zhí)行 如果實(shí)際線程數(shù)corePoolSize，則將任務(wù)添加到緩存隊(duì)列，
                                               直到資源耗盡 

BlockingQueue queue =
                    //new LinkedBlockingQueue();//無界隊(duì)列
                    new ArrayBlockingQueue(10);//有界隊(duì)列
            ExecutorService executor  = new ThreadPoolExecutor(
                    5,         //core
                    10,     //max
                    120L,     //120s
                    TimeUnit.SECONDS,
                    queue);

JDK的拒絕策略

AbortPolicy:直接拋出異常 系統(tǒng)正常工作

CallerRunsPolicy：只要線程池未被關(guān)閉 嘗試運(yùn)行被丟棄的任務(wù)

DiscardOldestPolicy:丟失最老的請(qǐng)求 嘗試提交當(dāng)前任務(wù)

DiscardPolicy：丟棄無法處理的任務(wù)不給予處理

JDK提供的拒絕策略不友好，可以自定義拒絕策略，實(shí)現(xiàn)RejectedExecutionHandler接口（添加日志等等）

    public class MyRejected implements RejectedExecutionHandler {
    
        public MyRejected(){}

        @Override
        public void rejectedExecution(Runnable r, 
        ThreadPoolExecutor executor) {
            System.out.println("自定義處理");
            System.out.println("當(dāng)前被拒絕的任務(wù)為"+r.toString());
        }
    }

2.Concurrent.util工具類詳解

CyclicBarrier
假設(shè)每一個(gè)線程代表一個(gè)運(yùn)動(dòng)員，當(dāng)運(yùn)動(dòng)員都準(zhǔn)備好了，才能一起出發(fā)。

CyclicBarrier barrier = new CyclicBarrier(3);

CountDownLatch
經(jīng)常用于監(jiān)聽某些初始化操作，當(dāng)初始化執(zhí)行完畢以后，通知主線程繼續(xù)工作

final CountDownLatch countDownLatch = new CountDownLatch(2);

Callable 和Future使用
Futrue模式費(fèi)用適合在處理耗時(shí)很長的業(yè)務(wù)邏輯進(jìn)行使用，可以有效的減小系統(tǒng)的影響，
提高系統(tǒng)的吞吐量

    public class UseFuture implements Callable{
        private String para;
        
        public UseFuture(String para){
            this.para = para;
        }
        
        /**
         * 這里是真實(shí)的業(yè)務(wù)邏輯，其執(zhí)行可能很慢
         */
        @Override
        public String call() throws Exception {
            //模擬執(zhí)行耗時(shí)
            Thread.sleep(5000);
            String result = this.para + "處理完成";
            return result;
        }
        
        //主控制函數(shù)
        public static void main(String[] args) throws Exception {
            String queryStr = "query";
            //構(gòu)造FutureTask，并且傳入需要真正進(jìn)行業(yè)務(wù)邏輯處理的類,
            //該類一定是實(shí)現(xiàn)了Callable接口的類
            FutureTask future = 
            new FutureTask(new UseFuture(queryStr));
            
            FutureTask future2 = 
            new FutureTask(new UseFuture(queryStr));
            //創(chuàng)建一個(gè)固定線程的線程池且線程數(shù)為1,
            ExecutorService executor = Executors.newFixedThreadPool(2);
            //這里提交任務(wù)future,則開啟線程執(zhí)行RealData的call()方法執(zhí)行
            //submit和execute的區(qū)別： 
            //第一點(diǎn)是submit可以傳入實(shí)現(xiàn)Callable接口的實(shí)例對(duì)象，
            // 第二點(diǎn)是submit方法有返回值
            
            Future f1 = executor.submit(future);        
            //多帶帶啟動(dòng)一個(gè)線程去執(zhí)行的
            Future f2 = executor.submit(future2);
            System.out.println("請(qǐng)求完畢");
            
            try {
                //這里可以做額外的數(shù)據(jù)操作，也就是主程序執(zhí)行其他業(yè)務(wù)邏輯
                System.out.println("處理實(shí)際的業(yè)務(wù)邏輯...");
                Thread.sleep(1000);
            } catch (Exception e) {
                e.printStackTrace();
            }
            //調(diào)用獲取數(shù)據(jù)方法,如果call()方法沒有執(zhí)行完成,則依然會(huì)進(jìn)行等待
            System.out.println("數(shù)據(jù)：" + future.get());
            System.out.println("數(shù)據(jù)：" + future2.get());
            
            executor.shutdown();
        }
    
    }

Semaphore信號(hào)量
可以控制系統(tǒng)的流量，拿到線程的信號(hào)量則訪問否則等待
通過acquire和release來獲取和釋放線程

 final Semaphore semp = new Semaphore(5);

3.鎖的高級(jí)深化

Lock and Condition
使用synchronized關(guān)鍵字可以實(shí)現(xiàn)線程間的同步互斥工作

使用Lock對(duì)象也可以實(shí)現(xiàn)同步互斥

如果多個(gè)線程之間需要實(shí)現(xiàn)協(xié)作 使用Object的wait和nofity,notifyAll

在使用Lock的時(shí)候可以使用一個(gè)新的等待/通知的類Condition 只針對(duì)一個(gè)具體的鎖

    public class UseCondition {

        private Lock lock = new ReentrantLock();
        private Condition condition = lock.newCondition();
        
        public void method1(){
            try {
                lock.lock();
                System.out.println("當(dāng)前線程：" + 
    Thread.currentThread().getName() + "進(jìn)入等待狀態(tài)..");
                Thread.sleep(3000);
                System.out.println("當(dāng)前線程：" + 
    Thread.currentThread().getName() + "釋放鎖..");
                condition.await();    // Object wait 
                System.out.println("當(dāng)前線程：" + 
    Thread.currentThread().getName() +"繼續(xù)執(zhí)行...");
                condition.signal();        //Object notify
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }

ReentrantLock重入鎖

    private Lock lock = new ReentrantLock(boolean isFair);//是否為公平鎖

ReentrantReadWriteLock讀寫鎖
核心是實(shí)現(xiàn)讀寫分離 在都多寫少的情況下 性能高于重入鎖

public class UseReentrantReadWriteLock {

    private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    private ReadLock readLock = rwLock.readLock();
    private WriteLock writeLock = rwLock.writeLock();
    
    public void read(){
        try {
            readLock.lock();
            System.out.println("當(dāng)前線程:" + 
Thread.currentThread().getName() + "進(jìn)入...");
            Thread.sleep(3000);
            System.out.println("當(dāng)前線程:" + 
Thread.currentThread().getName() + "退出...");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readLock.unlock();
        }
    }
    
    public void write(){
        try {
            writeLock.lock();
            System.out.println("當(dāng)前線程:" + 
Thread.currentThread().getName() + "進(jìn)入...");
            Thread.sleep(3000);
            System.out.println("當(dāng)前線程:" + 
Thread.currentThread().getName() + "退出...");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            writeLock.unlock();
        }
    }
}

鎖的優(yōu)化

避免死鎖

減少鎖的持有時(shí)間

減少鎖的粒度

鎖的分離

盡量使用無鎖的操作 比如原子類操作