程序員筆記|如何編寫高性能的Java代碼

ky0ncheng 發(fā)布于2019-08-16 17:18 / 3332人閱讀

摘要：常見標(biāo)高線程上下文切換頻繁線程太多鎖競(jìng)爭(zhēng)激烈標(biāo)高如果的占用很高，排查涉及到的程序，比如把改造成。抖動(dòng)問題原因字節(jié)碼轉(zhuǎn)為機(jī)器碼需要占用時(shí)間片，大量的在執(zhí)行字節(jié)碼時(shí)，導(dǎo)致長(zhǎng)期處于高位現(xiàn)象，占用率最高解決辦法保證編譯線程的占比。

一、并發(fā)

Unable to create new native thread ……

問題1：Java中創(chuàng)建一個(gè)線程消耗多少內(nèi)存？

每個(gè)線程有獨(dú)自的棧內(nèi)存，共享堆內(nèi)存

問題2：一臺(tái)機(jī)器可以創(chuàng)建多少線程？

CPU，內(nèi)存，操作系統(tǒng)，JVM，應(yīng)用服務(wù)器

我們編寫一段示例代碼，來驗(yàn)證下線程池與非線程池的區(qū)別：

//線程池和非線程池的區(qū)別
public class ThreadPool {
  
     public static int times = 100;//100,1000,10000
  
     public static ArrayBlockingQueue arrayWorkQueue = new ArrayBlockingQueue(1000);
     public static ExecutorService threadPool = new ThreadPoolExecutor(5, //corePoolSize線程池中核心線程數(shù)
             10,
             60,
             TimeUnit.SECONDS,
             arrayWorkQueue,
             new ThreadPoolExecutor.DiscardOldestPolicy()
     );
  
     public static void useThreadPool() {
         Long start = System.currentTimeMillis();
         for (int i = 0; i < times; i++) {
             threadPool.execute(new Runnable() {
                 public void run() {
                     System.out.println("說點(diǎn)什么吧...");
                 }
             });
         }
         threadPool.shutdown();
         while (true) {
             if (threadPool.isTerminated()) {
                 Long end = System.currentTimeMillis();
                 System.out.println(end - start);
                 break;
             }
         }
     }
  
     public static void createNewThread() {
         Long start = System.currentTimeMillis();
         for (int i = 0; i < times; i++) {
  
             new Thread() {
                 public void run() {
                     System.out.println("說點(diǎn)什么吧...");
                 }
             }.start();
         }
         Long end = System.currentTimeMillis();
         System.out.println(end - start);
     }
  
     public static void main(String args[]) {
         createNewThread();
         //useThreadPool();
     }
 }

啟動(dòng)不同數(shù)量的線程，然后比較線程池和非線程池的執(zhí)行結(jié)果：

	非線程池	線程池
100次	16毫秒	5ms的
1000次	90毫秒	28ms
10000次	1329ms	164ms

結(jié)論：不要new Thread()，采用線程池

非線程池的缺點(diǎn)：

每次創(chuàng)建性能消耗大

無序，缺乏管理。容易無限制創(chuàng)建線程，引起OOM和死機(jī)

1.1 使用線程池要注意的問題

避免死鎖，請(qǐng)盡量使用CAS

我們編寫一個(gè)樂觀鎖的實(shí)現(xiàn)示例：

public class CASLock {
  
     public static int money = 2000;
  
     public static boolean add2(int oldm, int newm) {
         try {
             Thread.sleep(2000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         if (money == oldm) {
             money = money + newm;
             return true;
         }
         return false;
     }
  
     public synchronized static void add1(int newm) {
         try {
             Thread.sleep(3000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         money = money + newm;
     }
  
     public static void add(int newm) {
         try {
             Thread.sleep(3000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         money = money + newm;
     }
  
     public static void main(String args[]) {
         Thread one = new Thread() {
             public void run() {
                 //add(5000)
                 while (true) {
                     if (add2(money, 5000)) {
                         break;
                     }
                 }
             }
         };
         Thread two = new Thread() {
             public void run() {
                 //add(7000)
                 while (true) {
                     if (add2(money, 7000)) {
                         break;
                     }
                 }
             }
         };
         one.start();
         two.start();
         try {
             one.join();
             two.join();
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println(money);
     }
 }

使用ThreadLocal要注意

ThreadLocalMap使用ThreadLocal的弱引用作為key，如果一個(gè)ThreadLocal沒有外部強(qiáng)引用來引用它，那么系統(tǒng) GC 的時(shí)候，這個(gè)ThreadLocal勢(shì)必會(huì)被回收，這樣一來，ThreadLocalMap中就會(huì)出現(xiàn)key為null的Entry，就沒有辦法訪問這些key為null的Entry的value，如果當(dāng)前線程再遲遲不結(jié)束的話，這些key為null的Entry的value就會(huì)一直存在一條強(qiáng)引用鏈：Thread Ref -> Thread -> ThreaLocalMap -> Entry -> value永遠(yuǎn)無法回收，造成內(nèi)存泄漏。

我們編寫一個(gè)ThreadLocalMap正確使用的示例：

//ThreadLocal應(yīng)用實(shí)例
public class ThreadLocalApp {
  
     public static final ThreadLocal threadLocal = new ThreadLocal();
  
     public static void muti2() {
         int i[] = (int[]) threadLocal.get();
         i[1] = i[0] * 2;
         threadLocal.set(i);
     }
  
     public static void muti3() {
         int i[] = (int[]) threadLocal.get();
         i[2] = i[1] * 3;
         threadLocal.set(i);
     }
  
     public static void muti5() {
         int i[] = (int[]) threadLocal.get();
         i[3] = i[2] * 5;
         threadLocal.set(i);
     }
  
     public static void main(String args[]) {
         for (int i = 0; i < 5; i++) {
             new Thread() {
                 public void run() {
                     int start = new Random().nextInt(10);
                     int end[] = {0, 0, 0, 0};
                     end[0] = start;
                     threadLocal.set(end);
                     ThreadLocalApp.muti2();
                     ThreadLocalApp.muti3();
                     ThreadLocalApp.muti5();
                     //int end = (int) threadLocal.get();
                     System.out.println(end[0] + "  " + end[1] + "  " + end[2] + "  " + end[3]);
                     threadLocal.remove();
                 }
             }.start();
         }
     }
 }

1.2 線程交互—線程不安全造成的問題

經(jīng)典的HashMap死循環(huán)造成CPU100%問題

我們模擬一個(gè)HashMap死循環(huán)的示例：

//HashMap死循環(huán)示例
public class HashMapDeadLoop {
  
     private HashMap hash = new HashMap();
  
     public HashMapDeadLoop() {
         Thread t1 = new Thread() {
             public void run() {
                 for (int i = 0; i < 100000; i++) {
                     hash.put(new Integer(i), i);
                 }
                 System.out.println("t1 over");
             }
         };
  
         Thread t2 = new Thread() {
             public void run() {
                 for (int i = 0; i < 100000; i++) {
                     hash.put(new Integer(i), i);
                 }
                 System.out.println("t2 over");
             }
         };
         t1.start();
         t2.start();
     }
  
     public static void main(String[] args) {
         for (int i = 0; i < 1000; i++) {
             new HashMapDeadLoop();
         }
         System.out.println("end");
     }
 }
https://coolshell.cn/articles/9606.html

HashMap死循環(huán)發(fā)生后，我們可以在線程棧中觀測(cè)到如下信息：

/HashMap死循環(huán)產(chǎn)生的線程棧
Thread-281" #291 prio=5 os_prio=31 tid=0x00007f9f5f8de000 nid=0x5a37 runnable [0x0000700006349000]
   java.lang.Thread.State: RUNNABLE
       at java.util.HashMap$TreeNode.split(HashMap.java:2134)
       at java.util.HashMap.resize(HashMap.java:713)
       at java.util.HashMap.putVal(HashMap.java:662)
       at java.util.HashMap.put(HashMap.java:611)
       at com.example.demo.HashMapDeadLoop$2.run(HashMapDeadLoop.java:26)

應(yīng)用停滯的死鎖，Spring3.1的deadlock 問題

我們模擬一個(gè)死鎖的示例：

//死鎖的示例
public class DeadLock {
     public static Integer i1 = 2000;
     public static Integer i2 = 3000;
         public static synchronized Integer getI2() {
         try {
             Thread.sleep(3000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         return i2;
     }
     public static void main(String args[]) {
         Thread one = new Thread() {
             public void run() {
                 synchronized (i1) {
                     try {
                         Thread.sleep(3000);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                     synchronized (i2) {
                         System.out.println(i1 + i2);
                     }
                 }
             }
         };
         one.start();
         Thread two = new Thread() {
             public void run() {
                 synchronized (i2) {
                     try {
                         Thread.sleep(3000);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                     synchronized (i1) {
                         System.out.println(i1 + i2);
                     }
                 }
             }
         };
         two.start();
     }
 }

死鎖發(fā)生后，我們可以在線程棧中觀測(cè)到如下信息：

//死鎖時(shí)產(chǎn)生堆棧
"Thread-1":
       at com.example.demo.DeadLock$2.run(DeadLock.java:47)
       - waiting to lock  (a java.lang.Integer)
       - locked  (a java.lang.Integer)
"Thread-0":
       at com.example.demo.DeadLock$1.run(DeadLock.java:31)
       - waiting to lock  (a java.lang.Integer)
       - locked  (a java.lang.Integer)
Found 1 deadlock.

1.3 基于JUC的優(yōu)化示例

一個(gè)計(jì)數(shù)器的優(yōu)化，我們分別用Synchronized，ReentrantLock，Atomic三種不同的方式來實(shí)現(xiàn)一個(gè)計(jì)數(shù)器，體會(huì)其中的性能差異

//示例代碼
public class SynchronizedTest {
  
     public static int threadNum = 100;
     public static int loopTimes = 10000000;
  
     public static void userSyn() {
         //線程數(shù)
         Syn syn = new Syn();
         Thread[] threads = new Thread[threadNum];
         //記錄運(yùn)行時(shí)間
         long l = System.currentTimeMillis();
         for (int i = 0; i < threadNum; i++) {
             threads[i] = new Thread(new Runnable() {
                 @Override
                 public void run() {
                     for (int j = 0; j < loopTimes; j++) {
                         //syn.increaseLock();
                         syn.increase();
                     }
                 }
             });
             threads[i].start();
         }
         //等待所有線程結(jié)束
         try {
             for (int i = 0; i < threadNum; i++)
                 threads[i].join();
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println("userSyn" + "-" + syn + " : " + (System.currentTimeMillis() - l) + "ms");
     }
  
     public static void useRea() {
         //線程數(shù)
         Syn syn = new Syn();
         Thread[] threads = new Thread[threadNum];
         //記錄運(yùn)行時(shí)間
         long l = System.currentTimeMillis();
         for (int i = 0; i < threadNum; i++) {
             threads[i] = new Thread(new Runnable() {
                 @Override
                 public void run() {
                     for (int j = 0; j < loopTimes; j++) {
                         syn.increaseLock();
                         //syn.increase();
                     }
                 }
             });
             threads[i].start();
         }
         //等待所有線程結(jié)束
         try {
             for (int i = 0; i < threadNum; i++)
                 threads[i].join();
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println("userRea" + "-" + syn + " : " + (System.currentTimeMillis() - l) + "ms");
     }
    public static void useAto() {
         //線程數(shù)
         Thread[] threads = new Thread[threadNum];
         //記錄運(yùn)行時(shí)間
         long l = System.currentTimeMillis();
         for (int i = 0; i < threadNum; i++) {
             threads[i] = new Thread(new Runnable() {
                 @Override
                 public void run() {
                     for (int j = 0; j < loopTimes; j++) {
                         Syn.ai.incrementAndGet();
                     }
                 }
             });
             threads[i].start();
         }
         //等待所有線程結(jié)束
         try {
             for (int i = 0; i < threadNum; i++)
                 threads[i].join();
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println("userAto" + "-" + Syn.ai + " : " + (System.currentTimeMillis() - l) + "ms");
     }
  
     public static void main(String[] args) {
         SynchronizedTest.userSyn();
         SynchronizedTest.useRea();
         SynchronizedTest.useAto();
     }
 }
  
 class Syn {
     private int count = 0;
     public final static AtomicInteger ai = new AtomicInteger(0);
  
     private Lock lock = new ReentrantLock();
  
     public synchronized void increase() {
         count++;
     }
  
     public void increaseLock() {
         lock.lock();
         count++;
         lock.unlock();
     }
  
     @Override
     public String toString() {
         return String.valueOf(count);
     }
 }

結(jié)論，在并發(fā)量高，循環(huán)次數(shù)多的情況，可重入鎖的效率高于Synchronized，但最終Atomic性能最好。

二、通信 2.1 數(shù)據(jù)庫連接池的高效問題

一定要在finally中close連接

一定要在finally中release連接

2.2 OIO/NIO/AIO

	OIO	NIO	AIO
類型	阻塞	非阻塞	非阻塞
使用難度	簡(jiǎn)單	復(fù)雜	復(fù)雜
可靠性	差	高	高
吞吐量	低	高	高

結(jié)論：我性能有嚴(yán)苛要求下，盡量應(yīng)該采用NIO的方式進(jìn)行通信。

2.3 TIME_WAIT(client)，CLOSE_WAIT(server)問題

反應(yīng)：經(jīng)常性的請(qǐng)求失敗

獲取連接情況 netstat -n | awk "/^tcp/ {++S[$NF]} END {for(a in S) print a, S[a]}"

TIME_WAIT：表示主動(dòng)關(guān)閉，優(yōu)化系統(tǒng)內(nèi)核參數(shù)可。

CLOSE_WAIT：表示被動(dòng)關(guān)閉。

ESTABLISHED：表示正在通信

解決方案：二階段完成后強(qiáng)制關(guān)閉

2.4 串行連接，持久連接（長(zhǎng)連接），管道化連接

結(jié)論：

管道連接的性能最優(yōu)異，持久化是在串行連接的基礎(chǔ)上減少了打開/關(guān)閉連接的時(shí)間。

管道化連接使用限制：

1、HTTP客戶端無法確認(rèn)持久化（一般是服務(wù)器到服務(wù)器，非終端使用）；

2、響應(yīng)信息順序必須與請(qǐng)求信息順序一致；

3、必須支持冪等操作才可以使用管道化連接.

三、數(shù)據(jù)庫操作

必須要有索引（特別注意按時(shí)間查詢）

單條操作or批量操作

注：很多程序員在寫代碼的時(shí)候隨意采用了單條操作的方式，但在性能要求前提下，要求采用批量操作方式。

四、JVM 4.1 CPU標(biāo)高的一般處理步驟

top查找出哪個(gè)進(jìn)程消耗的cpu高

top –H –p查找出哪個(gè)線程消耗的cpu高

記錄消耗cpu最高的幾個(gè)線程

printf %x 進(jìn)行pid的進(jìn)制轉(zhuǎn)換

jstack記錄進(jìn)程的堆棧信息

找出消耗cpu最高的線程信息

4.2 內(nèi)存標(biāo)高（OOM）一般處理步驟

jstat命令查看FGC發(fā)生的次數(shù)和消耗的時(shí)間，次數(shù)越多，耗時(shí)越長(zhǎng)說明存在問題；

連續(xù)查看jmap –heap 查看老生代的占用情況，變化越大說明程序存在問題；

使用連續(xù)的jmap –histo:live 命令導(dǎo)出文件，比對(duì)加載對(duì)象的差異，差異部分一般是發(fā)生問題的地方。

4.3 GC引起的單核標(biāo)高

單個(gè)CPU占用率高，首先從GC查起。

4.4 常見SY標(biāo)高

線程上下文切換頻繁

線程太多

鎖競(jìng)爭(zhēng)激烈

4.5 Iowait標(biāo)高

如果IO的CPU占用很高，排查涉及到IO的程序，比如把OIO改造成NIO。

4.6 抖動(dòng)問題

原因：字節(jié)碼轉(zhuǎn)為機(jī)器碼需要占用CPU時(shí)間片，大量的CPU在執(zhí)行字節(jié)碼時(shí)，導(dǎo)致CPU長(zhǎng)期處于高位；

現(xiàn)象：“C2 CompilerThread1” daemon，“C2 CompilerThread0” daemon CPU占用率最高；

解決辦法：保證編譯線程的CPU占比。

作者：梁鑫

來源：宜信技術(shù)學(xué)院

GPU云服務(wù)器云服務(wù)器如何編寫高性能的javascript java的編寫程序怎么編寫程序代碼如何編寫網(wǎng)站代碼

文章版權(quán)歸作者所有，未經(jīng)允許請(qǐng)勿轉(zhuǎn)載,若此文章存在違規(guī)行為，您可以聯(lián)系管理員刪除。

轉(zhuǎn)載請(qǐng)注明本文地址：http://www.ezyhdfw.cn/yun/74508.html

發(fā)表評(píng)論

登陸后可評(píng)論

0條評(píng)論

ky0ncheng

男|高級(jí)講師

我要關(guān)注我要私信

TA的文章

使用fiddler進(jìn)行mock測(cè)試

閱讀 809·2021-11-16 11:44
JavaScript中的原型與繼承

閱讀 3657·2019-08-26 12:13
React V16.9來了無痛感升級(jí) 加入性能檢測(cè) 【譯-真香】

閱讀 3313·2019-08-26 10:46
JavaScript專題之模擬實(shí)現(xiàn)call和apply

閱讀 2434·2019-08-23 12:37
react 官網(wǎng)動(dòng)畫庫（react-transition-group）的新寫法

閱讀 1286·2019-08-22 18:30
react源碼解析之stack reconciler

閱讀 2625·2019-08-22 17:30
vue基礎(chǔ)知識(shí) 匯總

閱讀 1924·2019-08-22 17:26
Local Storage 操作小插件 iStorage 介紹

閱讀 2373·2019-08-22 16:20

亚洲中字慕日产2020,大陆极品少妇内射AAAAAA,无码av大香线蕉伊人久久,久久精品国产亚洲av麻豆网站

資訊專欄INFORMATION COLUMN

上云采購季！| 2核2G4M爆款云服務(wù)器低至59元/年，更有多臺(tái)、長(zhǎng)期優(yōu)惠，快來選購！

程序員筆記|如何編寫高性能的Java代碼

相關(guān)文章

**《深入理解java虛擬機(jī)》學(xué)習(xí)筆記系列——java內(nèi)存區(qū)域劃分**

Java基礎(chǔ)-模塊系統(tǒng)筆記（1）

**「Java 8 函數(shù)式編程」讀書筆記——數(shù)據(jù)并行化**

Python

基本方法筆記 - 收藏集 - 掘金

發(fā)表評(píng)論

0條評(píng)論

ky0ncheng

男|高級(jí)講師

TA的文章

使用fiddler進(jìn)行mock測(cè)試

JavaScript中的原型與繼承

React V16.9來了無痛感升級(jí) 加入性能檢測(cè) 【譯-真香】

JavaScript專題之模擬實(shí)現(xiàn)call和apply

react 官網(wǎng)動(dòng)畫庫（react-transition-group）的新寫法

react源碼解析之stack reconciler

vue基礎(chǔ)知識(shí) 匯總

Local Storage 操作小插件 iStorage 介紹

最新活動(dòng)

資訊專欄INFORMATION COLUMN

上云采購季！| 2核2G4M爆款云服務(wù)器低至59元/年，更有多臺(tái)、長(zhǎng)期優(yōu)惠，快來選購！

程序員筆記|如何編寫高性能的Java代碼

相關(guān)文章

發(fā)表評(píng)論

0條評(píng)論

男|高級(jí)講師

TA的文章

最新活動(dòng)

上云采購季！| 2核2G4M爆款云服務(wù)器低至59元/年，更有多臺(tái)、長(zhǎng)期優(yōu)惠，快來選購！