Shulou(Shulou.com)06/02 Report--

This article mainly introduces how to write high-performance Java code, has a certain reference value, interested friends can refer to, I hope you can learn a lot after reading this article, the following let Xiaobian take you to understand.

1. Concurrency

Unable to create new native thread...

How much memory does it take to create a thread in question 1:Java?

Each thread has its own stack memory, shared heap memory

Question 2: how many threads can a machine create?

CPU, memory, operating system, JVM, application server

Let's write a sample code to verify the difference between the thread pool and the non-thread pool:

/ / the difference between public class ThreadPool {public static int times = 100 thread pool and non-thread pool; public static ExecutorService threadPool = new ThreadPoolExecutor (10, 60, TimeUnit.SECONDS, arrayWorkQueue, new ThreadPoolExecutor.DiscardOldestPolicy ()) in the thread pool. 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("说点什么吧..."); } }); } 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("说点什么吧..."); } }.start(); } Long end = System.currentTimeMillis(); System.out.println(end - start); } public static void main(String args[]) { createNewThread(); //useThreadPool(); } } 启动不同数量的线程，然后比较线程池和非线程池的执行结果： 非线程池线程池100次16毫秒5ms的1000次90毫秒28ms10000次1329ms164ms 结论：不要new Thread()，采用线程池 非线程池的缺点： 每次创建性能消耗大 无序，缺乏管理。容易无限制创建线程，引起OOM和死机 1.1 使用线程池要注意的问题 避免死锁，请尽量使用CAS 我们编写一个乐观锁的实现示例： 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，如果一个ThreadLocal没有外部强引用来引用它，那么系统 GC 的时候，这个ThreadLocal势必会被回收，这样一来，ThreadLocalMap中就会出现key为null的Entry，就没有办法访问这些key为null的Entry的value，如果当前线程再迟迟不结束的话，这些key为null的Entry的value就会一直存在一条强引用链：Thread Ref ->

Thread-> ThreaLocalMap-> Entry-> value can never be recycled, resulting in a memory leak.

Let's write an example of the correct use of ThreadLocalMap:

/ / ThreadLocal application example 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 线程交互-线程不安全造成的问题 经典的HashMap死循环造成CPU100%问题 我们模拟一个HashMap死循环的示例： //HashMap死循环示例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死循环发生后，我们可以在线程栈中观测到如下信息： /HashMap死循环产生的线程栈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) 应用停滞的死锁，Spring3.1的deadlock 问题 我们模拟一个死锁的示例： //死锁的示例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(); } } 死锁发生后，我们可以在线程栈中观测到如下信息： //死锁时产生堆栈"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的优化示例 一个计数器的优化，我们分别用Synchronized，ReentrantLock，Atomic三种不同的方式来实现一个计数器，体会其中的性能差异 //示例代码public class SynchronizedTest { public static int threadNum = 100; public static int loopTimes = 10000000; public static void userSyn() { //线程数 Syn syn = new Syn(); Thread[] threads = new Thread[threadNum]; //记录运行时间 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(); } //等待所有线程结束 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() { //线程数 Syn syn = new Syn(); Thread[] threads = new Thread[threadNum]; //记录运行时间 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(); } //等待所有线程结束 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() { //线程数 Thread[] threads = new Thread[threadNum]; //记录运行时间 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(); } //等待所有线程结束 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); } } 结论，在并发量高，循环次数多的情况，可重入锁的效率高于Synchronized，但最终Atomic性能最好。 二、通信2.1 数据库连接池的高效问题 一定要在finally中close连接 一定要在finally中release连接 2.2 OIO/NIO/AIO OIONIOAIO类型阻塞非阻塞非阻塞使用难度简单复杂复杂可靠性差高高吞吐量低高高 结论：我性能有严苛要求下，尽量应该采用NIO的方式进行通信。 2.3 TIME_WAIT(client)，CLOSE_WAIT(server)问题 反应：经常性的请求失败 获取连接情况 netstat -n | awk '/^tcp/ {++S[$NF]} END {for(a in S) print a, S[a]}' TIME_WAIT：表示主动关闭，优化系统内核参数可。 CLOSE_WAIT：表示被动关闭。 ESTABLISHED：表示正在通信 解决方案：二阶段完成后强制关闭 2.4 串行连接，持久连接（长连接），管道化连接

Conclusion:

Pipe connections have the best performance, and persistence reduces the time it takes to open / close connections on the basis of serial connections.

Restrictions on the use of pipelined connections:

1. HTTP client cannot confirm persistence (usually server-to-server, non-terminal use)

2. The order of response information must be the same as that of request information.

3. Idempotent operations must be supported before pipelized connections can be used.

III. Database operation

There must be an index (pay special attention to query by time)

Single operation or batch operation

Note: many programmers use a single operation at will when writing code, but batch operation is required under the premise of performance requirements.

IV. General processing steps of JVM4.1 CPU elevation

Top finds out which process consumes the highest cpu

Top-H-p finds out which thread consumes more cpu

Record the threads that consume the most cpu

Printf x performs binary conversion of pid

Jstack records the stack information of the process

Find out the thread information that consumes the most cpu

4.2 General processing steps for memory elevation (OOM)

The jstat command checks the number of times and time consumed by FGC. The more times it takes, the longer it takes to indicate that there is a problem.

Check jmap-heap continuously to check the occupancy of the older generation. The greater the change, the problem with the program.

Use the continuous jmap-histo:live command to export the file, and the difference is usually the place where the problem occurs compared to the difference of the loaded object.

4.3 single core elevation caused by GC

The occupancy rate of a single CPU is high, so start with GC.

4.4 Common SY elevation

Thread context switches frequently

Too many threads

Lock competition is fierce

4.5 Iowait elevation

If the CPU footprint of IO is high, troubleshoot programs that involve IO, such as transforming OIO into NIO.

4.6 Jitter issu

Reason: the conversion of bytecode to machine code takes up CPU time slices. When a large number of CPU executes bytecode, CPU remains high for a long time.

Phenomenon: "C2 CompilerThread1" daemon, "C2 CompilerThread0" daemon CPU has the highest occupancy rate

Solution: make sure the compilation thread has a percentage of CPU.

Thank you for reading this article carefully. I hope the article "how to write High-performance Java Code" shared by the editor will be helpful to you. At the same time, I also hope you will support us and pay attention to the industry information channel. More related knowledge is waiting for you to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.