程序员笔记如何编写高性能的Java代码

36次阅读

共计 12872 个字符，预计需要花费 33 分钟才能阅读完成。

一、并发

无法创建新的本机线程 ……

问题 1：Java 的中创建一个线程消耗多少内存？

每个线程有独自的栈内存，共享堆内存

问题 2：一台机器可以创建多少线程？

CPU，内存，操作系统，JVM，应用服务器

我们编写一段示例代码，来验证下线程池与非线程池的区别：

// 线程池和非线程池的区别 <font></font>
public class ThreadPool {<font></font>
 <font></font>
     public static int times = 100;//100,1000,10000<font></font>
 <font></font>
     public static ArrayBlockingQueue arrayWorkQueue = new ArrayBlockingQueue(1000);<font></font>
     public static ExecutorService threadPool = new ThreadPoolExecutor(5, //corePoolSize 线程池中核心线程数 <font></font>
             10,<font></font>
             60,<font></font>
             TimeUnit.SECONDS,<font></font>
             arrayWorkQueue,<font></font>
             new ThreadPoolExecutor.DiscardOldestPolicy()<font></font>);<font></font>
 <font></font>
     public static void useThreadPool() {<font></font>
         Long start = System.currentTimeMillis();<font></font>
         for (int i = 0; i < times; i++) {<font></font>
             threadPool.execute(new Runnable() {<font></font>
                 public void run() {<font></font>
                     System.out.println("说点什么吧...");<font></font>
                 }<font></font>
             });<font></font>
         }<font></font>
         threadPool.shutdown();<font></font>
         while (true) {<font></font>
             if (threadPool.isTerminated()) {<font></font>
                 Long end = System.currentTimeMillis();<font></font>
                 System.out.println(end - start);<font></font>
                 break;<font></font>
             }<font></font>
         }<font></font>
     }<font></font>
 <font></font>
     public static void createNewThread() {<font></font>
         Long start = System.currentTimeMillis();<font></font>
         for (int i = 0; i < times; i++) {<font></font>
 <font></font>
             new Thread() {<font></font>
                 public void run() {<font></font>
                     System.out.println("说点什么吧...");<font></font>
                 }<font></font>
             }.start();<font></font>}<font></font>
         Long end = System.currentTimeMillis();<font></font>
         System.out.println(end - start);<font></font>
     }<font></font>
 <font></font>
     public static void main(String args[]) {<font></font>
         createNewThread();<font></font>
         //useThreadPool();<font></font>}<font></font>
 }

启动不同数量的线程，然后比较线程池和非线程池的执行结果：

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

结论 ：不要新的 Thread（），采用线程池

非线程池的缺点 ：

  • 每次创建性能消耗大
  • 无序，缺乏管理。容易无限制创建线程，引起 OOM 和死机

1.1 使用线程池要注意的问题

避免死锁，请尽量使用 CAS

我们编写一个乐观锁的实现示例：

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

使用 ThreadLocal 中要注意

ThreadLocalMap 使用 ThreadLocal 的弱引用作为 key，如果一个 ThreadLocal 没有外部强引用来引用它，那么系统 GC 的时候，这个 ThreadLocal 势必会被回收，这样一来，ThreadLocalMap 中就会出现 key 为 null 的条目，就没有办法访问这些键为 null 的条目的值，如果当前线程再迟迟不结束的话，这些键为 null 的条目的值就会一直存在一条强引用链：线程参考 – > 线程 – > ThreaLocalMap – > 条目 – > 值永远无法回收，造成内存泄漏。

我们编写一个 ThreadLocalMap 正确使用的示例：

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

1.2 线程交互 – 线程不安全造成的问题

经典的 HashMap 的死循环造成 CPU100%问题

我们模拟一个 HashMap 的死循环的示例：

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

HashMap 的死循环发生后，我们可以在线程栈中观测到如下信息：

/HashMap 死循环产生的线程栈 <font></font>
Thread-281" #291 prio=5 os_prio=31 tid=0x00007f9f5f8de000 nid=0x5a37 runnable [0x0000700006349000]<font></font>
   java.lang.Thread.State: RUNNABLE<font></font>
       at java.util.HashMap$TreeNode.split(HashMap.java:2134)<font></font>
       at java.util.HashMap.resize(HashMap.java:713)<font></font>
       at java.util.HashMap.putVal(HashMap.java:662)<font></font>
       at java.util.HashMap.put(HashMap.java:611)<font></font>
       at com.example.demo.HashMapDeadLoop$2.run(HashMapDeadLoop.java:26)

应用停滞的死锁，Spring3.1 的死锁问题

我们模拟一个死锁的示例：

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

死锁发生后，我们可以在线程栈中观测到如下信息：

// 死锁时产生堆栈 <font></font>
"Thread-1":<font></font>
       at com.example.demo.DeadLock$2.run(DeadLock.java:47)<font></font>
       - waiting to lock  (a java.lang.Integer)<font></font>
       - locked  (a java.lang.Integer)<font></font>
"Thread-0":<font></font>
       at com.example.demo.DeadLock$1.run(DeadLock.java:31)<font></font>
       - waiting to lock  (a java.lang.Integer)<font></font>
       - locked  (a java.lang.Integer)<font></font>
Found 1 deadlock.

1.3 基于洁悠神的优化示例

一个计数器的优化，我们分别用同步，ReentrantLock 的，原子三种不同的方式来实现一个计数器，体会其中的性能差异 

// 示例代码 <font></font>
public class SynchronizedTest {<font></font>
 <font></font>
     public static int threadNum = 100;<font></font>
     public static int loopTimes = 10000000;<font></font>
 <font></font>
     public static void userSyn() {<font></font>
         // 线程数 <font></font>
         Syn syn = new Syn();<font></font>
         Thread[] threads = new Thread[threadNum];<font></font>
         // 记录运行时间 <font></font>
         long l = System.currentTimeMillis();<font></font>
         for (int i = 0; i < threadNum; i++) {<font></font>
             threads[i] = new Thread(new Runnable() {<font></font>
                 @Override<font></font>
                 public void run() {<font></font>
                     for (int j = 0; j < loopTimes; j++) {<font></font>
                         //syn.increaseLock();<font></font>
                         syn.increase();<font></font>}<font></font>
                 }<font></font>
             });<font></font>
             threads[i].start();<font></font>}<font></font>
         // 等待所有线程结束 <font></font>
         try {<font></font>
             for (int i = 0; i < threadNum; i++)<font></font>
                 threads[i].join();<font></font>} catch (InterruptedException e) {<font></font>
             e.printStackTrace();<font></font>}<font></font>
         System.out.println("userSyn" + "-" + syn + ":" + (System.currentTimeMillis() - l) + "ms");<font></font>
     }<font></font>
 <font></font>
     public static void useRea() {<font></font>
         // 线程数 <font></font>
         Syn syn = new Syn();<font></font>
         Thread[] threads = new Thread[threadNum];<font></font>
         // 记录运行时间 <font></font>
         long l = System.currentTimeMillis();<font></font>
         for (int i = 0; i < threadNum; i++) {<font></font>
             threads[i] = new Thread(new Runnable() {<font></font>
                 @Override<font></font>
                 public void run() {<font></font>
                     for (int j = 0; j < loopTimes; j++) {<font></font>
                         syn.increaseLock();<font></font>
                         //syn.increase();<font></font>}<font></font>
                 }<font></font>
             });<font></font>
             threads[i].start();<font></font>}<font></font>
         // 等待所有线程结束 <font></font>
         try {<font></font>
             for (int i = 0; i < threadNum; i++)<font></font>
                 threads[i].join();<font></font>} catch (InterruptedException e) {<font></font>
             e.printStackTrace();<font></font>}<font></font>
         System.out.println("userRea" + "-" + syn + ":" + (System.currentTimeMillis() - l) + "ms");<font></font>
     }<font></font>
    public static void useAto() {<font></font>
         // 线程数 <font></font>
         Thread[] threads = new Thread[threadNum];<font></font>
         // 记录运行时间 <font></font>
         long l = System.currentTimeMillis();<font></font>
         for (int i = 0; i < threadNum; i++) {<font></font>
             threads[i] = new Thread(new Runnable() {<font></font>
                 @Override<font></font>
                 public void run() {<font></font>
                     for (int j = 0; j < loopTimes; j++) {<font></font>
                         Syn.ai.incrementAndGet();<font></font>}<font></font>
                 }<font></font>
             });<font></font>
             threads[i].start();<font></font>}<font></font>
         // 等待所有线程结束 <font></font>
         try {<font></font>
             for (int i = 0; i < threadNum; i++)<font></font>
                 threads[i].join();<font></font>} catch (InterruptedException e) {<font></font>
             e.printStackTrace();<font></font>}<font></font>
         System.out.println("userAto" + "-" + Syn.ai + ":" + (System.currentTimeMillis() - l) + "ms");<font></font>
     }<font></font>
 <font></font>
     public static void main(String[] args) {<font></font>
         SynchronizedTest.userSyn();<font></font>
         SynchronizedTest.useRea();<font></font>
         SynchronizedTest.useAto();<font></font>}<font></font>
 }<font></font>
 <font></font>
 class Syn {<font></font>
     private int count = 0;<font></font>
     public final static AtomicInteger ai = new AtomicInteger(0);<font></font>
 <font></font>
     private Lock lock = new ReentrantLock();<font></font>
 <font></font>
     public synchronized void increase() {<font></font>
         count++;<font></font>
     }<font></font>
 <font></font>
     public void increaseLock() {<font></font>
         lock.lock();<font></font>
         count++;<font></font>
         lock.unlock();<font></font>}<font></font>
 <font></font>
     @Override<font></font>
     public String toString() {<font></font>
         return String.valueOf(count);<font></font>
     }<font></font>
 }

结论 ：在并发量高，循环次数多的情况，可重入锁的效率高于同步，但最终原子性能最好。

二、通信

2.1 数据库连接池的高效问题

  • 一定要在最后接近中连接
  • 一定要在最后发布中连接

2.2 OIO / NIO / AIO

OIO NIO AIO
类型 阻塞 非阻塞 非阻塞
使用难度 简单 复杂 复杂
可靠性 差 高 高
吞吐量 低 高 高

结论 ：当性能有严苛要求时，应该尽量采用 NIO 的方式进行通信。

2.3 TIME_WAIT（客户端），CLOSE_WAIT（服务器）问题

反应：经常性的请求失败

获取连接情况 netstat -n | awk’/ ^ tcp / {++ S [$ NF]} END {for（a in a）print a，S [a]}’

  • TIME_WAIT：表示主动关闭，优化系统内核参数可。
  • CLOSE_WAIT：表示被动关闭。
  • ESTABLISHED：表示正在通信

解决方案 ：二阶段完成后强制关闭

2.4 串行连接，持久连接（长连接），管道化连接

结论

管道连接的性能最优异，持久化是在串行连接的基础上减少了打开 / 关闭连接的时间。

管道化连接使用限制：

  • HTTP 客户端无法确认持久化（一般是服务器到服务器，非终端使用）;
  • 响应信息顺序必须与请求信息顺序一致;
  • 必须支持幂等操作才可以使用管道化连接。

三、数据库操作

  • 必须要有索引（特别注意按时间查询）
  • 单条操作或批量操作

注 ：很多程序员在写代码的时候随意采用了单条操作的方式，但在性能要求前提下，要求采用批量操作方式。

四、JVM

4.1 CPU 标高的一般处理步骤

  • 顶部查找出哪个进程消耗的 CPU 高
  • top -H - p 查找出哪个线程消耗的 cpu 高
  • 记录消耗 CPU 最高的几个线程
  • printf%x 进行 pid 的进制转换
  • jstack 记录进程的堆栈信息
  • 找出消耗 CPU 最高的线程信息

4.2 内存标高（OOM）一般处理步骤

  • jstat 命令查看 FGC 发生的次数和消耗的时间，次数越多，耗时越长说明存在问题;
  • 连续查看 jmap -heap 查看老生代的占用情况，变化越大说明程序存在问题;
  • 使用连续的 jmap -histo：live 命令导出文件，比对加载对象的差异，差异部分一般是发生问题的地方。

4.3 GC 引起的单核标高

  • 单个 CPU 占用率高，首先从 GC 查起。

4.4 常见 SY 标高

  • 线程上下文 e 月刊频繁
  • 线程太多
  • 锁竞争激烈

4.5 爱荷华州标高

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

4.6 抖动问题

原因 ：字节码转为机器码需要占用 CPU 时间片，大量的 CPU 在执行字节码时，导致 CPU 长期处于高位;

现象 ：“C2 CompilerThread1”守护进程，“C2 CompilerThread0”守护进程 CPU 占用率最高;

解决办法 ：保证编译线程的 CPU 占比。

作者：梁鑫

来源：宜信技术学院

正文完
jvm 并发 线程池
发表至： java
2019-05-10
 0
INTELLIJ-MAC查看类结构快捷键
关于java:网站架构变迁
关于java:程序员缺乏经验的-7-种表现
关于java:MySQL执行查询的内部原理