public?static?Integer?valueOf(int?i)?{
????if?(i?>=?IntegerCache.low?&&?i?<= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

5. Kira 2 kali 8 dengan cara yang paling cekap

Ini mungkin yang dipanggil "rakan sepasukan babi". >

6、&和&&的區(qū)別？

&&：邏輯與運(yùn)算符。當(dāng)運(yùn)算符左右兩邊的表達(dá)式都為 true，才返回 true。同時(shí)具有短路性，如果第一個(gè)表達(dá)式為 false，則直接返回 false。

&：邏輯與運(yùn)算符、按位與運(yùn)算符。

按位與運(yùn)算符：用于二進(jìn)制的計(jì)算，只有對(duì)應(yīng)的兩個(gè)二進(jìn)位均為1時(shí)，結(jié)果位才為1 ，否則為0。

邏輯與運(yùn)算符：& 在用于邏輯與時(shí)，和 && 的區(qū)別是不具有短路性。所在通常使用邏輯與運(yùn)算符都會(huì)使用 &&，而 & 更多的適用于位運(yùn)算。

7、String 是 Java 基本數(shù)據(jù)類型嗎？

答：不是。Java 中的基本數(shù)據(jù)類型只有8個(gè)：byte、short、int、long、float、double、char、boolean；除了基本類型（primitive type），剩下的都是引用類型（reference type）。

基本數(shù)據(jù)類型：數(shù)據(jù)直接存儲(chǔ)在棧上

引用數(shù)據(jù)類型區(qū)別：數(shù)據(jù)存儲(chǔ)在堆上，棧上只存儲(chǔ)引用地址

8、String 類可以繼承嗎？

不行。String 類使用 final 修飾，無法被繼承。

9、String和StringBuilder、StringBuffer的區(qū)別？

String：String 的值被創(chuàng)建后不能修改，任何對(duì) String 的修改都會(huì)引發(fā)新的 String 對(duì)象的生成。

StringBuffer：跟 String 類似，但是值可以被修改，使用 synchronized 來保證線程安全。

StringBuilder：StringBuffer 的非線程安全版本，沒有使用 synchronized，具有更高的性能，推薦優(yōu)先使用。

10、String s = new String("xyz") 創(chuàng)建了幾個(gè)字符串對(duì)象？

一個(gè)或兩個(gè)。如果字符串常量池已經(jīng)有“xyz”，則是一個(gè)；否則，兩個(gè)。

當(dāng)字符創(chuàng)常量池沒有 “xyz”，此時(shí)會(huì)創(chuàng)建如下兩個(gè)對(duì)象：

一個(gè)是字符串字面量 "xyz" 所對(duì)應(yīng)的、駐留（intern）在一個(gè)全局共享的字符串常量池中的實(shí)例，此時(shí)該實(shí)例也是在堆中，字符串常量池只放引用。

另一個(gè)是通過 new String() 創(chuàng)建并初始化的，內(nèi)容與"xyz"相同的實(shí)例，也是在堆中。

11、String s = "xyz" 和 String s = new String("xyz") 區(qū)別？

兩個(gè)語(yǔ)句都會(huì)先去字符串常量池中檢查是否已經(jīng)存在 “xyz”，如果有則直接使用，如果沒有則會(huì)在常量池中創(chuàng)建 “xyz” 對(duì)象。

另外，String s = new String("xyz") 還會(huì)通過 new String() 在堆里創(chuàng)建一個(gè)內(nèi)容與 "xyz" 相同的對(duì)象實(shí)例。

所以前者其實(shí)理解為被后者的所包含。

12、== 和 equals 的區(qū)別是什么？

==：運(yùn)算符，用于比較基礎(chǔ)類型變量和引用類型變量。

對(duì)于基礎(chǔ)類型變量，比較的變量保存的值是否相同，類型不一定要相同。

short s1 = 1; long l1 = 1;
// 結(jié)果：true。類型不同，但是值相同
System.out.println(s1 == l1);

對(duì)于引用類型變量，比較的是兩個(gè)對(duì)象的地址是否相同。

Integer i1 = new Integer(1);
Integer i2 = new Integer(1);
// 結(jié)果：false。通過new創(chuàng)建，在內(nèi)存中指向兩個(gè)不同的對(duì)象
System.out.println(i1 == i2);

equals：Object 類中定義的方法，通常用于比較兩個(gè)對(duì)象的值是否相等。

equals 在 Object 方法中其實(shí)等同于 ==，但是在實(shí)際的使用中，equals 通常被重寫用于比較兩個(gè)對(duì)象的值是否相同。

Integer i1 = new Integer(1);
Integer i2 = new Integer(1);
// 結(jié)果：true。兩個(gè)不同的對(duì)象，但是具有相同的值
System.out.println(i1.equals(i2));

// Integer的equals重寫方法
public boolean equals(Object obj) {
    if (obj instanceof Integer) {
        // 比較對(duì)象中保存的值是否相同
        return value == ((Integer)obj).intValue();
    }
    return false;
}

13、兩個(gè)對(duì)象的 hashCode() 相同，則 equals() 也一定為 true，對(duì)嗎？

不對(duì)。hashCode() 和 equals() 之間的關(guān)系如下：

當(dāng)有 a.equals(b) == true 時(shí)，則 a.hashCode() == b.hashCode() 必然成立，

反過來，當(dāng) a.hashCode() == b.hashCode() 時(shí)，a.equals(b) 不一定為 true。

14、什么是反射

反射是指在運(yùn)行狀態(tài)中，對(duì)于任意一個(gè)類都能夠知道這個(gè)類所有的屬性和方法；并且對(duì)于任意一個(gè)對(duì)象，都能夠調(diào)用它的任意一個(gè)方法；這種動(dòng)態(tài)獲取信息以及動(dòng)態(tài)調(diào)用對(duì)象方法的功能稱為反射機(jī)制。

15、深拷貝和淺拷貝區(qū)別是什么？

數(shù)據(jù)分為基本數(shù)據(jù)類型和引用數(shù)據(jù)類型。基本數(shù)據(jù)類型：數(shù)據(jù)直接存儲(chǔ)在棧中；引用數(shù)據(jù)類型：存儲(chǔ)在棧中的是對(duì)象的引用地址，真實(shí)的對(duì)象數(shù)據(jù)存放在堆內(nèi)存里。

淺拷貝：對(duì)于基礎(chǔ)數(shù)據(jù)類型：直接復(fù)制數(shù)據(jù)值；對(duì)于引用數(shù)據(jù)類型：只是復(fù)制了對(duì)象的引用地址，新舊對(duì)象指向同一個(gè)內(nèi)存地址，修改其中一個(gè)對(duì)象的值，另一個(gè)對(duì)象的值隨之改變。

深拷貝：對(duì)于基礎(chǔ)數(shù)據(jù)類型：直接復(fù)制數(shù)據(jù)值；對(duì)于引用數(shù)據(jù)類型：開辟新的內(nèi)存空間，在新的內(nèi)存空間里復(fù)制一個(gè)一模一樣的對(duì)象，新老對(duì)象不共享內(nèi)存，修改其中一個(gè)對(duì)象的值，不會(huì)影響另一個(gè)對(duì)象。

深拷貝相比于淺拷貝速度較慢并且花銷較大。

16、并發(fā)和并行有什么區(qū)別？

并發(fā)：兩個(gè)或多個(gè)事件在同一時(shí)間間隔發(fā)生。

并行：兩個(gè)或者多個(gè)事件在同一時(shí)刻發(fā)生。

并行是真正意義上，同一時(shí)刻做多件事情，而并發(fā)在同一時(shí)刻只會(huì)做一件事件，只是可以將時(shí)間切碎，交替做多件事情。

網(wǎng)上有個(gè)例子挺形象的：

你吃飯吃到一半，電話來了，你一直到吃完了以后才去接，這就說明你不支持并發(fā)也不支持并行。

你吃飯吃到一半，電話來了，你停了下來接了電話，接完后繼續(xù)吃飯，這說明你支持并發(fā)。

你吃飯吃到一半，電話來了，你一邊打電話一邊吃飯，這說明你支持并行。

17、構(gòu)造器是否可被 重寫?

Constructor 不能被 override（重寫），但是可以 overload（重載），所以你可以看到?個(gè)類中有多個(gè)構(gòu)造函數(shù)的情況。

18、當(dāng)一個(gè)對(duì)象被當(dāng)作參數(shù)傳遞到一個(gè)方法后，此方法可改變這個(gè)對(duì)象的屬性，并可返回變化后的結(jié)果，那么這里到底是值傳遞還是引用傳遞？

值傳遞。Java 中只有值傳遞，對(duì)于對(duì)象參數(shù)，值的內(nèi)容是對(duì)象的引用。

19、Java 靜態(tài)變量和成員變量的區(qū)別。

public class Demo {
    /**
     * 靜態(tài)變量：又稱類變量，static修飾
     */
    public static String STATIC_VARIABLE = "靜態(tài)變量";
    /**
     * 實(shí)例變量：又稱成員變量，沒有static修飾
     */
    public String INSTANCE_VARIABLE = "實(shí)例變量";
}

成員變量存在于堆內(nèi)存中。靜態(tài)變量存在于方法區(qū)中。

成員變量與對(duì)象共存亡，隨著對(duì)象創(chuàng)建而存在，隨著對(duì)象被回收而釋放。靜態(tài)變量與類共存亡，隨著類的加載而存在，隨著類的消失而消失。

成員變量所屬于對(duì)象，所以也稱為實(shí)例變量。靜態(tài)變量所屬于類，所以也稱為類變量。

成員變量只能被對(duì)象所調(diào)用 。靜態(tài)變量可以被對(duì)象調(diào)用，也可以被類名調(diào)用。

20、是否可以從一個(gè)靜態(tài)（static）方法內(nèi)部發(fā)出對(duì)非靜態(tài)（non-static）方法的調(diào)用？

區(qū)分兩種情況，發(fā)出調(diào)用時(shí)是否顯示創(chuàng)建了對(duì)象實(shí)例。

1）沒有顯示創(chuàng)建對(duì)象實(shí)例：不可以發(fā)起調(diào)用，非靜態(tài)方法只能被對(duì)象所調(diào)用，靜態(tài)方法可以通過對(duì)象調(diào)用，也可以通過類名調(diào)用，所以靜態(tài)方法被調(diào)用時(shí)，可能還沒有創(chuàng)建任何實(shí)例對(duì)象。因此通過靜態(tài)方法內(nèi)部發(fā)出對(duì)非靜態(tài)方法的調(diào)用，此時(shí)可能無法知道非靜態(tài)方法屬于哪個(gè)對(duì)象。

public class Demo {
    public static void staticMethod() {
        // 直接調(diào)用非靜態(tài)方法：編譯報(bào)錯(cuò)
        instanceMethod();
    }
    public void instanceMethod() {
        System.out.println("非靜態(tài)方法");
    }
}

2）顯示創(chuàng)建對(duì)象實(shí)例：可以發(fā)起調(diào)用，在靜態(tài)方法中顯示的創(chuàng)建對(duì)象實(shí)例，則可以正常的調(diào)用。

public class Demo {
    public static void staticMethod() {
        // 先創(chuàng)建實(shí)例對(duì)象，再調(diào)用非靜態(tài)方法：成功執(zhí)行
        Demo demo = new Demo();
        demo.instanceMethod();
    }
    public void instanceMethod() {
        System.out.println("非靜態(tài)方法");
    }
}

21、初始化考察，請(qǐng)指出下面程序的運(yùn)行結(jié)果。

public class InitialTest {
    public static void main(String[] args) {
        A ab = new B();
        ab = new B();
    }
}
class A {
    static { // 父類靜態(tài)代碼塊
        System.out.print("A");
    }
    public A() { // 父類構(gòu)造器
        System.out.print("a");
    }
}
class B extends A {
    static { // 子類靜態(tài)代碼塊
        System.out.print("B");
    }
    public B() { // 子類構(gòu)造器
        System.out.print("b");
    }
}

執(zhí)行結(jié)果：ABabab，兩個(gè)考察點(diǎn)：

1）靜態(tài)變量只會(huì)初始化（執(zhí)行）一次。

2）當(dāng)有父類時(shí)，完整的初始化順序?yàn)椋焊割愳o態(tài)變量（靜態(tài)代碼塊）->子類靜態(tài)變量（靜態(tài)代碼塊）->父類非靜態(tài)變量（非靜態(tài)代碼塊）->父類構(gòu)造器 ->子類非靜態(tài)變量（非靜態(tài)代碼塊）->子類構(gòu)造器 。

關(guān)于初始化，這題算入門題，我之前還寫過一道有（fei）點(diǎn)（chang）意（bian）思（tai）的進(jìn)階題目，有興趣的可以看看：一道有意思的“初始化”面試題

22、重載（Overload）和重寫（Override）的區(qū)別？

方法的重載和重寫都是實(shí)現(xiàn)多態(tài)的方式，區(qū)別在于前者實(shí)現(xiàn)的是編譯時(shí)的多態(tài)性，而后者實(shí)現(xiàn)的是運(yùn)行時(shí)的多態(tài)性。

重載：一個(gè)類中有多個(gè)同名的方法，但是具有有不同的參數(shù)列表（參數(shù)類型不同、參數(shù)個(gè)數(shù)不同或者二者都不同）。

重寫：發(fā)生在子類與父類之間，子類對(duì)父類的方法進(jìn)行重寫，參數(shù)都不能改變，返回值類型可以不相同，但是必須是父類返回值的派生類。即外殼不變，核心重寫！重寫的好處在于子類可以根據(jù)需要，定義特定于自己的行為。

23、為什么不能根據(jù)返回類型來區(qū)分重載？

如果我們有兩個(gè)方法如下，當(dāng)我們調(diào)用：test(1) 時(shí)，編譯器無法確認(rèn)要調(diào)用的是哪個(gè)。

//?方法1
int?test(int?a);
//?方法2
long?test(int?a);

方法的返回值只是作為方法運(yùn)行之后的一個(gè)“狀態(tài)”，但是并不是所有調(diào)用都關(guān)注返回值，所以不能將返回值作為重載的唯一區(qū)分條件。

24、抽象類（abstract class）和接口（interface）有什么區(qū)別？

抽象類只能單繼承，接口可以多實(shí)現(xiàn)。

抽象類可以有構(gòu)造方法，接口中不能有構(gòu)造方法。

抽象類中可以有成員變量，接口中沒有成員變量，只能有常量（默認(rèn)就是 public static final）

抽象類中可以包含非抽象的方法，在 Java 7 之前接口中的所有方法都是抽象的，在 Java 8 之后，接口支持非抽象方法：default 方法、靜態(tài)方法等。Java 9 支持私有方法、私有靜態(tài)方法。

抽象類中的方法類型可以是任意修飾符，Java 8 之前接口中的方法只能是 public 類型，Java 9 支持 private 類型。

設(shè)計(jì)思想的區(qū)別：

接口是自上而下的抽象過程，接口規(guī)范了某些行為，是對(duì)某一行為的抽象。我需要這個(gè)行為，我就去實(shí)現(xiàn)某個(gè)接口，但是具體這個(gè)行為怎么實(shí)現(xiàn)，完全由自己決定。

抽象類是自下而上的抽象過程，抽象類提供了通用實(shí)現(xiàn)，是對(duì)某一類事物的抽象。我們?cè)趯憣?shí)現(xiàn)類的時(shí)候，發(fā)現(xiàn)某些實(shí)現(xiàn)類具有幾乎相同的實(shí)現(xiàn)，因此我們將這些相同的實(shí)現(xiàn)抽取出來成為抽象類，然后如果有一些差異點(diǎn)，則可以提供抽象方法來支持自定義實(shí)現(xiàn)。

我在網(wǎng)上看到有個(gè)說法，挺形象的：

普通類像親爹 ，他有啥都是你的。

抽象類像叔伯，有一部分會(huì)給你，還能指導(dǎo)你做事的方法。

接口像干爹，可以給你指引方法，但是做成啥樣得你自己努力實(shí)現(xiàn)。

25、Error 和 Exception 有什么區(qū)別？

Error 和 Exception 都是 Throwable 的子類，用于表示程序出現(xiàn)了不正常的情況。區(qū)別在于：

Error 表示系統(tǒng)級(jí)的錯(cuò)誤和程序不必處理的異常，是恢復(fù)不是不可能但很困難的情況下的一種嚴(yán)重問題，比如內(nèi)存溢出，不可能指望程序能處理這樣的情況。

Exception 表示需要捕捉或者需要程序進(jìn)行處理的異常，是一種設(shè)計(jì)或?qū)崿F(xiàn)問題，也就是說，它表示如果程序運(yùn)行正常，從不會(huì)發(fā)生的情況。

26、Java 中的 final 關(guān)鍵字有哪些用法？

修飾類：該類不能再派生出新的子類，不能作為父類被繼承。因此，一個(gè)類不能同時(shí)被聲明為abstract 和 final。

修飾方法：該方法不能被子類重寫。

修飾變量：該變量必須在聲明時(shí)給定初值，而在以后只能讀取，不可修改。 如果變量是對(duì)象，則指的是引用不可修改，但是對(duì)象的屬性還是可以修改的。

public?class?FinalDemo?{
????//?不可再修改該變量的值
????public?static?final?int?FINAL_VARIABLE?=?0;
????//?不可再修改該變量的引用，但是可以直接修改屬性值
????public?static?final?User?USER?=?new?User();
????public?static?void?main(String[]?args)?{
????????//?輸出：User(id=0,?name=null,?age=0)
????????System.out.println(USER);
????????//?直接修改屬性值
????????USER.setName("test");
????????//?輸出：User(id=0,?name=test,?age=0)
????????System.out.println(USER);
????}
}

27、闡述 final、finally、finalize 的區(qū)別。

其實(shí)是三個(gè)完全不相關(guān)的東西，只是長(zhǎng)的有點(diǎn)像。。

final 如上所示。

finally：finally 是對(duì) Java 異常處理機(jī)制的最佳補(bǔ)充，通常配合 try、catch 使用，用于存放那些無論是否出現(xiàn)異常都一定會(huì)執(zhí)行的代碼。在實(shí)際使用中，通常用于釋放鎖、數(shù)據(jù)庫(kù)連接等資源，把資源釋放方法放到 finally 中，可以大大降低程序出錯(cuò)的幾率。

finalize：Object 中的方法，在垃圾收集器將對(duì)象從內(nèi)存中清除出去之前做必要的清理工作。finalize()方法僅作為了解即可，在 Java 9 中該方法已經(jīng)被標(biāo)記為廢棄，并添加新的 java.lang.ref.Cleaner，提供了更靈活和有效的方法來釋放資源。這也側(cè)面說明了，這個(gè)方法的設(shè)計(jì)是失敗的，因此更加不能去使用它。

28、try、catch、finally 考察，請(qǐng)指出下面程序的運(yùn)行結(jié)果。

public?class?TryDemo?{
????public?static?void?main(String[]?args)?{
????????System.out.println(test());
????}
????public?static?int?test()?{
????????try?{
????????????return?1;
????????}?catch?(Exception?e)?{
????????????return?2;
????????}?finally?{
????????????System.out.print("3");
????????}
????}
}

執(zhí)行結(jié)果：31。

相信很多同學(xué)應(yīng)該都做對(duì)了，try、catch。finally 的基礎(chǔ)用法，在 return 前會(huì)先執(zhí)行 finally 語(yǔ)句塊，所以是先輸出 finally 里的 3，再輸出 return 的 1。

29、try、catch、finally 考察2，請(qǐng)指出下面程序的運(yùn)行結(jié)果。

public?class?TryDemo?{
????public?static?void?main(String[]?args)?{
????????System.out.println(test1());
????}
????public?static?int?test1()?{
????????try?{
????????????return?2;
????????}?finally?{
????????????return?3;
????????}
????}
}

執(zhí)行結(jié)果：3。

這題有點(diǎn)陷阱，但也不難，try 返回前先執(zhí)行 finally，結(jié)果 finally 里不按套路出牌，直接 return 了，自然也就走不到 try 里面的 return 了。

finally 里面使用 return 僅存在于面試題中，實(shí)際開發(fā)中千萬不要這么用。

30、try、catch、finally 考察3，請(qǐng)指出下面程序的運(yùn)行結(jié)果。

public?class?TryDemo?{
????public?static?void?main(String[]?args)?{
????????System.out.println(test1());
????}
????public?static?int?test1()?{
????????int?i?=?0;
????????try?{
????????????i?=?2;
????????????return?i;
????????}?finally?{
????????????i?=?3;
????????}
????}
}

執(zhí)行結(jié)果：2。

這邊估計(jì)有不少同學(xué)會(huì)以為結(jié)果應(yīng)該是 3，因?yàn)槲覀冎涝?return 前會(huì)執(zhí)行 finally，而 i 在 finally 中被修改為 3 了，那最終返回 i 不是應(yīng)該為 3 嗎？確實(shí)很容易這么想，我最初也是這么想的，當(dāng)初的自己還是太年輕了啊。

這邊的根本原因是，在執(zhí)行 finally 之前，JVM 會(huì)先將 i 的結(jié)果暫存起來，然后 finally 執(zhí)行完畢后，會(huì)返回之前暫存的結(jié)果，而不是返回 i，所以即使這邊 i 已經(jīng)被修改為 3，最終返回的還是之前暫存起來的結(jié)果 2。

Sebenarnya, ia boleh dilihat dengan mudah berdasarkan kod bait Sebelum memasuki akhirnya, JVM akan menggunakan arahan iload dan istore untuk menyimpan hasil sementara apabila ia akhirnya kembali, ia akan mengembalikan hasil sementara melalui iload dan arahan pemulangan.

Untuk mengelakkan suasana menjadi tidak normal lagi, saya tidak akan menyiarkan program bytecode khusus di sini. Pelajar yang berminat boleh menyusunnya dan menyemaknya sendiri.

31. Apakah ciri baharu selepas JDK1.8?

Kaedah lalai antara muka: Java 8 membenarkan kami menambah pelaksanaan kaedah bukan abstrak pada antara muka, hanya gunakan kata kunci lalai

Ungkapan Lambda dan antara muka berfungsi: Lambda Satu ungkapan ialah pada asasnya kelas dalaman tanpa nama, atau ia boleh menjadi sekeping kod yang boleh dihantar. Lambda membenarkan fungsi digunakan sebagai parameter kaedah (fungsi dihantar ke kaedah sebagai parameter Gunakan ungkapan Lambda untuk membuat kod lebih ringkas, tetapi jangan menyalahgunakannya, jika tidak, akan ada masalah kebolehbacaan, Josh). Bloch, pengarang "Effective Java" mencadangkan Sebaik-baiknya menggunakan ungkapan lambda dalam tidak lebih daripada 3 baris.

API Strim: Alat untuk melaksanakan operasi kompleks pada kelas pengumpulan menggunakan pengaturcaraan berfungsi Ia boleh digunakan dengan ungkapan Lambda untuk memproses koleksi dengan mudah. Abstraksi utama untuk bekerja dengan koleksi dalam Java 8. Ia membolehkan anda menentukan operasi yang ingin anda lakukan pada koleksi dan boleh melakukan operasi yang sangat kompleks seperti mencari, menapis dan memetakan data. Menggunakan API Strim untuk mengendalikan data pengumpulan adalah serupa dengan menggunakan SQL untuk melaksanakan pertanyaan pangkalan data. Anda juga boleh menggunakan API Strim untuk melaksanakan operasi secara selari. Ringkasnya, Stream API menyediakan cara yang cekap dan mudah digunakan untuk memproses data.

Rujukan kaedah: Rujukan kaedah menyediakan sintaks yang sangat berguna yang boleh merujuk secara langsung kaedah atau pembina kelas atau objek Java (contoh). Digunakan bersama lambda, rujukan kaedah boleh menjadikan struktur bahasa lebih padat dan ringkas serta mengurangkan kod berlebihan.

API tarikh dan masa: Java 8 memperkenalkan API tarikh dan masa baharu untuk menambah baik pengurusan tarikh dan masa.

Kelas pilihan: NullPointerException yang terkenal ialah punca kegagalan sistem yang paling biasa. Projek Google Guava telah lama diperkenalkan Pilihan sebagai cara untuk menyelesaikan pengecualian penuding nol, tidak meluluskan kod yang dicemari oleh kod semakan nol dan mengharapkan pengaturcara menulis kod bersih. Diilhamkan oleh Google Guava, Optional kini merupakan sebahagian daripada perpustakaan Java 8.

Alat baharu: alatan kompilasi baharu, seperti: jjs enjin Nashorn, jdeps penganalisis pergantungan kelas.

32 Perbezaan antara kaedah wait() dan sleep()

Sumbernya berbeza: sleep() datang dari kelas Thread, wait() datang dari kelas Objek.

Kesan pada kunci penyegerakan adalah berbeza: sleep() tidak akan berfungsi sebagai kunci penyegerakan pada meja Jika utas semasa memegang kunci penyegerakan, sleep tidak akan membenarkan utas melepaskan kunci penyegerakan. wait() akan melepaskan kunci penyegerakan dan membenarkan utas lain memasuki blok kod disegerakkan untuk pelaksanaan.

Skop penggunaan yang berbeza: sleep() boleh digunakan di mana-mana sahaja. wait() hanya boleh digunakan dalam kaedah kawalan disegerakkan atau blok kawalan disegerakkan, jika tidak, IllegalMonitorStateException akan dibuang.

Kaedah pemulihan adalah berbeza: kedua-duanya akan menjeda urutan semasa, tetapi pemulihan adalah berbeza. sleep() akan disambung semula selepas masa tamat; wait() memerlukan urutan lain untuk memanggil notify()/nofityAll() objek yang sama untuk disambung semula.

33 Apakah perbezaan antara kaedah sleep() thread dan yield()?

Benang memasuki keadaan menunggu tamat masa (TIMED_WAITING) selepas melaksanakan kaedah sleep() dan memasuki keadaan sedia (READY) selepas melaksanakan kaedah yield().

Kaedah sleep() tidak mengambil kira keutamaan utas apabila memberi peluang kepada utas lain untuk dijalankan, jadi kaedah ini akan memberi peluang kepada utas keutamaan rendah untuk dijalankan; keutamaan yang sama atau keutamaan yang lebih tinggi Benang mempunyai peluang untuk dijalankan.

34 Untuk apa kaedah join() benang?

digunakan untuk menunggu urutan semasa ditamatkan. Jika utas A melaksanakan penyataan threadB.join(), maksudnya ialah: thread semasa A menunggu sehingga threadB ditamatkan sebelum kembali daripada threadB.join() dan terus melaksanakan kodnya sendiri.

35. Berapa banyak cara yang ada untuk menulis program berbilang benang?

Secara umumnya, terdapat tiga cara: 1) mewarisi kelas Thread 2) melaksanakan antara muka Boleh Dipanggil;

Antaranya, Thread sebenarnya melaksanakan antara muka Boleh Dijalankan. Perbezaan utama antara Runnable dan Callable ialah sama ada terdapat nilai pulangan.

36 Perbezaan antara kaedah panggilan Thread start() dan kaedah run() memanggil

run(): panggilan kaedah biasa, dilaksanakan dalam utas utama, bukan Urutan baharu akan dibuat untuk pelaksanaan.

start(): Mulakan thread baharu Pada masa ini, thread berada dalam keadaan sedia (runnable) dan tidak berjalan Setelah kepingan masa CPU diperoleh, kaedah run() mula dilaksanakan.

37. Aliran keadaan benang

Suatu urutan boleh berada dalam salah satu keadaan berikut:

NEW：新建但是尚未啟動(dòng)的線程處于此狀態(tài)，沒有調(diào)用 start() 方法。

RUNNABLE：包含就緒（READY）和運(yùn)行中（RUNNING）兩種狀態(tài)。線程調(diào)用 start() 方法會(huì)會(huì)進(jìn)入就緒（READY）狀態(tài)，等待獲取 CPU 時(shí)間片。如果成功獲取到 CPU 時(shí)間片，則會(huì)進(jìn)入運(yùn)行中（RUNNING）狀態(tài)。

BLOCKED：線程在進(jìn)入同步方法/同步塊（synchronized）時(shí)被阻塞，等待同步鎖的線程處于此狀態(tài)。

WAITING：無限期等待另一個(gè)線程執(zhí)行特定操作的線程處于此狀態(tài)，需要被顯示的喚醒，否則會(huì)一直等待下去。例如對(duì)于 Object.wait()，需要等待另一個(gè)線程執(zhí)行 Object.notify() 或 Object.notifyAll()；對(duì)于 Thread.join()，則需要等待指定的線程終止。

TIMED_WAITING：在指定的時(shí)間內(nèi)等待另一個(gè)線程執(zhí)行某項(xiàng)操作的線程處于此狀態(tài)。跟 WAITING 類似，區(qū)別在于該狀態(tài)有超時(shí)時(shí)間參數(shù)，在超時(shí)時(shí)間到了后會(huì)自動(dòng)喚醒，避免了無期限的等待。

TERMINATED：執(zhí)行完畢已經(jīng)退出的線程處于此狀態(tài)。

線程在給定的時(shí)間點(diǎn)只能處于一種狀態(tài)。這些狀態(tài)是虛擬機(jī)狀態(tài)，不反映任何操作系統(tǒng)線程狀態(tài)。

38、synchronized 和 Lock 的區(qū)別

1）Lock 是一個(gè)接口；synchronized 是 Java 中的關(guān)鍵字，synchronized 是內(nèi)置的語(yǔ)言實(shí)現(xiàn)；

2）Lock 在發(fā)生異常時(shí)，如果沒有主動(dòng)通過 unLock() 去釋放鎖，很可能會(huì)造成死鎖現(xiàn)象，因此使用 Lock 時(shí)需要在 finally 塊中釋放鎖；synchronized 不需要手動(dòng)獲取鎖和釋放鎖，在發(fā)生異常時(shí)，會(huì)自動(dòng)釋放鎖，因此不會(huì)導(dǎo)致死鎖現(xiàn)象發(fā)生；

3）Lock 的使用更加靈活，可以有響應(yīng)中斷、有超時(shí)時(shí)間等；而 synchronized 卻不行，使用 synchronized 時(shí)，等待的線程會(huì)一直等待下去，直到獲取到鎖；

4）在性能上，隨著近些年 synchronized 的不斷優(yōu)化，Lock 和 synchronized 在性能上已經(jīng)沒有很明顯的差距了，所以性能不應(yīng)該成為我們選擇兩者的主要原因。官方推薦盡量使用 synchronized，除非 synchronized 無法滿足需求時(shí)，則可以使用 Lock。

39、synchronized 各種加鎖場(chǎng)景的作用范圍

1.作用于非靜態(tài)方法，鎖住的是對(duì)象實(shí)例（this），每一個(gè)對(duì)象實(shí)例有一個(gè)鎖。

public?synchronized?void?method()?{}

2.作用于靜態(tài)方法，鎖住的是類的Class對(duì)象，因?yàn)镃lass的相關(guān)數(shù)據(jù)存儲(chǔ)在永久代元空間，元空間是全局共享的，因此靜態(tài)方法鎖相當(dāng)于類的一個(gè)全局鎖，會(huì)鎖所有調(diào)用該方法的線程。

public?static?synchronized?void?method()?{}

3.作用于 Lock.class，鎖住的是 Lock 的Class對(duì)象，也是全局只有一個(gè)。

synchronized?(Lock.class)?{}

4.作用于 this，鎖住的是對(duì)象實(shí)例，每一個(gè)對(duì)象實(shí)例有一個(gè)鎖。

synchronized?(this)?{}

5.作用于靜態(tài)成員變量，鎖住的是該靜態(tài)成員變量對(duì)象，由于是靜態(tài)變量，因此全局只有一個(gè)。

public?static?Object?monitor?=?new?Object();?synchronized?(monitor)?{}

40、如何檢測(cè)死鎖？

死鎖的四個(gè)必要條件：

1）互斥條件：進(jìn)程對(duì)所分配到的資源進(jìn)行排他性控制，即在一段時(shí)間內(nèi)某資源僅為一個(gè)進(jìn)程所占有。此時(shí)若有其他進(jìn)程請(qǐng)求該資源，則請(qǐng)求進(jìn)程只能等待。

2）請(qǐng)求和保持條件：進(jìn)程已經(jīng)獲得了至少一個(gè)資源，但又對(duì)其他資源發(fā)出請(qǐng)求，而該資源已被其他進(jìn)程占有，此時(shí)該進(jìn)程的請(qǐng)求被阻塞，但又對(duì)自己獲得的資源保持不放。

3）不可剝奪條件：進(jìn)程已獲得的資源在未使用完畢之前，不可被其他進(jìn)程強(qiáng)行剝奪，只能由自己釋放。

4）環(huán)路等待條件：存在一種進(jìn)程資源的循環(huán)等待鏈，鏈中每一個(gè)進(jìn)程已獲得的資源同時(shí)被 鏈中下一個(gè)進(jìn)程所請(qǐng)求。即存在一個(gè)處于等待狀態(tài)的進(jìn)程集合{Pl, P2, …, pn}，其中 Pi 等待的資源被 P(i+1) 占有（i=0, 1, …, n-1)，Pn 等待的資源被 P0占 有，如下圖所示。

41、怎么預(yù)防死鎖？

預(yù)防死鎖的方式就是打破四個(gè)必要條件中的任意一個(gè)即可。

1）打破互斥條件：在系統(tǒng)里取消互斥。若資源不被一個(gè)進(jìn)程獨(dú)占使用，那么死鎖是肯定不會(huì)發(fā)生的。但一般來說在所列的四個(gè)條件中，“互斥”條件是無法破壞的。因此，在死鎖預(yù)防里主要是破壞其他幾個(gè)必要條件，而不去涉及破壞“互斥”條件。。

2）打破請(qǐng)求和保持條件：1）采用資源預(yù)先分配策略，即進(jìn)程運(yùn)行前申請(qǐng)全部資源，滿足則運(yùn)行，不然就等待。 2）每個(gè)進(jìn)程提出新的資源申請(qǐng)前，必須先釋放它先前所占有的資源。

3) Memecahkan syarat yang tidak boleh dipisahkan: Apabila sesuatu proses menduduki sumber tertentu dan kemudian memohon lagi untuk sumber lain tetapi tidak dapat memenuhinya, proses itu mesti mengeluarkan sumber yang didudukinya pada asalnya.

4) Putuskan keadaan menunggu gelung: laksanakan strategi peruntukan sumber yang teratur, nomborkan semua sumber dalam sistem secara seragam dan semua proses hanya boleh memohon sumber dalam bentuk peningkatan nombor jujukan.

42. Mengapa menggunakan kumpulan benang? Bukankah selesa untuk membuat rangkaian baharu secara langsung?

Jika kita terus mencipta benang baru dalam kaedah pemprosesan, apabila kaedah ini kerap dipanggil, banyak benang akan dibuat, yang bukan sahaja akan menggunakan sumber sistem, tetapi juga mengurangkan kestabilan Berhati-hati untuk merosakkan sistem, dan anda boleh pergi terus ke bahagian kewangan untuk menyelesaikan bil.

Jika kita menggunakan kumpulan benang secara munasabah, kita boleh mengelakkan dilema untuk merosakkan sistem. Secara umum, menggunakan kumpulan benang boleh membawa faedah berikut:

• Kurangkan penggunaan sumber. Kurangkan kos pembuatan dan pemusnahan benang dengan menggunakan semula benang yang dicipta.
• Tingkatkan kelajuan tindak balas. Apabila tugasan tiba, tugasan itu boleh dilaksanakan dengan serta-merta tanpa menunggu urutan dibuat.
• Tingkatkan kebolehurusan benang. Benang adalah sumber yang terhad, dan kumpulan benang boleh digunakan untuk peruntukan bersatu, penalaan dan pemantauan.
  

43 Apakah sifat teras kumpulan benang?

threadFactory: Kilang digunakan untuk mencipta benang pekerja.

corePoolSize (bilangan utas teras): Apabila kumpulan utas berjalan kurang daripada utas corePoolSize, utas baharu akan dibuat untuk mengendalikan permintaan, walaupun utas pekerja lain melahu.

workQueue (queue): Satu baris gilir menyekat yang digunakan untuk mengekalkan tugasan dan menyerahkannya kepada urutan pekerja.

maximumPoolSize (bilangan maksimum utas): Bilangan maksimum utas yang dibenarkan dibuka dalam kumpulan benang.

pengendali (dasar penolakan): Apabila menambahkan tugas pada kumpulan benang, dasar penolakan akan dicetuskan dalam dua situasi berikut: 1) Status berjalan kumpulan benang tidak BERJALAN; pool telah mencapai bilangan maksimum benang dan disekat Apabila baris gilir penuh.

keepAliveTime (kekalkan masa hidup): Jika bilangan utas semasa dalam kumpulan benang melebihi corePoolSize, lebihan utas akan ditamatkan apabila masa terbiarnya melebihi keepAliveTime.

44. Mari kita bincangkan tentang proses pengendalian kumpulan benang.

45. Apakah strategi penolakan untuk kumpulan benang?

Polisi Gugur: Dasar Gugurkan. Strategi penolakan lalai terus membuang RejectedExecutionException. Pemanggil boleh menangkap pengecualian ini dan menulis kod pengendaliannya sendiri mengikut keperluan.

Polisi Buang: Dasar buang. Jangan lakukan apa-apa dan buang sahaja tugas yang ditolak.

DiscardOldestPolicy: Buang polisi tertua. Meninggalkan tugas tertua dalam baris gilir menyekat adalah bersamaan dengan tugas seterusnya dalam baris gilir yang akan dilaksanakan, dan kemudian menyerahkan semula tugas yang ditolak. Jika baris gilir menyekat adalah baris gilir keutamaan, maka strategi "jatuhkan tertua" akan menyebabkan tugasan keutamaan tertinggi digugurkan, jadi sebaiknya jangan gunakan strategi ini dengan baris gilir keutamaan.

CallerRunsPolicy: Dasar panggilan pemanggil. Laksanakan tugas dalam urutan pemanggil. Strategi ini melaksanakan mekanisme pelarasan yang tidak meninggalkan tugasan mahupun melemparkan pengecualian, tetapi menggulung semula tugasan kepada pemanggil (utas utama yang memanggil kumpulan utas untuk melaksanakan tugasan Memandangkan melaksanakan tugasan mengambil masa tertentu ,). jadi utas utama tidak boleh menyerahkan tugasan untuk sekurang-kurangnya satu tempoh masa, membenarkan masa kumpulan utas selesai memproses tugasan yang sedang dilaksanakan.

46 Apakah perbezaan antara Senarai, Set dan Peta?

Senarai (pembantu yang baik untuk menangani pesanan): Antara muka Senarai menyimpan a. set bukan unik ( Terdapat beberapa elemen yang merujuk objek yang sama), objek yang dipesan.

Set (fokus pada sifat unik): Set pendua tidak dibenarkan dan berbilang elemen tidak akan merujuk objek yang sama.

Peta (pengguna profesional yang menggunakan Kunci untuk mencari): Gunakan storan pasangan nilai kunci. Peta mengekalkan nilai yang dikaitkan dengan Key. Dua Kekunci boleh merujuk kepada objek yang sama, tetapi Kekunci tidak boleh diulangi Kekunci biasa ialah jenis Rentetan, tetapi ia juga boleh menjadi sebarang objek.

47 Perbezaan antara ArrayList dan LinkedList.

ArrayList dilaksanakan berdasarkan tatasusunan dinamik di bahagian bawah, dan LinkedList dilaksanakan berdasarkan senarai terpaut di bahagian bawah.

Untuk mengindeks data mengikut indeks (kaedah dapatkan/set): ArrayList mencari terus nod pada kedudukan sepadan tatasusunan melalui indeks, manakala LinkedList perlu mula merentasi dari nod kepala atau nod ekor sehingga nod sasaran ditemui, jadi dari segi kecekapan, ArrayList adalah lebih baik daripada LinkedList.

Untuk sisipan dan pemadaman rawak: ArrayList perlu mengalihkan nod di belakang nod sasaran (gunakan kaedah System.arraycopy untuk mengalihkan nod), manakala LinkedList hanya perlu mengubah suai atribut nod seterusnya atau sebelumnya sebelum dan selepas nod sasaran, jadi dari segi kecekapan LinkedList adalah lebih baik daripada ArrayList.

Untuk sisipan dan pemadaman berurutan: Memandangkan ArrayList tidak memerlukan nod bergerak, ia lebih baik daripada LinkedList dari segi kecekapan. Inilah sebabnya mengapa terdapat lebih banyak ArrayLists dalam penggunaan sebenar, kerana kebanyakan penggunaan kami adalah sisipan berurutan.

48. Perbezaan antara ArrayList dan Vektor.

Vector dan ArrayList adalah hampir sama Satu-satunya perbezaan ialah Vector menggunakan kaedah yang disegerakkan untuk memastikan keselamatan thread, jadi ArrayList mempunyai prestasi yang lebih baik dari segi prestasi.

Perhubungan yang serupa termasuk: StringBuilder dan StringBuffer, HashMap dan Hashtable.

49 Memperkenalkan struktur data asas HashMap

Kami sedang menggunakan JDK 1.8 dan lapisan bawah terdiri daripada "pohon merah hitam senarai terpaut" , seperti yang ditunjukkan di bawah, dan sebelum JDK 1.8, ia terdiri daripada "senarai pautan tatasusunan".

50. Mengapakah ia perlu ditukar kepada "pohon merah hitam senarai terpaut"?

Terutamanya untuk meningkatkan prestasi carian apabila konflik cincang teruk (senarai terpaut terlalu panjang Prestasi carian menggunakan senarai terpaut ialah O(n), manakala menggunakan pokok merah-hitam adalah O(log masuk).

51. Bilakah anda perlu menggunakan senarai terpaut? Bila hendak menggunakan pokok merah-hitam?

Untuk sisipan, lalai adalah menggunakan nod senarai terpaut. Apabila bilangan nod pada kedudukan indeks yang sama melebihi 8 (ambang 8) selepas ditambah: jika panjang tatasusunan lebih besar daripada atau sama dengan 64, ia akan mencetuskan penukaran nod senarai terpaut kepada nod pokok merah-hitam ( treeifyBin); dan jika panjang tatasusunan kurang daripada 64, maka Senarai terpaut tidak akan dicetuskan untuk menukar kepada pokok merah-hitam, tetapi akan dikembangkan kerana jumlah data pada masa ini masih agak kecil.

Untuk penyingkiran, apabila bilangan nod pada kedudukan indeks yang sama mencapai 6 selepas dialih keluar, dan nod pada kedudukan indeks ialah nod pokok merah-hitam, penukaran nod pokok merah-hitam kepada nod senarai terpaut (untreeify) akan dicetuskan.

52 Apakah kapasiti awal lalai HashMap? Adakah terdapat had untuk kapasiti HashMap?

Kapasiti asal lalai ialah 16. Kapasiti HashMap mestilah 2 kepada kuasa Nth HashMap akan mengira 2 terkecil kepada kuasa Nth yang lebih besar daripada atau sama dengan kapasiti berdasarkan kapasiti yang kita lalui. Contohnya, jika 9 diluluskan, kapasiti adalah. 16.

53. Apakah proses pemasukan HashMap?

54. Apakah proses pengembangan (saiz semula) HashMap?

55. Selain HashMap, apakah Peta lain yang telah anda gunakan dan bagaimana anda memilih apabila menggunakannya?

56 Perbezaan antara HashMap dan Hashtable?

HashMap membenarkan kunci dan nilai menjadi batal, Hashtable tidak. bukan.

Kapasiti asal lalai HashMap ialah 16 dan Hashtable ialah 11.

Peluasan HashMap ialah 2 kali ganda daripada asal, dan pengembangan Hashtable ialah 2 kali ganda daripada asal tambah 1.

HashMap tidak selamat untuk benang, Hashtable selamat untuk benang.

Nilai cincang HashMap telah dikira semula dan Hashtable menggunakan Kod cincang secara langsung.

HashMap mengalih keluar kaedah mengandungi dalam Hashtable.

HashMap mewarisi daripada kelas AbstractMap dan Hashtable mewarisi daripada kelas Kamus.

57. Struktur memori Java (kawasan data masa jalan)

Kaunter program: peribadi benang. Ruang memori kecil yang boleh dianggap sebagai penunjuk nombor baris bagi kod bait yang dilaksanakan oleh utas semasa. Jika utas melaksanakan kaedah Java, pembilang ini merekodkan alamat arahan kod bait mesin maya yang sedang dilaksanakan jika utas melaksanakan kaedah Native, nilai pembilang adalah kosong.

Timbunan mesin maya Java: benang peribadi. Kitaran hayatnya adalah sama seperti benang. Tindanan mesin maya menerangkan model memori pelaksanaan kaedah Java: apabila setiap kaedah dilaksanakan, bingkai tindanan dicipta untuk menyimpan jadual pembolehubah tempatan, tindanan operan, pautan dinamik, kaedah keluar dan maklumat lain. Proses daripada panggilan kepada penyiapan pelaksanaan setiap kaedah sepadan dengan proses daripada menolak bingkai tindanan ke dalam tindanan mesin maya kepada mengeluarkannya.

Timbunan kaedah setempat: benang peribadi. Fungsi yang dimainkan oleh timbunan kaedah tempatan dan timbunan mesin maya adalah sangat serupa Satu-satunya perbezaan antaranya ialah timbunan mesin maya berfungsi untuk mesin maya untuk melaksanakan kaedah Java (iaitu, kod bait), manakala timbunan kaedah tempatan digunakan. oleh mesin maya Kepada perkhidmatan kaedah Asli.

Timbunan Java: perkongsian benang. Untuk kebanyakan aplikasi, timbunan Java ialah sekeping memori terbesar yang diuruskan oleh mesin maya Java. Timbunan Java ialah kawasan memori yang dikongsi oleh semua benang dan dicipta apabila mesin maya dimulakan. Satu-satunya tujuan kawasan memori ini adalah untuk menyimpan contoh objek, dan hampir semua kejadian objek memperuntukkan memori di sini.

Kaedah kaedah: Seperti timbunan Java, ia adalah kawasan memori yang dikongsi oleh setiap utas Ia digunakan untuk menyimpan maklumat kelas (kaedah pembinaan, definisi antara muka), pemalar, pembolehubah statik dan tepat dalam masa. penyusun yang telah dimuatkan oleh mesin maya Kod tersusun (kod bait) dan data lain. Kawasan kaedah ialah konsep yang ditakrifkan dalam spesifikasi JVM Di mana ia diletakkan, pelaksanaan yang berbeza boleh diletakkan di tempat yang berbeza.

運(yùn)行時(shí)常量池：運(yùn)行時(shí)常量池是方法區(qū)的一部分。Class文件中除了有類的版本、字段、方法、接口等描述信息外，還有一項(xiàng)信息是常量池，用于存放編譯期生成的各種字面量和符號(hào)引用，這部分內(nèi)容將在類加載后進(jìn)入方法區(qū)的運(yùn)行時(shí)常量池中存放。

String?str?=?new?String("hello");

上面的語(yǔ)句中變量 str 放在棧上，用 new 創(chuàng)建出來的字符串對(duì)象放在堆上，而"hello"這個(gè)字面量是放在堆中。

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

如果一個(gè)類加載器收到了類加載的請(qǐng)求，它首先不會(huì)自己去嘗試加載這個(gè)類，而是把這個(gè)請(qǐng)求委派給父類加載器去完成，每一個(gè)層次的類加載器都是如此，因此所有的加載請(qǐng)求最終都應(yīng)該傳送到頂層的啟動(dòng)類加載器中，只有當(dāng)父加載器反饋?zhàn)约簾o法完成這個(gè)加載請(qǐng)求（它的搜索范圍中沒有找到所需的類）時(shí)，子加載器才會(huì)嘗試自己去加載。

59、Java虛擬機(jī)中有哪些類加載器？

啟動(dòng)類加載器（Bootstrap ClassLoader）：

這個(gè)類加載器負(fù)責(zé)將存放在\lib目錄中的，或者被-Xbootclasspath參數(shù)所指定的路徑中的，并且是虛擬機(jī)識(shí)別的（僅按照文件名識(shí)別，如rt.jar，名字不符合的類庫(kù)即使放在lib目錄中也不會(huì)被加載）類庫(kù)加載到虛擬機(jī)內(nèi)存中。

擴(kuò)展類加載器（Extension ClassLoader）：

這個(gè)加載器由sun.misc.Launcher$ExtClassLoader實(shí)現(xiàn)，它負(fù)責(zé)加載\lib\ext目錄中的，或者被java.ext.dirs系統(tǒng)變量所指定的路徑中的所有類庫(kù)，開發(fā)者可以直接使用擴(kuò)展類加載器。

應(yīng)用程序類加載器（Application ClassLoader）：

這個(gè)類加載器由sun.misc.Launcher$AppClassLoader實(shí)現(xiàn)。由于這個(gè)類加載器是ClassLoader中的getSystemClassLoader()方法的返回值，所以一般也稱它為系統(tǒng)類加載器。它負(fù)責(zé)加載用戶類路徑（ClassPath）上所指定的類庫(kù)，開發(fā)者可以直接使用這個(gè)類加載器，如果應(yīng)用程序中沒有自定義過自己的類加載器，一般情況下這個(gè)就是程序中默認(rèn)的類加載器。

自定義類加載器：

用戶自定義的類加載器。

60、類加載的過程

類加載的過程包括：加載、驗(yàn)證、準(zhǔn)備、解析、初始化，其中驗(yàn)證、準(zhǔn)備、解析統(tǒng)稱為連接。

加載：通過一個(gè)類的全限定名來獲取定義此類的二進(jìn)制字節(jié)流，在內(nèi)存中生成一個(gè)代表這個(gè)類的java.lang.Class對(duì)象。

驗(yàn)證：確保Class文件的字節(jié)流中包含的信息符合當(dāng)前虛擬機(jī)的要求，并且不會(huì)危害虛擬機(jī)自身的安全。

準(zhǔn)備：為靜態(tài)變量分配內(nèi)存并設(shè)置靜態(tài)變量初始值，這里所說的初始值“通常情況”下是數(shù)據(jù)類型的零值。

解析：將常量池內(nèi)的符號(hào)引用替換為直接引用。

初始化：到了初始化階段，才真正開始執(zhí)行類中定義的 Java 初始化程序代碼。主要是靜態(tài)變量賦值動(dòng)作和靜態(tài)語(yǔ)句塊（static{}）中的語(yǔ)句。

61、介紹下垃圾收集機(jī)制（在什么時(shí)候，對(duì)什么，做了什么）？

在什么時(shí)候？

在觸發(fā)GC的時(shí)候，具體如下，這里只說常見的 Young GC 和 Full GC。

觸發(fā)Young GC：當(dāng)新生代中的 Eden 區(qū)沒有足夠空間進(jìn)行分配時(shí)會(huì)觸發(fā)Young GC。

觸發(fā)Full GC：

• 當(dāng)準(zhǔn)備要觸發(fā)一次Young GC時(shí)，如果發(fā)現(xiàn)統(tǒng)計(jì)數(shù)據(jù)說之前Young GC的平均晉升大小比目前老年代剩余的空間大，則不會(huì)觸發(fā)Young GC而是轉(zhuǎn)為觸發(fā)Full GC。（通常情況）
• 如果有永久代的話，在永久代需要分配空間但已經(jīng)沒有足夠空間時(shí)，也要觸發(fā)一次Full GC。
• System.gc()默認(rèn)也是觸發(fā)Full GC。
• heap dump帶GC默認(rèn)也是觸發(fā)Full GC。
• CMS GC時(shí)出現(xiàn)Concurrent Mode Failure會(huì)導(dǎo)致一次Full GC的產(chǎn)生。

對(duì)什么？

對(duì)那些JVM認(rèn)為已經(jīng)“死掉”的對(duì)象。即從GC Root開始搜索，搜索不到的，并且經(jīng)過一次篩選標(biāo)記沒有復(fù)活的對(duì)象。

做了什么？

對(duì)這些JVM認(rèn)為已經(jīng)“死掉”的對(duì)象進(jìn)行垃圾收集，新生代使用復(fù)制算法，老年代使用標(biāo)記-清除和標(biāo)記-整理算法。

62、GC Root有哪些?

在Java語(yǔ)言中，可作為GC Roots的對(duì)象包括下面幾種：

• Objek dirujuk dalam tindanan mesin maya (jadual pembolehubah tempatan dalam bingkai tindanan).
• Objek yang dirujuk oleh sifat statik kelas dalam kawasan kaedah.
• Objek yang dirujuk oleh pemalar dalam kawasan kaedah.
• Objek yang dirujuk oleh JNI (biasanya kaedah Native) dalam timbunan kaedah tempatan.

63. Apakah algoritma kutipan sampah dan ciri masing-masing?

Mark-Clear Algorithm

Tanda dahulu semua objek yang perlu dikitar semula, dan selepas penandaan selesai, semua objek yang ditanda akan dikitar semula secara seragam. Terdapat dua kelemahan utama: satu ialah masalah kecekapan, kecekapan proses penandaan dan pembersihan tidak tinggi, yang lain adalah masalah ruang, selepas penandaan dan pembersihan akan menghasilkan sejumlah besar serpihan ingatan tidak berterusan, terlalu banyak serpihan ruang mungkin; sebab Pada masa hadapan, apabila objek yang lebih besar perlu diperuntukkan semasa program sedang berjalan, memori bersebelahan yang mencukupi tidak dapat ditemui dan satu lagi tindakan kutipan sampah perlu dicetuskan terlebih dahulu.

Algoritma Salin

Untuk menyelesaikan masalah kecekapan, algoritma pengumpulan dipanggil "Menyalin" muncul, yang membahagikan memori yang tersedia kepada saiz mengikut kapasiti yang sama kepingan, hanya gunakan satu daripadanya pada satu masa. Apabila blok memori ini kehabisan, salin objek yang masih hidup ke blok lain, dan kemudian bersihkan ruang memori yang digunakan sekaligus. Dengan cara ini, keseluruhan separuh kawasan dikitar semula setiap kali, dan tidak perlu mempertimbangkan situasi yang rumit seperti pemecahan memori apabila memperuntukkan memori Hanya gerakkan penunjuk atas timbunan dan peruntukkan memori mengikut urutan cekap untuk dijalankan. Cuma kos algoritma ini adalah untuk mengurangkan memori kepada separuh daripada saiz asalnya, yang agak terlalu tinggi.

Tanda - Algoritma Penyusunan

Algoritma pengumpulan salinan akan melakukan lebih banyak operasi penyalinan apabila kadar kemandirian objek tinggi, dan kecekapan akan menjadi lebih rendah. Lebih penting lagi, jika anda tidak mahu membazirkan 50% ruang, anda perlu mempunyai ruang tambahan untuk jaminan peruntukan untuk menangani situasi yang melampau di mana semua objek dalam memori yang digunakan adalah 100% hidup Oleh itu, peruntukan seperti ini tidak boleh digunakan secara langsung dalam algoritma generasi lama.

Mengikut ciri-ciri generasi lama, seseorang telah mencadangkan satu lagi algoritma "Mark-Compact" Proses penandaan masih sama seperti algoritma "Mark-Compact", tetapi langkah-langkah seterusnya tidak berkaitan secara langsung. ke objek yang boleh dikitar semula, tetapi semua objek yang masih hidup dialihkan ke satu hujung, dan kemudian ingatan di luar sempadan hujung terus dibersihkan.

Algoritma Pengumpulan Generasi

Pada masa ini, mesin maya komersial semuanya menggunakan algoritma "Koleksi Generasi" untuk pengumpulan sampah idea hanyalah untuk membahagikan memori kepada beberapa blok mengikut kitaran hidup objek yang berbeza.

Secara amnya, heap Java dibahagikan kepada generasi baru dan generasi lama, supaya algoritma pengumpulan yang paling sesuai boleh digunakan mengikut ciri-ciri setiap generasi.

Dalam generasi baru, didapati bahawa sebilangan besar objek mati setiap kali semasa pengumpulan sampah, dan hanya beberapa yang bertahan Kemudian menggunakan algoritma salinan, dan hanya perlu membayar kos salinan yang kecil bilangan objek yang masih hidup untuk melengkapkan koleksi.

Pada generasi lama, kerana kadar survival objek adalah tinggi dan tiada ruang tambahan untuk menjamin peruntukannya, algoritma mark-clean atau mark-clean mesti digunakan untuk kitar semula.

Akhirnya

Pada musim emas, tiga dan perak, saya percaya ramai pelajar sedang bersedia untuk menukar pekerjaan.

Saya telah meringkaskan artikel asal saya yang baru-baru ini: ringkasan asal, yang mengandungi analisis banyak soalan temu duga frekuensi tinggi, yang kebanyakannya saya temui semasa menemu duga dengan syarikat-syarikat besar Saya menyemak setiap satunya Apabila menganalisis soalan, mereka akan dianalisis secara mendalam mengikut piawaian yang lebih tinggi Anda mungkin tidak dapat memahaminya sepenuhnya selepas membacanya sekali sahaja, tetapi saya percaya bahawa anda akan memperoleh sesuatu dengan membacanya berulang kali.

Untuk lebih banyak pengetahuan berkaitan pengaturcaraan, sila lawati: Kursus Pengaturcaraan! !

Atas ialah kandungan terperinci [Kompilasi Hematemesis] Soalan dan jawapan temu duga frekuensi tinggi asas Java 2023 (Koleksi). Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!