知識點掃盲

時間 2019-11-08

標籤知識掃盲简体版

原文原文鏈接

知識點掃盲

Java基礎

註解html
泛型java
List\Map\Set是否都是Collection的子類？web
**【String類面試題】 **補課->深刻理解Java中的String面試
String str = new String("abc")到底建立了幾個對象？
答：2個對象。一個對象是"abc"，另外一個是指向"abc"的引用對象"s"；redis
你對String對象的intern()熟悉嗎？算法
接口和抽象類的區別？spring
List是否能夠存null,Set是否能夠存null,List和Map的區別？sql
switch是否可使用string做參數？byte?long?編程
Object中有哪些公共方法？json
Java的四種引用？WeakReference和SoftReference的區別？
什麼是不可變對象？final關鍵字
Runnable和Callable有什麼區別？
Runnable不會返回結果，Callable會。
Object 的 hashcode 方法重寫了，equals 方法要不要重寫？
try catch finally塊中return的執行順序

當沒有異常發生時，優先級finally>try

當有異常發生時，優先級finally>catch>捕獲異常最外面的return

Java的深拷貝和淺拷貝
a. 引用拷貝和對象拷貝就是淺拷貝和深拷貝嗎？
-- 不是。淺拷貝和深拷貝都屬於對象拷貝。淺拷貝僅複製屬性的引用而不復制屬性引用所指的對象。深拷貝直接複製該屬性指向的對象（即原對象和新對象的屬性地址不一樣）。
b. 如何實現淺拷貝？如何實現深拷貝？
-- 淺拷貝：1. 實現Cloneable接口並從新clone方法。
-- 深拷貝：1. 實現Cloneable接口並從新clone方法。2. 經過序列化方式實現。
c. Objct對象的clone()方法爲何要聲明爲protected?
--// todo
Java中拆箱與裝箱的原理？
自動裝箱：編譯器調用valueOf()將原始類型值轉成對象；
自動拆箱：編譯器經過相似intValue(),doubleValue（）這些方法將對象轉換成原始類型值。
Java中的++操做符線程安全嗎？
-- 線程不安全。
-- 解決辦法：加鎖
什麼是ThreadLocal？
爲使用該變量的每一個線程維護一份獨立的變量副本，每一個線程均可以改變本身的副本，而不影響其餘線程的副本;
線程有哪些狀態？以及5大狀態之間的流轉？
Java NIO經常使用的三個類
同步IO和異步IO
IO操做分2個步驟，請求IO和實際IO，同步IO和異步IO的主要區別是第二步是否阻塞。
若實際IO操做阻塞請求進程（即請求進程輪詢查看IO是否就緒），則爲同步IO。
若實際IO操做並不阻塞請求進程（即由OS進行實際IO操做並返回結果），則爲異步IO。
阻塞IO和非阻塞IO
阻塞和非阻塞IO的區別在於第一步是否阻塞。
若發起IO請求後，請求線程一直等待時間實際IO操做完成，則爲阻塞IO。
若發起IO請求後，請求進程返回而不等待，則爲非阻塞IO。
BIO、NIO、AIO
BIO-同步阻塞
NIO-同步非阻塞
AIO-異步非阻塞
java線程阻塞調用wait()和sleep()區別和聯繫，還有函數yield，notify等的做用?
區別主要看2點：1. CPU是否繼續執行。2.鎖是否釋放掉。
sleep是Thread的方法。
暫停當前線程的執行，將CPU讓給其餘線程，保持對象鎖直到睡眠結束。若是外包層有Synchronize，那麼
wait是Object的方法。
調用對象的await方法。會致使當前線程放棄對象的鎖（線程暫停執行），進入對象的等待池（wait pool），只有調用對象的notify方法或notifyALl(),才能喚醒等待池中的線程進入鎖池（Lock pool），若是線程從新得到對象的鎖，就會進入就緒狀態。
從Java內存模型角度 JMM 分析DCL
【List、Map、Set總結】
List中的元素：有序、可重複、可爲NULL；
Set中的元素：無序、不可重複、只有一個NULL；
Map中的元素：無序、Key不重，Value可重、可一個NULL Key,多個NULL值；
JMM中對共享變量的讀寫原理；

J.U.C

說一說對輕量級鎖CAS的理解？
原理
在 CAS 中有三個參數：內存值 V、舊的預期值 A、要更新的值 B ，當且僅當內存值 V 的值等於舊的預期值 A 時，纔會將內存值V的值修改成 B ，不然什麼都不幹。
CPU如何實現多處理器下的原子操做？
總線加鎖
緩存加鎖
地位：
CAS是J.U.C的基石；整個AQS同步組件、Atomic原子類操做都是基於CAS實現的。
Unsafe是CAS的核心類；--提供了硬件級別的原子操做。
缺點：
循環時間太長；
只能保證對一個共享變量的原子操做；
ABA問題；--如何解決？Java提供AtomicStampedReference來解決#版本號#；
說一說對於AQS和CLH的理解？
CLH（隊列鎖）是一個FIFO的同步隊列。AQS依賴CLH來完成同步狀態的管理。
AQS（隊列同步器）使用Template設計模式實現，使用者只要繼承並重寫指定方法。
AQS隊列同步器是如何實現線程同步的？
獨佔式獲取和釋放同步狀態；--void acquire(int arg)/boolean release(int arg)
在獲取同步狀態的時候，會維護一個同步隊列，若是獲取失敗的線程會經過CAS的方式加入到隊列中並進行自旋。
被移除隊列的條件是：前驅節點是頭節點而且成功獲取同步狀態。
共享式獲取和釋放同步狀態；-- void acquireShared(int arg)/boolean releaseShared(int arg)
獨佔式和共享式的主要區別是：同一時刻是否有多個線程獲取到同步狀態。
tryRelease()必須線程安全的釋放，通常經過CAS來保證。
超時獲取同步狀態； --
涉及概念：
響應中斷與不響應中斷
可重入與不可重入的區別？
可重入：任何線程在獲取到鎖以後，能夠再錯獲取到鎖而不被阻塞的特性。
sychronized支持可重入:如遞歸方法用synchronized修飾，會連續屢次加鎖。
公平鎖與非公平鎖
公平鎖：等待時間越久的線程，優先獲取鎖。能減小「飢餓」的發生。
AQS如何實現線程的等待與喚醒？-- LockSupport
如何實現一個Lock?
寫一個死鎖例子 --可使用CountDownLatch寫一個死鎖例子
說一說對於重量級鎖Synchronized的理解?
說一說對於線程池的理解？
CyclicBarrier和CountDownLatch的區別,內部實現有何不一樣**？**分別在什麼場景下使用？join和CountDownLatch有什麼區別？ | | CyclicBarrier | CountDownLatch | | --- | --- | --- | | 原理 | | 調用countDown（）進行減1計算，調用awit()方法進行阻塞。 | | 場景 | 1. Boss要開會，須要N我的都到了纔開始。
適用於多線程計算，獲取最終結果。 | 電商詳情頁由不少模塊獲取，彼此之間沒啥關聯，爲提供響應時間，能夠併發獲取數據，所有獲取完畢後返回，這種場景可使用CDL | | 區別 | 1. 能夠條用reset（）重置；適用更加複雜的場景，若是發生計算錯誤，能夠重置。
提供了更多方法，例如getNumberWaiting獲取阻塞線程數量； | 1. 計數器不能複用。 |
講講獨佔鎖 ReentrantLock 原理？
Lock和Synchronized的區別？他們都是可重入鎖嗎？哪一個效率更高？
談談讀寫鎖 ReentrantReadWriteLock 原理？
ReentrantReadWriteLock鎖降級：寫鎖降級爲讀鎖
ReentrantReadWriteLock不支持鎖升級。
講講對JUC 中迴環屏障 CyclicBarrier 的使用？
Semaphore 的內部實現是怎樣的？
適用於（單機）流量控制。
併發組件CopyOnWriteArrayList 是如何經過寫時拷貝實現併發安全的 List？
~~線程間交換數據Exchange~~
無
LockSupport
Condition

線程、進程相關問題

說說線程、進程、協程之間的區別？
進程是OS分配資源的最小單元，線程是OS調度的最小單元；（進程是最小的資源管理單元；線程是最小的執行單元）
一個程序至少有一個進程，一個進程至少有一個線程；
聯繫：線程從屬於進程，是程序的實際執行者。線程擁有本身的棧空間
線程不一樣狀態之間的切換是由誰完成的？是JVM嗎？
不是。JVM經過TCB（Thread Control Block）模塊來改變下線程的狀態，這一過程須要消耗CPU資源；
線程進程的痛點（協程和進程線程之間有什麼關係？）：線程之間如何進行協做？
最經典的例子：生產者/消費者模型；
生產者/消費者模型性能不高緣由？
涉及到了同步鎖；
涉及線程上下文的切換；
如何解決？-->協程
什麼是協程？
比線程更輕量級的一種存在；
一個線程擁有多個協程；
協程的好處？-- 協程的開銷遠遠小於線程。協程不被OS所管理，徹底有程序控制（在用戶態執行）；
Java中原生語法沒有實現協程；
你瞭解守護線程嗎？它和非守護線程有什麼區別？
什麼是多線程上下文的切換？
建立線程的2種方式是什麼？他們有什麼區別？
Thread類中的run和start有什麼區別？
怎麼檢測一個線程是否有對象監視器？
死鎖與活鎖的區別？飢餓與死鎖的區別？產生死鎖的條件？
concurrenthashmap和hashmap的區別，chm的實現原理，你在什麼場景下用到chm，爲何，我說了多線程查詢數據，put可能覆蓋，或者hashmap的擴容可能產生死鏈
Spring瞭解麼，問我瞭解五大組件不，不瞭解，說了ioc和aop。而後問我分別怎麼實現的，使用xml和註解配置實現類有什麼區別，怎麼解析它們的數據；

大數據排序問題

如何快速對一個2億數據的List進行排序；
10G的數據，在2G內存的單臺機器上排序的算法；

併發問題

【HashMap問題集合】

底層實現？put和get的原理？
底層實現使用的是：數組+鏈表的數據結構。
put原理：（擴容機制）
根據key獲取相應的Hash值：int hash = hash(key.hash.hashcode())
根據（Hash值和數組長度）肯定引用位置：int i = indexFor(hash,table.length)。若是不一樣的key映射到相同的位置，就放入鏈表。
get原理：
獲取對應數據位置；
遍歷該數組所在鏈表:key.equals();
HashMap和TreeMap的區別？和HashTable有什麼區別？和ConcurrentHashMap的區別
和TreeMap的區別:
和HashTable區別：
線程安全：不安全；線程安全
負載因子：16；11
NULL值： KV都容許爲NULL；容許；
和ConcurrentHashMap區別：
HashMap遇到Hash碰撞的時候，除了拉鍊法解決，仍是什麼其餘的方法嗎？
開放定址法
線性探測再散列
再Hash
HashMap的負載因子是多少？達到負載因子擴容仍是沒達到就擴容了？ConncurrentHashMap呢？

0.75

爲何ConcurrentHashMap和HashTable都是線程安全的，可是前者性能更高？

由於2者使用的鎖的粒度不一樣。ConcurrentHashMap使用的是分段鎖。

JDK1.7和JDK1.8的HashMap有什麼區別？

爲了加快查詢效率，JDK1.8的HashMap引入了紅黑樹結構。
當鏈表長度>8時，該鏈表就會改爲紅黑樹結構，從而加快查詢效率。

計算機網絡

tcp三次握手、四次揮手；爲何握手是三次？爲何要四次揮手？
兩次握手會出現什麼問題？
三次握手主要目的是：防止出現請求超時而致使髒鏈接；
若是兩次握手：若是有超時的請求，而Server返回ACK確認報文，可是Client由於是超時的請求而沒有處理，就會致使Server白白創建鏈接；
爲何握手只要3次，而揮手須要4次？
由於Server須要把沒有傳完的數據傳完；
爲何TIME_WAIT狀態須要通過2MSL（最大報文段生存時間）才返回CLOSE狀態？
爲了保證Client發送的最後一個ACK報文可以到達Server;
容許老的重複的分節在網絡中消失；
什麼是滑動窗口機制？什麼是慢啓動?什麼是擁塞避免？
說一說OSI七層模型；每一層都幹了哪些？
說一說TCP/IP四層模型；
請簡述tcp和udp的區別？
鏈接。-- TCP面向鏈接；UDP無鏈接；
可靠服務。--TCP提供可靠服務；UDP提供盡最大努力服務；
字節字符。--TCP面向字節流；UDP面向字符流；
點對點。--TCP是點對點。UDP支持一對多、多對1、多對多；
效率。--TCP傳輸速率慢，安全。UDP傳輸快，不安全；
怎樣使不可靠的udp變得可靠？
-- RUDP。
-- 重傳。傳送門：www.infoq.cn/article/how…
TCP協議如何保證可靠性？juejin.im/post/5b7be0…
校驗和。
目的是檢測數據傳輸過程當中的任何變化。
中止等待協議。
基本原理就是每發完一個分組就中止發送，等待對方確認。在收到確認後再發下一個分組。
無差錯狀況；
出現差錯狀況（超時重傳）；
確認丟失|確認遲到；
自動重傳ARQ協議
指超過一段時間仍沒有收到確認，就重傳以前發送過的分組；
每發送完一個分組，就設置一個超時計時器；
連續ARQ協議** **--提升信道利用率
發送方維持一個發送窗口，凡是在這個窗口以內的分組均可以連續發送出去，不須要中止等待對方確認。
流量控制.
TCP使用滑動窗口機制實現流量控制；
爲了控制發送方速率，保證接收方來得及接收；
接收方能夠經過發送ACK報文中的窗口字段，能夠控制發送方窗口大小，從而影響發送方速率；
擁塞控制
參照下面8

-- 流量控制和擁塞控制的區別

擁塞控制是防止過多的數據注入到網絡中，可使網絡中的路由器或鏈路不致過載，是一個全局性的過程。
流量控制是點對點通訊量的控制，是一個端到端的問題，主要就是抑制發送端發送數據的速率，以便接收端來得及接收。

經典的擁塞算法有哪幾個部分？

慢開始、擁塞避免、快重傳、快恢復；

慢開始。
若是剛開始就發送大量數據，就會致使網絡擁堵，就會產生大量丟包，大量重傳，影響效率；
不要一開始就發送大量數據，先嗅探下網絡的擁塞程度，從小到大增大cwnd窗口；
擁塞避免.
當擁塞窗口 cwnd 達到一個閾值時，窗口大小再也不呈指數上升，而是以線性上升，避免增加過快致使網絡擁塞。
讓cwnd窗口緩慢增加，即每通過一個往返RTT，就把發送方的cwnd值+1，而不是加倍，讓擁塞窗口按線性緩慢增加；
快重傳。
發送方只要一連收到三個重複確認就應當當即重傳對方還沒有收到的報文段，而沒必要繼續等待設置的重傳計時器時間到期。
當發送方連續收到三個重複確認時，就執行「乘法減少」算法，把ssthresh門限減半。可是接下去並不執行慢開始算法。
快恢復。和快重傳配合使用。
考慮到若是網絡出現擁塞的話就不會收到好幾個重複的確認，所以發送方如今認爲網絡可能沒有出現擁塞。因此此時不執行慢開始算法，而是將cwnd設置爲ssthresh的大小，而後執行擁塞避免算法。
在瀏覽器輸入網址以後發生了什麼？
HTTP與HTTPS區別？HTTP2.0?
HTTP的長短鏈接？
從HTTP1.0開始默認使用長鏈接；使用長鏈接的HTTP請求，默認會在Header添加Connection:keep-alive。
HTTP協議的長短鏈接實質是TCP協議的長短鏈接；

數據結構

blog.csdn.net/qq_16399991…

快排（非遞歸） --要求手寫

public class QuickSort {

    public static void main(String[] args) {
        int[] table = {38, 26, 97, 19, 66, 1, 5, 49};
        quickSort(table);
        for (int i = 0; i < table.length; i++) {
            System.out.print(table[i] + "\t");
        }
    }

    private static void quickSort(int[] table) {
        quickSort(table, 0, table.length - 1);
    }

    /** * 時間複雜度 * 最好的狀況下是：O(NlogN) * 最壞的狀況下是：O(N^2) * @param table * @param begin * @param end */
    private static void quickSort(int[] table, int begin, int end) {
        if (begin < end) {
            int i   = begin;
            int j   = end;
            int vot = table[i];
            while (i != j) {
                // 尾指針向前移動
                while (i < j && table[j] >= vot) {
                    j--;
                }
                if (table[j] < vot) {
                    table[i++] = table[j];
                }
                // 頭指針向後移動
                while (i < j && table[i] <= vot) {
                    i++;
                }
                if (table[i] > vot) {
                    table[j--] = table[i];
                }
            }
            table[i] = vot;
            //
            quickSort(table, begin, j - 1);
            quickSort(table, j + 1, end);
        }

    }
}
複製代碼

鏈表反轉-- 要求手寫
二分查找（遞歸和非遞歸）

/** * 二分查找[非遞歸實現] * * @param array * @param target * @return 返回出如今數組中的位置 */
    public static int binSearch(int[] array, int target) {
        int low  = 0;
        int high = array.length - 1;
        int mid;
        while (low <= high) {
            mid = (low + high) / 2;

            if (array[mid] == target) {
                return mid + 1;
            } else if (array[mid] < target) {
                low = mid + 1;
            } else if (array[mid] > target) {
                high = mid - 1;
            }
        }

        return -1;
    }

    /** * 二分查找[遞歸實現] * 時間複雜度O(logN) * * @param array * @param target * @return */
    public static int binSearch2(int[] array, int target, int low, int high) {
        if (low <= high) {
            int mid = (low + high) / 2;
            if (array[mid] == target) {
                return mid + 1;
            } else if (array[mid] < target) {
                return binSearch2(array, target, mid + 1, high);
            } else {
                return binSearch2(array, target, low, mid - 1);
            }
        }
        return -1;
    }
複製代碼