2. 程式人生 > >【本人禿頂程式設計師】面試-執行緒池的成長之路

【本人禿頂程式設計師】面試-執行緒池的成長之路

阿新 • • 發佈：2018-12-25

←←←←←←←←←←←← 我都禿頂了，還不點關注！

背景

相信大家在面試過程中遇到面試官問執行緒的很多，執行緒過後就是執行緒池了。從易到難，都是這麼個過程，還有就是確實很多人在工作中接觸執行緒池比較少，最多的也就是建立一個然後往裡面提交執行緒，對於一些經驗很豐富的面試官來說，一下就可以問出很多執行緒池相關的問題，與其被問的暈頭轉向，還不如好好學習。此時不努力更待何時。

什麼是執行緒池？

執行緒池是一種多執行緒處理形式，處理過程中將任務提交到執行緒池，任務的執行交由執行緒池來管理。

如果每個請求都建立一個執行緒去處理，那麼伺服器的資源很快就會被耗盡，使用執行緒池可以減少建立和銷燬執行緒的次數，每個工作執行緒都可以被重複利用，可執行多個任務。

如果用生活中的列子來說明，我們可以把執行緒池當做一個客服團隊，如果同時有1000個人打電話進行諮詢，按照正常的邏輯那就是需要1000個客服接聽電話，服務客戶。現實往往需要考慮到很多層面的東西，比如：資源夠不夠，招這麼多人需要費用比較多。正常的做法就是招100個人成立一個客服中心，當有電話進來後分配沒有接聽的客服進行服務，如果超出了100個人同時諮詢的話，提示客戶等待，稍後處理，等有客服空出來就可以繼續服務下一個客戶，這樣才能達到一個資源的合理利用，實現效益的最大化。

Java中的執行緒池種類

1. newSingleThreadExecutor

建立方式：

ExecutorService pool = Executors.newSingleThreadExecutor();

一個單執行緒的執行緒池。這個執行緒池只有一個執行緒在工作，也就是相當於單執行緒序列執行所有任務。如果這個唯一的執行緒因為異常結束，那麼會有一個新的執行緒來替代它。此執行緒池保證所有任務的執行順序按照任務的提交順序執行。

使用方式：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPool {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            pool.execute(() -> {
                System.out.println(Thread.currentThread().getName() + "\t開始發車啦....");
            });
        }
    }
}

輸出結果如下：

pool-1-thread-1    開始發車啦....
pool-1-thread-1    開始發車啦....
pool-1-thread-1    開始發車啦....
pool-1-thread-1    開始發車啦....
pool-1-thread-1    開始發車啦....
pool-1-thread-1    開始發車啦....
pool-1-thread-1    開始發車啦....
pool-1-thread-1    開始發車啦....
pool-1-thread-1    開始發車啦....
pool-1-thread-1    開始發車啦....

從輸出的結果我們可以看出，一直只有一個執行緒在執行。

2.newFixedThreadPool

建立方式：

ExecutorService pool = Executors.newFixedThreadPool(10);

建立固定大小的執行緒池。每次提交一個任務就建立一個執行緒，直到執行緒達到執行緒池的最大大小。執行緒池的大小一旦達到最大值就會保持不變，如果某個執行緒因為執行異常而結束，那麼執行緒池會補充一個新執行緒。

使用方式：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPool {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10; i++) {
            pool.execute(() -> {
                System.out.println(Thread.currentThread().getName() + "\t開始發車啦....");
            });
        }
    }
}

輸出結果如下：

pool-1-thread-1    開始發車啦....
pool-1-thread-4    開始發車啦....
pool-1-thread-3    開始發車啦....
pool-1-thread-2    開始發車啦....
pool-1-thread-6    開始發車啦....
pool-1-thread-7    開始發車啦....
pool-1-thread-5    開始發車啦....
pool-1-thread-8    開始發車啦....
pool-1-thread-9    開始發車啦....
pool-1-thread-10 開始發車啦....

3. newCachedThreadPool

建立方式：

ExecutorService pool = Executors.newCachedThreadPool();

建立一個可快取的執行緒池。如果執行緒池的大小超過了處理任務所需要的執行緒，那麼就會回收部分空閒的執行緒，當任務數增加時，此執行緒池又新增新執行緒來處理任務。

使用方式如上2所示。

4.newScheduledThreadPool

建立方式：

ScheduledExecutorService pool = Executors.newScheduledThreadPool(10);

此執行緒池支援定時以及週期性執行任務的需求。

使用方式：

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ThreadPool {
    public static void main(String[] args) {
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(10);
        for (int i = 0; i < 10; i++) {
            pool.schedule(() -> {
                System.out.println(Thread.currentThread().getName() + "\t開始發車啦....");
            }, 10, TimeUnit.SECONDS);
        }
    }
}

上面演示的是延遲10秒執行任務,如果想要執行週期性的任務可以用下面的方式，每秒執行一次

//pool.scheduleWithFixedDelay也可以
pool.scheduleAtFixedRate(() -> {
                System.out.println(Thread.currentThread().getName() + "\t開始發車啦....");
}, 1, 1, TimeUnit.SECONDS);

5.newWorkStealingPool
newWorkStealingPool是jdk1.8才有的，會根據所需的並行層次來動態建立和關閉執行緒，通過使用多個佇列減少競爭，底層用的ForkJoinPool來實現的。ForkJoinPool的優勢在於，可以充分利用多cpu，多核cpu的優勢，把一個任務拆分成多個“小任務”，把多個“小任務”放到多個處理器核心上並行執行；當多個“小任務”執行完成之後，再將這些執行結果合併起來即可。

說說執行緒池的拒絕策略

當請求任務不斷的過來，而系統此時又處理不過來的時候，我們需要採取的策略是拒絕服務。RejectedExecutionHandler介面提供了拒絕任務處理的自定義方法的機會。在ThreadPoolExecutor中已經包含四種處理策略。

  • AbortPolicy策略：該策略會直接丟擲異常，阻止系統正常工作。

。

public static class AbortPolicy implements RejectedExecutionHandler {
    public AbortPolicy() { }
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        throw new RejectedExecutionException("Task " + r.toString() +
                                                 " rejected from " +
                                                 e.toString());
    }
}
  • CallerRunsPolicy 策略：只要執行緒池未關閉，該策略直接在呼叫者執行緒中，運行當前的被丟棄的任務。

.

public static class CallerRunsPolicy implements RejectedExecutionHandler {
    public CallerRunsPolicy() { }
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
                r.run();
        }
    }
}
  • DiscardOleddestPolicy策略： 該策略將丟棄最老的一個請求，也就是即將被執行的任務，並嘗試再次提交當前任務。

.

public static class DiscardOldestPolicy implements RejectedExecutionHandler {
    public DiscardOldestPolicy() { }
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            e.getQueue().poll();
            e.execute(r);
        }
    }
}
  • DiscardPolicy策略：該策略默默的丟棄無法處理的任務，不予任何處理。

.

public static class DiscardPolicy implements RejectedExecutionHandler {
    public DiscardPolicy() { }
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    }
}

除了JDK預設為什麼提供的四種拒絕策略，我們可以根據自己的業務需求去自定義拒絕策略，自定義的方式很簡單，直接實現RejectedExecutionHandler介面即可

比如Spring integration中就有一個自定義的拒絕策略CallerBlocksPolicy，將任務插入到佇列中，直到佇列中有空閒並插入成功的時候，否則將根據最大等待時間一直阻塞，直到超時

package org.springframework.integration.util;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
public class CallerBlocksPolicy implements RejectedExecutionHandler {
    private static final Log logger = LogFactory.getLog(CallerBlocksPolicy.class);
    private final long maxWait;
    /**
     * @param maxWait The maximum time to wait for a queue slot to be
     * available, in milliseconds.
     */
    public CallerBlocksPolicy(long maxWait) {
        this.maxWait = maxWait;
    }
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        if (!executor.isShutdown()) {
            try {
                BlockingQueue<Runnable> queue = executor.getQueue();
                if (logger.isDebugEnabled()) {
                    logger.debug("Attempting to queue task execution for " + this.maxWait + " milliseconds");
                }
                if (!queue.offer(r, this.maxWait, TimeUnit.MILLISECONDS)) {
                    throw new RejectedExecutionException("Max wait time expired to queue task");
                }
                if (logger.isDebugEnabled()) {
                    logger.debug("Task execution queued");
                }
            }
            catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new RejectedExecutionException("Interrupted", e);
            }
        }
        else {
            throw new RejectedExecutionException("Executor has been shut down");
        }
    }
}

定義好之後如何使用呢？光定義沒用的呀，一定要用到執行緒池中呀，可以通過下面的方式自定義執行緒池，指定拒絕策略。

BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(100);
ThreadPoolExecutor executor = new ThreadPoolExecutor(
    10, 100, 10, TimeUnit.SECONDS, workQueue, new CallerBlocksPolicy());

execute和submit的區別？

在前面的講解中，我們執行任務是用的execute方法，除了execute方法，還有一個submit方法也可以執行我們提交的任務。

這兩個方法有什麼區別呢？分別適用於在什麼場景下呢？我們來做一個簡單的分析。

execute適用於不需要關注返回值的場景，只需要將執行緒丟到執行緒池中去執行就可以了

public class ThreadPool {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(10);
        pool.execute(() -> {
            System.out.println(Thread.currentThread().getName() + "\t開始發車啦....");
        });
    }
}

submit方法適用於需要關注返回值的場景，submit方法的定義如下：

public interface ExecutorService extends Executor {
　　...
　　<T> Future<T> submit(Callable<T> task);
　　<T> Future<T> submit(Runnable task, T result);
　　Future<?> submit(Runnable task);
　　...
}

其子類AbstractExecutorService實現了submit方法,可以看到無論引數是Callable還是Runnable，最終都會被封裝成RunnableFuture，然後再呼叫execute執行。

/**
 * @throws RejectedExecutionException {@inheritDoc}
 * @throws NullPointerException       {@inheritDoc}
 */
public Future<?> submit(Runnable task) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<Void> ftask = newTaskFor(task, null);
    execute(ftask);
    return ftask;
}
/**
 * @throws RejectedExecutionException {@inheritDoc}
 * @throws NullPointerException       {@inheritDoc}
 */
public <T> Future<T> submit(Runnable task, T result) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<T> ftask = newTaskFor(task, result);
    execute(ftask);
    return ftask;
}
/**
 * @throws RejectedExecutionException {@inheritDoc}
 * @throws NullPointerException       {@inheritDoc}
 */
public <T> Future<T> submit(Callable<T> task) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<T> ftask = newTaskFor(task);
    execute(ftask);
    return ftask;
}

下面我們來看看這三個方法分別如何去使用：

submit(Callable task);

public class ThreadPool {
    public static void main(String[] args) throws Exception {
        ExecutorService pool = Executors.newFixedThreadPool(10);
        Future<String> future = pool.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                return "Hello";
            }
        });
        String result = future.get();
        System.out.println(result);
    }
}

submit(Runnable task, T result);

public class ThreadPool {
    public static void main(String[] args) throws Exception {
        ExecutorService pool = Executors.newFixedThreadPool(10);
        Data data = new Data();
        Future<Data> future = pool.submit(new MyRunnable(data), data);
        String result = future.get().getName();
        System.out.println(result);
    }
}
class Data {
    String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
class MyRunnable implements Runnable {
    private Data data;
    public MyRunnable(Data data) {
        this.data = data;
    }
    @Override
    public void run() {
        data.setName("yinjihuan");
    }
}

Future<?> submit(Runnable task);
直接submit一個Runnable是拿不到返回值的，返回值就是null.

五種執行緒池的使用場景

  • newSingleThreadExecutor：一個單執行緒的執行緒池，可以用於需要保證順序執行的場景，並且只有一個執行緒在執行。

  • newFixedThreadPool：一個固定大小的執行緒池，可以用於已知併發壓力的情況下，對執行緒數做限制。

  • newCachedThreadPool：一個可以無限擴大的執行緒池，比較適合處理執行時間比較小的任務。

  • newScheduledThreadPool：可以延時啟動，定時啟動的執行緒池，適用於需要多個後臺執行緒執行週期任務的場景。

  • newWorkStealingPool：一個擁有多個任務佇列的執行緒池，可以減少連線數，建立當前可用cpu數量的執行緒來並行執行。

執行緒池的關閉

關閉執行緒池可以呼叫shutdownNow和shutdown兩個方法來實現

shutdownNow：對正在執行的任務全部發出interrupt()，停止執行，對還未開始執行的任務全部取消，並且返回還沒開始的任務列表

public class ThreadPool {
    public static void main(String[] args) throws Exception {
        ExecutorService pool = Executors.newFixedThreadPool(1);
        for (int i = 0; i < 5; i++) {
            System.err.println(i);
            pool.execute(() -> {
                try {
                    Thread.sleep(30000);
                    System.out.println("--");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
        }
        Thread.sleep(1000);
        List<Runnable> runs = pool.shutdownNow();
    }
}

上面的程式碼模擬了立即取消的場景，往執行緒池裡新增5個執行緒任務，然後sleep一段時間，執行緒池只有一個執行緒，如果此時呼叫shutdownNow後應該需要中斷一個正在執行的任務和返回4個還未執行的任務，控制檯輸出下面的內容：

0
1
2
3
4
[fs.ThreadPool$$Lambda$1/[email protected], 
fs.ThreadPool$$Lambda$1/[email protected], 
fs.ThreadPool$$Lambda$1/[email protected], 
fs.ThreadPool$$Lambda$1/[email protected]]
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at fs.ThreadPool.lambda$0(ThreadPool.java:15)
    at fs.ThreadPool$$Lambda$1/990368553.run(Unknown Source)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
    at java.lang.Thread.run(Thread.java:745)

shutdown：當我們呼叫shutdown後，執行緒池將不再接受新的任務，但也不會去強制終止已經提交或者正在執行中的任務

public class ThreadPool {
    public static void main(String[] args) throws Exception {
        ExecutorService pool = Executors.newFixedThreadPool(1);
        for (int i = 0; i < 5; i++) {
            System.err.println(i);
            pool.execute(() -> {
                try {
                    Thread.sleep(30000);
                    System.out.println("--");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
        }
        Thread.sleep(1000);
        pool.shutdown();
        pool.execute(() -> {
            try {
                Thread.sleep(30000);
                System.out.println("--");
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
    }
}

上面的程式碼模擬了正在執行的狀態，然後呼叫shutdown，接著再往裡面新增任務，肯定是拒絕新增的，請看輸出結果：

0
1
2
3
4
Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task fs.ThreadPool$$Lambda$2/[email protected] rejected from [email protected][Shutting down, pool size = 1, active threads = 1, queued tasks = 4, completed tasks = 0]
    at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2047)
    at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:823)
    at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1369)
    at fs.ThreadPool.main(ThreadPool.java:24)

還有一些業務場景下需要知道執行緒池中的任務是否全部執行完成，當我們關閉執行緒池之後，可以用isTerminated來判斷所有的執行緒是否執行完成，千萬不要用isShutdown，isShutdown只是返回你是否呼叫過shutdown的結果。

public class ThreadPool {
    public static void main(String[] args) throws Exception {
        ExecutorService pool = Executors.newFixedThreadPool(1);
        for (int i = 0; i < 5; i++) {
            System.err.println(i);
            pool.execute(() -> {
                try {
                    Thread.sleep(3000);
                    System.out.println("--");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
        }
        Thread.sleep(1000);
        pool.shutdown();
        while(true){  
            if(pool.isTerminated()){  
                System.out.println("所有的子執行緒都結束了！");  
                break;  
            }  
            Thread.sleep(1000);    
        }  
    }
}

自定義執行緒池

在實際的使用過程中，大部分我們都是用Executors去建立執行緒池直接使用，如果有一些其他的需求，比如指定執行緒池的拒絕策略，阻塞佇列的型別，執行緒名稱的字首等等，我們可以採用自定義執行緒池的方式來解決。

如果只是簡單的想要改變執行緒名稱的字首的話可以自定義ThreadFactory來實現，在Executors.new…中有一個ThreadFactory的引數，如果沒有指定則用的是DefaultThreadFactory。

自定義執行緒池核心在於建立一個ThreadPoolExecutor物件，指定引數

下面我們看下ThreadPoolExecutor建構函式的定義：

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) ;
  • corePoolSize
    執行緒池大小，決定著新提交的任務是新開執行緒去執行還是放到任務佇列中，也是執行緒池的最最核心的引數。一般執行緒池開始時是沒有執行緒的，只有當任務來了並且執行緒數量小於corePoolSize才會建立執行緒。
  • maximumPoolSize
    最大執行緒數，執行緒池能建立的最大執行緒數量。
  • keepAliveTime
    線上程數量超過corePoolSize後，多餘空閒執行緒的最大存活時間。
  • unit
    時間單位
  • workQueue
    存放來不及處理的任務的佇列，是一個BlockingQueue。
  • threadFactory
    生產執行緒的工廠類，可以定義執行緒名，優先順序等。
  • handler
    拒絕策略，當任務來不及處理的時候，如何處理, 前面有講解。

瞭解上面的引數資訊後我們就可以定義自己的執行緒池了，我這邊用ArrayBlockingQueue替換了LinkedBlockingQueue，指定了佇列的大小，當任務超出佇列大小之後使用CallerRunsPolicy拒絕策略處理。

這樣做的好處是嚴格控制了佇列的大小，不會出現一直往裡面新增任務的情況，有的時候任務處理的比較慢，任務數量過多會佔用大量記憶體，導致記憶體溢位。

當然你也可以在提交到執行緒池的入口進行控制，比如用CountDownLatch, Semaphore等。

/**
 * 自定義執行緒池<br>
 * 預設的newFixedThreadPool裡的LinkedBlockingQueue是一個無邊界佇列，如果不斷的往裡加任務，最終會導致記憶體的不可控<br>
 * 增加了有邊界的佇列，使用了CallerRunsPolicy拒絕策略
 * @author yinjihuan
 *
 */
public class FangjiaThreadPoolExecutor {
    private static ExecutorService executorService = newFixedThreadPool(50);
    private static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<Runnable>(10000), new DefaultThreadFactory(), new CallerRunsPolicy());
    }
    public static void execute(Runnable command) {
        executorService.execute(command);
    }
    public static void shutdown() {
        executorService.shutdown();
    }
    static class DefaultThreadFactory implements ThreadFactory {
        private static final AtomicInteger poolNumber = new AtomicInteger(1);
        private final ThreadGroup group;
        private final AtomicInteger threadNumber = new AtomicInteger(1);
        private final String namePrefix;
        DefaultThreadFactory() {
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() :
                                  Thread.currentThread().getThreadGroup();
            namePrefix = "FSH-pool-" +
                          poolNumber.getAndIncrement() +
                         "-thread-";
        }
        public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r,
                                  namePrefix + threadNumber.getAndIncrement(),
                                  0);
            if (t.isDaemon())
                t.setDaemon(false);
            if (t.getPriority() != Thread.NORM_PRIORITY)
                t.setPriority(Thread.NORM_PRIORITY);
            return t;
        }
    }
}

寫在最後：

禿頂程式設計師的不易，看到這裡，點了關注吧！
點關注，不迷路，持續更新！！！

相關推薦

【本人禿頂程式設計師】面試-執行緒池的成長之路

←←←←←←←←←←←← 我都禿頂了，還不點關注！ 背景 相信大家在面試過程中遇到面試官問執行緒的很多，執行緒過後就是執行緒池了。從易到難，都是這麼個過程，還有就是確實很多人在工作中接觸執行緒池比較少，最多的也就是建立一個然後往裡面提交執行緒，對於一些經驗很豐富的面試官來說，一下就可

【本人禿頂程式設計師】Java執行緒池詳解，看這篇就夠了！

←←←←←←←←←←←← 快！點關注！！！ 構造一個執行緒池為什麼需要幾個引數？如果避免執行緒池出現OOM？Runnable和Callable的區別是什麼？本文將對這些問題一一解答，同時還將給出使用執行緒池的常見場景和程式碼片段。 基礎知識 Executors建立執行緒池 J

【本人禿頂程式設計師】多執行緒：為什麼在while迴圈中加入System.out.println，執行緒可以停止

在論壇看到這樣一個程式碼： public class StopThread { private static boolean stopRequested; public static void main(String[] args) throws InterruptedE

【本人禿頂程式設計師】java面試遇到的坑，你都遇見過嗎？

←←←←←←←←←←←← 我都禿頂了，還不點關注！ 親愛的同學們，本人因為連續幾周遭遇一定的工作壓力幾乎被壓榨的只剩一個空殼，還好經常鍛鍊有一副好身體（皮囊），算是挺過來了。為了大家年前能早早入坑馬不停蹄回到陣地給大家帶來第二期的面試坑題，有些題是大家經常被問到的，有些可能還未接觸到先可

【本人禿頂程式設計師】技術面試與HR談薪資技巧

←←←←←←←←←←←← 快！點關注 作為“生在紅旗下，長在春風裡”的“四有新人”，筆者從畢業至今，與各路 HR、HRD 鬥智鬥勇，再加上自己的不懈努力，歷盡千辛萬苦終於將畢業時的 1500 每月的薪資提高了二十幾倍。本文就和大家嘮嘮這些年風裡來雨裡去無數次鎩羽而歸、兢兢業業、如履薄冰、

【本人禿頂程式設計師】只會增刪改查，當你有一定的開發經驗時，應該如何提升自己？

←←←←←←←←←←←← 我都禿頂了，還不點關注！ 工作1-5年開發經驗，當你們提出漲工資的時候，或者要offer的時候底氣怎麼樣，是不是底氣十足，不給漲工資就辭職，是不是有自信提出來主管、或者是專案經理都能同意，他們相當設法把你留住。如果這樣你才是成功。什麼技術都沒有何談工資！ 給你分

【本人禿頂程式設計師】記一次生產資料庫"意外"重啟的經歷

←←←←←←←←←←←← 我都禿頂了，還不點關注！ 前言 在一個陽光明媚的下午，電腦右下角傳來一片片郵件提醒，同時伴隨著微信釘釘的震動，開啟一看，應用各種出錯，天兔告警，資料庫伺服器記憶體爆紅，Mysql資料庫例項掛掉了。 排查 先交代一下資料庫版本： mysql&

【本人禿頂程式設計師】JAVA多執行緒之執行緒間的通訊方式

←←←←←←←←←←←← 我都禿頂了，還不點關注！ 一，介紹 本總結我對於JAVA多執行緒中執行緒之間的通訊方式的理解，主要以程式碼結合文字的方式來討論執行緒間的通訊，故摘抄了書中的一些示例程式碼。 二，執行緒間的通訊方式 ①同步 這裡講的同步是指多個執行緒通過synchro

【本人禿頂程式設計師】Java併發系列 | ReentrantLock原始碼分析

←←←←←←←←←←←← 我都禿頂了，還不點關注！ 在Java5.0之前，協調對共享物件的訪問可以使用的機制只有synchronized和volatile。我們知道synchronized關鍵字實現了內建鎖，而volatile關鍵字保證了多執行緒的記憶體可見性。 在大多數情況下，這些

【本人禿頂程式設計師】nginx反向代理轉發apache配置 之 cookie去哪兒了？

←←←←←←←←←←←← 我都禿頂了，還不點關注！ 在公司接手了個微信專案，由於微信環境下訪問網站需要使用對外開放的域名，所以有相關問題，都是直接運維同事幫忙處理。 原理是這樣： 方案一： 將域名解析指向測試伺服器的地址； 開放相關埠訪問許可權； 方案二： 將域名解析指向

【本人禿頂程式設計師】Java面試題集（意思意思）

←←←←←←←←←←←← 我都禿頂了，還不點關注！ 一、什麼是Spring MVC ？簡單介紹下你對springMVC的理解? Spring MVC是一個基於MVC架構的 用來簡化web應用程式開發的應用開發框架， 它是Spring的一個模組, 無需中間整合層來整合 ， 它和Stru

【本人禿頂程式設計師】面試題：如何設計一個高併發系統？

←←←←←←←←←←←← 我都禿頂了，還不點關注！ 面試題 如何設計一個高併發系統？ 面試官心理分析 說實話，如果面試官問你這個題目，那麼你必須要使出全身吃奶勁了。為啥？因為你沒看到現在很多公司招聘的 JD 裡都是說啥，有高併發就經驗者優先。 如果你確實有真才實學，在網際

【本人禿頂程式設計師】刷題啦：LeetCode演算法題-Valid Anagram

←←←←←←←←←←←← 我都禿頂了，還不點關注！ 今天介紹的是LeetCode演算法題中Easy級別的題。給定兩個字串s和t，寫一個函式來確定t是否是s的anagram。例如： 輸入：s =“anagram”，t =“nagaram” 輸出：true 輸入：s =“rat”，t

【本人禿頂程式設計師】【轉】一個畢業6年的程式設計師工作經歷和成長感悟

←←←←←←←←←←←← 我都禿頂了，還不點關注！ 【本人禿頂程式設計師】轉自今日頭條：Java高階 原文連結：https://www.toutiao.com/i6611344590853112324/ 把時鐘撥回到2007年的夏天，大學畢業。那時非常迷茫，不知道自己能做什麼，想做什

【本人禿頂程式設計師】三分鐘讓你明白 Activity工作流（java運用）

←←←←←←←←←←←← 我都禿頂了，還不點關注！ 一. 什麼是工作流 以請假為例，現在大多數公司的請假流程是這樣的 員工打電話（或網聊）向上級提出請假申請——上級口頭同意——上級將請假記錄下來——月底將請假記錄上交公司——公司將請假錄入電腦 採用工作流技術的公司的請假流程是

【本人禿頂程式設計師】關於redis，學會這8點就夠了

←←←←←←←←←←←← 我都禿頂了，還不點關注！ 一、redis是什麼 redis是一種支援Key-Value等多種資料結構的儲存系統。可用於快取、事件釋出或訂閱、高速佇列等場景。該資料庫使用ANSI C語言編寫，支援網路，提供字串、雜湊、列表、佇列、集合結構直接存取，基於記憶體，

【本人禿頂程式設計師】講解MyBatis攔截器原理探究

←←←←←←←←←←←← 我都禿頂了，還不點關注！ MyBatis攔截器介紹 MyBatis提供了一種外掛(plugin)的功能，雖然叫做外掛，但其實這是攔截器功能。那麼攔截器攔截MyBatis中的哪些內容呢？ 我們進入官網看一看： MyBatis 允許你在已對映語句

【本人禿頂程式設計師】這也許是你不曾留意過的 Mybatis 細節

←←←←←←←←←←←← 我都禿頂了，還不點關注！ 本人禿頂程式設計師 Mybatis 可以說是 Java 後端的必備技能，可能你和我一樣經常使用到它。但有時 cv 多了，會忘記了一些細節處理，比如為什麼要加上這個註解？它的作用是什麼等等。 這篇文章是我以前寫的一些關於 Myba

【本人禿頂程式設計師】Spring Cloud Stream如何消費自己生產的訊息

←←←←←←←←←←←← 我都禿頂了，還不點關注！ 本文將繼續說說在另外一個被經常問到的問題：如果微服務生產的訊息自己也想要消費一份，應該如何實現呢？ 常見錯誤 在放出標準答案前，先放出一個常見的錯誤姿勢和告警資訊（以便您可以通過搜尋引擎找到這裡_）。以下錯誤基於S

【本人禿頂程式設計師】【程式人生】為什麼說 Java 程式設計師必須掌握 Spring Boot

←←←←←←←←←←←← 我都禿頂了，還不點關注！ Spring Boot 誕生的背景是什麼？Spring 企業又是基於什麼樣的考慮建立 Spring Boot? 傳統企業使用 Spring Boot 會給我們帶來什麼樣變革? Spring Boot 2.0 的推出又激起了