Zusammenfassung der Leistungsoptimierung des Java-Entwicklungscodes

Code-Optimierung mag für manche Leute nutzlos klingen, aber ich denke, Sie sollten Ihr Bestes geben, um während des Entwicklungsprozesses gute Gewohnheiten zu entwickeln . Okay, lassen Sie mich die Zusammenfassung mit Ihnen teilen, die ich normalerweise verwendet sehe.

Ziele der Codeoptimierung

1 Reduzieren Sie die Codegröße

2 Verbessern Sie die Leistung von das gesamte System Betriebseffizienz

Optimierung von Codedetails

1 Versuchen Sie, den endgültigen Modifikator der Klasse anzugeben und Methode

Klassen mit endgültiger Änderung werden nicht abgeleitet. In der Java-Kern-API gibt es viele Beispiele für die Verwendung von final, z. B. java.lang.String. Die Angabe des finalen Modifikators für eine Klasse kann verhindern, dass die Klasse vererbt wird, und die Angabe von final für eine Methode Verhindern Sie, dass die Methode vererbt wird. Wenn Sie eine Klasse als final angeben, sind alle Methoden der Klasse final. Der Java-Compiler sucht nach Möglichkeiten, alle endgültigen Methoden zu integrieren. Inlining spielt eine wichtige Rolle bei der Verbesserung der Java-Laufzeitoptimierung. Dadurch kann die Leistung um durchschnittlich 50 % verbessert werden.

2 Versuchen Sie, Objekte wiederzuverwenden

Insbesondere für die Verwendung von String-Objekten sollte StringBuilder/ als String verwendet werden Stattdessen treten StringBuffer-Verbindungen auf. Da die Java Virtual Machine nicht nur Zeit damit verbringt, Objekte zu generieren, muss sie möglicherweise in Zukunft auch Zeit damit verbringen, diese Objekte zu sammeln und zu verarbeiten. Daher hat die Generierung zu vieler Objekte große Auswirkungen auf die Leistung des Programms.

3 Verwenden Sie wann immer möglich lokale Objekte

Parameter, die beim Aufruf einer Methode übergeben werden, und temporäre Variablen, die beim Aufruf erstellt werden werden alle im Stapel gespeichert und sind schneller. Andere Variablen, wie z. B. statische Variablen und Instanzvariablen, werden im Heap erstellt und sind langsamer. Darüber hinaus gehen die Inhalte der im Stapel erstellten Variablen verloren, wenn die Methode endet, und es ist keine zusätzliche Speicherbereinigung erforderlich.

4 Schließen Sie den Stream umgehend

Stellen Sie während des Java-Programmierungsprozesses sicher, dass Sie Datenbankverbindungen herstellen und/oder O-Stream-Vorgänge Achten Sie darauf, ihn sofort nach der Verwendung zu schließen, um Ressourcen freizugeben. Da der Betrieb dieser großen Objekte einen hohen Systemaufwand verursacht, kann eine kleine Nachlässigkeit schwerwiegende Folgen haben.

5 Versuchen Sie, wiederholte Berechnungen von Variablen zu reduzieren

Klaren Sie ein Konzept, den Aufruf einer Methode, sogar in Eine Methode Es gibt nur eine Anweisung, die auch verbraucht wird, einschließlich der Erstellung eines Stapelrahmens, des Schutzes der Szene beim Aufruf der Methode, der Wiederherstellung der Szene beim Aufruf der Methode usw. Es wird beispielsweise empfohlen, die folgende Operation zu ersetzen:

for (int i = 0; i < list.size(); i++)
{...}

durch:

for (int i = 0, int length = list.size(); i < length; i++)
{...}

Wenn list.size() sehr groß ist, gibt es viele Der Verbrauch wird reduziert

6 Versuchen Sie, eine Lazy-Loading-Strategie anzuwenden, d Es wird empfohlen, es zu ersetzen durch:

7 Ausnahmen mit Vorsicht verwenden

String str = "aaa";if (i == 1)
{
list.add(str);
}

if (i == 1)
{String str = "aaa";
list.add(str);
}

Ausnahmen beeinträchtigen die Leistung. Um eine Ausnahme auszulösen, müssen Sie zunächst ein neues Objekt erstellen. Der Konstruktor der Throwable-Schnittstelle ruft die lokale Synchronisierungsmethode namens fillInStackTrace() auf. Die Methode fillInStackTrace() überprüft den Stapel und sammelt Aufrufverfolgungsinformationen. Immer wenn eine Ausnahme ausgelöst wird, muss die Java Virtual Machine den Aufrufstapel anpassen, da während der Verarbeitung ein neues Objekt erstellt wird. Ausnahmen sollten nur zur Fehlerbehandlung und nicht zur Steuerung des Programmablaufs verwendet werden.

8 Verwenden Sie try...catch... nicht in einer Schleife, es sollte außerhalb

platziert werden, es sei denn, dies ist der Fall ist unbedingt notwendig. Wenn Sie dies ohne Angabe von Gründen schreiben, wird Ihr Vorgesetzter Sie, solange er älter ist und an einer Zwangsstörung leidet, höchstwahrscheinlich ausschimpfen, weil Sie solchen Müllcode geschrieben haben

9 Wenn die Länge des hinzuzufügenden Inhalts geschätzt werden kann, geben Sie die Anfangslänge für die zugrunde liegende Sammlung und Werkzeugklasse an, die im Array

wie ArrayList, LinkedLlist, StringBuilder, implementiert sind. StringBuffer, HashMap, HashSet usw., am Beispiel von StringBuilder:

(1) StringBuilder() // Standardmäßig 16 Zeichen Leerzeichen zuweisen

(2) StringBuilder (int size) // Die Standardzuordnung ist die Größe des Zeichenraums

(3) StringBuilder(String str) // Die Standardzuordnung ist 16 Zeichen + str.length()-Zeichenraum

Sie können die Initialisierungskapazität über die Klasse festlegen (hier bezieht sich nicht nur auf den oben genannten StringBuilder), was die Leistung erheblich verbessern kann. Beispielsweise stellt die Länge von StringBuilder die Anzahl der Zeichen dar, die der aktuelle StringBuilder aufnehmen kann. Denn wenn StringBuilder seine maximale Kapazität erreicht, erhöht es seine Kapazität auf das Zweifache seiner aktuellen Kapazität plus 2. Immer wenn StringBuilder seine maximale Kapazität erreicht, muss er ein neues Zeichenarray erstellen und dann die alten Zeichen durch den Inhalt ersetzen Array werden in ein neues Zeichenarray kopiert – dies ist ein sehr leistungsintensiver Vorgang. Stellen Sie sich vor, wenn Sie abschätzen können, dass etwa 5000 Zeichen im Zeichenarray gespeichert werden, ohne die Länge anzugeben, die nächste Potenz von 2 bis 5000 4096 ist und für jede Erweiterung 2 hinzugefügt wird, dann:

(1) Beantragen Sie auf der Basis von 4096 8194 Zeichen-Arrays, was einer gleichzeitigen Anwendung von 12290 Zeichen-Arrays entspricht. Wenn Sie zu Beginn ein Zeichen-Array mit 5000 Größen angeben können, Das spart mehr als das Doppelte an Platz

(2) Kopieren Sie die ursprünglichen 4096 Zeichen in das neue Zeichenarray

这样，既浪费内存空间又降低代码运行效率。所以，给底层以数组实现的集合、工具类设置一个合理的初始化容量是错不了的，这会带来立竿见影的效果。但是，注意，像HashMap这种是以数组+链表实现的集合，别把初始大小和你估计的大小设置得一样，因为一个table上只连接一个对象的可能性几乎为0。初始大小建议设置为2的N次幂，如果能估计到有2000个元素，设置成new HashMap(128)、new HashMap(256)都可以。

10 当复制大量数据时，使用 System.arraycopy() 命令

11 乘法和除法使用移位操作

例如：

for (val = 0; val < 100000; val += 5)
{
a = val * 8;
b = val / 2;
}

用移位操作可以极大地提高性能，因为在计算机底层，对位的操作是最方便、最快的，因此建议修改为：

for (val = 0; val < 100000; val += 5)
{
a = val << 3;
b = val >> 1;
}

移位操作虽然快，但是可能会使代码不太好理解，因此最好加上相应的注释。

12 循环内不要不断创建对象引用

例如：

for (int i = 1; i <= count; i++)
{Object obj = new Object();
}

这种做法会导致内存中有count份Object对象引用存在，count很大的话，就耗费内存了，建议为改为：Object obj = null;for (int i = 0; i <= count; i++) { obj = new Object(); }
这样的话，内存中只有一份Object对象引用，每次new Object()的时候，Object对象引用指向不同的Object罢了，但是内存中只有一份，这样就大大节省了内存空间了。

13基于效率和类型检查的考虑，应该尽可能使用array，无法确定数组大小时才使用ArrayList

14尽量使用HashMap、ArrayList、StringBuilder，除非线程安全需要，否则不推荐使用Hashtable、Vector、StringBuffer，后三者由于使用同步机制而导致了性能开销

15 不要将数组声明为 public static final

因为这毫无意义，这样只是定义了引用为 static final ，数组的内容还是可以随意改变的，将数组声明为 public 更是一个安全漏洞，这意味着这个数组可以被外部类所改变

16 尽量在合适的场合使用单例

使用单例可以减轻加载的负担、缩短加载的时间、提高加载的效率，但并不是所有地方都适用于单例，简单来说，单例主要适用于以下三个方面：

（1）控制资源的使用，通过线程同步来控制资源的并发访问

（2）控制实例的产生，以达到节约资源的目的

（3）控制数据的共享，在不建立直接关联的条件下，让多个不相关的进程或线程之间实现通信

17 尽量避免随意使用静态变量

要知道，当某个对象被定义为 static 的变量所引用，那么 gc 通常是不会回收这个对象所占有的堆内存的，如：

public class A{private static B b = new B();
}

以上就是Java开发代码性能优化总结的内容，更多相关内容请关注PHP中文网（www.php.cn）！