當前位置：首頁 > 编程资源 > 编程问答 >内容正文

编程问答

2022年java知识点汇总，面试大全！超级全面，逐步完善！

發布時間：2023/12/31 编程问答 27 豆豆

生活随笔收集整理的這篇文章主要介紹了 2022年java知识点汇总，面试大全！超级全面，逐步完善！小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

文章目錄

**一、java基礎知識**
- 1.1 **String類相關**
- 1. 2 **多線程**
- - 1.2.1 實現多線程的方式
  - 1.2.2 線程狀態結構圖
  - 1.2.3 線程常用方法
  - 1.2.4 線程調度
  - 1.2.5 線程池原理
  - 1.2.6 幾種常見線程池
  - 1.2.7 線程池參數設計規則
  - 1.2.8 ThreadLocal
  - 1.2.9 volatile
  - 1.2.10 synchronized
  - 1.2.11 **ReentrantLock**
  - 1.2.12 Unsafe
  - 1. 2.13 多線程相關面試題
  - 執行execute()方法和submit()方法的區別是什么呢？
- 1.3 集合
- - 1.3.1 理論知識
  - 1.3.2 原理及使用場景
  - 1.3.1 集合相關面試題
- 1.4 文件流以及IO
- - 1.4.1 理論知識以及結構圖
  - 1.4.2 實際操作
  - 1.4.3 NIO、BIO、AIO
  - 1.4.4 文件流相關面試題
- 1.5 鎖
- - 1.5.1 鎖的定義、原理、作用
  - 1.5.2 鎖的分類以及實現方法
  - 1.5.3 鎖的實際應用
  - 1.5.4 鎖優化、以及使用過程中的問題
  - 1.5.5 鎖相關面試題
- 1.6 網絡協議
- - 1.6.1 網絡協議原理
  - 1.6.2 網絡協議分類
  - 1.6.3 網絡協議運用
  - 1.6.4 http請求相關問題
  - 1.6.5 相關面試題
- 1.7 tomcat、webSocket等服務器知識
- - 1.7.1 tomcat介紹、原理、作用
  - 1.7.2 tomcat使用
  - 1.7.3 tomcat 調優
  - 1.7.4 webSocket原理、作用
  - 1.7.5 相關面試題
- 1.8 反射原理
- - 1.8.1 反射原理、底層
  - 1.8.2 反射應用、常見方法
  - 1.8.3 反射相關面試題
  - 1.9 對象相關知識
二、JVM
- 2.1 JVM內存模型
- 2.2 類加載機制
- 2.3 垃圾回收機制、工具、算法
- 2.4 JVM調優方法
- 2.5 JVM 常見指令以及在服務器中的配置
- 2.6 JVM常見問題排查（內存溢出、內存不足、死鎖等）
- 2.7 學習相關連接
- 2.8 JVM堆外內存
- 2.9 JVM相關面試題
三、網絡編程
- 3.1 http原理以及三次握手
- 3.2 常用IP/TCP協議
- 3.3 網頁請求方式，請求頭，請求體
- 3.4 常見的java方法
- 3.5 常見面試題
四、數據庫技術
- 4.1 基本操作
- 4.2 索引
- 4.3 引擎
- 4.4 事務
- 4.5 鎖
- 4.6 常用函數
- 4.7 復雜查詢
- 4.8 分庫分表以及分庫分表帶來的數據一致性問題解決
- 4.9 優化以及執行計劃
- 4.10 相關面試題
- 4.11 拓展工具
五、Spring框架
- 5.1 Spring原理解析
- 5.2 認識bean
- 5.3 IOC、AOP、DI原理
- 5.4 設計模式
- 5.5 相關源碼解析
- 5.6 注解
- 5.7 相關面試題
- - - **DefaultListableBeanFactory**：整個bean加載的核心部分，是spring注冊以及加載bean的默認實現，繼承自AbstractAutowireCapableBeanFactory ；
    - **XmlBeanDefinitionReader**：資源文件讀取，解析以及注冊
六、SpringMVC框架
- 6.1 原理
- 6.2 請求流程
- 6.3 常見配置
- 6.4 相關面試題
七、Mybatis框架
- 7.1 理論基礎
- 7.2 執行流程
- 7.3 常見面試題
- 7.4 Mybatis Plus
- 7.5 常見優化工具
八、SpringBoot
- 8.1 原理解析
- 8.2 與Spring相比優勢
- 8.3 微服務核心思想
- 8.4 拓展框架
- 8.5 springboot相關面試題
九、SpringClould
- 9.1 springCloud原理
- 9.2 springcloud各類微服務模塊原理以及作用
- 9.3 springCloud服務治理、監控
- 9.4 各大版本差異性
- 9.5 springcloud相關面試題
十、redis
- 10.1 原理解析
- 10.2 常見數據類型以及作用
- 10.3 redis高級特性
- 10.4 redis常用高級組件
- 10.5 redis 應用
- 10.6 redis 相關面試題
十一、Dubbo
- 11.1 dubbo 底層原理解析
- 11.2 dubbo 常見配置
- 11.3 dubbo底層協議
- 11.4 dubbo高級特性
- 11.5 dubbo應用場景
- 11.6 dubbo重復消費，消息丟失等問題
- 11.7 關于Zookeeper相關
- 11.8 dubbo集群
- 11.9 dubbo相關面試題
十二、消息中間件以及Zookeeper
- 12.1 zookeeper底層原理
- 12.2 zookeeper 常見問題分析
- 12.3 zookeeper 分布式鎖實現
- 12.4 zookeeper 高級特性
- 12.5 zookeeper 集群配置
- 12.6 zookeeper 相關面試題
- 12.7 消息中間件AQ、MQ、Rb相關原理解析
- 12.8 消息丟失、重復消費、事務相關
十三、高并發集群問題
- 13.1 高并發解決辦法
- 13.2 高并發常用工具框架
- 13.3 集群問題分析解決
- 13.4 高并發集群相關面試題
十四、算法以及數據結構
- 14.1 java常見的算法
- 14.2 java常見的數據結構以及應用
- 14.3 算法、數據結構相關面試題
十五、Netty通信
- 15.1 Netty原理
- 15.2 Netty 應用
- 15.3 Netty相關面試題
十六、工具類
- 16.1 POI導入導出（以及各種性能優化問題）
- 16.2 文件傳輸、存儲相關工具類（前端、后端）
- 16.3 ES大數據相關
- 16.4 單點登錄以及JWT
- 16.5 權限管理以及技術拓展
- 16.6 定時任務XXJOB
- 16.7 美團萬億級KV存儲架構與實踐：[美團萬億級 KV 存儲架構與實踐](https://tech.meituan.com/2020/07/01/kv-squirrel-cellar.html)
十七、Maven、Git工具集
- 17.1 Maven基礎知識
- 17.2 Maven高級特性
- 17.3 Maven關鍵字解析
- 17.4 git 原理（以及與SVN區別）
- 17.5 git常用命令
- 17.6 Maven與git常見面試題
十八、高級前端面試
- 18.1 vue高級面試
- 18.2 react高級面試
- 18.3 js+H5高級面試
- 18.4 小程序開發
- 18.5 app打包常用命令
- 18.6 優秀表單、報表、統計圖開發工具
十九、高級架構思想
- 19.1 架構流程圖
- 19.2 架構需要考慮的因素
- 19.3 架構案列
- 19.4 架構常見面試題
- 19.5 性能監測、跟蹤相關
二十、高并發編程、事務、鎖機制
- 20.1 高并發編程
- 20.2 高并發如何解決事務
- 20.3 高并發中的鎖
- 20.4 高并發需要解決的問題
- 20.5 高并發場景
- 20.5 相關面試題
二十一、Linux常用命令
- 21.1 操作系統常用命令
- 21.2 優化調優命令
- 21.3 網絡環境搭建
- 21.4 項目部署
- 21.5 日志，問題查找
- 21.6 Docker技術
- 21.7 K8s自動化部署
二十二、源碼解析
- 22.1 spring源碼
- 22.2 springboot源碼
- 22.3 springMVC源碼
- 22.4 springcloud相關
- 22.5 源碼相關面試

一、java基礎知識

1.1 String類相關

String、StringBuilder和StringBuffer

? String是不可變的，后兩者可變，StringBuffer線程安全，StringBuilder線程不安全，但是StringBuilder效率高；

? 另外，StringBuffer和Stringbuilder都沒有重寫equals方法，在進行equals比較時，還是比較的是地址，而不是值

public static void main(String[] args) {String a="abc";String b="abc";System.out.println(a==b);System.out.println(a.equals(b)); }

? 結果都是：true true ，因為都在常量池中，比較的是值，地址也相同；

public static void test1(){String a="abc";String b=new String("abc");System.out.println(a==b);System.out.println(a.equals(b));}

? 此時結果是：false true，==比較的是地址，equals比較的是值；

String t0 = new String("hello") + new String("world");t0.intern();String t1 = "helloworld";System.out.println(t0 == t1);這個運行結果，在JDK1.8中是true,1.7中是false,JDK1.7之前的版本中，intern方法會優先在方法區的運行時常量池中查找是否已經存在相同的字符串，倘若已經存在，則返回已存在的字符串，否則則在常量池中添加一個字符串常量，并返回字符串。從JDK1.7開始，HotSpot虛擬機將字符串常量移至Java Heap，intern方法的實現也發生了變化，首先還是會先去查詢常量池中是否已經存在，如果存在，則返回常量池中的字符串，否則不再將字符串拷貝到常量池，而只是在常量池中保存字符串對象的引用。

String幾個經典方法作用解析

equals(Object obj): 比較字符串的內容是否相同，區分大小寫； equalsIgnoreCase(String str)：比較字符串的內容是否相同，忽略大小寫 contains(String str)：判斷大字符串中是否包含小字符串 startsWith(String str)：判斷字符串是否以某個指定的字符串開頭 endsWidth(String str)：判斷字符串是否以某個指定的字符串結尾 isEmpty()：判斷字符串是否為空

為什么String用final 修飾

為了安全，多個線程對String進行讀取時，不會發生線程安全問題，因為final是不可變性；還能保證Arrays數組的安全；實現字符串常量池，可提高效率，實現對內存的優化；標記為final。不可被繼承，保證String類型的對象只能是String類型，不會是其他子類型； String 對象是緩存在String池中，由于緩存的字符串是在多個客戶端之間共享，因此存在風險，因此通過String類不可變來規避這種風險

String類常用方法

char charAt(int index);//返回指定索引處的char值int compareTo(Object o);//把這個字符串跟另一個字符串比較String concat(String str);//連接兩個字符串boolean contentEquals(StringBuffer sb);//當且僅當字符串與指定的StringBuffer有相同順序的字符時候返回真String substring(int beginIndex); String substring(int beginIndex,int endIndex); //截取字符串int indexOf(String str, int fromIndex): 返回從 fromIndex 位置開始查找指定字符在字符串中第一次出現處的索引，如果此字符串中沒有這樣的字符，則返回 -1。例：獲取指定字符串中某個子串出現的次數 public static int strNum(String obj,String str){int fromIndex = 0;int count =0;while (true){int index = str.indexOf(obj,fromIndex);if(-1 != index){fromIndex = index +1;count ++;}else {break;}}return count; }

String類可以有多長

臨時變量一般是存在java堆中的，String類的長度理論上取決于傳入的byte數組長度，byte[]數據數組最大長度理論上應該是Integer.MAX_VALUE,但是實際從ArrayList源碼可以看出，應該是Integer.MAX_VALUE-8,但是還是會受到java堆可分配內存大小的限制如果String變量是一個全局變量，其變量是存在java方法區的，此時他的長度取決于.class描述全局String類型變量的數據結構，如果是u2(描述是2個字節的數據類型)，這意味著最大是65535。如果是字符數，一個UTF-8編碼的字符對應3個字節，所以此時可容納的字符數應該是65535/3;

HashCode、equals、==區別?

equals() 定義在JDK的Object中，通過判斷兩個對象的地址是否相等（即，是否是同一個對象）來區分它們是否相等，默認的equals方法等價于“==”，所以一般要重新equals方法，若兩個對象的內容相等，則返回true,否則返回false

在String中，“==”用來比較兩個變量的內存地址是否相同，而equals用來比較內容是否相同(因為String重寫了equals方法)

String a="abc";String b="abc";String c =new String("abc");System.out.println(a==b); // trueSystem.out.println(a.equals(b));//trueSystem.out.println(a==c);//falseSystem.out.println(a.equals(c)); //true

HashCodes()是獲取哈希碼，確定該對象在哈希表中的位置，僅當創建了某個類的散列表，該類的hashCode()才有用，

在散列表中，若兩個元素相等，那么他們的散列碼一定相同，但是反過來，若兩個對象相等，他們的hashCode()并不一定相等；

1. 2 多線程

1.2.1 實現多線程的方式

? 主要有5種方式，繼承Thread類，實現Runnable接口，實現Callable接口通過FutureTask包裝器來創建Thread線程，使用線程池接口ExecutorService結合Callable、future實現有返回結果的多線程，前兩種沒有返回值，后兩種有返回值，還可以使用Spring的@Async注解非常方便的實現多線程。

繼承Thread類重寫run方法創建線程

Thread 類本質上是實現了Runnable接口的一個實例，啟動線程是通過Thread類的start()方法，start方法是一個native方法，將會啟動一個新線程，并執行run()方法；

public class Mythread extends Thread {@Overridepublic void run() {System.out.println(Mythread.currentThread().getName());}public static void main(String[] args) {Mythread mythread = new Mythread();mythread.start();Mythread mythread1 = new Mythread();mythread1.start();} } 結果： Thread-0 Thread-1 Process finished with exit code 0

實現Runnable接口
如果自己的類已經繼承了另外一個類，則無法再繼承，此時需要實現接口

public class RunnableTest extends ParentDemo implements Runnable{@Overridepublic void testDemo() {System.out.println("123");}@Overridepublic void run() {System.out.println("這是Runnable執行結果");}public static void main(String[] args) {RunnableTest runnableTest=new RunnableTest();Thread thread=new Thread(runnableTest);thread.start();} }

? 當傳入一個Runnable target參數給Thread后，Thread的run()方法就會調用target.run()；

? 繼承Thread類存在局限性，因為java是單繼承多實現，所以如果繼承Thread類就不能在繼承其它類，其次，Thread類更適合開啟多個線程完成多個任務的場景，而實現Runnable接口更適合一個任務多個線程去完成的場景。

實現Callable接口通過FutureTask包裝器來創建Thread線程

public class CallAbleTest implements Callable<Integer> {@Overridepublic Integer call() throws Exception {int sum = 0;for (int i = 0; i < 10000; i++) {sum += i;}return sum;}public static void main(String[] args) {CallAbleTest callAbleTest = new CallAbleTest();FutureTask<Integer> result = new FutureTask<>(callAbleTest);new Thread(result).start();new Thread(result).start();try {Integer sum = result.get();System.out.println(sum);} catch (InterruptedException | ExecutionException e) {e.printStackTrace();}} }

? Callable 對象實際屬于Executor框架的功能類；
? Callable 可以在任務結束的時候提供一個返回值，Runnable沒有；
? Callable 中的call方法可以拋出異常，Runnable不能；
? 運行Callable可以拿到一個future對象，future對象表示異步計算的結果，可提供檢查運算是否結束的方法，由于線程屬于異步計算模型，所以無法從其他線程中得到方法的返回值，在這種情況之下，就可以使用future來監視目標線程調用call方法的情況，當調用future的get方法以獲取結果時，當前線程就會被阻塞，直到call方法結束返回結果

使用線程池接口ExecutorService結合Callable、Future實現有返回結果的線程

public class ExecutorTest {static class MyCallable implements Callable<Object> {private String taskNum;MyCallable(String taskNum) {this.taskNum = taskNum;}@Overridepublic Object call() throws Exception {System.out.println(">>>>" + taskNum + "開啟任務");Thread.sleep(1000);System.out.println(">>>>" + taskNum + "任務結束");return taskNum;}}public static void main(String[] args) throws ExecutionException, InterruptedException {System.out.println("開始執行-------");//創建一個線程池ExecutorService pool = Executors.newFixedThreadPool(5);//創建多個有返回值的任務List<Future> list = new ArrayList<Future>();for (int i = 0; i < 5; i++) {Callable c = new MyCallable(i + " ");//執行任務并獲取Future對象Future f = pool.submit(c);list.add(f);}//關閉線程池pool.shutdown();for (Future f : list) {System.out.println(">>>" + f.get().toString());}System.out.println("程序運行結束--------");} }

? Executors類提供了一系列工廠方法用于創建線程池，返回的線程池都實現了ExecutorService接口，ExecutorService中提供submit()方法，傳遞一個Callable,或者Runnable,返回Future,如果Executor沒有完成Callable的計算，調用返回Future對象的get()方法將阻塞，直到計算完成。

Spring的@Async注解實現多線程

? 首選需要配置線程參數

#核心線程數,當線程數小于核心線程數時,即使有線程空閑,線程池也會優先創建新線程,設置allowCoreThreadTimeout=true（默認false）時,核心線程會超時退出 spring.task.pool.corePoolSize=20 #最大線程數,當線程數大于等于corePoolSize,且任務隊列已滿時,線程池會創建新線程來處理任務 spring.task.pool.maxPoolSize=60 #線程空閑時間,當線程空閑時間達到keepAliveSeconds(秒)時,線程會退出,直到線程數量等于corePoolSize,如果allowCoreThreadTimeout=true,則會直到線程數量等于0 spring.task.pool.keepAliveSeconds=1 #任務隊列容量,當核心線程數達到最大時,新任務會放在隊列中排隊等待執行 spring.task.pool.queueCapacity=400

? 創建線程池配置類

@Configuration @EnableAsync public class AsyncTaskConfig {@Autowiredprivate ThreadPoolCOnfig threadPoolCOnfig;public ThreadPoolTaskExecutor myThreadPool(){ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();//設置參數executor.setCorePoolSize(threadPoolCOnfig.getCorePoolSize());executor.setMaxPoolSize(threadPoolCOnfig.getMaxPoolSize());executor.setQueueCapacity(threadPoolCOnfig.getQueueCapacity());executor.setKeepAliveSeconds(threadPoolCOnfig.getKeepAliveSeconds());executor.setAllowCoreThreadTimeOut(true);executor.setThreadNamePrefix("MyThreadPool");executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());executor.initialize();return executor;} }

? 目前String已經實現5種線程池

1. SimpleAsyncTaskExecutor :不是真的線程池，這個類不重用線程，默認每次調用都會創建一個新的線程。 2. SyncTaskExecutor: 這個類沒有實現異步調用，只是一個同步操作。只適用于不需要多線程的地方。 3. ConcurrentTaskExecutor: Executor的適配類，不推薦使用。如果ThreadPoolTaskExecutor不滿足要求時，才用考慮使用這個類。 4. SimpleThreadPoolTaskExecutor: 是Quartz的SimpleThreadPool的類。線程池同時被quartz和非quartz使用，才需要使用此類。 5. ThreadPoolTaskExecutor : 最常使用，推薦。其實質是對java.util.concurrent.ThreadPoolExecutor的包裝。@Async正常使用默認線程池，為SimpleAsyncTaskExecutor，一般有兩種調用，一種是無返回值的調用，一種是有返回值的Future調用。基于@Async無返回值調用，直接作用在類，使用方法上，加上@Async注解；有返回值的Future調用，返回類型設置為Future<Object>,需要我們在方法中捕獲異常并處理，或者在調用方調用Future.get時捕獲異常進行處理有返回值CompletableFuture調用，在jdk1.8中提供了強大的Future拓展功能，可以簡化異步編程的復雜性，并且提供函數式編程能力private static final ThreadPoolExecutor SELECT_POOL_EXECUTOR = new ThreadPoolExecutor(10, 20, 5000,TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(1024), new ThreadFactoryBuilder().setNameFormat("selectThreadPoolExecutor-%d").build());// tradeMapper.countTradeLog(tradeSearchBean)方法表示，獲取數量，返回值為int// 獲取總條數CompletableFuture<Integer> countFuture = CompletableFuture.supplyAsync(() -> tradeMapper.countTradeLog(tradeSearchBean), SELECT_POOL_EXECUTOR);// 同步阻塞CompletableFuture.allOf(countFuture).join();// 獲取結果int count = countFuture.get();

? 默認線程池存在比較多的弊端，一般不用Executors去創建，推薦使用ThreadPoolExecutor方式，Executors方法各個弊端如下

newFixedThreadPool和newSingleThreadExecutor：主要問題是堆積的請求處理隊列可能會耗費非常大的內存，甚至OOM。 newCachedThreadPool和newScheduledThreadPool：要問題是線程數最大數是Integer.MAX_VALUE，可能會創建數量非常多的線程，甚至OOM。@Async 默認是使用SimpleAsyncTaskExecutor，該線程池默認是來一個任務創建一個線程，如果系統不斷創建線程，最終會導致占用內存過高，引發OutOfMemoryError錯誤，但是它本身也存在一個限流機制，ConcurrencyLimit屬性，其大于等于0，開啟限流機制，等于-1，關閉限流@Async 存在自定義線程池，方法如下實現接口AsyncConfigurer 繼承AsyncConfigurerSupport 配置自定義的TaskExecutor配置參數代替內置的任務執行器不管是繼承還是重新實現接口，都需要指定一個線程池，并且重新實現getAsyncExecutor()方法

1.2.2 線程狀態結構圖

初始狀態（new）：new一個線程實例，線程進入初始狀態；

就緒狀態（ready):

調用線程的start()方法，線程進入就緒狀態，當前線程sleep()方法結束，其他線程join()結束，等待用戶輸入完畢，某個線程拿到對象鎖，這些線程也將進入就緒狀態；
當前線程時間片段用完了，調用當前線程的yield()方法，當前線程進入就緒狀態；
鎖池里的線程拿到對象鎖后，進入就緒狀態；

運行中狀態（Running）：線程調用run方法，進入運行態；

阻塞狀態（Blocked): 線程阻塞在進入synchronized關鍵字修飾的方法或代碼塊（獲取鎖）時的狀態；

等待（waiting): 此狀態的線程不會被CPU分配執行時間，要等待被顯示的喚醒，否則將無限等待；

超時等待（TIMED_WAITING): 和等待狀態類似，但是此狀態不需要無限期等待，當達到一定時間，會被自動喚醒；

終止狀態（TERMINATED): 當線程run()方法完成，或者主線程main()方法完成，我們就可以認為是終止的，一旦終止，不能復生，此時調用start()方法會拋出異常；

1.2.3 線程常用方法

start(): 用于開啟多線程，使線程處于就緒態，當CPU分配時間片后可執行run()方法，并且start()方法是一個synchronized修飾的方法，而run只是一個普通方法，start()可實現并發

run(): 是一個普通方法，當線程調用了start()方法，一旦獲取CPU調度，處于運行態，線程就會調用這個run();

wait(): 線程等待，讓線程進入阻塞狀態，2種方式，一種無限等待，需要使用notify()方法喚醒，另外一種，設置等待時間，時間一到自動喚醒wait(long time), wait()方法屬于Object方法，釋放CPU執行權，同時釋放鎖，同時wait()方法只能在同步代碼方法中或者同步代碼塊中使用，使用時需要捕獲InterruptedException異常

sleep(): 強迫一個線程睡眠N毫秒，釋放CPU資源，不釋放鎖，使用地點也不需要限制，但是需要捕獲異常，而且sleep()是Thread類的方法

isAlive(): 判斷一個線程是否存活

currentThread(): 獲取當前線程

yield(): 線程禮讓，暫停當前正在執行的線程對象，雖然讓出CPU時間，但是不會讓線程阻塞，線程任然處于可執行狀態，隨時可再分的CPU執行時間

getPriority()與setPriority(): 設置獲取線程優先級

getId():

join(): 線程自閉，等待其他線程終止，在當前線程中調用另一個線程的join()方法，則當前線程轉入阻塞狀態，直到另一個進程運行結束，當前線程再由阻塞轉為就緒。

package com.example.day1.one;public class Mythread extends Thread {@Overridepublic void run() {for (int i = 0; i < 50; i++) {System.out.println(Mythread.currentThread().getName());}}public static void main(String[] args) throws InterruptedException {Mythread mythread = new Mythread();Mythread mythread1 = new Mythread();Mythread mythread2 = new Mythread();mythread.start();//mythread.join()mythread1.start();//mythread1.join()mythread2.start();//mythread2.join()} }結果：如果不加join(),在第一個線程還沒結束的時候，第二個或者第三個就可能開始執行，如果加上join(),一定是第一個執行完，第二個執行，然后第三個執行

interrupted(): 判斷是否被中斷，并清除當前中斷狀態；

interrupt(): 中斷線程，設置中斷標志位；

isInterrupted(): 判斷是否被中斷；

isDaemon()與setDaemon(boolean on): 設置一個線程為守護線程（用戶線程和守護線程的區別在于，是否等待主線程依賴于主線程結束而結束）

stop():

notify(): 喚醒一個線程繼續運行

notifyAll(): 喚醒所有線程進入爭搶鎖狀態

1.2.4 線程調度

線程調度是指系統為線程分配處理器使用權的過程，主要調度方式有：協同式線程調度和搶占式線程調度；

協同式線程調度：線程的執行時間由線程本身控制，線程把自己工作執行完成之后，要主動通知系統切換到另外一個線程上

搶占式線程調度：每個線程都將由系統來分配時間，線程的切換不由線程本身決定

1.2.5 線程池原理

線程池作用：降低系統資源消耗，通過重用已存在的線程，降低線程創建與銷毀造成的消耗；提高系統響應速度，有任務到達，通過復用已存在的線程，無需等待新線程的創建便能立即執行；方便線程并發數管理；

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-hHAh7hpE-1618197750701)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\image-20210301204725267.png)]

? submit(task): 可用來提交Callable或Runnable任務，并返回代表此任務的Future對象

? shutdown(): 在完成已提交的任務后封閉辦事，不在接管新任務

? shutdownNow(): 停止所有正在履行的任務并封閉辦事；

? isTerminated(): 測試是否所有任務都履行完畢了；

? ThreadPoolExecutor參數解析

Ctl: 對線程池的運行狀態和線程池中有效的數量進行控制的一個字段，包含2部分信息：線程池的運行狀態（runState)和線程池內有效線程的數量（workerCount)五種狀態：Runing：可接受新任務，并且處理已經添加的任務，線程池的初始化狀態就是running shutdown: 不接受新任務，但是可以處理已經添加的新任務，調用shutdown()方法，由running變成shutdown stop: 不接受新任務，不處理已添加的任務，并且還會中斷正在處理的任務； tidying: 當所有任務終止，ctl記錄的任務數為0，線程池就會變成tidying狀態，此時會執行鉤子函數terminated(); terminated: 當線程池處于tidying狀態并且執行了terminated()方法，就會變成此狀態；參數解析 corePoolSize:線程池核心線程數，如果當線程池中的線程數為corePoolSize,繼續提交的任務將被保存到"阻塞隊列中"，等待被執行，如果執行了線程池的prestartAllCoreThreads()方法，線程池會提前創建并啟動所有核心線程 maximumPoolSize:線程池中允許的最大線程數，如果當前阻塞隊列滿了，且繼續提交任務，則創建新的線程任務，前提是當前線程數少于maximumPoolSize; keepAliveTime: 線程池維護線程所允許的空閑時間，當線程池中的線程數大于corePoolSize的時候，如果此時沒有新的任務提交，核心線程外的線程不會立即銷毀，而是會等待，直到等待的時間超過了keepAliveTime; unit: keepAliveTime的單位 workQueue: 用來保存等待被執行的任務的阻塞隊列，任務必須實現Runnable接口,有如下幾種阻塞隊列1. ArrayBlockingQueue:基于數組結構的有界阻塞隊列，按 FIFO排序任務;2. LinkedBlockingQuene：基于鏈表結構的阻塞隊列，按FIFO排序任務3. SynchronousQuene：一個不存儲元素的阻塞隊列，每個插入操作必須等到另一個線程調用移除操作，否則插入操作一直處于阻塞狀態;4. priorityBlockingQuene：具有優先級的無界阻塞隊列；5. DelayQueue（延遲隊列）是一個任務定時周期的延遲執行的隊列6. LinkedTransferQueue:由鏈表構成的無界阻塞隊列；7. LinkedBlockingDeque:一個由鏈表結構組成的雙向阻塞隊列，隊列頭部和尾部都可以添加和移除元素，多線程并發時，可將鎖的競爭降到一半；threadFactory ：ThreadFactory，用來創建新線程。默認使用 Executors.defaultThreadFactory() 來創建線程。使用默認的ThreadFactory來創建線程時，會使新創建的線程具有相同的NORM_PRIORITY優先級并且是非守護線程，同時也設置了線程的名稱。 Handler：線程池的拒絕策略，當阻塞隊列滿了，且沒有空閑的工作線程，如果繼續提交任務，必須采取一種策略處理該任務，線程池提供了4種策略：1、AbortPolicy：直接拋出異常，默認策略；2、CallerRunsPolicy：用調用者所在的線程來執行任務；3、DiscardOldestPolicy：丟棄阻塞隊列中靠最前的任務，并執行當前任務；4、DiscardPolicy：直接丟棄任務；上面的4種策略都是ThreadPoolExecutor的內部類。當然也可以根據應用場景實現RejectedExecutionHandler接口，自定義策略。

? **注意：**通過execute或者submit向線程池提交任務。任務提交的時候先提交給核心線程（corePoolSize）；

? 如果核心線程滿了，就將任務放到workQueue里面去排隊等待；如果隊列也滿了（取決用的什么隊列，以及

? 設置的大小），就會將新進來的任務提交給非核心線程，非核心線程數量等于maximumPoolSize -

? corePoolSize，非核心線程使用之后會被回收。如果非核心線程也滿了，那么就執行相應的拒絕策略

? RejectedExecutionHandler。

? 原理解析

1. execute方法解析：先獲取當前工作線程數，-->添加任務到核心線程上去執行-->核心線程數滿了，線程池狀態是running,則添加到任務隊列中去-->添加任務之后，保證線程池狀態還是running,否則移除剛才添加的任務，并知心拒絕策略；2. 關鍵在于AddWork方法，先判斷狀態是否是running,shutdown時隊列是否有數據，判斷工作線程是否大于容量；3. worker內部類，繼承AbstractQueuedSynchronizer并且實現了Runnable接口

1.2.6 幾種常見線程池

? newFixedThreadPool (固定數目線程的線程池)

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

? 核心線程數和最大線程數大小一樣；

? 沒有所謂的非空閑時間，keepAliveTime為0;

? 阻塞隊列為無界阻塞隊列LinkedBlockingQueue;

? 特點

? 如果線程數少于核心線程數，創建核心線程執行任務；

? 等于核心線程數，把任務添加到阻塞隊列；

? 任務執行完畢去阻塞隊列獲取任務繼續執行；

ExecutorService executor = Executors.newFixedThreadPool(10);for (int i = 0; i < Integer.MAX_VALUE; i++) {executor.execute(()->{try {Thread.sleep(10000);} catch (InterruptedException e) {//do nothing}});

? 因為是無界阻塞隊列，最大可容納INTEGER.MAX個，可能會導致OOM,適用于處理CPU密集型的任務，適用

? 于執行長期的任務

? newCachedThreadPool(可緩存線程的線程池)

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

? 特點

? 核心線程數為0；

? 最大線程數為Integer.MAX_VAULE,阻塞隊列是SynchronousQuene；

? 非核心線程空閑存活時間為60秒；

ExecutorService executor = Executors.newCachedThreadPool();for (int i = 0; i < 5; i++) {executor.execute(() -> {System.out.println(Thread.currentThread().getName()+"正在執行");});}

? 用于執行大量短期的小任務；

? newSingleThreadExecutor(單線程的線程池)

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

? 特點：

? 核心線程數和最大線程數都是1；

? 阻塞隊列是LinkedBlockingQueue;

? keepAliveTime 為0

? 適用于串行執行任務的場景，一個任務一個任務的執行

? newScheduledThreadPool(定時及周期執行的線程池)

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

? 特點：

? 最大線程數為Integer.MAX_VALUE

? 阻塞隊列是DelayedWorkQueue

? keepAliveTime為0

? scheduleAtFixedRate() ：按某種速率周期執行

? scheduleWithFixedDelay()：在某個延遲后執行

? 技能提升

? 為什么不用Executors創建線程池？

? 因為LinkedBlockingQueue.offer方法，如果使用LinkedBlockingQueue隊列而不限制大小的話，就是一個無

? 邊界的隊列，會導致內存溢出問題，一般采用構造函數ThreadPoolExecutor來創建，并指定容量，另外還可

? 以使用開源庫，apache的guava,可以提供ThreadFactoryBuilder來創建線程池

public class ExecutorsDemo {private static ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFormat("demo-pool-%d").build();private static ExecutorService pool = new ThreadPoolExecutor(5, 200,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());public static void main(String[] args) {for (int i = 0; i < Integer.MAX_VALUE; i++) {pool.execute(new SubThread());}} }

1.2.7 線程池參數設計規則

? 首先需要理解一些概念：

? CPU密集型，也叫計算密集型，指的是系統的硬盤，內存性能相對CPU要好很多，CPU讀/寫I/O(硬盤/內存)，

? IO在很短的時間就可以完成，CPU占用率很高。

? IO密集型，指系統的CPU性能相對硬盤，內存要好很多，此時，系統大部分狀況是CPU在等IO(硬盤/內存)讀寫

? 操作，CPU利用并不高

? 一般情況下，一個服務器只部署一個應用并且只有一個線程池，

? 針對CPU密集型：線程數=n+1,n為CPU核數

? IO密集型：線程數=2n+1

? 通常應該考慮線程的執行時間，可以這么設置

? 最佳線程數=((線程等待時間+線程CPU時間)/線程CPU時間)*CPU核數；

? 另外，也可根據情況動態調整；

技術文章：美團線程池實踐：https://tech.meituan.com/2020/04/02/java-pooling-pratice-in-meituan.html

1.2.8 ThreadLocal

? 實現線程同步，除了用synchronized，另外也可以用ThreadLocal，前者是用時間換空間，保證每次只有

? 一個線程去訪問，后者采用空間換時間，ThreadLocal在每個線程中都是獨立的，一個變量在每一個線程中都

? 存在其實例的引用，各個線程之間沒有關系。

? **原理：**其內部有一個ThreadLocalMap內部類，ThreadLocalMap內部有個Entry內部類。

? 在每個線程Thread內部有一個ThreadLocalMap 類型的成員變量ThreadLocals,其就是用來存儲實際的變

? 量副本，鍵值為當前ThreadLocal變量，value 為變量副本；

? 最開始，在Thread里面，threadLocals為空，當通過ThreadLocal變量調用get()方法或者set()方法，就會

? 對Thread類中的threadLocals進行初始化，并且以當前ThreadLocal變量為鍵值，以ThreadLocal要保存的副

? 本變量為value，存到threadLocals

? 使用場景

? 在同一個線程的不同開發層次中共享數據

建立一個類，并在其中封裝一個靜態的ThreadLocal變量，使其成為一個共享數據環境；

在類中實現訪問靜態ThreadLocal變量的靜態方法(設值和取值)

? 最常見的場景是用來解決數據庫連接、Session管理等

private` `static` `ThreadLocal<Connection> connectionHolder = ` `new` `ThreadLocal<Connection>() { public` `Connection initialValue() {` `return` `DriverManager.getConnection(DB_URL); } }; public` `static` `Connection getConnection() { return` `connectionHolder.get(); } private static final ThreadLocal threadSession = new ThreadLocal();public static Session getSession() throws InfrastructureException {Session s = (Session) threadSession.get();try {if (s == null ) {s = getSessionFactory().openSession();threadSession.set(s);}} catch (HibernateException ex) {throw new InfrastructureException(ex);}return s; }

ThreadLocal內存泄露問題

內存泄露：程序在申請內存后，無法釋放已申請的內存空間，特別是內存泄露堆積，危害很大，不會被使用的對象或者變量占用的內存不能被回收，就是內存泄露強引用：一個對象具有強引用，不會被垃圾回收器回收，當內存空間不足，java虛擬機寧愿拋出異常，使程序異常終止，也不回收這種對象，如果想取消強引用和某個對象的關聯，可以顯示的將引用賦值為null;弱引用：JVM進行垃圾回收的時候，無論內存是否充足，都會回收被弱引用關聯的對象，在java中，用java.lang.ref.WeakReference類來表示。可以在緩存中使用弱引用每一個Thread維護一個ThreadLocalMap，key為使用弱引用的ThreadLocal實例，value為線程變量的副本，hreadLocalMap使用ThreadLocal的弱引用作為key，如果一個ThreadLocal不存在外部強引用時，Key(ThreadLocal)勢必會被GC回收，這樣就會導致ThreadLocalMap中key為null，而value還存在著強引用，只有thead線程退出以后,value的強引用鏈條才會斷掉，但如果當前線程再遲遲不結束的話，這些key為null的Entry的value就會一直存在一條強引用鏈，永遠無法回收，造成內存泄漏由于Thread中包含變量ThreadLocalMap，因此ThreadLocalMap與Thread的生命周期是一樣長，如果都沒有手動刪除對應key，都會導致內存泄漏，但是使用弱引用可以多一層保障：弱引用ThreadLocal不會內存泄漏，對應的value在下一次ThreadLocalMap調用set(),get(),remove()的時候會被清除。因此，ThreadLocal內存泄漏的根源是：由于ThreadLocalMap的生命周期跟Thread一樣長，如果沒有手動刪除對應key就會導致內存泄漏，而不是因為弱引用；所以，每次使用完ThreadLocal都要調用他的remove()方法清除數據，將ThreadLocal變量定義成private static,這樣就一直存在ThreadLocal的強引用，也就能保證任何時候都能通過ThreadLocal的弱引用訪問到Entry的value值，進而清除掉；

? 如何在子線程中獲取主線程threadLocal中set()方法設置的值

? 可以使用InheritableThreadLocal,ThreadLocal threadLocal = new InheritableThreadLocal()，這樣在子線程

? 中就可以通過get方法獲取到主線程set方法設置的值了，

? InheritableThreadLocal繼承了ThreadLocal，并且重寫了childValue、getMap和createMap方法，當在主線程

? 中創建InheritableThreadLocal實例對象后，當前線程Thread對象中維護了一個inheritableThreadLocals變

? 量，它也是ThreadLocalMap類型，在創建子線程的過程中，將主線程維護的inheritableThreadLocals變量的

? 值復制到子線程維護的inheritableThreadLocals變量中，這樣子線程就可以獲取到主線程設置的值了

1.2.9 volatile

? volatile是java提供的一種輕量級的同步機制，java中包含兩種在內的同步機制，同步塊（或方法）和volatitle

? 變量，相比于synchronized（重量級鎖），volatile更輕量級，因為它不會引起線程上下文的切換和調度。但是

? volatile 變量的同步性較差（有時它更簡單并且開銷更低），而且其使用也更容易出錯。

并發編程3個基本概念

原子性

可見性:多個線程訪問同一個變量時，一個線程修改了這個變量的值，其他線程能夠立即看到修改的值

在多線程環境下，一個線程對共享變量的操作對其他線程是不可見的，java提供了volatitle來保證可見性，當一個變量被volatitle修飾后，表示著線程本地內存無效，當一個線程修改共享變量后他會立即被更新到主內存中，其他線程讀取共享變量時，會直接從主內存中讀取。當然，synchronize和Lock都可以保證可見性。synchronized和Lock能保證同一時刻只有一個線程獲取鎖然后執行同步代碼，并且在釋放鎖之前會將對變量的修改刷新到主存當中。因此可以保證可見性。

有序性：如果在本線程內觀察，所有操作都是有序的；如果在一個線程中觀察另一個線程，所有操作都是無序的。前半句是指“線程內表現為串行語義”，后半句是指“指令重排序”現象和“工作內存主主內存同步延遲”現象，Java提供volatile來保證一定的有序性。最著名的例子就是單例模式里面的DCL（雙重檢查鎖）。另外，可以通過synchronized和Lock來保證有序性，synchronized和Lock保證每個時刻是有一個線程執行同步代碼，相當于是讓線程順序執行同步代碼，自然就保證了有序性。

鎖的互斥和可見性

互斥：一次只允許一個線程持有某個特定的鎖，一次就只有一個線程能夠使用該共享數據

可見性：它必須確保釋放鎖之前對共享數據做出的更改對于隨后獲得該鎖的另一個線程是可見的。也即當一條線程修改了共享變量的值，新值對于其他線程來說是可以立即得知的**。**如果沒有同步機制提供的這種可見性保證，線程看到的共享變量可能是修改前的值或不一致的值，這將引發許多嚴重問題

volatile 變量提供理想的線程安全，必須同時滿足下面兩個條件

對變量的寫操作不依賴于當前值

該變量沒有包含在具有其他變量的不變式中；

JMM定義了線程和主內存之間的抽象關系：共享變量存儲在主內存(Main Memory)中，每個線程都有一個私有的本地內存（Local Memory），本地內存保存了被該線程使用到的主內存的副本拷貝，線程對變量的所有操作都必須在工作內存中進行，而不能直接讀寫主內存中的變量。

解決這種共享變量在多線程模型中的不可見性問題，較粗暴的方式自然就是加鎖，但是此處使用synchronized或者Lock這些方式太重量級了，比較合理的方式其實就是volatile；

volatitle變量特性

保證可見性，不保證原子性，當寫一個volatile變量時，JMM會把該線程本地內存中的變量強制刷新到主內存中去，這個寫會操作會導致其他線程中的volatile變量緩存無效；

禁止指令重排：重排序操作不會對存在數據依賴關系的操作進行重排序，重排序是為了優化性能，但是不管怎么重排序，單線程下程序的執行結果不能被改變

使用volatile關鍵字修飾共享變量便可以禁止這種重排序。若用volatile修飾共享變量，在編譯時，會在指令序列中插入內存屏障來禁止特定類型的處理器重排序,volatile禁止指令重排序也有一些規則：

當程序執行到volatile變量的讀操作或者寫操作時，在其前面的操作的更改肯定全部已經進行，且結果已經對后面的操作可見；在其后面的操作肯定還沒有進行；

在進行指令優化時，不能將對volatile變量訪問的語句放在其后面執行，也不能把volatile變量后面的語句放到其前面執行；

volatitle不適用的場景

不適合復合操作；可用synchronized代替，或者Lock,或者CAS操作，java并發包里AtomicInteger()類

volatitle原理

volatile可以保證線程可見性且提供了一定的有序性，但是無法保證原子性。在JVM底層volatile是采用“內存屏障”來實現的。觀察加入volatile關鍵字和沒有加入volatile關鍵字時所生成的匯編代碼發現，加入volatile關鍵字時，會多出一個lock前綴指令，lock前綴指令實際上相當于一個內存屏障（也成內存柵欄），內存屏障會提供3個功能：

它確保指令重排序時不會把其后面的指令排到內存屏障之前的位置，也不會把前面的指令排到內存屏障的后面；即在執行到內存屏障這句指令時，在它前面的操作已經全部完成；

它會強制將對緩存的修改操作立即寫入主存；

如果是寫操作，它會導致其他CPU中對應的緩存行無效。

單列模式的雙重鎖為啥要加volatitle

如果發生指令重排，會導致程序初始化錯誤

第一重鎖，判斷是否初始化，第二重鎖，判斷是否被多次實例化

class Singleton{// 確保產生的對象完整性private volatile static Singleton instance = null;private Singleton() {}public static Singleton getInstance() {if(instance==null) { // 第一次檢查synchronized (Singleton.class) {if(instance==null) // 第二次檢查instance = new Singleton();}}return instance;} }

Memory Barrier(內存屏障)

LoadLoad屏障：對于這樣的語句Load1; LoadLoad; Load2，在Load2及后續讀取操作要讀取的數據被訪問前，保證Load1要讀取的數據被讀取完畢。
StoreStore屏障：對于這樣的語句Store1; StoreStore; Store2，在Store2及后續寫入操作執行前，保證Store1的寫入操作對其它處理器可見。
LoadStore屏障：對于這樣的語句Load1; LoadStore; Store2，在Store2及后續寫入操作被刷出前，保證Load1要讀取的數據被讀取完畢。
StoreLoad屏障：對于這樣的語句Store1; StoreLoad; Load2，在Load2及后續所有讀取操作執行前，保證Store1的寫入對所有處理器可見。它的開銷是四種屏障中最大的。在大多數處理器的實現中，這個屏障是個萬能屏障，兼具其它三種內存屏障的功能

volatile語義中的內存屏障

在每個volatile寫操作前插入StoreStore屏障，在寫操作后插入StoreLoad屏障；
在每個volatile讀操作前插入LoadLoad屏障，在讀操作后插入LoadStore屏障；

final語義中的內存屏障

新建對象過程中，構造體中對final域的初始化寫入(StoreStore屏障)和這個對象賦值給其他引用變量，這兩個操作不能重排序；
初次讀包含final域的對象引用和讀取這個final域（LoadLoad屏障），這兩個操作不能重排序；

優秀博文：https://blog.csdn.net/cy973071263/article/details/104383636

1.2.10 synchronized

資源共享解決方案

使用static關鍵字修飾要共享的變量，將其變為全局變量，也就是放到了JVM主內存中，實現資源共享；

實現Runnable接口，因為實現Runnable接口的線程所操作的資源對象本質是同一個對象；

synchronized原理

synchronized用來保證原子性和可見性，是利用鎖的機制來實現線程同步，synchronized能保證原子性，可見性，有序性，和可重入性（避免死鎖）

一個變量在同一個時刻只允許一個線程對其進行lock,持有一個鎖的兩個同步塊只能串行執行，這就保證了原子性和有序性；

在對一個變量進行unlock操作前，必須也先把此變量同步回主內存中，這就實現了可見性

synchronized用法

synchronized可以修飾靜態方法，成員函數（非靜態方法），還可以直接修飾代碼塊，但是上鎖的資源只有兩類，對象和類

修飾一個方法：被修飾的方法稱為同步方法，其作用的范圍是整個方法，作用的對象是調用這個方法的對象；

修飾一個靜態的方法：其作用的范圍是整個方法，作用的對象是這個類的所有對象；

修飾一個代碼塊，指定加鎖對象：被修飾的代碼塊稱為同步語句塊，其作用范圍是大括號{}括起來的代碼塊，如果synchronized后面括號括起來的是****一個類*，那么*作用的對象是這個類的所有實例對象*；如果synchronized后面括號括起來的是*一個對象實例*，那么*作用的對象是這個對象實例****；

同步方法：是通過頭部標志位用ACC_synchronized標志，告訴JVM這是一個同步方法；

同步代碼塊：通過Moninorenter和Monitorexit指令，會讓線程在執行時，使其持有的鎖計數器加1或者減1。每一個對象在同一時間只與一個monitor(鎖)相關聯，而一個monitor在同一時間只能被一個線程獲得，一個線程在嘗試獲得與對象相關聯的Monitor鎖的所有權的時候；

java對象頭

在java中，每個對象都會有一個monitor對象（監視器），JVM中，對象分三部分組成（對象頭、實例數據、填充數據）

monitor對象是實現鎖機制的基礎，線程獲取鎖本質是線程獲取Java對象對應的monitor對象。*重量級鎖就是通過**ObjectMonitor**實現的，也就是說重量級鎖是基于對象的**monitor**來實現的*

ObjectMonitor中有2個隊列，—WaitSet和—EntryList

JVM對synchronized的優化

在 Java 早期版本中，synchronized 屬于重量級鎖，效率低下，因為監視器鎖（monitor）是依賴于底層的操作系統的 Mutex Lock（互斥鎖）來實現的。Java 的線程是映射到操作系統的原生線程之上的（詳見Java線程和操作系統線程的關系）。如果要掛起或者喚醒一個線程，都需要操作系統幫忙完成，而操作系統實現線程之間的切換時需要從用戶態轉換到內核態

jdk1.6作出了大量的優化，主要有自旋鎖、適應性自旋鎖、鎖消除、鎖粗化等優化方法，又增加了兩個鎖的狀態：偏向鎖，輕量級鎖，所以現在synchronized一共有四種鎖狀態，依次是：無鎖狀態、偏向鎖狀態、輕量級鎖狀態、重量級鎖狀態

synchronized鎖優化方法

鎖膨脹：根據實際情況進行膨脹升級，依次是：無鎖——>偏向鎖——>輕量級鎖——>重量級鎖，并且膨脹方向不可逆。也就是說對象對應的鎖是會根據當前線程申請，搶占鎖的情況自行改變鎖的類型。

**偏向鎖：**減少同一線程獲取鎖的代價。在大多數情況下，鎖不存在多線程競爭，總是由同一線程多次獲得，那么此時就是偏向鎖。偏向鎖的“偏”就是偏心的偏，它的意思是會偏向于第一個獲得它的線程，如果在接下來的執行中，該鎖沒有被其他線程獲取，那么持有偏向鎖的線程就不需要進行同步！線程的阻塞和喚醒需要CPU從用戶態轉為核心態，頻繁的阻塞和喚醒對CPU來說是一件負擔很重的工作，使用偏向鎖也就去掉了這一部分的負擔，也取消掉了加鎖和解鎖的過程消耗。

*輕量級鎖在無競爭的情況下使用* *CAS 操作**去代替使用互斥量。而偏向鎖在無競爭的情況下會把整個同步都消除掉*。

輕量級鎖：偏向鎖只允許一個線程獲得鎖，輕量級鎖是允許多個線程獲得鎖，但是只允許他們順序拿，不允許存在競爭，輕量級鎖的加鎖和解鎖都是通過CAS操作實現

自旋鎖：輪詢申請鎖，在輕量級鎖轉重量級鎖之間，可能會存在自旋；

重量級鎖：當同一時間有多個線程競爭鎖時，鎖就會被升級成重量級鎖，此時其申請鎖帶來的開銷也就變大，這種依賴于操作系統Mutex Lock所實現的鎖我們稱之為 “重量級鎖”。它通過操作系統的互斥量和線程的阻塞和喚醒來實現鎖機制；

各自優缺點

鎖消除

消除鎖是虛擬機另外一種鎖的優化，這種優化更徹底，在****JIT****編譯時，對運行上下文進行掃描，去除不可能存在競爭的鎖。鎖消除可以節省毫無意義的請求鎖的時間。比如下面代碼的method1和method2的執行效率是一樣的，因為object鎖是私有局部變量，不存在所得競爭關系。

主要通過"逃逸分析"技術來實現，判斷一個同步塊所使用的鎖對象是否只能被一個線程訪問而沒有被發布到其他線程；

鎖粗化

鎖粗化是虛擬機對另一種極端情況的優化處理，通過擴大鎖的范圍，避免反復加鎖和釋放鎖

博文連接：https://blog.csdn.net/cy973071263/article/details/104388899

1.2.11 ReentrantLock

加鎖可以使用 synchronized 關鍵字，也可以使用 ReentrantLock 對象。synchronized 加鎖后，會在同步代碼塊內添加 monitorenter他monitorexit這兩個字節碼指令。而 ReentrantLock 加鎖，則是api層面實現的，它主要依賴于 Unsafe類的線程掛起和恢復功能。

ReentrantLock 重入鎖，實現lock接口的一個類，支持可重入性，公平鎖和非公平鎖，

可重入獲取鎖，加鎖核心方法是nonfairTryAcquire；

釋放鎖：tryRelease方法；

ReentrantLock 與synchronized區別

實現方式：synchronized由JVM實現，所有JDK版本都支持，ReentrantLock 由JDK實現，1.5以后的版本才支持；
性能差異：JDK1.6在Synchronized中引入了自旋鎖、偏向鎖、輕量級鎖的優化后，性能和ReentrantLock差不多，之前的版本Synchronized效率比ReentrantLock低很多；
Synchronized加鎖和解鎖都是由JVM自動完成的，ReentrantLock需要手動加鎖和解鎖；
ReentrantLock獨有的三大功能：
- 可以指定是公平鎖還是非公平鎖，Synchronized只能是非公平鎖
- 可以結合Condition類實現有條件的分組喚醒，Synchronized結合wait/notify/notifyAll只能隨機喚醒一個線程或者全部喚醒；
- 提供了能夠中斷等待鎖的線程的機制
Synchronized比較好定位異常，因為其生成線程dump文件的時候，能包括鎖定信息，能標識死鎖或者其他異常問題來源，而ReentrantLock只是JDK中的一個普通類，JVM并不知道哪些線程擁有Lock對象；
Synchronized以監視器模式實現鎖，而ReentrantLock是采用AQS模式實現鎖，支持響應中斷、超時、嘗試獲取鎖，同時可關聯多個條件隊列，Synchronized只能關聯一個

ReentrantLock指定公平鎖和非公平鎖

? 公平鎖和非公平鎖描述的是多個線程競爭鎖的時候要不要排隊，直接排隊的就是公平鎖；先嘗試插隊，插隊失敗再排隊的就是非公平鎖；

//ReentrantLock兩個構造方法，ReentrantLock默認是非公平鎖，第二個傳入參數能夠聲明是公平還是非公平 public ReentrantLock() {sync = new NonfairSync(); }public ReentrantLock(boolean fair) {sync = fair ? new FairSync() : new NonfairSync(); }

ReentrantLock結合Condition類實現有條件的分組喚醒

如果有三個線程Thread1,Thread2,Thread3按順序打印A、B、C,可以使用ReentrantLock結合Condition

public class ReentrantLockTest {private static final Lock lock = new ReentrantLock();private static Condition conditionA = lock.newCondition();private static Condition conditionB = lock.newCondition();private static Condition conditionC = lock.newCondition();public static volatile int permit = 0;public static void main(String[] args) {Thread thread1 =new Thread(() -> {try {Thread.sleep(200);lock.lock();for (int i = 0; i < 10; i++) {while ((permit % 3) !=0) {conditionA.await();}System.out.println("A");permit++;conditionB.signal();}conditionB.signal();} catch (InterruptedException e){e.printStackTrace();}finally {lock.unlock();}});Thread thread2 = new Thread(() ->{try {Thread.sleep(200);lock.lock();for (int i = 0; i < 10; i++) {while ((permit % 3) !=1) {conditionB.await();}System.out.println("B");permit++;conditionC.signal();}conditionC.signal();} catch (InterruptedException e){e.printStackTrace();}finally {lock.unlock();}});Thread thread3 = new Thread(() ->{try {Thread.sleep(200);lock.lock();for (int i = 0; i < 10; i++) {while ((permit % 3) !=2) {conditionC.await();}System.out.println("C");permit++;conditionA.signal();}conditionA.signal();} catch (InterruptedException e){e.printStackTrace();}finally {lock.unlock();}});thread1.start();thread2.start();thread3.start();} }上面的方法還可以優化一下，去掉取余運算public class AbcTest implements Runnable {//打印次數private static final int PRINT_COUNT = 10;//鎖private final ReentrantLock reentrantLock;//本次要打印所需要的conditionprivate final Condition thisCondition;//下次要打印所需要的conditionprivate final Condition nextCondition;//要打印的字符private final char printChar;public AbcTest(ReentrantLock reentrantLock, Condition thisCondition,Condition nextCondition, char printChar) {this.reentrantLock = reentrantLock;this.thisCondition = thisCondition;this.nextCondition = nextCondition;this.printChar = printChar;}@Overridepublic void run() {//進入臨界區reentrantLock.lock();try {for (int i = 0; i < PRINT_COUNT; i++) {System.out.println(printChar);//使用nextCondition喚醒下一個線程//因為只有一個線程，所以signal或者signalAll都可以nextCondition.signal();//不是最后一次，則通過thisCondition等待被喚醒//此處要加判斷，不然10次后會死鎖if (i < PRINT_COUNT - 1) {try {thisCondition.await();} catch (InterruptedException e) {e.printStackTrace();}}}} finally {reentrantLock.unlock();}}public static void main(String[] args) throws InterruptedException {ReentrantLock lock = new ReentrantLock();Condition conditionA = lock.newCondition();Condition conditionB = lock.newCondition();Condition conditionC = lock.newCondition();Thread thread = new Thread(new AbcTest(lock, conditionA, conditionB, 'A'));Thread thread1 = new Thread(new AbcTest(lock, conditionB, conditionC, 'B'));Thread thread2 = new Thread(new AbcTest(lock, conditionC, conditionA, 'C'));thread.start();Thread.sleep(100);thread1.start();Thread.sleep(100);thread2.start();Thread.sleep(100);} }方法二：通過一個鎖和一個狀態變量來實現（推薦） public class AbcTest1 {//狀態變量private volatile int state = 0;//打印線程private class Printer implements Runnable {private static final int PRINT_COUNT = 10;//打印鎖private final Object printLock;//打印標志位和state變量相關private final int printFlag;//后續線程的線程打印標志位private final int nextPrintFlag;//打印字符private final char printChar;public Printer(Object printLock, int printFlag, int nextPrintFlag, char printChar) {this.printLock = printLock;this.printFlag = printFlag;this.nextPrintFlag = nextPrintFlag;this.printChar = printChar;}@Overridepublic void run() {//獲取打印鎖，進入臨界區synchronized (printLock) {//聯系打印printCount次for (int i = 0; i < PRINT_COUNT; i++) {//循環檢驗標志位，每次都阻塞然后等待喚醒while (state != printFlag) {try {printLock.wait();} catch (InterruptedException e) {return;}}System.out.print(printChar);//設置狀態變量為下一個線程標志位state = nextPrintFlag;//一個線程在操作，另外兩個在等待，所以需要notifyAll();printLock.notifyAll();}}}}public void test() throws InterruptedException {Object lock = new Object();Thread threadA = new Thread(new Printer(lock, 0, 1, 'A'));Thread threadB = new Thread(new Printer(lock, 1, 2, 'B'));Thread threadC = new Thread(new Printer(lock, 2, 0, 'C'));threadA.start();Thread.sleep(100);threadB.start();Thread.sleep(100);threadC.start();Thread.sleep(100);}public static void main(String[] args) throws InterruptedException {AbcTest1 abcTest1 = new AbcTest1();abcTest1.test();} }

三個Java多線程循環打印遞增的數字，每個線程打印5個數值，打印周期1-75

public class AddNumberTest {//計數器private final AtomicInteger atomicInteger = new AtomicInteger(0);private class Printer implements Runnable {//總打印次數private static final int TOTAL_PRINT_COUNT = 5;//每次打印5次private static final int PER_PRINT_COUNT = 5;private final ReentrantLock reentrantLock;//本線程的Conditionprivate final Condition thisCondition;//前一個線程的Conditionprivate final Condition afterCondition;public Printer(ReentrantLock reentrantLock, Condition thisCondition, Condition afterCondition) {this.reentrantLock = reentrantLock;this.thisCondition = thisCondition;this.afterCondition = afterCondition;}@Overridepublic void run() {//進入臨界區reentrantLock.lock();try {//循環打印5次for (int i = 0; i < TOTAL_PRINT_COUNT; i++) {//打印操作，每次打印5個數for (int j = 0; j < PER_PRINT_COUNT; j++) {//以原子方式將當前值加1//incrementAndGet返回的是新值（加1后的值）System.out.print(atomicInteger.incrementAndGet());}//操作完成通知后面的線程afterCondition.signalAll();if (i < TOTAL_PRINT_COUNT - 1) {try {//本線程釋放鎖并等待喚醒thisCondition.await();} catch (InterruptedException e) {e.printStackTrace();}}}} finally {reentrantLock.unlock();}}}public void test() throws InterruptedException {ReentrantLock reentrantLock = new ReentrantLock();Condition conditionA = reentrantLock.newCondition();Condition conditionB = reentrantLock.newCondition();Condition conditionC = reentrantLock.newCondition();Thread threadA = new Thread(new Printer(reentrantLock, conditionA, conditionB));Thread threadB = new Thread(new Printer(reentrantLock, conditionB, conditionC));Thread threadC = new Thread(new Printer(reentrantLock, conditionC, conditionA));threadA.start();Thread.sleep(100);threadB.start();Thread.sleep(100);threadC.start();}public static void main(String[] args) throws InterruptedException {AddNumberTest addNumberTest=new AddNumberTest();addNumberTest.test();} }

ReentrantLock提供了能夠中斷等待鎖的線程的機制

ReentrantLock主要是靠ReentrantLock#lockInterruptibly()方法來提供一種可中斷的機制

public class LockDemo {private static final Lock lock = new ReentrantLock();public static void main(String[] args) throws InterruptedException {Thread threadA = new Thread(() -> {try {lock.lockInterruptibly();System.out.println(System.currentTimeMillis() + " -> thread-1 獲取了鎖");} catch (InterruptedException e) {System.out.println(System.currentTimeMillis() + "-> thread-1 被中斷");} finally {//lock.unlock();}});Thread threadB = new Thread(() -> {try {lock.lockInterruptibly();System.out.println(System.currentTimeMillis() + "-> thread-2 獲取到了鎖");Thread.sleep(3000);System.out.println(System.currentTimeMillis() + "-> thread-2 中斷thread-1");threadA.interrupt();} catch (InterruptedException e) {e.printStackTrace();} finally {lock.unlock();}});threadB.start();Thread.sleep(200);threadA.start();} } 輸出 1614852259509-> thread-2 獲取到了鎖 1614852262510-> thread-2 中斷thread-1 1614852262510-> thread-1 被中斷

ReentrantLock內部有一個成員變量，sync，它繼承自AbstractQueuedSynchronizer類，同時 sync 有兩個實現類，NonfairSync 和 FairSync類，分別代表著非公平鎖模式和公平鎖模式。ReentrantLock內部的 sync 成員變量默認是非公平鎖模式。

其實 ReentrantLock 的邏輯有一大半依靠 AbstractQueuedSynchronizer 類實現，它就是大名頂頂的 AQS，AQS定義了一套多線程訪問共享資源的同步器框架，許多同步類實現都依賴于它，如常用的ReentrantLock/Semaphore/CountDownLatch

先簡單介紹AQS

AbstractQueuedSynchronizer(簡稱AQS),提供原子式管理狀態、阻塞和喚醒線程功能以及隊列模型的簡單框架

static final class NonfairSync extends Sync {...final void lock() {if (compareAndSetState(0, 1))setExclusiveOwnerThread(Thread.currentThread());elseacquire(1);}... } 這段代碼含義為： a. 若通過CAS設置變量State（同步狀態）成功，也就是獲取鎖成功，則將當前線程設置為獨占線程。 b. 若通過CAS設置變量State（同步狀態）失敗，也就是獲取鎖失敗，則進入 Acquire方法進行后續處理。在看公平鎖 tatic final class FairSync extends Sync {... final void lock() {acquire(1);}... } Lock函數通過Acquire方法進行加鎖，但是具體是如何加鎖的呢？結合公平鎖和非公平鎖的加鎖流程，雖然流程上有一定的不同，但是都調用了Acquire方法，而Acquire方法是FairSync和UnfairSync的父類AQS中的核心方法

AQS整體架構

AQS框架共分為5層：API層、鎖獲取方法層、對列方法層、排隊方法層、數據提供層；

**AQS核心思想：**如果被請求的共享資源空閑，那么就將當前請求資源的線程設置為有效的工作線程，將共享資源設置為鎖定狀態，如果共享資源被占用，就需要一定的阻塞等待喚醒機制來保證鎖分配，這個機制主要是CLH隊列的變體實現的，將暫時獲取不到鎖的線程加入到隊列中；

CLH：Craig、Landin and Hagersten隊列，是單向鏈表，AQS中的隊列是CLH變體的虛擬雙向隊列（FIFO），AQS是通過將每條請求共享資源的線程封裝成一個節點來實現鎖的分配

AQS使用一個volatitle的int成員變量來表示同步狀態（state)，通過內置的FIFO隊列來完成資源獲取的排隊工作，通過CAS完成對state值修改，下圖(AQS數據結構)

waitStatus: 當前節點在隊列中的狀態

thread: 表示處于該節點的線程

prev: 前驅指針

predecessor：返回前驅節點，沒有拋出npe

nextWaiter: 指向下一個處于CONDITION狀態節點

next: 后續指針

線程鎖的2種模式

shared: 表示線程以共享的模式等待鎖；

exclusive: 表示線程正在以獨占的方式等待鎖；

JUC中AQS應用場景

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-svZVQcnv-1618197750707)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\image-20210304190836375.png)]

AQS主要是加鎖acquire()方法，解鎖release()方法以及state標識

AQS解析：https://tech.meituan.com/2019/12/05/aqs-theory-and-apply.html

美團技術團隊：https://tech.meituan.com/

1.2.12 Unsafe

功能：

普通讀寫：讀寫一個Object對象的field,直接從內存中的一個地址讀寫

volatitle讀寫：可以保證可見性和有序性；

有序寫：保證有序性不保證可見性；

直接內存操作：申請內存，重新申請內存，內存初始化，釋放內存，內存復制

CAS相關：提供int，long,和Object的CAS操作；

偏移量相關：staticFieldOffset方法用于獲取靜態屬性Field在對象中的偏移量，讀寫靜態屬性時必須獲取其偏移量。objectFieldOffset方法用于獲取非靜態屬性Field在對象實例中的偏移量，讀寫對象的非靜態屬性時會用到這個偏移量。staticFieldBase方法用于返回Field所在的對象。arrayBaseOffset方法用于返回數組中第一個元素實際地址相對整個數組對象的地址的偏移量。arrayIndexScale方法用于計算數組中第一個元素所占用的內存空間。

線程調度：LockSupport中的park和unpark方法正是通過Unsafe來實現的，park掛起線程，unpark喚醒線程；

類加載：defineClass方法定義一個類，用于動態地創建類。
defineAnonymousClass用于動態的創建一個匿名內部類。
allocateInstance方法用于創建一個類的實例，但是不會調用這個實例的構造方法，如果這個類還未被初始化，則初始化這個類。
shouldBeInitialized方法用于判斷是否需要初始化一個類。
ensureClassInitialized方法用于保證已經初始化過一個類。

內存屏障：loadFence：保證在這個屏障之前的所有讀操作都已經完成。
storeFence：保證在這個屏障之前的所有寫操作都已經完成。
fullFence：保證在這個屏障之前的所有讀寫操作都已經完成。

unsafe應用

內存操作：內存分配、釋放、拷貝等，java中對堆外內存的操作，依賴于Unsafe提供的操作堆外內存的native方法；

為什么使用堆外內存：對垃圾回收停頓的改善，堆外內存直接受操作系統管理而不是JVM,所以當我們使用堆外內存時，即可保持較小的堆內內存規模。從而在GC時減少回收停頓對于應用的影響;

提升程序I/O操作的性能。通常在I/O通信過程中，會存在堆內內存到堆外內存的數據拷貝操作，對于需要頻繁進行內存間數據拷貝且生命周期較短的暫存數據，都建議存儲到堆外內存;

DirectByteBuffer是java用于實現堆外內存的一個重要類，通常用在通信過程中做緩沖池，如在Netty、MINA等NIO框架中應用廣泛。DirectByteBuffer對于堆外內存的創建、使用、銷毀等邏輯均由Unsafe提供的堆外內存API來實現；

創建DirectByteBuffer的時候，通過Unsafe.allocateMemory分配內存、Unsafe.setMemory進行內存初始化，而后構建Cleaner對象用于跟蹤DirectByteBuffer對象的垃圾回收，以實現當DirectByteBuffer被垃圾回收時，分配的堆外內存一起被釋放

unsafe應用解析：https://tech.meituan.com/2019/02/14/talk-about-java-magic-class-unsafe.html

1.2.13 并發工具三巨頭CountDownLatch、CyclicBarrier、Semaphore使用

1. 2.13 多線程相關面試題

執行execute()方法和submit()方法的區別是什么呢？

execute() 方法用于提交不需要返回值的任務，所以無法判斷任務是否被線程池執行成功與否；

2)submit()方法用于提交需要返回值的任務。線程池會返回一個future類型的對象，通過這個future對象可以判斷任務是否執行成功，并且可以通過future的get()方法來獲取返回值，get()方法會阻塞當前線程直到任務完成，而使用 get（long timeout，TimeUnit unit）方法則會阻塞當前線程一段時間后立即返回，這時候有可能任務沒有執行完；

JUC包中的原子類是哪4類？

基本類型：

AtomicInter:整型原子類
AtomicLong:長整型原子類
AtomicBoolean:布爾型原子類

數組類型：

AtomicIntegerArray：整形數組原子類
AtomicLongArray：長整形數組原子類
AtomicReferenceArray ：引用類型數組原子類

引用類型：

AtomicReference：引用類型原子類
AtomicStampedRerence：原子更新引用類型里的字段原子類
AtomicMarkableReference ：原子更新帶有標記位的引用類型

對象的屬性修改類型：

AtomicIntegerFieldUpdater:原子更新整形字段的更新器
AtomicLongFieldUpdater：原子更新長整形字段的更新器
AtomicStampedReference ：原子更新帶有版本號的引用類型。該類將整數值與引用關聯起來，可用于解決原子的更新數據和數據的版本號，可以解決使用 CAS 進行原子更新時可能出現的 ABA 問題

AtomicInteger的使用

public final int get() //獲取當前的值 public final int getAndSet(int newValue)//獲取當前的值，并設置新的值 public final int getAndIncrement()//獲取當前的值，并自增 public final int getAndDecrement() //獲取當前的值，并自減 public final int getAndAdd(int delta) //獲取當前的值，并加上預期的值 boolean compareAndSet(int expect, int update) //如果輸入的數值等于預期值，則以原子方式將該值設置為輸入值（update） public final void lazySet(int newValue)//最終設置為newValue,使用 lazySet 設置之后可能導致其他線程在之后的一小段時間內還是可以讀到舊的值。inCrementAndGet();//實現++操作，原子性，不需要加鎖也是線程安全的；

AtomicInteger主要使用CAS+volatitle和native方法保證原子性，從而避免synchronized的高開銷，設計到Unsafe方法；

AQS組件總結

Semaphore(信號量)-允許多個線程同時訪問：synchronized 和 ReentrantLock 都是一次只允許一個線程訪問某個資源，Semaphore(信號量)可以指定多個線程同時訪問某個資源；
CountDownLatch(倒計時器)：CountDownLatch是一個同步工具類，用來協調多個線程之間的同步。這個工具通常用來控制線程等待，它可以讓某一個線程等待直到倒計時結束，再開始執行；
CyclicBarrier(循環柵欄)：CyclicBarrier 和 CountDownLatch 非常類似，它也可以實現線程間的技術等待，但是它的功能比 CountDownLatch 更加復雜和強大。主要應用場景和 CountDownLatch 類似。CyclicBarrier 的字面意思是可循環使用（Cyclic）的屏障（Barrier）。它要做的事情是，讓一組線程到達一個屏障（也可以叫同步點）時被阻塞，直到最后一個線程到達屏障時，屏障才會開門，所有被屏障攔截的線程才會繼續干活。CyclicBarrier默認的構造方法是 CyclicBarrier(int parties)，其參數表示屏障攔截的線程數量，每個線程調用await方法告訴 CyclicBarrier 我已經到達了屏障，然后當前線程被阻塞；

CountDownLatch 和CycliBarrier有什么不同

CountDownLatch類位于java.util.concurrent包下，利用它可以實現類似計數器的功能，一個線程(或者多個)，等待另外N個線程完成某個事情之后才能執行

CyclicBarrier通過它可以實現讓一組線程等待至某個狀態之后再全部同時執行，CyclicBarrier可以被重用

? [外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-Kv71Wceh-1618197750707)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\image-20210305102855558.png)]

volatitle關鍵字場景

狀態標記量
雙重檢查
public class Singleton {private volatile static Singleton instance = null;private Singleton() {}public static Singleton getInstance() {if (instance == null) {synchronized (Singleton.class) {// 1if (instance == null) {// 2instance = new Singleton();// 3}}}return instance;} }
獨立觀察
開銷較低的讀-寫鎖策略

如何終止一個線程

一般是當使用run()或者call()方法時，執行完畢線程會自動結束，如果要手動結束一個線程，可以使用volatitle布爾變量來退出run()方法的循環或者是取消任務來中斷線程；

生產者消費者模型

public class ProductAndConsumer {final Lock lock = new ReentrantLock();final Condition notFull = lock.newCondition();final Condition notEmpty = lock.newCondition();final Object[] items = new Object[100];int putptr, takeptr, count;public void put(Object x) throws InterruptedException {lock.lock();try {while (count == items.length) {notFull.await();}items[putptr] = x;if (++putptr == items.length) {putptr = 0;}++count;notEmpty.signal();} finally {lock.unlock();}}public Object take() throws InterruptedException {lock.lock();try {while (count == 0)notEmpty.await();Object x = items[takeptr];if (++takeptr == items.length)takeptr = 0;--count;notFull.signal();return x;} finally {lock.unlock();}} }

什么是FutureTask

表示一個可以取消的異步運算，它有啟動和取消運算、查詢運算是否完成和取回運算結果等方法，此類提供了對 Future 的基本實現。只有當運算完成的時候結果才能取回，如果運算尚未完成get方法將會阻塞。可使用 FutureTask 包裝 Callable 或 Runnable 對象。因為 FutureTask 實現了 Runnable，所以可將 FutureTask 提交給 Executor 執行

Java中interrupt 、interrupted 和 isInterruptedd方法的區別？

interrupt 中斷線程，如果沒有中斷，則該線程的checkAccess方法會被調用，可能拋出SecurityException異常；

如果線程在調用 Object 類的 wait()、wait(long) 或 wait(long, int) 方法，或者該類的 join()、join(long)、join(long, int)、sleep(long) 或 sleep(long, int) 方法過程中受阻，則其中斷狀態將被清除，它還將收到一個 InterruptedException；

如果該線程在可中斷的通道上的 I/O 操作中受阻，則該通道將被關閉，該線程的中斷狀態將被設置并且該線程將收到一個 ClosedByInterruptException。

如果該線程在一個 Selector 中受阻，則該線程的中斷狀態將被設置，它將立即從選擇操作返回，并可能帶有一個非零值，就好像調用了選擇器的 wakeup 方法一樣。
interrupted() 和 isInterrupted()的主要區別是前者會將中斷狀態清除而后者不會。

interrupted 是作用于當前線程，isInterrupted 是作用于調用該方法的線程對象所對應的線程

java中的同步集合與并發集合有什么區別？

都支持線程安全，主要區別體現在性能和可擴展性，還有如何實現線程安全的；

同步：HashMap,Hashtable,HashSet,Vector,ArrayList相對比他們并發實現（如ConcurrentHashMap,CopyOnWriteArrayList,CopyOnWriteHashSet)會慢很多，造成此種原因是因為鎖，同步集合會加鎖，而并發集合不會加鎖，并發集合實現線程安全是通過先進和成熟的技術像鎖剝離，比如ConcurrentHashMap分段；

fail-fast和fail-safe機制

fail-fast即快速失敗機制，是java集合(Collection)中的一種錯誤檢測機制。當在迭代集合的過程中該集合在結構上發生改變的時候，就有可能會發生fail-fast，即拋出ConcurrentModificationException異常

fail-safe 采用安全失敗機制的集合容器，在遍歷時不是直接在集合內容上訪問的，而是先復制原有集合內容，在拷貝的集合上進行遍歷

優秀博文：https://blog.csdn.net/hzau_itdog/article/details/91359145

優秀博文：https://blog.csdn.net/qq_36860032/article/details/89928062

java多線程實現消費者生產者模型：https://www.jb51.net/article/183079.htm

1.3 集合

1.3.1 理論知識

Collection接口是List、set、Queue的父級接口；

Set接口有三個常用實現類，HashSet、TreeSet;EnumSet;

List下有ArrayList和Vector;

1.3.2 原理及使用場景

1.3.1 集合相關面試題

Collection框架中實現比較要怎么做？

實體類實現Compareable接口，并實現compareTo(T t)方法，此法為內部比較器；
創建一個外部比較器，外部比較器要實現Comparator接口的compare(T t1,T t2)方法
1. 定義外部類Student,無需實現任何接口 2. 定義外部比較器實現Comparator接口 public class StudentComparator implements Comparator<Student>{@Overridepublic int compare(Student o1, Student o2) {if (o1.getAge() > o2.getAge()) {return 1;}else if (o1.getAge() == o2.getAge()) {return 0;}else{return -1;}}

ArrayList和Vector的區別（是否有序，是否重復、數據結構、底層實現）

兩者都實現了List接口，都是有序集合，都允許重復，底層都是數組，查詢快，增刪改慢（查詢是對引用地址的訪問，不需要遍歷，增刪慢是因為每次都需要向前或者向后移動元素，插入元素還需要判斷是否擴容，擴容是需要創建一個新的數組，增加length再將元素放入較為繁瑣）；
ArrayList線程不安全，Vector線程安全，前者效率高
ArrayList每次增長為原來的0.5倍，Vector增長為原來的一倍，兩者都可以設置初始空間大小，Vector還可以設置增長空間大小；

ArrayList和LinkedList區別？

ArrayList是基于數組實現，LinkedList基于雙向鏈表實現；
隨機訪問List（get和set)，ArrayList效率高，因為LinkedList是線性的數據存儲方式，需要移動指針從前往后依次查找；
增加刪除時，LinkedList效率要高，只需要改變指針的地址，不影響其他；
自由性不同，ArrayList需要手動設置固定大小的容量；
ArrayList會預留空間，而LinkedList需要存儲節點信息和節點指針信息；

ArrayList和Set的區別？

set元素無序、不重復，有兩個實現類HashSet和TreeSet,HashSet是根據對象的Hash值來確定元素在集合中的存儲位置，因此具有良好的存取和查找性能，TreeSet則是二叉樹的方式存儲元素，可以對集合進行排序；

ArrayList、Vector、LinkedList、Set遍歷方式

For循環遍歷ArrayList
增強for循環foreach 遍歷ArrayList
迭代器Iterator遍歷
Iterator iterator = list.iterator();while(iterator.hasNext()) {System.out.print(iterator.next() + " ");}
雙向迭代器listIterator
ListIterator listIterator = list.listIterator();while (listIterator.hasNext()) {System.out.print(listIterator.next() + " ");}

HashMap與HashTable區別？

HashMap線程不安全、HashTable 線程安全，HashMap允許null鍵值，hashTable 不允許；
HashMap線程不安全是因為主要考慮到了多線程環境下進行擴容可能出現HashMap死循環，hashtable 單個方法操作是線程安全的，但是符合操作時不一定能保證，容易導致越界異常
繼承的父類不同，hashMap繼承自AbstractMap類，而hashtable繼承自Dictionary類，不過都同時實現了map,Cloneable（可復制）、Serializable(可序列化)三個接口
當需要線程安全的時候也可以實現ConcurrentHashMap,效率也比hashTable高，因為其使用了分段鎖；
擴容不同，HashTable默認初始化大小是11，之后每次擴容，容量是原來2n+1倍，HashMap默認是16，每次擴容為原來的2倍，

hashtable會盡量使用素數，基數，hashMap總是使用2的冪作為哈希表大小；
計算hash值方法不同，HashTable直接使用對象的hashCode,**hashCode是JDK根據對象的地址或者字符串或者數字算出來的int類型的數值。然后再使用除留余數法來獲得最終的位置。**所以比較耗時，hashMap是將hash表的大小固定在2的冪，這樣在取模運算時，不需要做除法運算，只需要做位運算，效率比除法高，但是相應的hash沖突也多了，hashMap也采取了分散法來打散運算結果；
或者可以使用Collections的synchronizedMap方法使hashMap具有同步的能力，LinkedHashMap記錄了插入順序（有序）
synchronizedMap使用互斥鎖+synchronized關鍵字實現線程安全

HashMap遍歷？

1.通過Map.keySet來遍歷key和valuefor (String key : map.keySet()) {System.out.println("key= "+key+" and value= "+map.get(key));}2. 通過Map.entrySet使用iterator遍歷key和value Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();while(it.hasNext()){Map.Entry<String, String> entry = it.next();System.out.println("key= "+entry.getKey()+" and value= "+entry.getValue());}3. 通過Map.values()遍歷所有的value,但是不能遍歷key;

Map集合java8新特性？

結構上,1.7中底層是數組+鏈表形式，1.8中是數組+鏈表+紅黑樹（解決了鏈表太長導致的查詢變慢的問題）；
初始化方式:1.7 infateTable()，1.8直接集成了擴容函數resize()
hash值計算方式：1.7中9次擾動=4次位運算+5次異或運算，1.8中 2次擾動=1次位運算+1次異或運算
存放規則：1.7 無沖突存放數組，有沖突,數組+鏈表，1.8無沖突數組，有沖突，鏈表長度小于8，數組+鏈表，鏈表>8，加紅黑樹
插入數據方式：1.7 頭插法，1.8尾插發

HashMap擴容機制？

初始容量是16，擴容因子是0.75，擴容完成，容量為2n,當容量達到16*0.75=12,就可能需要擴容；
為什么長度是2的冪：減少沖突（碰撞）的次數，提高效率，如果是2的冪，length-1轉化為二進制是1111…的形式，如果不是2的冪，則length-1轉化為二進制是1110…,最后一位都是0，會導致空間浪費，會增加碰撞幾率；

hashSet和TreeSet的區別

**HashSet底層使用了Hash表實現。**保證元素唯一性的原理：判斷元素的hashCode值是否相同。如果相同，還會繼續判斷元素的equals方法，是否為true
**TreeSet底層使用了紅黑樹來實現。**保證元素唯一性是通過Comparable或者Comparator接口實現

解決hash沖突方法？

拉鏈法
線性探測再散列法
二次探測再散列法
偽隨機探測再散列法
使用2次擾動函數（hash函數）來降低哈希沖突的概率；
使用紅黑樹進一步降低遍歷的時間復雜度；

數組和集合List之間的轉換？
主要通過Arrays.asList以及List.toArray方法

hashMap的put方法的具體流程？

1. 如果table為空或者長度為0，即沒有元素，使用resize方法擴容； 2. 計算插入存儲的數組索引i,如果數組為空，即不存在hash沖突，則直接插入數組； 3. 插入時如果發生hash沖突，則進行判斷：a. 判斷table[i]的元素key是否與需要插入的key相同，若相同則直接使用新的vlue覆蓋掉舊的value,使用equals方法；b. 繼續判斷，需要插入的數據結構是紅黑樹還是鏈表，如果是紅黑樹，則直接在樹中插入or更新鍵值對，如果是鏈表，則在鏈表中插入或者更新鍵值對；鏈表長度>8，則轉為紅黑樹； 4. 插入成功，檢查存在的鍵值對數量size>最大容量，大于則進行擴容；

jdk1.8，Map為什么要引入紅黑樹

主要是為了解決二叉樹的缺陷，二叉樹在特殊情況下會變成一條線性結構（會跟鏈表一樣，造成很深的問題），遍歷查詢會非常慢，而紅黑樹在插入新數據時可能通過左旋、右旋、變色操作保持平衡，可以解決查找數據慢，鏈表深度太深的問題，當然鏈表很短就不需要引入紅黑樹；

為什么hashMap在鏈表長度大于8的時候轉為紅黑樹？
主要是考慮到樹需要存儲節點占用空間是普通節點的2倍，節點足夠多的時候，可以一空間換時間，保證效率，通常情況下鏈表長度很難達到8，在鏈表長度為8時性能已經很差；

1.4 文件流以及IO

1.4.1 理論知識以及結構圖

1.4.2 實際操作

1.4.3 NIO、BIO、AIO

介紹

BIO:同步阻塞IO，在讀寫操作完成之前，線程一直阻塞；

NIO:多路復用同步非阻塞IO,提供了Chanel、selector、buffer等新的概念

AIO: 異步非阻塞IO

NIO主要有三大核心：channel(通道)、Buffer(緩沖區)、Selector(選擇區)

channel(通道)：雙向的，可進行讀操作，也可進行寫操作，主要實現有FileChannel，DatagramChannel,SocketChannel,ServerSocketChannel;

Buffer:緩沖區

Selector（選擇區）：能夠檢測多個注冊的通道上是否有事件發生，如果有事件發生，便獲取事件然后針對每個事件進行相應的響應處理；

多路復用三種實現？

**select:**它僅僅知道，有I/O事件發生，并不知道是那個流，只能無差別輪詢所有流，找出能讀或者寫入的流，操作流程

使用copy_from_user 從用戶空間拷貝fd_set到內核空間；

注冊回調函數_pollwait

遍歷所有fd,調用其對應的poll方法；

以tcp_poll為例，其核心實現就是_pollwait

__pollwait的主要工作就是把current(當前進程)掛到設備的等待隊列中，不同的設備有不同的等待隊列；

poll方法返回時會返回一個描述讀寫操作是否就緒的mask掩碼，根據這個mask掩碼給fd_set賦值；

如果遍歷完所有的fd，還沒有返回一個可讀寫的mask掩碼，則會調用schedule_timeout是調用select的進程(也就是current)進入睡眠；

把fd_set從內核空間拷貝到用戶空間；

**缺點：**單個進程所打印的fd是有限制的，通過FD_SETSIZE設置，默認1024；

都會把fd從用戶態拷貝到內核態，這個開銷在fd很多時很大；
poll:將用戶傳入的數組拷貝到內核空間，然后查詢每個fd對應的設備狀態，沒有最大連接數的限制，基于鏈表存儲；
鏈接：https://blog.csdn.net/weixin_39662142/article/details/110396979

1.4.4 文件流相關面試題

字節流和字符流那個好，怎么選擇？

大多數情況使用字節流，大多數IO都是直接操作磁盤文件，所以一般都是以字節的形式進行；

如果操作IO需要通過內存中頻繁處理字符串的情況，就用字符流，因為字符流具備緩沖區，提高了性能；

什么是java序列化，如何實現java序列化？

處理對象流的一種機制，將對象進行流花，可以對流化后的對象進行讀寫操作，一般實現Serialize接口；

BufferedReader屬于那種流，主要用來做什么？

用于處理流中的緩沖流，可以將讀取的數據存在內存里面，有readLine方法，用來讀取一行；

1.5 鎖

1.5.1 鎖的定義、原理、作用

1.5.2 鎖的分類以及實現方法

1.5.3 鎖的實際應用

1.5.4 鎖優化、以及使用過程中的問題

1.5.5 鎖相關面試題

1.6 網絡協議

1.6.1 網絡協議原理

1.6.2 網絡協議分類

1.6.3 網絡協議運用

1.6.4 http請求相關問題

1.6.5 相關面試題

Get請求和Post請求的區別？

get請求可被緩存，將保留在瀏覽器歷史記錄中，可被收藏為書簽，post都不可以
get請求不要再處理銘感數據時使用；
get請求有長度限制，post沒有；

DNS使用的協議

TCP和UDP都有使用，UDP報文最大長度是512字節，而TCP則超過512字節，DNS查詢超過512字節，盡量使用TCP;

區域傳送使用TCP:可以保證數據準確性，還有傳輸數據量大的問題；

域名解析使用UDP協議：不會經過TCP三次握手，字節數少，此時DNS負載低，響應快；

冪等

一個冪等操作的特點是其任意多次執行所產生的影響均與第一次執行的影響相同，冪等函數或者冪等方法，是指可以使用相同參數重復執行，并能獲得相同結果的函數，這些函數不會影響系統狀態；

http get請求可以認為是冪等；

http post請求不是冪等，put冪等，patch非冪等，delete是冪等；

http、UDP、TCP區別？

網絡七層模型，應用層、表示層、會話層、傳輸層、網絡層、數據鏈路層、物理層；
http:超文本傳輸協議，是一種無狀態協議，客戶端發送請求，服務器接收請求，經過處理返回給客戶端；
TCP: 傳輸控制協議，是面向連接的協議，在發數據前必須先和對方建立可靠的鏈接，一個TCP要經過3次對話才能建立起來，其屬于傳輸層;
UDP:用戶數據報協議，面向非連接，傳輸不可靠，用于傳輸少量數據

TCP三次握手？四次揮手？

TCP建立過程，A-B，B收到信息會用一個帶有確定應答的（ACK)和同步序列號（SYN)標志位的數據段響應主機A,A收到數據在發送確認應答,沒有應用層的數據；
TCP斷開（4次握手）：主機A完成數據傳輸后，將控制位FIN置為1，提出停止TCP連接，主機B收到FIN作出響應，確認這一方向上的TCP連接關閉，將ACK置1，B再反方向提出關閉請求，將FIN置1，主機A對主機B的請求進行確認，將ACKz置1，

cookies和session區別？

Cookiess是一種能夠讓網站服務器把少量數據存儲到客戶端的硬盤或者內存；
cookie數據存在客戶瀏覽器上，session數據存儲在服務器上；
cookie不是很安全，但是可以加密，cookie可以過期，session可以被銷毀；

TCP粘包和拆包區別？解決策略？

正向代理、反向代理區別聯系？應用？

正向代理：是一個位于客戶端和原始服務器之間的服務器，代理客戶端和原始服務器的，服務器端并不知道真正的客戶端到底是誰，隱匿的是客戶端，配置的也是客戶端
反向代理：服務器的代理，客戶端不知道真正的服務器是誰，隱匿的是服務端，配置的也是服務端

一次完整http請求過程？
域名解析–>發起TCP的3次握手–>建立TCP連接后發起httpq請求–>服務器響應http請求，瀏覽器得到html代碼–>瀏覽器解析html代碼，并請求html代碼中的資源–>瀏覽器對頁面進行渲染呈現給用戶；

TCP如何保證可靠傳輸？

三次握手
將數據截斷為合理的長度，應用數據被分割成TCP認為最適合發送的數據塊
超時重發，當TCP發出一個段后，它啟動一個定時器，如果不能及時收到一個確認就重發
對于收到的請求，給出確認響應
校驗出包有錯，丟棄報文段，不給出響應
對失效數據進行重新排序，然后才交給應用層

1.7 tomcat、webSocket等服務器知識

1.7.1 tomcat介紹、原理、作用

1.7.2 tomcat使用

1.7.3 tomcat 調優

1.7.4 webSocket原理、作用

1.7.5 相關面試題

tomcat使用哪種IO,為什么？
tomcat默認使用的是BIO,客戶系統使用BIO的時候往往為每一個web請求引入多線程，每個web請求一個單獨的線程，如果并發量上去，線程數就上去了，CPU忙著線程切換，所以BIO不適合高吞吐量，高可伸縮性的web服務器；

NIO是使用單線程（單個CPU)或者少量的多線程來接受socket,可以大大提高web服務器的可伸縮性；

有哪些服務器？區別和用途？

有tomcat服務器、Jetty服務器、Jboss服務器、Glassfish服務器、Websphere服務器、WebLogic服務器；
Tomcat和jetty都是一種Servlet引擎，都支持標準的servlet規范和javaEE規范；
jetty架構是基于Handler 來實現的，tomcat是基于容器設計的；
jetty可以同時處理大量連接而且可以長時間保持連接，適合做web聊天應用等等，可以減少服務器內存開銷，從而提高服務器性能，默認采用NIO，在處理I/O請求更占優勢，適合處理靜態資源，tomcat適合處理生命周期短的，不適合處理靜態資源；
Jboss不僅是Servlet容器，還是EJB容器

Tomcat組成？

主要有Container和Connector以及相關組件構成；
Server: 整個tomcat服務器，包含多組服務，負責管理和啟動各個Service,同時監聽8005端口發過來的shutdown命令，用于關閉整個容器；
Service：tomcat封裝的、對外提供完整的、基于組件的Web服務，包含Connectors、Container兩個核心組件，各個Service之間獨立，但是共享同一個JVM資源；
Connector: tomcat與外部世界的鏈接器，監聽固定端口接收外部請求，傳遞給Container、并將Container處理結果返回給外部；
Container ：用于管理Servlet生命周期，調用servlet相關方法；
Loader：封裝了java ClassLoader,用于Container加載類文件

1.8 反射原理

1.8.1 反射原理、底層

定義：指在運行狀態中，對于任意一個類，都能夠知道這個類的所有屬性和方法，對于任意一個對象，都能夠調用他的任意一個方法，動態獲取信息，以及動態調用對象的方法叫做java的反射機制；

應用：生成動態代理，面向切面編程

常見實現方法

對象.getClass()
Class.forName(className);
類名.class;

三種實現方式之間的區別：

類加載方式不同，Class.forName()屬于動態加載類，在代碼運行時加載指定類，Class.class屬于靜態加載類在代碼編譯時加載指定；
Object.getClass()取決于對象的產生方式，即可以是靜態加載類（通過new創建的對象）也可以是動態加載類；
**Class對象創建方式不同：**Class.forName()運行階段，JVM使用類裝載器，將類裝入內存中，并對類進行初始化（靜態代碼塊、非靜態代碼塊、構造函數調用以及靜態變量）最后返回Class對象；
class,編譯階段,JVM使用類裝載器，將類裝入內存中，并對類進行初始化操作，最后返回Class的對象；對于GetClass(),沒有其他操作

1.8.2 反射應用、常見方法

獲取所有公共構造函數：getConstructors()

獲取所有的構造函數：getDeclaredConstructors()

操作方法：

使用Class獲取對應方法：getMethods(),獲取所有的公共方法，包括父類的公共方法；
getDeclaredMethods()，獲取所有本類的方法，包括本類的私有方法；
getDeclareMethod(String name,Class<?>…parameterTypes)

獲取指定方法名稱的方法，和訪問權限無關；

創建對象的方法：

構造函數創建，newInstance(Object initargs)
Class類中創建：newInstance();
注意，如果是私有的構造方法，反射默認是無法直接執行的，可以找到父類的Accessible(boolean flag)的方法，設置為true,即可忽略訪問權限;

Method執行方法

invoke(Object obj,Object…args):執行方法；

Class中獲取字段：

getFields()，獲取當前class所表示類中所有的public字段，包括繼承的字段；
getDeclaredFields()，獲取當前Class所表示類中所有的字段，不包括繼承的字段
getField(String name):
getDeclaredField(String name):獲取指定名字的字段，但是不包括繼承的字段；

JDK動態代理反射機制？

動態代理：使用Proxy類的newProxyInstance方法創建代理對象，使用InvocationHandler來實現增強的邏輯（通常是創建一個InvocationHandler接口的實現類，在其invock方法中實現增強的邏輯），利用攔截器加上反射機制生成一個實現代理接口的匿名類，在調用具體方法前調用InvokeHandler來處理；
CGLib代理：使用MethodInterceptor接口實現增強邏輯，使用Enhancer生成代理對象，利用ASM開源包，對代理對象類的class文件加載進來，通過修改其字節碼生成子類來處理；
如果目標對象實現了接口，默認情況下會采用jdk的動態代理實現AOP;
如果目標對象實現了接口，可以強制使用CGLIB實現AOP
如果目標對象沒有實現接口，必須使用CGLIB庫；并在Spring配置文件中加入<aop:aspectj-autoproxy proxy-target-class = “true”/>

1.8.3 反射相關面試題

java序列化的作用和方法？

將對象狀態轉化為字節流，以后可以通過這些值再生出相同狀態的對象，用于存儲和傳輸，可以實現數據的持久化，可以把數據永久保存到硬盤上，序列化可以實現遠程通信，轉成在網絡上傳輸的字節序列；

**方法：**java.io.ObjectOutputStream對象輸出流，他的writeObject(Object obj)可以對參數指定的obj對象進行序列化；

ObjectInputStream對象輸入流，他的readObject()方法可以從輸入流讀取字節序列，再把它們反序列化成為一個對象；

實現Serializable或者Externalizable接口，可以實現序列化；

serialVersionUID ：它決定著是否能夠反序列化成功，相當于一個版本號，在反序列化的時候會進行序列號對比；

谷歌的一些工具也可以實現序列化；

繼承中方法執行順序：

父類靜態方法>子類靜態方法>父類普通方法>父類構造方法>子類普通方法>子類構造方法

1.9 對象相關知識

靜態內部內和非靜態內部類？匿名內部類、靜態內部類、非靜態內部類初始化順序？

靜態內部類方法和變量可以是靜態的也可以是非靜態的，靜態方法可以在外層通過靜態調用，而非靜態方法必須創建類的對象才能調用；
非靜態內部類不能有靜態成員（方法、屬性）；
靜態內部類只能訪問外部類的靜態成員，無法訪問非靜態成員，非靜態可以訪問所有；
一般靜態內部類先執行

繼承中靜態方法，構造方法，普通方法執行順序問題？

抽象類與接口？

方法重載與重寫？

1.20 基本數據類型

各種數據類型占用字節數？

各種數據類型范圍？

1.21 進制轉換

1.22 計算機原理

二、JVM

2.1 JVM內存模型

內存模型

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-07gnCuuc-1618197750710)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\image-20210308094500874.png)]

**程序計數器：**一塊較小的內存空間，當前線程所執行的字節碼的行號指示器，分支、循環、異常處理、線程恢復等基礎功能都需要依賴這個計數器來完成，程序計數器是線程私有的，唯一一個沒有OOM的區域；
**java虛擬機棧：**線程私有，java方法執行的內存模型，每個方法在執行時都會創建一個棧幀（用于存儲局部變量表、操作數棧、動態鏈接、方法出口等信息），在此區域規定了2種異常情況，如果線程請求的棧深度大于虛擬機所允許的深度，將拋出stackOverflowError異常，虛擬機棧也支持動態擴展長度，但是如果不能申請到足夠內存，也會拋出outOfMeeoryError異常；
**本地方法棧：**為虛擬機使用到的Native方法服務，也會拋出stackOverflowError異常和outOfMeeoryError異常
java堆：java內存中最大的一塊，所有線程共享的一塊內存，存放對象實例，也是垃圾收集器管理的主要區域，可分為新生代、老年代，再細致一點就是Eden空間、From Survivor空間、To Survivor空間；
方法區：與java堆一樣，也是線程共享的內存區域，用于存儲已被虛擬機加載的類信息、常量、靜態變量、即時編譯器編譯后的代碼等數據，也會出現outOfMeeoryError異常；
**運行時常量池：**是方法區的一部分，用于存放編譯期生成的各種字面量和符號引用，這部分內容將在類加載后進入方法區的運行時常量池存放，當常量池無法再申請到內存會拋出OutOfMemoryError異常；
直接內存：不是虛擬機運行時數據區的一部分，也不是java虛擬機規范中定義的內存區域；

堆內存分配

新生代，存放新生的對象，一般占據堆1/3空間，新生代又分為Eden區，ServivorFrom, ServivorTo三個區
Eden區：java新生對象出生地；
ServivorFrom：上一次GC幸存者，作為這一次GC的被掃描者；
ServivorTo：保留了一次 MinorGC 過程中的幸存者；

2.2 類加載機制

2.3 垃圾回收機制、工具、算法

判斷對象是活著還是死亡算法？

引用計數算法：有引用計數加1，引用失效計數減1，任何時刻計數器為0，就表示不會再被使用，但是存在一個問題就是，很難解決對象循環互相引用的問題；
在主流實現中，大部分都是通過可達性分析來判斷對象是否存活，核心思想：通過一系列的稱為"GC Roots"的對象作為起始點，從這些節點開始向下搜索，搜索過的路徑稱為引用鏈，當一個對象到GC Roots沒有任何引用鏈相連，表示對象不可用，可作為GC Roots的對象包括：虛擬機棧中引用的對象，方法區中類靜態屬性引用的對象，方法區中常量引用的對象，本地方法棧中JNI引用的對象；

垃圾收集算法

標記-清除算法：效率不高，容易產生大量不連續的內存碎片；
**復制算法：**將內存按容量化為大小相等的2塊，每次只使用一塊，一塊用完，將這塊還活著的對象復制到另外一塊，再把使用過的一次性清除，以空間換時間；分為一塊較大的Eden空間和2塊較小的Survivor空間；
標記-整理：針對老年代的垃圾回收算法，先標記，再整理-清除；

垃圾收集器？

Serial收集器：單線程版收集器，可能會造成停頓，新生代，復制算法；
ParNew收集器：Serial收集器的多線程版，采用復制算法，用在新生代，可以通過-XX:parallelGCThreads參數來控制收集的線程數；
Parallel Scavenge收集器：使用復制算法的手機器，又是并行的收集器
Serial Old收集器：使用標記-整理算法，作用與老年代；
parallel Old收集器：多線程的標記-整理算法；
CMS收集器：以獲取最短回收停頓時間為目標的收集器，基于標記-清除算法實現，包括初始標記、并發標記、重新標記、并發清除，會產生空間碎片，作用于老年代；
G1收集器：支持并行與并發，特點：分代收集、空間整合、可預測的停頓，實現步驟：初始標記、并發標記、最終標記、篩選回收，不會產生空間碎片，可精準控制停頓，作用于新生代和老年代；
ZGC:JDK11中推送出的一款低延遲垃圾回收器，適用于大內存低延遲服務的內存管理和回收

內存分配與回收策略？

對象優先在Eden分配；
大對象直接進入老年代；
長期存活的對象將進入老年代；
動態對象年齡判定
空間分配擔保

虛擬機類加載機制？

加載：在內存中生成一個代表這個類的java.lang.class對象，作為方法區這個類的各種數據入口；
**驗證：**確保 Class 文件的字節流中包含的信息是否符合當前虛擬機的要求
**準備：**在方法區中分配這些變量所使用的內存空間；
**解析：**虛擬機將常量池中的符號引用替換為直接引用的過程；
初始化：

虛擬機類加載器？

**啟動類加載器（Bootstrap ClassLoader)：**負責將JAVA_HOME/lib目錄中，或者被-Xbootclasspath參數所指引的路徑中，并且是虛擬機識別的類庫加載到虛擬機內存中，不能直接引用，需要委派給引導類加載器；
**拓展類加載器（Extension ClassLoader)😗*可直接使用擴展類加載器；
**應用程序類加載器（Application ClassLoader)😗*又稱系統類加載器，也是程序中默認的類加載器

常用工具：

命令行終端：標準終端類：jps、jinfo、jstat、jstack、jmap,功能整合類：jcmd、vjtools、arthas、greys
可視化界面：Jconsole、Jvisualvm、HA、GCHisto、GCViewer、MAT、JProfiler

雙親委派？

防止內存中出現多份同樣的字節碼，打破雙親委派需要繼承ClassLoader類，還要重寫loadClass和findClass方法

各命令詳解

JPS:虛擬機進程狀態工具

-L:輸出Java應用程序的main class完整包；

-q 僅顯示pid ,不顯示其他任何信息；

-m 輸出傳遞給main方法的參數；

-v 輸出傳遞給JVM的參數；
jstat: 虛擬機統計信息監視工具，可用來查看堆信息、垃圾回收信息等；
jinfo:java 配置信息工具

jinfo -flag 打印指定JVM的參數值

jinfo -flag [+/-] 設置指定JVM參數布爾值

jinfo -flag =設置指定JVM參數的值
jmap:java內存映像工具；

jmap -head pid查看進程堆內存使用情況；

jmap -histo[:live] pid 查看堆內存中的對象數目，大小統計直方圖；

jmap -dump:將當前程序堆快照導出到文件中
jstack:用來查看java應用程序堆棧信息

jstack -l 查看進程中線程狀態、檢查死鎖等；

JVM配置參數詳解

堆大小設置（-Xms -Xmx -Xmn -Xss):堆大小有三方面限制，操作系統的數據模型（32-bt還是64-bit)限制，系統可用虛擬內存限制，系統可用物理內幕才能限制，32位一般可設置為1.5G~2G，64位無限制；

-Xmx:jvm最大可用內存；

-Xms:JVM初始內存，可以設置為與-Xmx一樣，避免每次垃圾回收完后JVM重新分配內存；

-Xmn:設置年輕代內存大小，占整個堆大小的3/8;

-Xss: 設置每個線程的堆棧大小：經驗值3000k-5000k左右；
垃圾回收器設置（-XX)：

-Xmx300m

-Xms300m

-Xmn100m

-XX:SurvivorRatio=8

-XX:+UseG1GC

-XX:MaxTenuringThreshold=14

-XX:ParallelGCThreads=8

-XX:ConcGCThreads=8

-XX:+DisableExplicitGC

-XX:+HeapDumpOnOutOfMemoryError

-XX:HeapDumpPath=d:/a.dump

-XX:+PrintGCDetails

-XX:+PrintGCTimeStamps

-XX:+PrintHeapAtGC

-XX:+TraceClassLoading

-XX:+PrintClassHistogram

一次完整GC流程？

答：一般先描述堆的構成。

java堆 = 老年代 +新生代（1:2）
新生代 = Eden +survivor space S0 +survivor space S1（8:1:1）;
當Eden區填滿了，java虛擬機會觸發一次Minor GC，以收集新生代的垃圾，存活的對象進入survivor區；
大對象直接進入老年代
如果對象在Eden出生，并經過一次Minor GC后任然存活，并且被S0容納，年齡設為1，每熬過一次Minor GC，年齡加1，若年齡超過一定限制（默認15，通過-XX:+MaxTenuringThreshold設置），則被晉升到老年代；
老年代滿了無法容納更多對象，Minor GC之后通常就會進行FUll GC（包括年輕代喝老年代）；
Major GC發生在老年代，通常會伴隨著至少一次Minor GC,比Minor GC慢10倍

2.4 JVM調優方法

2.5 JVM 常見指令以及在服務器中的配置

2.6 JVM常見問題排查（內存溢出、內存不足、死鎖等）

JDK1.7及以前，java類信息、常量池、靜態變量都存在永久代里，類的元數據和靜態變量在類加載的時候分配給永久代，當類被卸載的時候垃圾收集器從永久代處理掉；
JDK1.8對JVM架構進行了改造，去掉了方法區，換成了元空間，常量池，靜態變量放到java堆里面，最明顯的變化是元空間從虛擬機轉移到本地內存

2.7 學習相關連接

https://blog.csdn.net/qq_41701956/article/details/100074023
https://blog.csdn.net/cy973071263/article/details/104318355
GC問題：https://tech.meituan.com/2020/11/12/java-9-cms-gc.html
Springboot堆外內存泄露問題：https://tech.meituan.com/2019/01/03/spring-boot-native-memory-leak.html；
新一代垃圾回收器ZGC:https://tech.meituan.com/2020/08/06/new-zgc-practice-in-meituan.html；
JVM性能調優監控工具JPS、jstack、jmap、jhat、jstat、hprof使用；

2.8 JVM堆外內存

定義：把內存對象分配在java虛擬機堆以外的內存，直接受操作系統管理（而不是虛擬機），能夠一定程度上減少垃圾回收對應用程序造成的影響；

java中分配堆外內存有2種方式：

a. 通過ByteBuffer.java#allocateDirect得到一個DirectByteBuffer對象；

b. 直接調用unsafe.java#allocateMemory分配內存

JVM的方法區屬于非堆內存

2.9 JVM相關面試題

什么情況下會發生棧溢出？

答：棧是線程私有的，生命周期與線程相同，用來存儲局部變量表，操作數棧，動態鏈接，方法出口等信息，如果線程請求的棧深度大于虛擬機所允許的最大深度，將拋出StackOverFlowError異常，方法遞歸調用可能產生這種異常，新建線程沒有足夠內存的時候，可以拋出outOfMemory異常，通過-Xss去調整JVM棧大小；

幾種垃圾回收器？

答：Serial收集器：單線程的收集器，收集垃圾時，必須stop the world，使用復制算法。
ParNew收集器： Serial收集器的多線程版本，也需要stop the world，復制算法。
Parallel Scavenge收集器： 新生代收集器，復制算法的收集器，并發的多線程收集器，目標是達到一個可控的吞吐量。如果虛擬機總共運行100分鐘，其中垃圾花掉1分鐘，吞吐量就是99%。
Serial Old收集器：是Serial收集器的老年代版本，單線程收集器，使用標記整理算法。
Parallel Old收集器：是Parallel Scavenge收集器的老年代版本，使用多線程，標記-整理算法。
CMS(Concurrent Mark Sweep) 收集器：是一種以獲得最短回收停頓時間為目標的收集器，標記清除算法，運作過程：初始標記，并發標記，重新標記，并發清除，收集結束會產生大量空間碎片。
G1收集器： 標記整理算法實現，運作流程主要包括以下：初始標記，并發標記，最終標記，篩選標記。不會產生空間碎片，可以精確地控制停頓。
CMS是老年代收集器，可以配合新生代的Serial和ParNew 收集器一起使用；

G1收集器是老年代和新生代；

CMS以最小停頓為目標的收集器；

G1收集器可預測垃圾回收的停頓時間；

CMS標記-清除，容易產生內存碎片；但是CMS可以配置參數進行內存整理，將碎片化的空間整理成一片連續的空間，也可配置碎片整理的Full GC次數；

G1 標記-整理，進行空間整合，降低內存空間碎片化

new對象時發生了什么？

先去檢查這個指令的參數是否能在常量池中定位到一個類的符號引用并檢查這個符號引用所代表的類是否已經被加載、解析和初始化過，如果沒有就執行類的加載過程；
類加載檢查通過，可以為新生對象分配內存（兩種方式"指針碰撞"，一種"空閑列表"），再將分配到的內存空間都初始化為零值，
對對象頭進行設置，包括這個對象屬于哪個類的實例，對象哈希碼，對象的GC分代年齡等信息；
接著執行init方法，進行初始化
String str = new String（“hello”）:str放在棧中，用new創建出來的字符串對象放在堆上，而"hello"這個字面量則放在方法區；

JVM內存模型、重排序、內存屏障、happen-before?

JVM內存分為主內存，工作內存；
指令重排序:指令的執行不一定需要按順序，有時候可以打亂順序；
內存屏障：用于控制特定條件下的重排序和內存可見性問題，分為以下幾種：

LoadLoad屏障；讀屏障；

StoreStore屏障：寫屏障；

LoadStore屏障：先讀后寫；

StoreLoad屏障：先寫后讀；

JVM類加載器？

定義：根據指定全限定名稱將class文件加載到JVM內存，轉為Class對象；

分為：啟動類加載器，擴展類加載器，應用程序類加載器，自定義類加載器；

使用雙親委派的好處：防止內存中出現多份同樣的字節碼；

打破雙親委派：要繼承ClassLoader類，還要重寫LoadClass和findClass

JVM線上調優？

通過top指令發現一個java線程cpu和內存使用率比較高；
jinfo pid 查看當前進程詳情（配置信息）；
查看GC情況：jstat -gccause pid，可以查看新生代YGC（gc次數）,YGCT（gc時間），老年代gc(FGC，FGCT),如果是新生代頻繁GC,可能是新生代設置太小；
此時可以查看當前內存分配：jmap -heap pid；
查看gc后的JVM詳情信息：jstat -gc pid 1000,1000表示查看1000行日志
如果手動Full gc發現內存并沒有被釋放，說明當前系統可能存在內存泄露，導致對象不能被清理釋放，可以查看當前系統線程詳細情況：jstack pid | head -50
查看jvm開啟的線程數：jstack pid | wc -l;
再查看當前服務器對不同IP建立的鏈接數，并通過分析鏈接最多的ip,找到問題所在

JVM參數配置？

配置堆棧大小：-Xmx -Xms -Xmn -Xss;
配置持久代大小：-XX:MaxPermSize，年輕代與年老代比值：-XX:NewRatio=4設置年輕代中Eden和Survivor區大小比值：-XX:SurvivorRatio=4
配置垃圾最大年齡：XX:MaxTenuringThreshold
配置垃圾收集器：-XX:+UseParallelGC： 選擇垃圾收集器為并行收集器，-XX:ParallelGCThreads=20： 配置并行收集器的線程數，-XX:+UseConcMarkSweepGC： 設置年老代為并發收集，-XX:CMSFullGCsBeforeCompaction：由于并發收集器不對內存空間進行壓縮、整理，所以運行一段時間以后會產生“碎片”，使得運行效率降低。此值設置運行多少次GC以后對內存空間進行壓縮、整理
輔助類信息相關：-XX:+PrintGC 輸出形式，-XX:+PrintGCDetails 輸出形式

java 對象頭結構？

java對象有三部分組成，對象頭、實例數據、對其填充；
對象頭有兩部分組成：第一部分是存儲對象自身運行時數據，哈希碼，GC分代年齡、鎖標識狀態、線程持有的鎖、偏向線程ID,第二部分是指針類型，指向對象的類元數據類型

JVM內存分配？

寄存器：jvm內部虛擬寄存器，存取速度非常快，程序不可控制
棧：保存局部變量，操作數棧，動態鏈接，方法出口，指針，基本數據類型的值；
堆：動態產生的數據，比如new 的對象
常量池：直接常量，符號引用，常量池存于堆中；
代碼段：從硬盤上讀取的源程序代碼；
數據段：用來存放static定義的靜態成員；

java堆內存結構？

新生代、老年代、永久代；

三、網絡編程

3.1 http原理以及三次握手

3.2 常用IP/TCP協議

3.3 網頁請求方式，請求頭，請求體

3.4 常見的java方法

3.5 常見面試題

四、數據庫技術

4.1 基本操作

4.2 索引

索引類型有哪些？

索引底層原理

B樹，B+樹區別

https://blog.csdn.net/a519640026/article/details/106940115/

4.3 引擎

Mysql 引擎mylsam 和innodb的區別？

Mylsam存儲引擎，基于傳統的ISAMl類型，支持全文檢索，但不是事務安全的，不支持外鍵，每張Mylsam表存放在三個文件中：frim文件存放表格定義，數據文件是MYD(MyData),索引文件是MYI(MyIndex)

InnoDB是事務型引擎，支持回滾，崩潰恢復能力，多版本并發控制、ACID事務，支持行級鎖定，也可以支持鎖全表，表和索引在同一個表空間

兩者核心區別：

Mylsam是非事務安全的，而InnoDB是事務安全的；

Mylsam鎖的粒度是表級，而InnoDB支持行級鎖定；

Mylsam支持全文類型索引，而InnoDB不支持全文索引；

Mylsam 小型應用效率要優于InnoDB；

應用上的區別：

Mylsam：以讀操作和寫操作為主，很少的更新和刪除

InnoDB：用于事務處理，支持外鍵，支持數據一致性；

Memory:能提供極快的訪問，但是對表的大小有限制，太大的表無法緩存到內存中

merge:高寫性能和高壓縮率；

TokuDB，高效的插入性能，優秀的壓縮特性

4.4 事務

4.5 鎖

4.6 常用函數

數字函數

ABS(x):返回x的絕對值；
MOD(N,M):返回N被M除的余數；
Floor(x):返回不大于x的最大整數值；
ceiling(x):返回不小于x的最小整數值；
round(x):返回參數x的四舍五入的一個整數；

字符串函數

Ascll(str):返回字符串最左邊ASCLL值；
Concat(str1,str2):返回兩個字符串拼接結果，可以有多個參數，有一個參數為null則返回null;
instr(str,substr):返回子串substr在字符串str中的第一個出現的位置;

日期函數

DATE_ADD(date,INTERVAL expr type) ,進行日期增加的操作，可以精確到秒；
DATE_SUB(date,INTERVAL expr type) ，進行日期減少的操作，可以精確到秒；
CURRENT_DATE:以‘YYYY-MM-DD’或YYYYMMDD格式返回今天日期值；
CURRENT_TIME:以‘HH:MM:SS’或HHMMSS格式返回當前時間值；

4.7 復雜查詢

4.8 分庫分表以及分庫分表帶來的數據一致性問題解決

? 水平分庫分表：每個表、庫結構一樣，每個表、庫數據不一樣，所有表、庫并集是全量數據；

? 垂直分庫分表：每個庫、表結構不一樣，數據也不一樣，所有表、庫并集是全量數據；

? **工具：**TDDL、Mycat,tddl是jar包，Mycat是中間件；

? 優秀文檔：分庫分表：

? https://blog.csdn.net/qq_17231297/article/details/108526004

4.9 優化以及執行計劃

字段層面上

盡量使用Tinyint、smallint、Medium_int代替int;

varchar長度只分配真正需要的空間；

使用枚舉或者整數代替字符串類型；

盡量使用timestamp而非DateTime;

單表字段不要太多；

避免使用null;

用整型來存IP;

開啟查詢緩存；

sql書寫層面

在mysql 5.0之前版本盡量避免使用or,可以用union或者子查詢代替，早期版本or會導致索引時失效，在之后的版本引入了索引合并，就不會導致索引失效的問題；
避免在where中使用！=或者<>操作符，會導致索引失效；
適當使用前綴索引,定義字符串的一部分作為索引，減少空間占用；
避免Select*
盡量使用連接查詢代替子查詢，子查詢會新創建臨時表，join不會建立臨時表；
先查小表后大表
不要再列字段上進行算術運算或者其他表達式運算；
適當增加冗余字段；
where條件中盡量避免字段類型轉換；
盡量使用union all 代替union,union會涉及排序，增大CPU運算；
盡量少排序order by;
需要查詢一條數據使用limit 1；
避免where中對null進行判斷；
不建議使用%前綴模糊查詢，如果使用建議使用全文索引；
遵守最左前綴

查詢計劃參數

id：選擇標識符，id越大優先級越高，就越先被執行；

select_type:查詢類型

table：輸出結果集的表

partitions:匹配的分區

type:表的連接類型，取值有：

all :掃描全表數據；
index：遍歷索引；
range: 索引范圍查找
index_subquery：在子查詢中使用ref
unique_subquery:在子查詢中使用eq_ref;
ref_or_null:對null進行索引的優化的ref;
fulltext:使用全文索引；
ref:使用非唯一索引查找數據；
eq_ref:在join查詢中使用主鍵或者唯一索引關聯；

possible_keys:在查詢時，可能使用的索引；

key:實際使用的索引；

key_len:索引字段的長度；

ref:列與索引的比較；

rows:大概估算的行數；

filtered：按表條件過濾的行百分比

Extra：執行情況的描述和說明

數據庫結構優化

最小數據長度，比如身份證，可以設置為char(18)，不要設置成varchar(18);

使用最簡單數據類型；

盡量少定義text類型

選擇合適的存儲引擎；

分庫分表，讀寫分離；

系統硬件優化

磁盤優化，固態硬盤，多個小磁盤代替一個大磁盤；

網絡方面優化；

內存優化，內存越大，存儲和緩存的信息也就越多；

優化慢查詢；

4.10 相關面試題

鎖的類型有哪些？

共享鎖、排它鎖，共享鎖也叫讀鎖，可以通過lock in share mode實現，只能讀不能寫，寫鎖是排它鎖，他會阻塞其他的寫鎖和讀鎖，從顆粒度上來分，又可以分為表鎖和行鎖兩種；

行鎖又可以分為樂觀鎖和悲觀鎖，樂觀鎖通過版本號實現，悲觀鎖通過for update實現

事務基本特性和隔離級別？

基本特性：

原子性：要么全部成功，要么全部失敗，可以由undo log日志保證；

**一致性：**總是從一個一致性狀態轉換為另外一個一致性狀態，代碼層面來保證；

**隔離性：**一個事務的修改在提交前對其他事物是不可見的，由MVCC保證；

持久性：事務一旦提交，所有的修改就會永久保存，由內存和redo log保證；

隔離級別：

**讀未提交：**可能讀到其他事物未提交的數據，也叫臟讀；

讀已提交： 兩次讀取結果不一致，也叫不可重復讀；

**可重復讀：**mysql默認級別，每次讀取結果一樣，但是有可能產生幻讀；

**串行：**給每一行讀取的數據加鎖，會導致大量超時和鎖競爭問題；

MVVC:多版本并發控制，保存數據在某個時間節點的快照；查找創建版本小于或者等于當前事務版本，刪除版本為空或者大于當前事務版本；

分表后如何保證ID唯一性？

設定步長；

分部式ID,自己實現或者基于雪花算法；

分表后不使用主鍵作為查詢依據；

mysql主從同步？

原理：

master提交事務后，寫入binlog;

slave連接到master,或者binlog;

master創建dump線程，推送binglog到slave

slave啟動一個IO線程讀取同步過來的master的binglog日志，記錄到relay log中；

slave 再開啟一個sql線程讀取relay log事件并在slave執行，完成同步；

slave 記錄自己的binglog;

引申出“全同步復制”，半同步復制（ACK確認機制）

MySQL B Tree索引和Hash索引的區別?

B+樹是一個平衡二叉樹，從根節點到每個葉子節點高度差值不超過1，而且同層級的節點有指針相互鏈接，基于索引的順序掃描時可以利用雙向指針快速左右移動，效率很高；因此被廣泛應用于數據庫，文件系統；

哈希索引：采用哈希算法，把鍵值換算成新的哈希值，不需要逐級查找，一次哈希就可以定位，速度很快；

等值查詢時，哈希索引有絕對優勢；

如果是范圍查詢檢索，最好使用B+索引，所以哈希不適合用于排序，以及 like ’xxx%‘這樣的部分模糊查詢；

哈希索引不支持多列聯合索引的最左匹配原則；

如果有大量重復值，也不適合用哈希，因為存在哈希碰撞；

數據庫范式？

第一范式：確保每列保持原子性；

第二范式：確保表中的每列都和主鍵相關；

第三范式：確保每列都和主鍵列直接相關，而不能間接相關；

數據庫崩潰時事務恢復機制？

Undo log：實現事務的原子性，也可以實現多版本并發控制，數據提交前先寫入磁盤，會導致大量磁盤IO,性能低；

Redo Log: 記錄的是新數據備份

分庫分表主鍵問題

UUID：業務無關性

雪花算法：由64位bit二進制數組組成，分為4大部分：

1位默認不使用
41位時間戳
10位機器ID
12位序列號

4.11 拓展工具

mysql 數據庫壓測工具

sysbench：壓測數據庫和壓測系統資源，

fio:測試linux磁盤IO性能

tpcc-mysql：比較全面會統計出系統的資源情況

**性能匹配指標：**TPS（讀），QPS(每秒可處理事務數)，RT，穩定性，CPU ,IO,內存，網絡

mysql 分庫分表工具

Shareding-sphere:是一個jar包

TDDL: jar包

Mycat：中間件

mysql 數據同步工具

DBSync

非侵入式，獨立運行
支持異構數據庫同步
支持增量同步
支持二進制字段
先比較再同步
無人值守同步
支持各種數據庫
支持跨平臺以及異地同步
支持雙向同步
支持同步后處理
秒級實時同步

SyncNavigator:

試用于mysql,SQL Server
自動/定時同步數據
無人值守
故障自動恢復
同構/異構數據庫同步
斷點續傳和增量同步

sql比較

sql增量

mysql 性能監控工具

Prometheus:

Grafana:

五、Spring框架

5.1 Spring原理解析

5.2 認識bean

5.3 IOC、AOP、DI原理

5.4 設計模式

5.5 相關源碼解析

5.6 注解

5.7 相關面試題

什么是Spring、原理、結構、作用？

開源應用框架，輕量級，松耦合的容器框架；

能夠簡化應用程序開發，提供IOC容器，根據需要生成對象并處理對象之間的依賴關系，管理對象的生命周期；

提供面向切面編程（AOP)思想，降低代碼耦合，給應用程序動態添加一些功能，完善業務邏輯；

提供事務管理（主要是聲明式事務），提高開發效率和質量；

也是一種粘合劑，除了自己提供的data（數據處理）,web應用程序，AOP,Beans，Core，Context，test等模塊，還能粘合springMVC,mybatis等框架進行聯合開發；

Spring應用上下文？

框架本身提供了很多容器實現，大概分為2種，一種是不常見的BeanFactory,最簡單的容器，提供基本的DI功能，另外一種就是集成了BeanFactory后派生而來的引應用上下文，抽象接口就是ApplicationContext

AnnotationConfigApplicationContext:從一個或多個基于java的配置類中加載上下文定義，適用于java注解的方式;
ClassPathXmlApplicationContext:從類路徑下的一個或多個xml配置文件中加載上下文定義，適用于xml配置的方式；
FileSystemXmlApplicationContext:從文件系統下的一個或多個xml配置文件中加載上下文定義，也就是說系統盤符中加載;
AnnotationConfigWebApplicationContext:專門為web應用準備的，適用于注解方式；
XmlWebApplicationContext:從web應用下的一個或多個xml配置文件加載上下文定義，適用于xml配置方式;

系統默認的是XmlWebApplicationContext；

在java項目中，會通過ClassPathXmlApplicationContext來實例化ApplicationContext容器，而在Web項目中是通過Web服務器來完成；

? WebApplicationContext擴展了ApplicationContext，它允許從相對于Web根目錄的路徑中裝載配置文件完成初始化工作。從WebApplicationContext中可以獲得ServletContext的引用，整個Web應用上下文對象將作為屬性放置到ServletContext`中，以便Web應用環境可以訪問Spring應用上下文；

在非Web應用中，bean只有singleton和prototype兩種作用域，WebApplicationContext為bean添加了三個新的作用域：request、session、global session;

BeanFactory 和ApplicationContext 區別；

bean集合的工廠類，包含各種bean定義，以便在接收到客戶端請求時將對應的bean實例化；
beanFactory包含了bean生命周期的控制，調用客戶端的初始化和銷毀方法；
ApplicationContext 在此基礎上還提供了以下功能：

支持國際化消息；

統一資源文件讀取方式；

監聽接口可以監聽容器事件，并對事件進行響應處理；

**LifeCycle：**該接口是Spring 2.0 加入的，該接口提供了start()和stop()兩個方法，主要用于控制異步處理過程；

ConfigurableApplicationContext 擴展于ApplicationContext，它新增加了兩個主要的方法：refresh()和close()，讓ApplicationContext 具有啟動、刷新和關閉應用上下文的能力；

什么是bean?

bean的本質是java中的類，spring中的bean實際就是對實體類的引用，來產生java類對象，從而實現生產和管理bean;
bean工廠是spring最核心的接口，提供高級IOC配置機制;
bean提供三種實例化方式：構造器實例化，靜態工廠方式實例化、實例工廠方式實力化；

IOC實現方式？實現機制？

（1）基于XML文件的顯示裝配：

構造方法注入（需要含有有參構造器）；
set方法注入（需要含有無參構造器）；

? 此方法裝配可能導致XML文件過于臃腫，不好管理；

（2）基于注解（Annotation)的隱式裝配：此時需要使用context:annotation-config/在配置文件中開啟相應的注解器；

（3）接口注入：具備侵入性，實際體驗并不好；

實現機制：工廠模式加反射機制

bean 的作用域？

singleton: 單例作用域，在IOC容器中僅存在一個Bean實例；

prototype：每次從容器中調用Bean時，都返回一個新的實例；適用于有狀態的bean

request: 每次Http請求都會創建一個新的Bean,該作用域僅適用于web的 Spring WebApplicationContext環境;

session: 同一個http Session共享一個Bean,不同的Session使用不同的Bean,該作用域僅適用于web的 Spring WebApplicationContext環境;

application: 限定一個Bean的作用域為ServletContext的生命周期。該作用域僅適用于web的Spring WebApplicationContext環境

Spring幾種配置方式？

基于Xml配置；

基于注解配置；

基于java API實現：通過@Bean 和@Configuration來實現

bean的生命周期？

實例化—>屬性賦值–>初始化—>銷毀（容器關閉）

createBeanInstance()->實例化

populateBean()->屬性賦值

initializBean()->初始化

spring bean自動裝配？

no:默認設置，表示沒有自動裝配，應使用顯式 bean 引用進行裝配；
byName - 它根據 bean 的名稱注入對象依賴項。它匹配并裝配其屬性與 XML 文件中由相同名稱定義的 bean；
byType - 它根據類型注入對象依賴項。如果屬性的類型與 XML 文件中的一個 bean 名稱匹配，則匹配并裝配屬性；
構造函數 - 它通過調用類的構造函數來注入依賴項。它有大量的參數。
autodetect - 首先容器嘗試通過構造函數使用 autowire 裝配，如果不能，則嘗試通過 byType 自動裝配；

spring 設計模式？

spring事務傳播？

事務類別：

有事務就用已有的，沒有就重新開啟一個；

有就用已有的，沒有也不重新開啟；

必須有事務，沒有拋異常；

開啟新事物，若當前已有事務，掛起當前事務；

不需要事務，當前已有則掛起；

不需要事務，當前已有則拋異常；

嵌套事務；

事務實現方式：

基于TransactionProxyFactoryBean聲明式事務管理；

基于@Transactional 的聲明式事務管理；

基于Aspectj AOP配置事務；

編程式事務：

使用TransactionTemplate 事務模板對象，
直接使用PlatformTransactionManager配置事務管理器;

聲明式事務：

定義事務管理器；
配置事務屬性；

spring核心類有哪些？

DefaultListableBeanFactory：整個bean加載的核心部分，是spring注冊以及加載bean的默認實現，繼承自AbstractAutowireCapableBeanFactory ；
XmlBeanFactory繼承自DefaultListableBeanFactory，對其進行了擴展，增加了XmlBeanDefinitionReader類型的reader屬性，在XmlBeanFactory中主要使用reader屬性對資源文件進行讀取和注冊；
XmlBeanDefinitionReader：資源文件讀取，解析以及注冊

AutoWired注解和Resource注解區別？

Resource作用相當于AutoWired，前者按byName注入，后者按byType注入；
Resource可以指定byName和byType;
AutoWired默認情況下要求依賴對象必須存在，如果允許null,可以設置required屬性為false,指定名稱可以和@Qualifier注解組合使用；
Resource屬于J2EE提供，需要JDK1.6以上，而AutoWired屬于spring提供；

六、SpringMVC框架

6.1 原理

6.2 請求流程

客戶端發起http請求被DispatcherServlet 捕獲；

DispatcherServlet 根據 -servlet.xml 中的配置對請求的 URL 進行解析，得到請求資源標識符（URI）。然后根據該 URI，調用 HandlerMapping 獲得該 Handler 配置的所有相關的對象（包括 Handler 對象以及 Handler 對象對應的攔截器），最后以HandlerExecutionChain 對象的形式返回；

DispatcherServlet 根據獲得的Handler，選擇一個合適的適配處理器 HandlerAdapter；

提取Request中的模型數據，填充Handler入參，執行controller,經過數據轉換，數據根式化，數據驗證;

Handler(Controller)執行完成后，向 DispatcherServlet 返回一個 ModelAndView 對象；

根據返回的ModelAndView，選擇一個適合的 ViewResolver（必須是已經注冊到 Spring 容器中的ViewResolver)返回給DispatcherServlet；

ViewResolver 結合Model和View，來渲染視圖,視圖負責將渲染結果返回給客戶端。

6.3 常見配置

6.4 相關面試題

七、Mybatis框架

7.1 理論基礎

每一個Mybatis應用程序入口都是：SqlSessionFactoryBuilder,作用是通過XML配置文件創建Configuration對象，然后通過build方法創建SqlSessionFactory對象；

SqlSessionFactory:實例中心，創建SqlSession會話；

SqlSession:Mybatis工作頂層API,表示和數據庫交互的對話，完成必要的數據庫增刪改查功能，SqlSession通過調用api的Statement ID找到對應的MappedStatement對象；

SqlSession是一個接口，默認使用DefaultSqlSession,他有2個必須配置的屬性：Configuration和Executor、SQLSession通過內部存放的執行器對數據進行CRUD;

Executor:Mybatis執行器，是Mybatis調度核心，在創建COnfiguration對象的時候創建，并且緩存在Configuration 對象里，負責sql語句的生成，調用StatementHandler訪問數據庫，查詢緩存的維護，解析MappedStatement對象，sql參數轉化，動態sql拼接，生成jdbc Statement對象，執行器有2個實現類，BaseExecutor(有三個繼承類，分被是BatchExecutor:重用語句并執行批量更新，ReuseExecutor:重用預處理語句prepared statements,SimpleExecutor：普通執行器)；

StatementHandler:封裝了JDBC Statement操作，負責對JDBCstatement的操作，如設置參數、將Statement結果集轉換成List集合，是真正訪問數據庫的地方，并調用ResultSetHandler處理查詢結果;

ResultSetHandler :負責將用戶傳遞的參數轉換成JDBC Statement 所需要的參數;

MappedStatement :用來存放我們SQL映射文件中的信息包括sql語句，輸入參數，輸出參數等等。一個SQL節點對應一個MappedStatement對象;

SqlSource:負責根據用戶傳遞的parameterObject，動態地生成SQL語句，將信息封裝到BoundSql對象中，并返回;

7.2 執行流程

7.3 常見面試題

Mybatis 一級緩存、二級緩存？

一級緩存: 基于 PerpetualCache 的 HashMap 本地緩存，其存儲作用域為 Session，當 Session flush 或 close 之后，該 Session 中的所有 Cache 就將清空，默認打開一級緩存；
二級緩存與一級緩存其機制相同，默認也是采用 PerpetualCache，HashMap 存儲，不同在于其存儲作用域為 Mapper(Namespace)，并且可自定義存儲源，如 Ehcache。
默認不打開二級緩存，要開啟二級緩存，使用二級緩存屬性類需要實現Serializable序列化接口(可用來保存對象的狀態),可在它的映射文件中配置；

7.4 Mybatis Plus

7.5 常見優化工具

美團技術沙龍：https://tech.meituan.com/2020/06/18/inf-bom-mybatis.html

八、SpringBoot

8.1 原理解析

啟動流程？

? 模塊劃分：

第一部分，運行SpringApplication的初始化模塊，配置基本的環境變量、資源、構造器、監聽器；
第二部分，實現應用具體的氣動方案，包括啟動流程的監聽模塊，加載配置模塊，以及核心的創建上下文環境模塊；
第三部分，自動化配置模塊；

? 啟動流程：

main方法是入口，通過SpringApplication.run()啟動；
SpringBootApplication注解包含三個注解，分別是：

@EnableAutoConfiguration:SpringBoot根據應用所聲明的依賴來對Spring框架進行自動配置;

@SpringBootConfiguration(內部為@Configuration)：被標注的類等于在spring的XML配置文件中(applicationContext.xml)，裝配所有bean事務，提供了一個spring的上下文環境;

@ComponentScan：組件掃描，可自動發現和裝配Bean，默認掃描SpringApplication的run方法里的Booter.class所在的包路徑下文件：組件掃描，可自動發現和裝配Bean，默認掃描SpringApplication的run方法里的Booter.class所在的包路徑下文件
run()方法內部先調用一個initialize(sources)方法；
創建應用的監聽器SpringApplicationRunListeners并開始監聽，
加載SpringBoot配置環境（ConfigurableEnvironment),如果通過Web容器發布，會加載StandardEnvironment;
將配置環境加入到監聽器對象中；
創建run方法的返回對象ConfigurableApplicationContext(應用配置上下文)，會先先獲取顯示設置的應用上下文，如果不存在，在加載默認環境配置，默認使用AnnotationConfigApplicationContext注解上下文，最后通過BeanUtis實例化上下文對象；

調用初始化refreshContext(context)方法，加載Spring.factories,主要用到SpringFactoriesLoader;

@EnableAutoConfiguration自動配置就變成了：從classpath中搜尋所有的META-INF/spring.factories配置文件，并將其中org.springframework.boot.autoconfigure.EnableutoConfiguration對應的配置項通過反射（Java Refletion）實例化為對應的標注了@Configuration的JavaConfig形式的IoC容器配置類，然后匯總為一個并加載到IoC容器;

優秀連接：https://blog.csdn.net/zlc3323/article/details/100137222?utm_medium=distribute.pc_relevant.none-task-blog-BlogCfData-1.baidujs&dist_request_id=&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCfData-1.baidujs

8.2 與Spring相比優勢

8.3 微服務核心思想

8.4 拓展框架

8.5 springboot相關面試題

九、SpringClould

9.1 springCloud原理

9.2 springcloud各類微服務模塊原理以及作用

服務注冊與發現（Eureka、consul、Nacos、zookeeper)

**概念：**服務治理模塊，實現服務治理與發現，分為服務端與客戶端，服務端用作注冊中心，支持集群部署，客戶端用來處理服務注冊與發現；

原理：

Eureka Server注冊表直接基于純內存，在內存里維護了一個數據結構，基于CocurrentHashMap;

服務注冊，服務下線，服務故障，全部在內存里維護和更新注冊表；

Eureka Server端采用多級緩存機制，避免同時讀寫內存數據結構造成并發沖突問題，進一步提升服務請求的響應速度；

在拉取注冊表的時候：先從ReadOnlyCacheMap里查緩存的注冊表

若沒有，就找ReadWriteCacheMap里的緩存注冊表，如果還沒有就在內存中獲取實際的注冊表數據；

**注冊表發生變更時：**在內存中更新變更的注冊表，同時過期掉ReadWriteCacheMap,不會影響ReadOnlyCacheMap,當發現ReadWriteCacheMap被清空，也會清空ReadOnlyCacheMap；

eureka自我保護：如果在15分鐘內超過15%的客戶端節點都沒有正常的心跳，那么Eureka就認為客戶端與注冊中心出現網絡故障，Eureka Server自動進入自我保護機制，會有三種情況：

Eureka Server不再從注冊列表中移除因為長時間沒收到心跳而應該過期的服務。
Eureka Server仍然能夠接受新服務的注冊和查詢請求，但是不會被同步到其它節點上，保證當前節點依然可用。
當網絡穩定時，當前Eureka Server新的注冊信息會被同步到其它節點中；
可通過配置 eureka.server.enable-self-preservation 來true打開/false禁用自我保護機制，默認打開狀態，建議生產環境打開此配置；
也可以修改減短服務心跳的時間：lease-expiration-duration-in-seconds: 默認90秒，lease-renewal-interval-in-seconds: 默認30秒；

eureka集群：各節點之間相互注冊，保證AP;

eureka配置詳解

eureka客戶端：配置@EnableEurekaServer注解
eureka服務端：@EnableEurekaClientz注解能實現但是只支持eureka作為注冊中心，@EnableDiscoveryClient可以是其他注冊中心；

eureka負載均衡策略：

在RestTemplate配置方法上添加@LoadBalanced注解

服務調用(rest、RPC、GRPC，SOAP)

RPC:遠程過程調用，用于解決協議約定、網絡傳輸、服務發現三個問題

RPCRuntime負責最底層的網絡傳輸；Stub處理客戶端和服務端約定好的語法語義的封裝和解封裝；用戶服務器這層負責處理業務邏輯；

**SOAP:**基于文本xml的一種應用協議；

協議約定使用WSDL(web服務描述語言)，面向對象；

基于HTTP進行傳輸；

服務發現使用UDDI(統一描述發現集成)

**gRPC:**二進制RPC框架，使用netty Channel進行數據傳輸，壓縮性高，速度快，基于HTTP2.0流傳輸，支持多語言；

REST:一種架構風格，通過http協議實現；

服務熔斷（Hystrix)

Hystrix是一個通過添加超時容錯和失敗容錯邏輯來幫助程序控制這些分布式系統的交互，通過隔離服務之間的訪問，阻止他們之間的級聯故障以及提供后背選項來實現這些；

作用：

通過第三方的調用，給與保護和控制延遲和失敗；
在復雜的分布式系統中復制級聯失敗；
快速失敗和修復；
可能情況下，回滾優雅失敗；
實時監控，報警和操作控制；

隔離方式：

線程隔離
信號量隔離
請求合并
請求緩存
儀表盤

使用：

增加服務熔斷機制@HystrixCommand；
主啟動類添加注解@EnableCircuitBreaker

負載均衡(Ribbon Nginx)

基于http和TCP的客戶端的負載均衡工具

將微服務之間的rest請求轉為客戶端的負載均衡的RPC調用；

默認策略是輪詢，但是不止一種；

工作原理：

微服務之間通過Feign調用，最后通過loadBalancerFeignClient發送請求；
loadBalancerFeignClient端從client端服務上的上下文環境中找到負載均衡器，并把提取到的服務名稱交給負載均衡器；
負載均衡器選擇server實例，將client端的請求包裝成調用請求loadBalancerCommand;
根據封裝的信息，發送遠程調用到具體的服務實例；
核心是LoadBalancer

負載均衡策略：

輪詢的方式；
隨機方式；
**最大可用策略：**會先過濾掉由于多次訪問故障而處于斷路器跳閘狀態的服務，然后選擇一個并發量小的服務；
**加權輪詢策略：**根據權重，響應越快服務權重越大，被選中的概率也越大；
**可用過濾策略：**先過濾掉由于多次訪問故障而處于斷路器狀態的服務，還有并發的連接數量超過閾值的服務，然后對剩余的服務列表按照輪詢策略進行訪問；
先按照輪詢策略獲取服務，如果獲取失敗則在指定時間內進行重試，獲取可用的服務；
**區域感知策略：**復合判斷Server所在區域的性能和Server的可用性選擇服務器；

服務接口調用（fegin)

簡化服務接口調用，通過@EnableFeignClients注解開啟fegin功能，在需要使用的接口上@FeignClient

消息隊列（kafka、Mq)

配置中心

服務網關Gateway

作用：

統一入口，為服務提供一個唯一的入口，網關起到外部和內部隔離的作用，保障了后臺服務的安全性；
鑒權校驗：識別每個請求的權限，拒絕不符合要求的請求
動態路由：動態的將請求路由到不同的后端集群中；
減少客戶端與服務端的耦合：服務可以獨立發展，通過網關層來做映射；

網關啟動器：@EnableZuulProxy

網關配置：默認、url、服務名稱、排除|忽略、前綴

ZUUL網關過濾器：用來過濾代理請求，提供額外功能邏輯，Zuul提供的過濾器是一個父類，父類是ZuulFilter，通過父類中的定義的抽象方法filterType,來決定當前的Filter種類是什么，有前置過濾、路由后過濾、后置過濾、異常過濾；

優秀博客：https://blog.csdn.net/rain_web/article/details/102469745

消息總線

輕量級的消息代理來構建一個共用的消息主題來連接各個微服務實例，它廣播的消息會被所有在注冊中心的微服務實例監聽和消費，也稱消息總線；

Nacos

功能：

服務地址管理
服務注冊
服務動態感知

原理：

服務提供者：Provider APP
服務消費者：Consumer APP
Name Server:通過Virtual IP或者DNS的方式實現Nacos高可用集群服務路由
Nacos Server :Nacos服務提供者

集群節點數據同步，采用Raft算法實現

9.3 springCloud服務治理、監控

9.4 各大版本差異性

9.5 springcloud相關面試題

什么是SpringCloud?

一系列框架的有序集合，利用Spring boot的開發遍歷巧妙的簡化了分布式系統基礎設施的開發，如服務注冊，配置中心，智能路由、消息總線、負載均衡、斷路器、數據監控等

SpringCloudApplication注解？

十、redis

10.1 原理解析

10.2 常見數據類型以及作用

10.3 redis高級特性

10.4 redis常用高級組件

10.5 redis 應用

10.6 redis 相關面試題

redis和Memcache的區別？

Redis和Memcache都是將數據存放在內存中，都是內存數據庫，不過后者還可以緩存圖片，視頻等；
redis 不僅支持簡單的k/v結構，還提供list,set,hash，string,SortedSet,HyperLogLog、Geo、pub/sub等數據存儲結構；
虛擬內存–Redis當物理內存用完時，可以將一些很久沒用到的value 交換到磁盤；
過期策略–memcache在set時就指定，例如set key1 0 0 8,即永不過期。Redis可以通過例如expire 設定，例如expire name 10；
分布式–設定memcache集群，利用magent做一主多從;redis可以做一主多從。都可以一主一從；
存儲數據安全–memcache掛掉后，數據沒了；redis可以定期保存到磁盤（持久化）；
災難恢復–memcache掛掉后，數據不可恢復; redis數據丟失后可以通過aof恢復；
Redis支持數據的備份，即master-slave模式的數據備份；
應用場景不一樣：Redis出來作為NoSQL數據庫使用外，還能用做消息隊列、數據堆棧和數據緩存等；Memcached適合于緩存SQL語句、數據集、用戶臨時性數據、延遲查詢數據和session等。

redis 高級應用？

redis Module
BloomFilter:實際上是一個很長的二進制向量和一系列隨機映射函數，可用于檢索一個元素是否在一個集合中，優點是空間利用率和查詢時間遠超一般算法，缺點是存在一定誤識和刪除困難

**原理：**當一個元素加入集合，通過k個散列函數將這個元素映射成一個位數組中的k個點，把他們置為1，檢索時，我們只要看看這些點是不是都是1就（大約）知道集合中有沒有它了：如果這些點有任何一個0，則被檢元素一定不在；如果都是1，則被檢元素很可能在。這就是布隆過濾器的基本思想。
RedisSearch
Redis-ML

十一、Dubbo

11.1 dubbo 底層原理解析

11.2 dubbo 常見配置

11.3 dubbo底層協議

11.4 dubbo高級特性

11.5 dubbo應用場景

11.6 dubbo重復消費，消息丟失等問題

11.7 關于Zookeeper相關

11.8 dubbo集群

11.9 dubbo相關面試題

十二、消息中間件以及Zookeeper

12.1 zookeeper底層原理

12.2 zookeeper 常見問題分析

zk數據存儲類型？

12.3 zookeeper 分布式鎖實現

12.4 zookeeper 高級特性

12.5 zookeeper 集群配置

12.6 zookeeper 相關面試題

12.7 消息中間件AQ、MQ、Rb相關原理解析

RocketMq原理解析

NameServer:mq注冊中心，管理2部分數據，集群的Topic-queue的路由配置，Broker的實時配置信息，其它模塊通過Nameserver提供的接口獲取最新的topic配置和路由信息；
producer/Consumer ,通過查詢接口獲取Topic對應的Broker的地址信息；consumer可以以兩種模式啟動，廣播和集群，廣播模式，一條信息會發給所有consumer,集群模式下信息只會發給一個consumer;
Broker:注冊配置信息到nameserver,實時更新topic信息到nameServer,負責接收并存儲信息，同事提供push/pull接口來將信息發送給consumer
Broker:接收Producer發送過來的信息、處理Consumer的消息請求、消息的持久化存儲、以及服務端過濾功能等；
消息存儲是由ConsumeQueue CommitLog配合完成的，真正消息存儲文件是CommitLog,ConsumeQueue是消息的邏輯隊列，CommitLog是以物理文件的方式存儲，CommitLog順序寫，隨機讀ConsumeQueue被寫到磁盤文件里做永久存儲，雖然是隨機讀，但是利用操作系統的pagecache機制，可以批量地從磁盤讀取，作為cache存到內存中，
RocketMq集群中，Master支持讀寫，slave只支持讀，并且維持了自動切換機制，master出現故障，也不會影響業務正常進行讀，保證消費端高可用，服務端高可用，創建topic的時候，可以吧topic的多個Message queue創建在多個Broker組上
同步刷盤和異步刷盤，通過broker中的flushDiskType參數設置，值可以取SYNC_FLUSH、ASYNC_FLUSH中一個；
同步復制，異步復制：異步復制有較低延遲較高吞吐量，但是容易造成數據丟失，同步復制，slave有備份，數據容易恢復，但是會增大數據寫入延遲，降低系統吞吐量，可以通過broker中的borkerRole參數設定，取值為ASYNC_MASTER、SYNC_MASTER、SLAVE;

中間件常用協議

AMQP:統一消息服務的應用層標準高級消息隊列協議
MQTT協議：即時通訊協議；
STOMP:流文本定向消息協議；
XMPP:可拓展消息處理現場協議；

各消息隊列區別

RabbitMq：基于主從做高可用的，有三種模式，單機模式，普通集群模式，鏡像集群模式，每臺機器上存儲著全量的數據

12.8 消息丟失、重復消費、事務相關

十三、高并發集群問題

13.1 高并發解決辦法

13.2 高并發常用工具框架

13.3 集群問題分析解決

13.4 高并發集群相關面試題

十四、算法以及數據結構

14.1 java常見的算法

冒泡排序

屬于比較排序，平均時間復雜度O(n^2),空間復雜度1,核心思想，兩個兩個比較，大的往下沉；

偽代碼：

public static void maoPao() {int[] array = new int[10];Scanner sc = new Scanner(System.in);for (int i = 0; i < array.length; i++) {array[i] = sc.nextInt();}int len = array.length;for (int i = 0; i < len; i++) {for (int j = 0; j < len - 1 - i; j++) {if (array[j] > array[j + 1]) {int temp = array[j];array[j] = array[j + 1];array[j + 1] = temp;}}}for (int i = 0; i < len - 1; i++) {System.out.print(array[i] + ",");}System.out.print(array[len - 1]);}

選擇排序

最穩定的排序算法之一，不管什么數據，時間復雜度都是O(n^2),所以用選擇排序，數據規模越小越好；

**核心思想：**首選在未排序列中找到最小（大）元素，存放到排序列的起始位置，然后再從剩余未排序元素中繼續尋找最小（大）元素，然后放到已排序的末尾，以此類推，直到所有元素排序完畢；

for (int i = 0; i < len - 1; i++) {int minIndex = i;for (int j = i + 1; j < len; j++) {if (array[j] < array[minIndex]) {minIndex = j;}}//交換位置if (i != minIndex) {int temp = array[i];array[i] = array[minIndex];array[minIndex] = temp;} }

插入排序

核心思想：通過構建有序序列，對于未排序數據，在已經排序序列中從后向前掃描，找到相應位置并插入；空間復雜度O(1),時間復雜度O(N)

步驟：

從第一個元素開始，該元素可以認為已經被排序；
取出下一個元素，在已經排序的元素序列中從后向前掃描；
如果該元素（已排序）大于新元素，將該元素移到下一位置；
重復步驟3，直到找到已排序的元素小于或者等于新元素的位置；
將新元素插入該位置后；
重復步驟2~5；

int inserNum; //要插入排序的數 for (int i=1;i<length;i++){insertNum = array[i];//已經排好序的元素個數int j = i-1;while(j >= 0 && array[j] >insertNum) {array[j+1] = array[j];j--;}array[j+1] = insertNum; }

希爾排序

核心思想：按一定增量分組，對每組使用直接插入排序算法，隨著增量逐漸減少，每組包含的關鍵詞越來越少，當增量減至1時，整個文件剛好被分成一組

第一部分，選擇增量length/2,將其分成length/2組，縮小增量，再以（length/2)/2,依次進行

代碼：

int length = array.length; int temp,gap = length/2; while (gap >0) {for (int i = gap;i<length; i++){temp = array[i];int preIndex = i-gap;while (preIndex >= 0 && array[preIndex] >temp){array[preIndex+gap] = array[preIndex];preIndex -= gap;}array[preIndex+gap] = temp;}gap /= 2; }

最佳情況：T(n) = O(nlog2 n) 最壞情況：T(n) = O(nlog2 n) 平均情況：T(n) =O(nlog2n)

歸并排序

采用分治法，把長度為n的序列分成2個長度為n/2的子序列；
對這2個子序列分別采用歸并排序；
將兩個排序好的子序列合并成一個最終的排序序列

sort(array,array.length -1);sort(int[] array,int left,int right) {if(left == right){return;}int mid = left +((right-left) >>1);//對左側子序列進行遞歸排序sort(array,left,mid);//對右側子序列進行遞歸排序sort(array,mid +1，right);//合并merge(array,left,mid,right); }merge(int[] array, int left, int mid, int right) {int[] temp = new int[right - left + 1];int i = 0;int p1 = left;int p2 = mid + 1;// 比較左右兩部分的元素，哪個小，把那個元素填入temp中while (p1 <= mid && p2 <= right) {temp[i++] = array[p1] < array[p2] ? array[p1++] : array[p2++];}// 上面的循環退出后，把剩余的元素依次填入到temp中// 以下兩個while只有一個會執行while (p1 <= mid) {temp[i++] = array[p1++];}while (p2 <= right) {temp[i++] = array[p2++];}// 把最終的排序的結果復制給原數組for (i = 0; i < temp.length; i++) {array[left + i] = temp[i];}

快速排序

從數列中挑選一個元素，稱為基準；
重新排序數列，所有比基準值曉得元素放在基準前面，所有比基準大的元素放在基準后面（相同可以放在任意一邊）
遞歸地把小于基準值元素的子數列和大于基準值元素的子數列排序；

public static void quickSort(int[] array) {quickSort(array, 0, array.length - 1); }private static void quickSort(int[] array, int left, int right) {if (array == null || left >= right || array.length <= 1) {return;}int mid = partition(array, left, right);quickSort(array, left, mid);quickSort(array, mid + 1, right); }private static int partition(int[] array, int left, int right) {int temp = array[left];while (right > left) {// 先判斷基準數和后面的數依次比較while (temp <= array[right] && left < right) {--right;}// 當基準數大于了 arr[left]，則填坑if (left < right) {array[left] = array[right];++left;}// 現在是 arr[right] 需要填坑了while (temp >= array[left] && left < right) {++left;}if (left < right) {array[right] = array[left];--right;}}array[left] = temp;return left; }

最佳情況：T(n) = O(nlogn) 最差情況：T(n) = O(n2) 平均情況：T(n) = O(nlogn)

堆排序

堆是一個近似完成二叉樹的結構，滿足堆的性質，子節點的鍵值或者索引總是小于（或者大于）他的父節點，大于等于其左右孩子節點的值，稱為大頂堆，小于或等于其左右孩子節點的值，稱為小頂堆

將初始待排序關鍵字序列構建成大頂堆；
將堆頂元素R[1]與最后一個元素R[n]交換，此時得到新的無序區(R1,R2,……Rn-1)和新的有序區(Rn),且滿足R[1,2…n-1]<=R[n]；
由于交換后新的堆頂R[1]可能違反堆的性質，因此需要對當前無序區(R1,R2,……Rn-1)調整為新堆，然后再次將R[1]與無序區最后一個元素交換，得到新的無序區(R1,R2….Rn-2)和新的有序區(Rn-1,Rn)。不斷重復此過程直到有序區的元素個數為n-1，則整個排序過程完成。

public static void duiPx(){int[] array = {1,34,2,67,3,89,56,23,11,5,8} ;}private static void heapSort(int[] array){if (array == null || array.length <=1){return;}int length = array.length;//構建大頂堆for (int i = length/2; i >=0; i--) {addHeap(array,i,length);}for (int j = length-1; j >0 ; j--) {//將堆頂元素與末尾元素盡心交換swap(array,0,j);//重新對堆進行調整addHeap(array,0,j);}}private static void addHeap(int[] array,int i,int length){int temp = array[i];for (int k = i*2+1; k <length ; k =k*2+1) {if(k+1 <length && array[k] <array[k+1]){k++;}if(array[k] > temp){array[i] = array[k];i=k;}else {break;}}array[i] = temp;}

計數排序

桶排序

基數排序

? 參考鏈接：https://javajgs.com/archives/1599

14.2 java常見的數據結構以及應用

樹

鏈表

隊列

堆

棧

14.3 算法、數據結構相關面試題

如何在一個1到100的整數數組中找到丟失的數字?

提示：如果是只有一個數，可以用求和的方式，如果多個，可以用位圖BitSet操作

如何在給定的整數數組中找到重復的數字？

答：使用set集合，使用map的key

https://www.jianshu.com/p/cec86f055b02

十五、Netty通信

15.1 Netty原理

15.2 Netty 應用

15.3 Netty相關面試題

十六、工具類

16.1 POI導入導出（以及各種性能優化問題）

16.2 文件傳輸、存儲相關工具類（前端、后端）

16.3 ES大數據相關

16.4 單點登錄以及JWT

16.5 權限管理以及技術拓展

16.6 定時任務XXJOB

16.7 美團萬億級KV存儲架構與實踐：美團萬億級 KV 存儲架構與實踐

十七、Maven、Git工具集

17.1 Maven基礎知識

17.2 Maven高級特性

17.3 Maven關鍵字解析

17.4 git 原理（以及與SVN區別）

17.5 git常用命令

17.6 Maven與git常見面試題

十八、高級前端面試

18.1 vue高級面試

父子組件傳值？

子組件通過props方法接受父組件傳來的值，子組件通過$emit方法向父組件傳達數據；

vue生命周期函數？

beforeCreate

created

beforeMount

mounted

beforeUpdate

updated

beforeDestroy

destroyed

創建指令？

directives結合inserted

動態路由？

組件被重復利用，通過參數傳遞不同的數據，進行渲染；

router-link組件：導航器，利用to屬性導航到目標組件；

axios和ajax區別？

axios是通過promise實現對ajax的一種封裝，就像JQuery實現ajax封裝一樣，ajax實現了網頁的局部數據刷新，axios實現了對ajax的封裝，axios是ajax;ajax不止axios;

axios用于瀏覽器和node.js的基于promise的http客戶端防止csRF

從瀏覽器制作XML HttpRequests

攔截請求和響應

轉換請求和響應數據

vue路由鉤子函數？

主要有6個

全局路由鉤子函數：beforeEach每次路由改變的時候都得執行一遍，有三個參數，to，from，next，可進行一些頁面跳轉前處理，afterEach：頁面加載之后

單個的路由鉤子函數：beforeEnter路由內鉤子

組件內的路由鉤子函數：beforeRouteEnter、beforeRouteLeave、beforeRouteUpdate

vue解決跨域問題？

方法一：

header(‘Access-Control-Allow-Origin:*’);//允許所有來源訪問

header(‘Access-Control-Allow-Method:POST,GET’);//允許訪問的方式

方法二：

使用jQuery提供的JSonp，將ajax請求的dataType設置為JSONP

方法三：

使用http-proxy-middleware代理解決，在config/index.js中的proxyTable

配置pathRewrite;

代替v-model?

v-bind:value和v-on:input動態監聽

如何給自定義組件添加點擊事件？

在@Click后面加上.native

vue中深拷貝與淺拷貝？

淺拷貝：新對象賦值，只是取的舊的對象棧中的值，也就是引用對象的值

深拷貝：會在堆里面開辟一個空間，存放自己的對象值；經常使用JSON.stringfy，遞歸，localStorage實現對象數組儲存，jQ的extend方法（三個參數：deep是否為深拷貝，target Object類型,目標對象,object1,objectN可選***$*.extend( [deep ], target, object1 [, objectN ] )**

淺拷貝針對基本數據類型，包括number、string、boolean、null、undefined五類，主要存在棧內存中；

深拷貝針對引用數據類型，包括無序對象，數組，以及函數，名字存在棧內存，值存在于堆內存中，棧內存會提供一個引用的地址指向堆內存中的值，

vue中獲取dom元素？

1.0版本中，通過v-el綁定，通過this.els.XXX獲取；

2.0版本中，通過給元素綁定ref = “XXX”，然后通過this.$refs.XXX或者this.refs[‘XXX’]獲取；

虛擬dom？

深度遍歷diff算法

18.2 react高級面試

區分Real dom和Virtual DOM?

real DOM:更新緩慢，可直接更新html,元素更新，則創建新DOM,DOM操作代價很高，消耗內存多

Virtual DOM：更新更快，無法直接更新html,元素更新，則更新JSX,DOM操作非常簡單，很少內存消耗；

Virtual DOM是一個節點樹，他將元素。他們的屬性和內容作為對象及其屬性，屬于real DOM的一個副本

React特點？

使用虛擬dom

服務器端渲染

遵循單向數據流或者數據綁定

基于JSX,代碼可讀性好

只是一個庫，而不是一個完整的框架

瀏覽器無法讀取JSX,需要使用Babel轉換器；

優秀文檔：https://blog.csdn.net/eyeofangel/article/details/88797314

18.3 js+H5高級面試

18.4 小程序開發

18.5 app打包常用命令

18.6 優秀表單、報表、統計圖開發工具

十九、高級架構思想

19.1 架構流程圖

19.2 架構需要考慮的因素

19.3 架構案列

19.4 架構常見面試題

19.5 性能監測、跟蹤相關

二十、高并發編程、事務、鎖機制

20.1 高并發編程

20.2 高并發如何解決事務

20.3 高并發中的鎖

20.4 高并發需要解決的問題

20.5 高并發場景

20.5 相關面試題

二十一、Linux常用命令

21.1 操作系統常用命令

21.2 優化調優命令

21.3 網絡環境搭建

21.4 項目部署

21.5 日志，問題查找

21.6 Docker技術

21.7 K8s自動化部署

二十二、源碼解析

22.1 spring源碼

22.2 springboot源碼

22.3 springMVC源碼

22.4 springcloud相關

22.5 源碼相關面試

UML

? https://blog.csdn.net/qq_35495763/article/details/80764914

Linux相關命令

https://blog.csdn.net/qq_23329167/article/details/8385643

3. 權限框架有哪些？各自區別用途？4.

服務器搭建配置

https://www.kancloud.cn/javamall/scbssmsc/710067

總結

以上是生活随笔為你收集整理的2022年java知识点汇总，面试大全！超级全面，逐步完善！的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

上一篇： SPSS可以生成正交表吗？
下一篇： Oracle 异常处理函数SQLCODE