Eine Sammlung von Java-Interviewfragen – Empfohlene Interviewfragen, damit Sie das Angebot einfacher erhalten

Vorwort

Nur ​​eine Glatze kann dich stark machen

Als ich vorher bloggte, stellte ich fest, dass einige gut geschriebene Blogs stillschweigend gesammelt wurden. Ich habe in letzter Zeit Auslassungen überprüft und einige Wissenspunkte sind relativ wichtig, aber ich habe sie in meinem vorherigen Blog nicht geschrieben, also habe ich meine Freizeit genutzt, um sie zu klären (empfohlen: JAVA Interview). Fragensammlung).

Textwissenspunkte:

• Integer-Konstantenpool

• TCP-Entpacken und Kleben

• select、poll、epollEinfacher Unterschied

• Sperrenoptimierung nach jdk1.6 synchronisieren

• Java-Speichermodell

Dieser Artikel versucht, jeden Wissenspunkt auf einfache Weise zu erklären, ich hoffe, dass Sie durch die Lektüre etwas gewinnen werden

Die magische Ganzzahl

A Als ich sah, wie jemand in der Gruppe über die Wahrheits- oder Falschfrage von Integer diskutierte, dachte ich, ich hätte diesen Wissenspunkt bereits verstanden. Aber ich habe trotzdem einen Fehler gemacht, also habe ich einen Freund um Rat gefragt. Ein Freund hat mir ein weiteres Bild geschickt:

Später fand ich heraus, dass dies aus „Vertiefendes Verständnis der Java Virtual Machine – JVM Advanced Features and Best Practices (2. Auflage)“ stammt. " )》In Abschnitt 10.3.2~

public class Main_1 {
    public static void main(String[] args) {
        Integer a = 1;
        Integer b = 2;
        Integer c = 3;
        Integer d = 3;
        Integer e = 321;
        Integer f = 321;
        Long g = 3L;
        Long h = 2L;
        System.out.println(c == d);
        System.out.println(e == f);
        System.out.println(c == (a + b));
        System.out.println(c.equals(a + b));
        System.out.println(g == (a + b));
        System.out.println(g.equals(a + b));
        System.out.println(g.equals(a + h));
    }

}

Sie können zuerst darüber nachdenken und dann die Antworten durchlesen, um zu sehen, ob Sie es richtig machen können.

1.1 Ideen zur Problemlösung

Ich glaube, viele Leute wissen vor der Lösung dieses Problems bereits, dass es in Java einen Integer-Cache-Pool gibt und die Cache-Größe ist: -128~127

Die Antwort ist:

• wahr

• falsch

• wahr

• wahr

• wahr

• falsch

• wahr

Eine kurze Erklärung:

• Verwendung von ==:

• Wenn Beim Vergleich von Ganzzahlvariablen ist der Standardvergleich Adresswert.

• Java's Integer verwaltet einen Cache-Pool von -128~127

• Wenn auf einer Seite des Vergleichs ein Operationsausdruck vorhanden ist (z. B. a +b), dann ist der Vergleich der spezifische Wert von

• unter Verwendung von equals():

• Ob Ganzzahl oder Lang, equals() ist standardmäßig numerischer Wert.

• Longs equals()-Methode, die Standardimplementierung von JDK: bestimmt, ob es sich um einen Long-Typ handelt

• Achten Sie auf Probleme beim automatischen Auspacken und Verpacken.

Dekompilieren Sie es und schauen Sie es sich an:

import java.io.PrintStream;

public class Main_1 {
    public static void main(String[] paramArrayOfString) {
        Integer localInteger1 = Integer.valueOf(1);
        Integer localInteger2 = Integer.valueOf(2);
        Integer localInteger3 = Integer.valueOf(3);
        Integer localInteger4 = Integer.valueOf(3);
        Integer localInteger5 = Integer.valueOf(321);
        Integer localInteger6 = Integer.valueOf(321);
        Long localLong = Long.valueOf(3L);

        // 缓存池
        System.out.println(localInteger3 == localInteger4);
        
        // 超出缓存池范围
        System.out.println(localInteger5 == localInteger6);
        
        // 存在a+b数值表达式，比较的是数值
        System.out.println(localInteger3.intValue() == localInteger1.intValue() + localInteger2.intValue());

        // equals比较的是数值
        System.out.println(localInteger3.equals(Integer.valueOf(localInteger1.intValue() + localInteger2.intValue())));
        // 存在a+b数值表达式，比较的是数值
        System.out.println(localLong.longValue() == localInteger1.intValue() + localInteger2.intValue());
        // Long的equals()先判断传递进来的是不是Long类型，而a+b自动装箱的是Integer类型
        System.out.println(localLong.equals(Integer.valueOf(localInteger1.intValue() + localInteger2.intValue())));

        // ... 最后一句在这里漏掉了，大家应该可以推断出来
    }
}

Das Dekompilierungstool, das ich verwende, ist jd-gui, falls Sie es nicht getan haben Habe es schon ausprobiert. Schüler, die dekompilieren, können Folgendes herunterladen und spielen:

• https://github.com/java-decompiler/jd-gui/releases

2. Was sind die Synchronize-Lock-Optimierungsmethoden?

Multithreading-Artikelrezension:

• ThreadLocal ist so einfach

• Multi-Threading Sie können in drei Minuten einsteigen!

• Thread-Quellcode-Analyse

• Grundlegende Wissenspunkte zum Multithreading! Lesen Sie weiter, um Multithreading zu lernen und mit halbem Aufwand das doppelte Ergebnis zu erzielen

• Erfahren Sie mehr über den Java-Sperrmechanismus

• AQS einfach durchgehen it

• Erfahren Sie mehr über die Lock-Unterklasse

• Möchten Sie nicht wirklich etwas über den Thread-Pool erfahren?

• Der Stillstand des Multithreadings ist so einfach

• Drei junge Leute, die Java-Multithreading unterstützen

Als ich zuvor einen Multithreading-Artikel geschrieben habe, habe ich kurz erwähnt, dass synchronisierte Sperren nach jdk1.6 verschiedene Optimierungen haben werden: Anpassung an Spin-Sperren, Sperrenbeseitigung, Sperrvergröberung, leichte Sperren und voreingenommene Sperren.

Ich dachte, diese Optimierungen seien sehr schwer zu verstehen, aber tatsächlich ~~~ ist es mit einem einfachen Verständnis leicht zu verstehen.

2.1 An Spin-Locks anpassen

Der Lock-Wettbewerb befindet sich im Kernel-Modus und durchläuft den Wechsel vom Benutzermodus in den Kernel-Modus, ja, das dauert länger.

Der Grund, warum Spin Lock erscheint, ist, dass die Leute feststellen, dass die Besetzung von Lock nur kurze Zeit dauert, sogar kürzer als die Zeit Das Umschalten in den Kernelmodus dauert einige Zeit. Lassen Sie den Thread also eine begrenzte Zeit warten, bevor er in den Kernelmodus wechselt. Wenn die Sperre innerhalb dieser Zeit erreicht werden kann, wird viel unnötige Zeit eingespart , und wechseln Sie dann in den Kernel-Modus, um um die Sperre zu konkurrieren.

Die adaptive Spin-Sperre wurde in JDK 1.6 eingeführt, was bedeutet, dass der Zeitpunkt des Spins nicht festgelegt ist und es immer intelligenter wird, ob gedreht werden soll oder nicht .

自旋锁在JDK1.4.2中就已经引入，只不过默认是关闭的，可以使用-XX：+UseSpinning参数来开启，在JDK1.6中就已经改为默认开启了。

2.2锁消除

如果JVM明显检测到某段代码是线程安全的(言外之意：无锁也是安全的)，JVM会安全地原有的锁消除掉！

比如说：

    public void vectorTest(){
        Vector<String> vector = new Vector<String>();
        for(int i = 0 ; i < 10 ; i++){
            vector.add(i + "");
        }

        System.out.println(vector);
    }

Vector是默认加锁的，但JVM如果发现vector变量仅仅在vectorTest()方法中使用，那该vector是线程安全的。JVM会把vector内部加的锁去除，这个优化就叫做：锁消除。

2.3锁粗化

默认情况下，总是推荐将同步块的作用范围限制得尽量小。

但是如果一系列的连续操作都对同一个对象反复加锁和解锁，甚至加锁操作是出现在循环体中的，频繁地进行互斥同步操作也会导致不必要的性能损耗。

JVM会将加锁的范围扩展(粗化)，这就叫做锁粗化。

2.4轻量级锁

轻量级锁能提升程序同步性能的依据是“对于绝大部分的锁，在整个同步周期内都是不存在竞争的”，这是一个经验数据。

• 如果没有竞争，轻量级锁使用CAS操作避免了使用互斥量的开销

• 但如果存在锁竞争，除了互斥量的开销外，还额外发生了CAS操作，因此在有竞争的情况下，轻量级锁会比传统的重量级锁更慢。

简单来说：如果发现同步周期内都是不存在竞争，JVM会使用CAS操作来替代操作系统互斥量。这个优化就被叫做轻量级锁。

2.5偏向锁

偏向锁就是在无竞争的情况下把整个同步都消除掉，连CAS操作都不做了！

偏向锁可以提高带有同步但无竞争的程序性能。它同样是一个带有效益权衡（Trade Off）性质的优化，也就是说，它并不一定总是对程序运行有利，如果程序中大多数的锁总是被多个不同的线程访问，那偏向模式就是多余的。在具体问题具体分析的前提下，有时候使用参数-XX：-UseBiasedLocking来禁止偏向锁优化反而可以提升性能。

2.6简单总结各种锁优化

• 自适应偏向锁：自旋时间不固定

• 锁消除：如果发现代码是线程安全的，将锁去掉

• 锁粗化：加锁范围过小(重复加锁)，将加锁的范围扩展

• 轻量级锁：在无竞争的情况下使用CAS操作去消除同步使用的互斥量

• 偏向锁：在无竞争环境下，把整个同步都消除，CAS也不做。

参考资料：

• https://blog.csdn.net/chenssy/article/details/54883355

三、TCP粘包，拆包

这是在看wangjingxin大佬面经的时候看到的面试题，之前对TCP粘包，拆包没什么概念，于是就简单去了解一下。

3.1什么是拆包粘包？为什么会出现？

在进行Java NIO学习时，可能会发现：如果客户端连续不断的向服务端发送数据包时，服务端接收的数据会出现两个数据包粘在一起的情况。

TCP的首部格式：

• TCP是基于字节流的，虽然应用层和TCP传输层之间的数据交互是大小不等的数据块，但是TCP把这些数据块仅仅看成一连串无结构的字节流，没有边界；

• 从TCP的帧结构也可以看出，在TCP的首部没有表示数据长度的字段

基于上面两点，在使用TCP传输数据时，才有粘包或者拆包现象发生的可能。

一个数据包中包含了发送端发送的两个数据包的信息，这种现象即为粘包

接收端收到了两个数据包，但是这两个数据包要么是不完整的，要么就是多出来一块，这种情况即发生了拆包和粘包

拆包和粘包的问题导致接收端在处理的时候会非常困难(因为无法区分一个完整的数据包)

3.2 Lösen des Auspackens und Klebens

Es gibt im Allgemeinen zwei allgemeine Lösungen für den Unterverpackungsmechanismus:

• 1, Sonderzeichensteuerung

• 2, fügen Sie die Länge des Datenpakets im Header hinzu

Wenn Sie Netty verwenden, gibt es spezielle Encoder und Decoder, um das Problem zu lösen Auspacken und Kleben von Paketen.

Tipps:Bei UDP gibt es kein Packet-Sticking-Problem, aber es kommt zu Paketverlusten und Störungen. Es wird keine unvollständigen Pakete geben und alle empfangenen Pakete werden vollständig korrekt sein. Das übertragene Dateneinheitsprotokoll ist eine UDP-Nachricht oder ein Benutzerdatagramm, das beim Senden weder zusammengeführt noch aufgeteilt wird.

4. Einfache Unterschiede zwischen Select, Poll und Epoll

NIO-Rezension:

• JDK10 wurde veröffentlicht, wie viel wissen Sie über nio? ?

So implementiert es das I/O-Wiederverwendungsmodell unter Linux:

Rufen Sie eine der select/poll/epoll-Funktionen auf und übergeben Sie mehrere Dateideskriptoren. Gibt zurück, wenn a Der Dateideskriptor ist bereit, andernfalls blockiert er bis zum Timeout.

Es gibt einige Unterschiede zwischen diesen Funktionen. Einige Interviewer fragen sich möglicherweise, was die Unterschiede zwischen diesen drei Funktionen sind:

Der Unterschied ist wie folgt:

Zusammenfassung in zwei Sätzen:

• select和poll muss jeden Dateideskriptor abfragen, epoll ist ereignisgesteuert und erfordert keine Abfrage

• select和pollSie müssen den Dateideskriptor jedes Mal kopieren, epollKeine Notwendigkeit

• selectDie maximale Anzahl von Verbindungen ist begrenzt, epoll和pollMax. Die Anzahl der Verbindungen ist unbegrenzt

Tipps: Implementierung von Epoll im Kernel, Verwendung des Rot-Schwarz-Baums zur Verwaltung von Ereignisblöcken

4.1 Beliebtes Beispiel

Jetzt 3 Jahre Bei einem Praktikum in einem Unternehmen muss der von Ihnen geschriebene Code erneut getestet werden.

select/pollSituation:

• Entwickler schreiben Code. Zu diesem Zeitpunkt fragtalle Entwickler nacheinander: Sind Sie fertig? das Programm schreiben? Möchten Sie testen?

epollSituation:

• Der Entwickler hat das Schreiben des Codes abgeschlossen und teilt dem Tester mit: „Ich habe den Code geschrieben, Sie.“ Gehen Sie und testen Sie es. Die Funktion ist XXX". Also suchte der Tester fröhlich nach Fehlern.

Andere beliebte Beschreibungen [1]:

Ein Barkeeper (ein Thread), vor dem eine Gruppe Betrunkener lag, rief plötzlich „Schenkt den Wein ein“ (Vorfall), du trabst hinüber, um ihm etwas einzuschenken, und lässt ihn dann gehen. Plötzlich möchte ein anderer etwas einschenken, und du gehst hin, um es noch einmal einzuschenken. Manchmal bedient niemand Getränke, und der Kellner ist untätig und kann etwas arbeiten. Ansonsten spielen Sie mit Ihrem Mobiltelefon. Was Epoll und Select betrifft, besteht der Unterschied zwischen Umfrage und Umfrage darin, dass die betrunkenen Personen in den letzten beiden Szenen nicht sprechen. Sie müssen einen nach dem anderen fragen, ob Sie etwas trinken möchten, und Sie haben keine Zeit, mit Ihrem Mobiltelefon zu spielen . io-Multiplexing bedeutet wahrscheinlich, dass diese Betrunkenen sich einen Kellner teilen.

Andere beliebte Beschreibungen [2]:

Ein einfaches Beispiel (vielleicht nicht sehr anschaulich) auswählen/umfragen Der Hotelkellner (Kernel) teilt dem Hotelbesitzer (Benutzerprogramm) mit: „Es sind Gäste da.“ Jetzt Kasse: „Aber keiner der Kellner hat dem Chef klar gesagt, für welche Tische die Gäste bezahlen.“ Der Chef muss an jeden Tisch gehen und fragen: Wollen Sie bezahlen? Der Epoll-Hotelkellner (Kernel) teilt dem Hotelbesitzer (Benutzerprogramm) mit: „Gäste Nr. 1, 2 und 5 checken aus.“ Der Chef kann direkt zu den Tischen 1, 2 und 5 gehen, um Geld einzusammeln

5. Java-Speichermodell

Rezension des JVM-Blogbeitrags:

• Wie hat sich JVM von den Anfängen bis zum Aufgeben entwickelt?

Als ich zuvor JVM geschrieben habe, habe ich einmal die JVM-Speicherstruktur und das Java-Speichermodell verwechselt~~~ Glücklicherweise haben mich einige begeisterte Internetnutzer darauf aufmerksam gemacht .

JVM-Speicherstruktur:

Java-Speichermodell:

Regeln beim Betrieb von Variablen:

• Das Java-Speichermodell schreibt vor, dass alle Variablen im Hauptspeicher

• Threads Arbeitsspeicher speichert den Hauptspeicher Kopie der vom Thread verwendeten Variablen

• alle

  Operationen des Threads an Variablen (lesen Sie Abruf, Zuweisung). usw.) muss im Arbeitsspeicher erfolgen, und Variablen im Hauptspeicher können nicht direkt gelesen und geschrieben

aus dem zurück in den Hauptspeicher synchronisiert werden

Arbeitsspeicher Speicher wird durch die folgenden 8 Operationen implementiert:

• Sperre (Sperre): Wirkt auf Variablen im Hauptspeicher und markiert eine Variable als exklusiv für einen Thread.

• unlock (unlock): Wirkt auf Hauptspeichervariablen, um eine Variable im gesperrten Zustand freizugeben. Nur die freigegebene Variable kann von anderen Threads gesperrt werden.

• read (lesen): Wirkt auf die Hauptspeichervariable und überträgt einen Variablenwert aus dem Hauptspeicher in den Arbeitsspeicher des Threads, damit er von der nachfolgenden Ladeaktion

• Laden: Eine Variable, die auf den Arbeitsspeicher wirkt. Sie legt den durch den Lesevorgang aus dem Hauptspeicher erhaltenen Variablenwert in eine Kopie der Variablen im Arbeitsspeicher ab.

• use (use): Wirkt auf Variablen im Arbeitsspeicher und übergibt einen Variablenwert im Arbeitsspeicher an die Ausführungs-Engine, wann immer die virtuelle Maschine auf ein Wort stößt, das verwendet werden muss Wert der Variablen. Diese Operation wird ausgeführt, wenn die Abschnittscodeanweisung ausgegeben wird.

• assign (Zuweisung): Wirkt auf eine Variable im Arbeitsspeicher. Es weist einen von der Ausführungs-Engine empfangenen Wert einer Variablen im Arbeitsspeicher zu Zuweisung Diese Operation wird beim Ausführen von Bytecode-Anweisungen ausgeführt.

• store (Speicherung): Wirkt auf Variablen im Arbeitsspeicher und überträgt den Wert einer Variablen im Arbeitsspeicher für nachfolgende Schreibvorgänge in den Hauptspeicher.

• schreiben: Wirkt auf Variablen im Hauptspeicher. Es überträgt den Speichervorgang vom Wert einer Variablen im Arbeitsspeicher auf eine Variable im Hauptspeicher.

Das Java-Speichermodell basiert auf den drei Merkmalen

wie man mit Atomizität, Sichtbarkeit und Ordnung umgehtin gleichzeitigen Prozessen

Operationen, die Atomizität garantieren :

• read、load、assign、use、store和write

• synchronisierte Sperre

garantiert bestellt (Nachbestellung führt zu Störung) Operationen:

• flüchtig

• synchronisierte Sperre

Garantierte Sichtbarkeit:

• flüchtig

• synchronisierte Sperre

• endgültig

Wie oben erwähnt, Ordnung kann durch flüchtige und synchronisierte Sperren gewährleistet werden, aber wenn wir normalerweise Programme schreiben

, achten wir nicht immer auf die Ordnung des Codes . Tatsächlich haben wir in Java ein Prinzip namens Prinzip von Happens-Before(passiert-vorher)

• Das „passiert-vorher“-Prinzip kann wie folgt weitergegeben werden: Mehrere

  Regeln lösen umfassend alle Probleme möglicher Konflikte zwischen zwei Vorgängen in einer gleichzeitigen Umgebung

• Mit diesen Regeln und unseren

  Vorgängen liegen innerhalb des durch diese Regeln definierten Geltungsbereichs . Wir können sicherstellen, dass Vorgang A definitiv vor Vorgang B erfolgt (es wird kein Nachbestellungsproblem auftreten)

Das „passiert-vorher“-Prinzip hat Folgendes:

• Programmreihenfolgeregel: Innerhalb eines Threads erfolgen entsprechend der Reihenfolge des Programmcodes die vorne geschriebenen Operationen vor den hinten geschriebenen Operationen. Genauer gesagt sollte es sich um die Kontrollflusssequenz und nicht um die Programmcodesequenz handeln, da Strukturen wie Verzweigungen und Schleifen berücksichtigt werden müssen.

• Sperrregel überwachen: Ein Entsperrvorgang erfolgt vor einem nachfolgenden Sperrvorgang für dasselbe Schloss. Hervorzuheben ist hier die gleiche Sperre, und „später“ bezieht sich auf die zeitliche Abfolge.

• Regel für flüchtige Variablen: Ein Schreibvorgang auf eine flüchtige Variable erfolgt zuerst, bevor ein nachfolgender Lesevorgang auf die Variable erfolgt. Das „später“ bezieht sich hier auch auf die Zeit. Thread-Startregel: Die start()-Methode des Thread-Objekts geht jeder Aktion dieses Threads voraus.

• Thread-Beendigungsregel: Alle Vorgänge im Thread werden zuerst bei der Beendigungserkennung dieses Threads ausgeführt. Wir können ihn über die Thread.join()-Methode beenden isAlive() und andere Mittel erkennen, dass die Ausführung des Threads beendet wurde.

• Thread-Unterbrechungsregel: Der Aufruf der Thread-Interrupt()-Methode erfolgt zuerst, bevor der Code des unterbrochenen Threads das Auftreten des Interrupt-Ereignisses erkennt. Sie können Thread.interrupted( ) übergeben. Die Methode erkennt, ob ein Interrupt auftritt.

• Objekt-Finalizer-Regel (Finalizer-Regel): Die Initialisierung eines Objekts (das Ende der Konstruktorausführung) erfolgt zuerst am Anfang seiner finalize()-Methode.

• Transitivität: Wenn Operation A vor Operation B und Operation B vor Operation C erfolgt, können wir daraus schließen, dass Operation A vor Operation C erfolgt.

Verwandte Artikel:

Zusammenfassung der Java-Interviewfragen

10 klassische Java-Hauptfragen Methodeninterviewfragen

Das obige ist der detaillierte Inhalt vonEine Sammlung von Java-Interviewfragen – Empfohlene Interviewfragen, damit Sie das Angebot einfacher erhalten. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!