前言 

短時間提升自己最快的手段就是背面試題，最近總結(jié)了Java常用的面試題，分享給大家，希望大家都能圓夢大廠，加油，我命由我不由天。

181、什么是類加載器，類加載器有哪些？

1、什么是類加載器？

類加載器負責加載所有的類，其為所有被載入內(nèi)存的類生成一個java.lang.Class實例對象。

2、類加載器有哪些？

JVM有三種類加載器：

（1）啟動類加載器

該類沒有父加載器，用來加載Java的核心類，啟動類加載器的實現(xiàn)依賴于底層操作系統(tǒng)，屬于虛擬機實現(xiàn)的一部分，它并不繼承自java.lang.classLoader。

（2）擴展類加載器

它的父類為啟動類加載器，擴展類加載器是純java類，是ClassLoader類的子類，負責加載JRE的擴展目錄。

（3）應(yīng)用程序類加載器

它的父類為擴展類加載器，它從環(huán)境變量classpath或者系統(tǒng)屬性java.lang.path所指定的目錄中加載類，它是自定義的類加載器的父加載器。

182、說一下類加載的執(zhí)行過程？

當程序主動使用某個類時，如果該類還未被加載到內(nèi)存中，JVM會通過加載、連接、初始化3個步驟對該類進行類加載。

1、加載

加載指的是將類的class文件讀入到內(nèi)存中，并為之創(chuàng)建一個java.lang.Class對象。

類的加載由類加載器完成，類加載器由JVM提供，開發(fā)者也可以通過繼承ClassLoader基類來創(chuàng)建自己的類加載器。

通過使用不同的類加載器可以從不同來源加載類的二進制數(shù)據(jù)，通常有如下幾種來源：

從本地文件系統(tǒng)加載從jar包加載通過網(wǎng)絡(luò)加載把一個Java源文件動態(tài)編譯，并執(zhí)行加載

2、連接

當類被加載之后，系統(tǒng)為之生成一個對應(yīng)的Class對象，接著進入連接階段，連接階段負責將類的二進制數(shù)據(jù)合并到JRE中。

類連接又可分為三個階段：

（1）驗證

• 文件格式驗證
• 元數(shù)據(jù)驗證
• 字節(jié)碼驗證
• 符號引用驗證

（2）準備

為類的靜態(tài)變量分配內(nèi)存，并設(shè)置默認初始值。

（3）解析

將類的二進制數(shù)據(jù)中的符號引用替換成直接引用。

3、初始化

為類的靜態(tài)變量賦予初始值。

183、JVM的類加載機制是什么？

JVM類加載機制主要有三種：

1、全盤負責

類加載器加載某個class時，該class所依賴的和引用其它的class也由該類加載器載入。

2、雙親委派

先讓父加載器加載該class，父加載器無法加載時才考慮自己加載。

3、緩存機制

緩存機制保證所有加載過的class都會被緩存，當程序中需要某個class時，先從緩存區(qū)中搜索，如果不存在，才會讀取該類對應(yīng)的二進制數(shù)據(jù)，并將其轉(zhuǎn)換成class對象，存入緩存區(qū)中。

這就是為什么修改了class后，必須重啟JVM，程序所做的修改才會生效的原因。

184、什么是雙親委派模型？

如果一個類收到了類加載請求，它并不會自己先去加載，而是把這個請求委托給父類的加載器執(zhí)行

如果父加載器還存在其父加載器，則進一步向上委托，依次遞歸，請求將最終到達頂層的啟動類加載器

如果父類加載器可以完成父加載任務(wù)，就成功返回，如果父加載器無法完成加載任務(wù)，子加載器才會嘗試自己去加載，這就是雙親委派模型。

雙親委派模式的優(yōu)勢：

避免重復(fù)加載；

考慮到安全因素，java核心api中定義類型不會被隨意替換

假設(shè)通過網(wǎng)絡(luò)傳遞一個名為java.lang.Integer的類，通過雙親委派模式傳遞到啟動加載器，而啟動加載器在核心Java API中發(fā)現(xiàn)同名的類，發(fā)現(xiàn)該類已經(jīng)被加載，就不會重新加載網(wǎng)絡(luò)傳遞的Integer類，而直接返回已加載過的Integer.class，這樣可以防止核心API庫被隨意篡改。

185、怎么判斷對象是否可以被回收？

1、引用計數(shù)算法

（1）判斷對象的引用數(shù)量

• 通過判斷對象的引用數(shù)量來決定對象是否可以被回收；
• 每個對象實例都有一個引用計數(shù)器，被引用+1，完成引用-1；
• 任何引用計數(shù)為0的對象實例可以被當做垃圾回收；

（2）優(yōu)缺點

• 優(yōu)點：執(zhí)行效率高，程序受影響較??；
• 缺點：無法檢測出循環(huán)引用的情況，導(dǎo)致內(nèi)存泄漏；

2、可達性分析算法

通過判斷對象的引用鏈是否可達來決定對象是否可以被回收。

如果程序無法再引用該對象，那么這個對象肯定可以被回收，這個狀態(tài)稱為不可達。

那么不可達狀態(tài)如何判斷呢？

答案是GC roots，也就是根對象，如果一個對象無法到達根對象的路徑，或者說從根對象無法引用到該對象，該對象就是不可達的。

以下三種對象在JVM中被稱為GC roots，來判斷一個對象是否可以被回收。

（1）虛擬機棧的棧幀

每個方法在執(zhí)行的時候，JVM都會創(chuàng)建一個相應(yīng)的棧幀（操作數(shù)棧、局部變量表、運行時常量池的引用），當方法執(zhí)行完，該棧幀就從棧中彈出，這樣一來，方法中臨時創(chuàng)建的獨享就不存在了，或者說沒有任何GC roots指向這些臨時對象，這些對象在下一次GC的時候便會被回收。

（2）方法區(qū)中的靜態(tài)屬性

靜態(tài)屬性數(shù)據(jù)類屬性，不屬于任何實例，因此該屬性自然會作為GC roots。這要這個class在，該引用指向的對象就一直存在，class也由被回收的時候。

class何時會被回收？

堆中不存在該類的任何實例加載該類的classLoader已經(jīng)被回收該類的java.lang.class對象沒有在任何地方被引用，也就是說無法通過反射訪問該類的信息

（3）本地方法棧引用的對象

186、說一下 jvm 有哪些垃圾回收算法？

1、對象是否已死算法

引用計數(shù)器算法可達性分析算法

2、GC算法

（1）標記清除算法

如果對象被標記后進行清除，會帶來一個新的問題--內(nèi)存碎片化。

如果下次有比較大的對象實例需要在堆上分配較大的內(nèi)存空間時，可能會出現(xiàn)無法找到足夠的連續(xù)內(nèi)存而不得不再次觸發(fā)垃圾回收。

（2）復(fù)制算法（Java堆中新生代的垃圾回收算法）

• 先標記待回收內(nèi)存和不用回收內(nèi)存；
• 將不用回收的內(nèi)存復(fù)制到新的內(nèi)存區(qū)域；
• 就的內(nèi)存區(qū)域就可以被全部回收了，而新的內(nèi)存區(qū)域也是連續(xù)的；
• 缺點是損失部分系統(tǒng)內(nèi)存，因為騰出部分內(nèi)存進行復(fù)制。

（3）標記壓縮算法（Java堆中老年代的垃圾回收算法）

對于新生代，大部分對象都不會存活，所以復(fù)制算法較高效，但對于老年代，大部分對象可能要繼續(xù)存活，如果此時使用復(fù)制算法，效率會降低。

標記壓縮算法首先還是標記，將不用回收的內(nèi)存對象壓縮到內(nèi)存一端，此時即可清除邊界處的內(nèi)存，這樣就能避免復(fù)制算法帶來的效率問題，同時也能避免內(nèi)存碎片化的問題。

老年代的垃圾回收算法稱為“Major GC”。

187、說一下 jvm 有哪些垃圾回收器？

說一下 jvm 有哪些垃圾回收器？

188、JVM棧堆概念，何時銷毀對象

類在程序運行的時候就會被加載，方法是在執(zhí)行的時候才會被加載，如果沒有任何引用了，Java自動垃圾回收，也可以用System.gc()開啟回收器，但是回收器不一定會馬上回收。

• 靜態(tài)變量在類裝載的時候進行創(chuàng)建，在整個程序結(jié)束時按序銷毀；
• 實例變量在類實例化對象時創(chuàng)建，在對象銷毀的時候銷毀；
• 局部變量在局部范圍內(nèi)使用時創(chuàng)建，跳出局部范圍時銷毀

189、新生代垃圾回收器和老生代垃圾回收器都有哪些？有什么區(qū)別？

新生代回收器：Serial、ParNew、Parallel Scavenge

老年代回收器：Serial Old、Parallel Old、CMS

新生代回收器一般采用的是復(fù)制算法，復(fù)制算法效率較高，但是浪費內(nèi)存；

老生代回收器一般采用標記清楚算法，比如最常用的CMS；

190、詳細介紹一下 CMS 垃圾回收器？

CMS 垃圾回收器是Concurrent Mark Sweep，是一種同步的標記-清除，CMS分為四個階段：

• 初始標記，標記一下GC Root能直接關(guān)聯(lián)到的對象，會觸發(fā)“Stop The World”；
• 并發(fā)標記，通過GC Roots Tracing判斷對象是否在使用中；
• 重新標記，標記期間產(chǎn)生對象的再次判斷，執(zhí)行時間較短，會觸發(fā)“Stop The World”；
• 并發(fā)清除，清除對象，可以和用戶線程并發(fā)進行；

191、簡述分代垃圾回收器是怎么工作的？

分代回收器分為新生代和老年代，新生代大概占1/3，老年代大概占2/3；

新生代包括Eden、From Survivor、To Survivor；

Eden區(qū)和兩個survivor區(qū)的 的空間比例 為8：1：1 ；

垃圾回收器的執(zhí)行流程：

1. 把 Eden + From Survivor 存活的對象放入 To Survivor 區(qū)；
2. 清空 Eden + From Survivor 分區(qū)，F(xiàn)rom Survivor 和 To Survivor 分區(qū)交換；每次交換后存活的對象年齡+1，到達15，升級為老年代，大對象會直接進入老年代；
3. 老年代中當空間到達一定占比，會觸發(fā)全局回收，老年代一般采取標記-清除算法；

192、Redis是什么？

Redis是一個key-value存儲系統(tǒng)，它支持存儲的value類型相對更多，包括string、list、set、zset（sorted set --有序集合）和hash。

這些數(shù)據(jù)結(jié)構(gòu)都支持push/pop、add/remove及取交集并集和差集及更豐富的操作，而且這些操作都是原子性的。

在此基礎(chǔ)上，Redis支持各種不同方式的排序。

為了保證效率，數(shù)據(jù)都是緩存在內(nèi)存中，Redis會周期性的把更新的數(shù)據(jù)寫入磁盤或者把修改操作寫入追加的記錄文件，并且在此基礎(chǔ)上實現(xiàn)了master-slave（主從）同步。

193、Redis都有哪些使用場景？

Redis是基于內(nèi)存的nosql數(shù)據(jù)庫，可以通過新建線程的形式進行持久化，不影響Redis單線程的讀寫操作通過list取最新的N條數(shù)據(jù)模擬類似于token這種需要設(shè)置過期時間的場景發(fā)布訂閱消息系統(tǒng)定時器、計數(shù)器

194、Redis有哪些功能？

1、基于本機內(nèi)存的緩存

當調(diào)用api訪問數(shù)據(jù)庫時，假如此過程需要2秒，如果每次請求都要訪問數(shù)據(jù)庫，那將對服務(wù)器造成巨大的壓力，如果將此sql的查詢結(jié)果存到Redis中，再次請求時，直接從Redis中取得，而不是訪問數(shù)據(jù)庫，效率將得到巨大的提升，Redis可以定時去更新數(shù)據(jù)（比如1分鐘）。

2、如果電腦重啟，寫入內(nèi)存的數(shù)據(jù)是不是就失效了呢，這時Redis還提供了持久化的功能。

3、哨兵（Sentinel）和復(fù)制

Sentinel可以管理多個Redis服務(wù)器，它提供了監(jiān)控、提醒以及自動的故障轉(zhuǎn)移功能；

復(fù)制則是讓Redis服務(wù)器可以配備備份的服務(wù)器；

Redis也是通過這兩個功能保證Redis的高可用；

4、集群（Cluster）

單臺服務(wù)器資源總是有上限的，CPU和IO資源可以通過主從復(fù)制，進行讀寫分離，把一部分CPU和IO的壓力轉(zhuǎn)移到從服務(wù)器上，但是內(nèi)存資源怎么辦，主從模式只是數(shù)據(jù)的備份，并不能擴充內(nèi)存；

現(xiàn)在我們可以橫向擴展，讓每臺服務(wù)器只負責一部分任務(wù)，然后將這些服務(wù)器構(gòu)成一個整體，對外界來說，這一組服務(wù)器就像是集群一樣。

195、Redis支持的數(shù)據(jù)類型有哪些？

字符串hashlistsetzset

196、Redis取值存值問題

1、先把Redis的連接池拿出來

JedisPool pool = new JedisPool(new JedisPoolConfig(),"127.0.0.1");
 
Jedis jedis = pool.getResource();

2、存取值

jedis.set("key","value");
jedis.get("key");
jedis.del("key");
//給一個key疊加value
jedis.append("key","value2");//此時key的值就是value + value2;
//同時給多個key進行賦值：
jedis.mset("key1","value1","key2","value2");

3、對map進行操作

Map<String,String> user = new HashMap();
user.put("key1","value1");
user.put("key2","value2");
user.put("key3","value3");
//存入
jedis.hmset("user",user);
//取出user中key1 
List<String> nameMap = jedis.hmget("user","key1");
//刪除其中一個鍵值
jedis.hdel("user","key2");
//是否存在一個鍵
jedis.exists("user");
//取出所有的Map中的值：
Iterator<String> iter = jedis.hkeys("user").iterator();
while(iter.next()){
    jedis.hmget("user",iter.next());
}

197、Redis為什么是單線程的？

• 代碼更清晰，處理邏輯更簡單；
• 不用考慮各種鎖的問題，不存在加鎖和釋放鎖的操作，沒有因為可能出現(xiàn)死鎖而導(dǎo)致的性能問題；
• 不存在多線程切換而消耗CPU；
• 無法發(fā)揮多核CPU的優(yōu)勢，但可以采用多開幾個Redis實例來完善

198、Redis真的是單線程的嗎？

Redis6.0之前是單線程的，Redis6.0之后開始支持多線程；

redis內(nèi)部使用了基于epoll的多路服用，也可以多部署幾個redis服務(wù)器解決單線程的問題；

redis主要的性能瓶頸是內(nèi)存和網(wǎng)絡(luò)；

內(nèi)存好說，加內(nèi)存條就行了，而網(wǎng)絡(luò)才是大 麻煩，所以redis6內(nèi)存好說，加內(nèi)存條就行了；

而網(wǎng)絡(luò)才是大 麻煩，所以redis6.0引入了多線程的概念，

redis6.0在網(wǎng)絡(luò)IO處理方面引入了多線程，如網(wǎng)絡(luò)數(shù)據(jù)的讀寫和協(xié)議解析等，需要注意的是，執(zhí)行命令的核心模塊還是單線程的。

199、Redis持久化有幾種方式？

redis提供了兩種持久化的方式，分別是RDB（Redis DataBase）和AOF（Append Only File）。

RDB，簡而言之，就是在不同的時間點，將redis存儲的數(shù)據(jù)生成快照并存儲到磁盤等介質(zhì)上；

AOF，則是換了一個角度來實現(xiàn)持久化，那就是將redis執(zhí)行過的所有寫指令記錄下來，在下次redis重新啟動時，只要把這些寫指令從前到后再重復(fù)執(zhí)行一遍，就可以實現(xiàn)數(shù)據(jù)恢復(fù)了。

其實RDB和AOF兩種方式也可以同時使用，在這種情況下，如果redis重啟的話，則會優(yōu)先采用AOF方式來進行數(shù)據(jù)恢復(fù)，這是因為AOF方式的數(shù)據(jù)恢復(fù)完整度更高。

如果你沒有數(shù)據(jù)持久化的需求，也完全可以關(guān)閉RDB和AOF方式，這樣的話，redis將變成一個純內(nèi)存數(shù)據(jù)庫，就像memcache一樣。

200、Redis和 memecache 有什么區(qū)別？

1、Redis相比memecache，擁有更多的數(shù)據(jù)結(jié)構(gòu)和支持更豐富的數(shù)據(jù)操作。

（1）Redis支持key-value，常用的數(shù)據(jù)類型主要有String、Hash、List、Set、Sorted Set。

（2）memecache只支持key-value。

2、內(nèi)存使用率對比，Redis采用hash結(jié)構(gòu)來做key-value存儲，由于其組合式的壓縮，其內(nèi)存利用率會高于memecache。

3、性能對比：Redis只使用單核，memecache使用多核。

4、Redis支持磁盤持久化，memecache不支持。

Redis可以將一些很久沒用到的value通過swap方法交換到磁盤。

5、Redis支持分布式集群，memecache不支持。

201、Redis支持的 java 客戶端都有哪些？

Redisson、Jedis、lettuce 等等，官方推薦使用 Redisson。

202、jedis 和 redisson 有哪些區(qū)別？

Jedis 和 Redisson 都是Java中對Redis操作的封裝。

Jedis 只是簡單的封裝了 Redis 的API庫，可以看作是Redis客戶端，它的方法和Redis 的命令很類似。

Redisson 不僅封裝了 redis ，還封裝了對更多數(shù)據(jù)結(jié)構(gòu)的支持，以及鎖等功能，相比于Jedis 更加大。

但Jedis相比于Redisson 更原生一些，更靈活。

203、什么是緩存穿透？怎么解決？

1、緩存穿透

一般的緩存系統(tǒng)，都是按照key去緩存查詢，如果不存在對用的value，就應(yīng)該去后端系統(tǒng)查找（比如DB數(shù)據(jù)庫）。

一些惡意的請求會故意查詢不存在的key，請求量很大，就會對后端系統(tǒng)造成很大的壓力。

這就叫做緩存穿透。

2、怎么解決？

對查詢結(jié)果為空的情況也進行緩存，緩存時間設(shè)置短一點，或者該key對應(yīng)的數(shù)據(jù)insert之后清理緩存。

對一定不存在的key進行過濾?？梢园阉械目赡艽嬖诘膋ey放到一個大的Bitmap中，查詢時通過該Bitmap過濾。

3、緩存雪崩

當緩存服務(wù)器重啟或者大量緩存集中在某一時間段失效，這樣在失效的時候，會給后端系統(tǒng)帶來很大的壓力，導(dǎo)致系統(tǒng)崩潰。

4、如何解決？

在緩存失效后，通過加鎖或者隊列來控制讀數(shù)據(jù)庫寫緩存的線程數(shù)量。

比如

• 對某個key只允許一個線程查詢數(shù)據(jù)和寫緩存，其它線程等待；
• 做二級緩存；
• 不同的key，設(shè)置不同的過期時間，讓緩存失效的時間盡量均勻；

204、怎么保證緩存和數(shù)據(jù)庫數(shù)據(jù)的一致性？

1、淘汰緩存

數(shù)據(jù)如果為較為復(fù)雜的數(shù)據(jù)時，進行緩存的更新操作就會變得異常復(fù)雜，因此一般推薦選擇淘汰緩存，而不是更新緩存。

2、選擇先淘汰緩存，再更新數(shù)據(jù)庫

假如先更新數(shù)據(jù)庫，再淘汰緩存，如果淘汰緩存失敗，那么后面的請求都會得到臟數(shù)據(jù)，直至緩存過期。

假如先淘汰緩存再更新數(shù)據(jù)庫，如果更新數(shù)據(jù)庫失敗，只會產(chǎn)生一次緩存穿透，相比較而言，后者對業(yè)務(wù)則沒有本質(zhì)上的影響。

3、延時雙刪策略

如下場景：同時有一個請求A進行更新操作，另一個請求B進行查詢操作。

請求A進行寫操作，刪除緩存請求B查詢發(fā)現(xiàn)緩存不存在請求B去數(shù)據(jù)庫查詢得到舊值請求B將舊值寫入緩存請求A將新值寫入數(shù)據(jù)庫

次數(shù)便出現(xiàn)了數(shù)據(jù)不一致問題。采用延時雙刪策略得以解決。

public void write(String key,Object data){
    redisUtils.del(key);
    db.update(data);
    Thread.Sleep(100);
    redisUtils.del(key);
}

這么做，可以將1秒內(nèi)所造成的緩存臟數(shù)據(jù)，再次刪除。這個時間設(shè)定可根據(jù)俄業(yè)務(wù)場景進行一個調(diào)節(jié)。

4、數(shù)據(jù)庫讀寫分離的場景

兩個請求，一個請求A進行更新操作，另一個請求B進行查詢操作。

1. 請求A進行寫操作，刪除緩存
2. 請求A將數(shù)據(jù)寫入數(shù)據(jù)庫了
3. 請求B查詢緩存發(fā)現(xiàn)，緩存沒有值
4. 請求B去從庫查詢這時，還沒有完成主從同步，因此查詢到的是舊值
5. 請求B將舊值寫入緩存
6. 數(shù)據(jù)庫完成主從同步，從庫變?yōu)樾轮?/li>

依舊采用延時雙刪策略解決此問題。

205、Redis，什么是緩存穿透？怎么解決？

1、緩存穿透

一般的緩存系統(tǒng)，都是按照key去緩存查詢，如果不存在對用的value，就應(yīng)該去后端系統(tǒng)查找（比如DB數(shù)據(jù)庫）。

一些惡意的請求會故意查詢不存在的key，請求量很大，就會對后端系統(tǒng)造成很大的壓力。

這就叫做緩存穿透。

2、怎么解決？

對查詢結(jié)果為空的情況也進行緩存，緩存時間設(shè)置短一點，或者該key對應(yīng)的數(shù)據(jù)insert之后清理緩存。

對一定不存在的key進行過濾。可以把所有的可能存在的key放到一個大的Bitmap中，查詢時通過該Bitmap過濾。

3、緩存雪崩

當緩存服務(wù)器重啟或者大量緩存集中在某一時間段失效，這樣在失效的時候，會給后端系統(tǒng)帶來很大的壓力，導(dǎo)致系統(tǒng)崩潰。

4、如何解決？

在緩存失效后，通過加鎖或者隊列來控制讀數(shù)據(jù)庫寫緩存的線程數(shù)量。

比如

1. 對某個key只允許一個線程查詢數(shù)據(jù)和寫緩存，其它線程等待；
2. 做二級緩存；
3. 不同的key，設(shè)置不同的過期時間，讓緩存失效的時間盡量均勻；

206、Redis怎么實現(xiàn)分布式鎖？

使用Redis實現(xiàn)分布式鎖

redis命令：set users 10 nx ex 12   原子性命令

//使用uuid，解決鎖釋放的問題
@GetMapping
public void testLock() throws InterruptedException {
    String uuid = UUID.randomUUID().toString();
    Boolean b_lock = redisTemplate.opsForValue().setIfAbsent("lock", uuid, 10, TimeUnit.SECONDS);
    if(b_lock){
        Object value = redisTemplate.opsForValue().get("num");
        if(StringUtils.isEmpty(value)){
            return;
        }
        int num = Integer.parseInt(value + "");
        redisTemplate.opsForValue().set("num",++num);
        Object lockUUID = redisTemplate.opsForValue().get("lock");
        if(uuid.equals(lockUUID.toString())){
            redisTemplate.delete("lock");
        }
    }else{
        Thread.sleep(100);
        testLock();
    }
}

備注：可以通過lua腳本，保證分布式鎖的原子性。

207、Redis分布式鎖有什么缺陷？

Redis 分布式鎖不能解決超時的問題，分布式鎖有一個超時時間，程序的執(zhí)行如果超出了鎖的超時時間就會出現(xiàn)問題。

Redis容易產(chǎn)生的幾個問題：

1. 鎖未被釋放
2. B鎖被A鎖釋放了
3. 數(shù)據(jù)庫事務(wù)超時
4. 鎖過期了，業(yè)務(wù)還沒執(zhí)行完
5. Redis主從復(fù)制的問題

208、Redis如何做內(nèi)存優(yōu)化？

1、縮短鍵值的長度

1. 縮短值的長度才是關(guān)鍵，如果值是一個大的業(yè)務(wù)對象，可以將對象序列化成二進制數(shù)組；
2. 首先應(yīng)該在業(yè)務(wù)上進行精簡，去掉不必要的屬性，避免存儲一些沒用的數(shù)據(jù)；
3. 其次是序列化的工具選擇上，應(yīng)該選擇更高效的序列化工具來降低字節(jié)數(shù)組大小；
4. 以Java為例，內(nèi)置的序列化方式無論從速度還是壓縮比都不盡如人意，這時可以選擇更高效的序列化工具，如: protostuff，kryo等

2、共享對象池

對象共享池指Redis內(nèi)部維護[0-9999]的整數(shù)對象池

。創(chuàng)建大量的整數(shù)類型redisObject存在內(nèi)存開銷，每個redisObject內(nèi)部結(jié)構(gòu)至少占16字節(jié)，甚至超過了整數(shù)自身空間消耗。

所以Redis內(nèi)存維護一個[0-9999]的整數(shù)對象池，用于節(jié)約內(nèi)存。

除了整數(shù)值對象，其他類型如list,hash,set,zset內(nèi)部元素也可以使用整數(shù)對象池。

因此開發(fā)中在滿足需求的前提下，盡量使用整數(shù)對象以節(jié)省內(nèi)存。

3、字符串優(yōu)化

4、編碼優(yōu)化

5、控制key的數(shù)量

到此這篇關(guān)于Java經(jīng)典面試題最全匯總208道(六)的文章就介紹到這了,更多相關(guān)Java面試題內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論