線程池原理

避免每次新起線程對內存的消耗，降低資源消耗，提高內存利用率，使用線程池將線程管理起來。

線程池 Executor

// 基礎用法
public class ExecutorTest {
    public static void main(String[] args) {
        // 可伸縮的線程池 大小爲10
        Executor executor = Executors.newFixedThreadPool(10);
        // 提交20個線程
        for (int i = 0; i < 20; i++) {
            executor.execute(new RunnableCase());
        }
    }

}
class RunnableCase implements Runnable{
    @Override
    public void run() {
        System.out.println("Hello" + Thread.currentThread().getName());
    }
}

Executor 框架管理了所有線程的生命週期

Executors

Executors是一個工廠類，可以生成多種線程池。就newFixedThreadPool來看

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
}

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }

corePoolSize：線程池中的核心線程數，如果線程池中執行的線程數等於corePoolSize的時候，如果有新任務，則會放到阻塞隊列裏。線程池的prestartAllCoreThreads()方法可以提前創建並啓動所有核心線程。
maxmiumPoolSize：線程池中允許最大的線程數，當阻塞隊列滿的時候，如果線程池中的線程數目小雨maxmiumPooSize，則會創建新的線程執行。
keepAliveTime：線程空閒時的存活時間，即當線程沒有任務執行時，繼續存活的時間；默認情況下，該參數只在線程數大於corePoolSize時纔有用
unit：表示的時間單位。
workQueue：用於保存超出corePoolSize的線程，具有如下特性：
1、ArrayBlockingQueue：基於數組結構的有界阻塞隊列，按FIFO排序任務；
2、LinkedBlockingQuene：基於鏈表結構的阻塞隊列，按FIFO排序任務，吞吐量通常要高於ArrayBlockingQuene；
3、SynchronousQuene：一個不存儲元素的阻塞隊列，每個插入操作必須等到另一個線程調用移除操作，否則插入操作一直處於阻塞狀態，吞吐量通常要高於LinkedBlockingQuene；
4、priorityBlockingQuene：具有優先級的無界阻塞隊列；

threadFactory
```
DefaultThreadFactory() {
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() :
                              Thread.currentThread().getThreadGroup();
        namePrefix = "pool-" +
                      poolNumber.getAndIncrement() +
                     "-thread-";
    }
```
線程創建工廠，給線程定義線程名。

handler

線程池以及隊列滿了以後的如果有任務提交的處理策略。
“`
// 默認的是AbortPolicy
private static final RejectedExecutionHandler defaultHandler =new AbortPolicy();

// AbortPolicy 拒絕策略
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
throw new RejectedExecutionException(“Task ” + r.toString()
+ ” rejected from ” + e.toString());
}
}
“`

AbortPolicy：默認策略、直接拋出異常。
CallerRunsPolicy：用調用者所在的線程來執行任務；
DiscardOldestPolicy：丟棄阻塞隊列中靠最前的任務，並執行當前任務；
DiscardPolicy：直接丟棄任務；
注意：如果以上策略都不滿足的話，可實現RejectedExecutionHandler接口，自定義處理策略。

各種線程池說明

newFixedThreadPool

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
}

corePoolSize == maximumPoolSize，Queue爲LinkingBlockingQueue，當線程池沒有可執行任務時，也不會釋放線程。

newCachedThreadPool

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
}

可緩存的線程池，默認緩存60s，線程池的線程數可達到Integer.MAX_VALUE，使用SynchronousQueue作爲阻塞隊列；
newCachedThreadPool在沒有任務執行時，當線程的空閒時間超過keepAliveTime，會自動釋放線程資源，當提交新任務時，如果沒有空閒線程，則創建新線程執行任務，會導致一定的系統開銷；

ScheduledThreadPoolExecutor

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}

public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
    new DelayedWorkQueue());
}

週期性提交任務。

newSingleThreadExecutor

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<Runnable>()));
}

線程池中只有一個線程，如果線程異常結束，則會創建一個新的線程繼續執行任務。

實現原理

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    // 29
    private static final int COUNT_BITS = Integer.SIZE - 3;
    private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

    // runState is stored in the high-order bits
    // 11100000000000000000000000000000
    private static final int RUNNING    = -1 << COUNT_BITS;
    // 0
    private static final int SHUTDOWN   =  0 << COUNT_BITS;
    // 100000000000000000000000000000
    private static final int STOP       =  1 << COUNT_BITS;
    // 1000000000000000000000000000000
    private static final int TIDYING    =  2 << COUNT_BITS;
    private static final int TERMINATED =  3 << COUNT_BITS;

    // Packing and unpacking ctl
    private static int runStateOf(int c)     { return c & ~CAPACITY; }
    private static int workerCountOf(int c)  { return c & CAPACITY; }
    private static int ctlOf(int rs, int wc) { return rs | wc; }

利用高3位表示線程狀態。
1、RUNNING：111，正常狀態，接受新的任務，並處理任務隊列中的任務；
2、SHUTDOWN：000，不接受新的任務，但是處理已經在任務隊列中的任務；
3、STOP ： 001，不接受新的任務，也不處理已經在任務隊列中的任務，同時會嘗試停止正在執行任務的線程；
4、TIDYING ： 010，線程池和任務隊列都爲空，該狀態下線程會執行 terminated() 方法；
5、TERMINATED：011，terminated() 方法執行完畢；

提交任務方式

兩種提交方式Executor.execute() 和ExecutorService.submit()

Executor.execute()

void execute(Runnable command);

只接受實現了Runnable接口的對象，無返回值，無法獲取線程結果。

ExecutorService.submit()

<T> Future<T> submit(Callable<T> task);

可以通過Future獲取返回值。

任務執行

Executor.execute()

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    int c = ctl.get();
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        if (! isRunning(recheck) && remove(command))
            reject(command);
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    else if (!addWorker(command, false))
        reject(command);
}

流程說明
1. 判定線程池任務是否小於核心線程數，如果小於則執行addWorker方法創建新的線程執行任務，如果大於執行步驟2
2. 如果線程池是running狀態，則把任務放進阻塞隊列，然後執行步驟3，如果放入失敗則執行步驟4。
3. 再次判斷線程池狀態是否爲running，如果不是，則從隊列裏刪除該命令，執行reject方法來處理。如果線程池中的任務爲0，則addWorker添加空任務。
4. 執行addWorker方法創建新的線程執行任務，如果失敗，則執行reject方法。

addWorker實現

addWorker在線程池中主要負責創建線程執行任務

private boolean addWorker(Runnable firstTask, boolean core) {
/*--------------------------------第1段----------------------*/
    retry:
    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);

        // Check if queue empty only if necessary.
        if (rs >= SHUTDOWN &&
            ! (rs == SHUTDOWN &&
               firstTask == null &&
               ! workQueue.isEmpty()))
            return false;

        for (;;) {
            int wc = workerCountOf(c);
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize))
                return false;
            if (compareAndIncrementWorkerCount(c))
                break retry;
            c = ctl.get();  // Re-read ctl
            if (runStateOf(c) != rs)
                continue retry;
            // else CAS failed due to workerCount change; retry inner loop
        }
    }
/*--------------------------------第2段----------------------*/
    boolean workerStarted = false;
    boolean workerAdded = false;
    Worker w = null;
    try {
        w = new Worker(firstTask);
        final Thread t = w.thread;
        if (t != null) {
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {
                // Recheck while holding lock.
                // Back out on ThreadFactory failure or if
                // shut down before lock acquired.
                int rs = runStateOf(ctl.get());

                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {
                    if (t.isAlive()) // precheck that t is startable
                        throw new IllegalThreadStateException();
                    workers.add(w);
                    int s = workers.size();
                    if (s > largestPoolSize)
                        largestPoolSize = s;
                    workerAdded = true;
                }
            } finally {
                mainLock.unlock();
            }
            if (workerAdded) {
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        if (! workerStarted)
            addWorkerFailed(w);
    }
    return workerStarted;
}

第1段
1. 如果線程池狀態大於等於SHUTDOWN，則返回，除非狀態爲SHUTDOWN&&提交的任務爲空&&隊列爲空。
2. 判斷是否爲核心線程，如果是，則大於coreSize就返回false，如果不是，則大於maxmumPoolSize就返回。
3. 跳出循環開始第2段，創建線程

第2段
加鎖的情況下，新建Worker類，將worker插入到workers裏，並啓動worker中的線程。
Worker代碼

 private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable
/*---------------------------*/
Worker(Runnable firstTask) {
    setState(-1); // inhibit interrupts until runWorker
    this.firstTask = firstTask;
    this.thread = getThreadFactory().newThread(this);
}

/** Delegates main run loop to outer runWorker  */
public void run() {
    runWorker(this);
}

繼承了AbstractQueuedSynchronizer類，可控制線程的中止；
實現了Runnable接口，自身就是一個任務；
傳入Runnable參數；
創建了線程的同時傳入了自身，線程執行方法調用的是runWorker方法。

runWorker方法

final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            while (task != null || (task = getTask()) != null) {
                w.lock();
                // If pool is stopping, ensure thread is interrupted;
                // if not, ensure thread is not interrupted.  This
                // requires a recheck in second case to deal with
                // shutdownNow race while clearing interrupt
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        task.run();
                    } catch (RuntimeException x) {
                        thrown = x; throw x;
                    } catch (Error x) {
                        thrown = x; throw x;
                    } catch (Throwable x) {
                        thrown = x; throw new Error(x);
                    } finally {
                        afterExecute(task, thrown);
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

先通過unlock方法釋放鎖，completedAbruptly設爲true。
上鎖，執行beforeExecute方法；然後執行run方法，最後執行afterExecute方法
執行完以後，會調用getTask來從阻塞隊列獲取等待任務，如果沒有，則掛起

getTask

private Runnable getTask() {
    boolean timedOut = false; // Did the last poll() time out?

    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);

        // Check if queue empty only if necessary.
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            decrementWorkerCount();
            return null;
        }

        int wc = workerCountOf(c);

        // Are workers subject to culling?
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

        if ((wc > maximumPoolSize || (timed && timedOut))
            && (wc > 1 || workQueue.isEmpty())) {
            if (compareAndDecrementWorkerCount(c))
                return null;
            continue;
        }

        try {
            Runnable r = timed ?
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                workQueue.take();
            if (r != null)
                return r;
            timedOut = true;
        } catch (InterruptedException retry) {
            timedOut = false;
        }
    }
}

for循環的情況下
1.workQueue.take，從阻塞線程中獲取線程，如隊列無線程則阻塞，如有線程，則獲取並返回。
2.workQueue.poll，在keepAlive時間內還未返回，則返回null
注意：從以上程序可以看出，執行完線程之後，會嘗試從隊列獲取線程，保證了隊列中的線程可以被執行。

Future和Callable

如果需要線程返回結果，則需要用到Future和Callable，還需要使用ExecutorService.submit()方法提交。

public class ExecutorTest {
    public static void main(String[] args) {
        // 可伸縮的線程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        Future<String> future = service.submit(new CallableCase());
        String result = null;
        try {
            result = future.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println(result);
    }
}
class CallableCase implements Callable<String> {

    @Override
    public String call() throws Exception {
        Thread.sleep(20000);
        return "sleep thread";
    }
}

Callable負責返回值，Future可獲取Callable返回的結果。
1. Future可以獲取返回值以及異常值
2. Future.get方法會一直阻塞到Callable有返回值。

ExecutorService.submit方法

public <T> Future<T> submit(Callable<T> task) {
    if (task == null) throw new NullPointerException();
       RunnableFuture<T> ftask = newTaskFor(task);
       execute(ftask);
       return ftask;
}

protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
    return new FutureTask<T>(callable);
}

Callable任務會被封裝成FutureTask對象。

private volatile int state;
private static final int NEW          = 0;
private static final int COMPLETING   = 1;
private static final int NORMAL       = 2;
private static final int EXCEPTIONAL  = 3;
private static final int CANCELLED    = 4;
private static final int INTERRUPTING = 5;
private static final int INTERRUPTED  = 6;

有多種狀態

public class FutureTask<V> implements RunnableFuture<V>
public interface RunnableFuture<V> extends Runnable, Future<V>

可以看出來FutureTask實現了Runnable狀態，所以可以使用ExecutorService來提交。最終執行的是FutureTask.run方法

FutureTask.get

public V get() throws InterruptedException, ExecutionException {
    int s = state;
    if (s <= COMPLETING)
        s = awaitDone(false, 0L);
    return report(s);
}

通過awaitDone來等待結果返回

awaitDone

private int awaitDone(boolean timed, long nanos)
    throws InterruptedException {
    final long deadline = timed ? System.nanoTime() + nanos : 0L;
    WaitNode q = null;
    boolean queued = false;
    for (;;) {
        if (Thread.interrupted()) {
            removeWaiter(q);
            throw new InterruptedException();
        }

        int s = state;
        if (s > COMPLETING) {
            if (q != null)
                q.thread = null;
            return s;
        }
        else if (s == COMPLETING) // cannot time out yet
            Thread.yield();
        else if (q == null)
            q = new WaitNode();
        else if (!queued)
            queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
                                                 q.next = waiters, q);
        else if (timed) {
            nanos = deadline - System.nanoTime();
            if (nanos <= 0L) {
                removeWaiter(q);
                return state;
            }
            LockSupport.parkNanos(this, nanos);
        }
        else
            LockSupport.park(this);
    }
}

如果主線程被中斷，則拋出中斷異常；
判斷FutureTask當前的state，如果大於COMPLETING，說明任務已經執行完成，則直接返回；
如果當前state等於COMPLETING，說明任務已經執行完，這時主線程只需通過yield方法讓出cpu資源，等待state變成NORMAL；
通過WaitNode類封裝當前線程，並通過UNSAFE添加到waiters鏈表；
最終通過LockSupport的park或parkNanos掛起線程；

FutureTask.run

public void run() {
    if (state != NEW ||
        !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                     null, Thread.currentThread()))
        return;
    try {
        Callable<V> c = callable;
        if (c != null && state == NEW) {
            V result;
            boolean ran;
            try {
                result = c.call();
                ran = true;
            } catch (Throwable ex) {
                result = null;
                ran = false;
                setException(ex);
            }
            if (ran)
                set(result);
        }
    } finally {
        // runner must be non-null until state is settled to
        // prevent concurrent calls to run()
        runner = null;
        // state must be re-read after nulling runner to prevent
        // leaked interrupts
        int s = state;
        if (s >= INTERRUPTING)
            handlePossibleCancellationInterrupt(s);
    }
}

執行Callable.call方法。
如果執行成功有結果，通過set保存對象。
如果有異常，則保存異常。

set方法

protected void set(V v) {
    if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
        outcome = v;
        UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
        finishCompletion();
    }
}

setException方法

protected void setException(Throwable t) {
  if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
        outcome = t;
        UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
        finishCompletion();
    }
}

set和setException方法中，都會通過UnSAFE修改FutureTask的狀態，並執行finishCompletion方法通知主線程任務已經執行完成；

finishCompletion

private void finishCompletion() {
    // assert state > COMPLETING;
    for (WaitNode q; (q = waiters) != null;) {
        if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
            for (;;) {
                Thread t = q.thread;
                if (t != null) {
                    q.thread = null;
                    LockSupport.unpark(t);
                }
                WaitNode next = q.next;
                if (next == null)
                    break;
                q.next = null; // unlink to help gc
                q = next;
            }
            break;
        }
    }

    done();

    callable = null;        // to reduce footprint
}

1、執行FutureTask類的get方法時，會把主線程封裝成WaitNode節點並保存在waiters鏈表中；
2、FutureTask任務執行完成後，通過UNSAFE設置waiters的值，並通過LockSupport類unpark方法喚醒主線程；

線程池 Executor

Executors

threadFactory

handler

各種線程池說明

newFixedThreadPool

newCachedThreadPool

ScheduledThreadPoolExecutor

newSingleThreadExecutor

實現原理

提交任務方式

Executor.execute()

ExecutorService.submit()

任務執行

Executor.execute()

addWorker實現

Future和Callable

ExecutorService.submit方法

FutureTask.get

awaitDone

FutureTask.run

set方法

setException方法

finishCompletion

常見字符串類

類與對象

JAVA 反射

數據庫中的各種鍵

工廠模式

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結