资讯专栏INFORMATION COLUMN

上云采购季！| 2核2G4M爆款云服务器低至59元/年，更有多台、长期优惠，快来选购！

立即前往
首页/文章专栏/程序员笔记|如何编写高性能的Java代码

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

ky0ncheng / 3328人阅读

摘要：常见标高线程上下文切换频繁线程太多锁竞争激烈标高如果的占用很高，排查涉及到的程序，比如把改造成。抖动问题原因字节码转为机器码需要占用时间片，大量的在执行字节码时，导致长期处于高位现象，占用率最高解决办法保证编译线程的占比。

一、并发

Unable to create new native thread ……

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

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

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

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

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

</>复制代码 
  1. //线程池和非线程池的区别
  2. public class ThreadPool {
  3.   
  4.      public static int times = 100;//100,1000,10000
  5.   
  6.      public static ArrayBlockingQueue arrayWorkQueue = new ArrayBlockingQueue(1000);
  7.      public static ExecutorService threadPool = new ThreadPoolExecutor(5, //corePoolSize线程池中核心线程数
  8.              10,
  9.              60,
  10.              TimeUnit.SECONDS,
  11.              arrayWorkQueue,
  12.              new ThreadPoolExecutor.DiscardOldestPolicy()
  13.      );
  14.   
  15.      public static void useThreadPool() {
  16.          Long start = System.currentTimeMillis();
  17.          for (int i = 0; i < times; i++) {
  18.              threadPool.execute(new Runnable() {
  19.                  public void run() {
  20.                      System.out.println("说点什么吧...");
  21.                  }
  22.              });
  23.          }
  24.          threadPool.shutdown();
  25.          while (true) {
  26.              if (threadPool.isTerminated()) {
  27.                  Long end = System.currentTimeMillis();
  28.                  System.out.println(end - start);
  29.                  break;
  30.              }
  31.          }
  32.      }
  33.   
  34.      public static void createNewThread() {
  35.          Long start = System.currentTimeMillis();
  36.          for (int i = 0; i < times; i++) {
  37.   
  38.              new Thread() {
  39.                  public void run() {
  40.                      System.out.println("说点什么吧...");
  41.                  }
  42.              }.start();
  43.          }
  44.          Long end = System.currentTimeMillis();
  45.          System.out.println(end - start);
  46.      }
  47.   
  48.      public static void main(String args[]) {
  49.          createNewThread();
  50.          //useThreadPool();
  51.      }
  52.  }

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

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

结论：不要new Thread()，采用线程池

非线程池的缺点：

每次创建性能消耗大

无序，缺乏管理。容易无限制创建线程，引起OOM和死机

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

避免死锁，请尽量使用CAS

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

</>复制代码 
  1. public class CASLock {
  2.   
  3.      public static int money = 2000;
  4.   
  5.      public static boolean add2(int oldm, int newm) {
  6.          try {
  7.              Thread.sleep(2000);
  8.          } catch (InterruptedException e) {
  9.              e.printStackTrace();
  10.          }
  11.          if (money == oldm) {
  12.              money = money + newm;
  13.              return true;
  14.          }
  15.          return false;
  16.      }
  17.   
  18.      public synchronized static void add1(int newm) {
  19.          try {
  20.              Thread.sleep(3000);
  21.          } catch (InterruptedException e) {
  22.              e.printStackTrace();
  23.          }
  24.          money = money + newm;
  25.      }
  26.   
  27.      public static void add(int newm) {
  28.          try {
  29.              Thread.sleep(3000);
  30.          } catch (InterruptedException e) {
  31.              e.printStackTrace();
  32.          }
  33.          money = money + newm;
  34.      }
  35.   
  36.      public static void main(String args[]) {
  37.          Thread one = new Thread() {
  38.              public void run() {
  39.                  //add(5000)
  40.                  while (true) {
  41.                      if (add2(money, 5000)) {
  42.                          break;
  43.                      }
  44.                  }
  45.              }
  46.          };
  47.          Thread two = new Thread() {
  48.              public void run() {
  49.                  //add(7000)
  50.                  while (true) {
  51.                      if (add2(money, 7000)) {
  52.                          break;
  53.                      }
  54.                  }
  55.              }
  56.          };
  57.          one.start();
  58.          two.start();
  59.          try {
  60.              one.join();
  61.              two.join();
  62.          } catch (InterruptedException e) {
  63.              e.printStackTrace();
  64.          }
  65.          System.out.println(money);
  66.      }
  67.  }

使用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永远无法回收，造成内存泄漏。

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

</>复制代码 
  1. //ThreadLocal应用实例
  2. public class ThreadLocalApp {
  3.   
  4.      public static final ThreadLocal threadLocal = new ThreadLocal();
  5.   
  6.      public static void muti2() {
  7.          int i[] = (int[]) threadLocal.get();
  8.          i[1] = i[0] * 2;
  9.          threadLocal.set(i);
  10.      }
  11.   
  12.      public static void muti3() {
  13.          int i[] = (int[]) threadLocal.get();
  14.          i[2] = i[1] * 3;
  15.          threadLocal.set(i);
  16.      }
  17.   
  18.      public static void muti5() {
  19.          int i[] = (int[]) threadLocal.get();
  20.          i[3] = i[2] * 5;
  21.          threadLocal.set(i);
  22.      }
  23.   
  24.      public static void main(String args[]) {
  25.          for (int i = 0; i < 5; i++) {
  26.              new Thread() {
  27.                  public void run() {
  28.                      int start = new Random().nextInt(10);
  29.                      int end[] = {0, 0, 0, 0};
  30.                      end[0] = start;
  31.                      threadLocal.set(end);
  32.                      ThreadLocalApp.muti2();
  33.                      ThreadLocalApp.muti3();
  34.                      ThreadLocalApp.muti5();
  35.                      //int end = (int) threadLocal.get();
  36.                      System.out.println(end[0] + "  " + end[1] + "  " + end[2] + "  " + end[3]);
  37.                      threadLocal.remove();
  38.                  }
  39.              }.start();
  40.          }
  41.      }
  42.  }
1.2 线程交互—线程不安全造成的问题

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

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

</>复制代码 
  1. //HashMap死循环示例
  2. public class HashMapDeadLoop {
  3.   
  4.      private HashMap hash = new HashMap();
  5.   
  6.      public HashMapDeadLoop() {
  7.          Thread t1 = new Thread() {
  8.              public void run() {
  9.                  for (int i = 0; i < 100000; i++) {
  10.                      hash.put(new Integer(i), i);
  11.                  }
  12.                  System.out.println("t1 over");
  13.              }
  14.          };
  15.   
  16.          Thread t2 = new Thread() {
  17.              public void run() {
  18.                  for (int i = 0; i < 100000; i++) {
  19.                      hash.put(new Integer(i), i);
  20.                  }
  21.                  System.out.println("t2 over");
  22.              }
  23.          };
  24.          t1.start();
  25.          t2.start();
  26.      }
  27.   
  28.      public static void main(String[] args) {
  29.          for (int i = 0; i < 1000; i++) {
  30.              new HashMapDeadLoop();
  31.          }
  32.          System.out.println("end");
  33.      }
  34.  }
  35. https://coolshell.cn/articles/9606.html

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

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

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

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

</>复制代码 
  1. //死锁的示例
  2. public class DeadLock {
  3.      public static Integer i1 = 2000;
  4.      public static Integer i2 = 3000;
  5.          public static synchronized Integer getI2() {
  6.          try {
  7.              Thread.sleep(3000);
  8.          } catch (InterruptedException e) {
  9.              e.printStackTrace();
  10.          }
  11.          return i2;
  12.      }
  13.      public static void main(String args[]) {
  14.          Thread one = new Thread() {
  15.              public void run() {
  16.                  synchronized (i1) {
  17.                      try {
  18.                          Thread.sleep(3000);
  19.                      } catch (InterruptedException e) {
  20.                          e.printStackTrace();
  21.                      }
  22.                      synchronized (i2) {
  23.                          System.out.println(i1 + i2);
  24.                      }
  25.                  }
  26.              }
  27.          };
  28.          one.start();
  29.          Thread two = new Thread() {
  30.              public void run() {
  31.                  synchronized (i2) {
  32.                      try {
  33.                          Thread.sleep(3000);
  34.                      } catch (InterruptedException e) {
  35.                          e.printStackTrace();
  36.                      }
  37.                      synchronized (i1) {
  38.                          System.out.println(i1 + i2);
  39.                      }
  40.                  }
  41.              }
  42.          };
  43.          two.start();
  44.      }
  45.  }

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

</>复制代码 
  1. //死锁时产生堆栈
  2. "Thread-1":
  3.        at com.example.demo.DeadLock$2.run(DeadLock.java:47)
  4.        - waiting to lock  (a java.lang.Integer)
  5.        - locked  (a java.lang.Integer)
  6. "Thread-0":
  7.        at com.example.demo.DeadLock$1.run(DeadLock.java:31)
  8.        - waiting to lock  (a java.lang.Integer)
  9.        - locked  (a java.lang.Integer)
  10. Found 1 deadlock.
1.3 基于JUC的优化示例

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

</>复制代码 
  1. //示例代码
  2. public class SynchronizedTest {
  3.   
  4.      public static int threadNum = 100;
  5.      public static int loopTimes = 10000000;
  6.   
  7.      public static void userSyn() {
  8.          //线程数
  9.          Syn syn = new Syn();
  10.          Thread[] threads = new Thread[threadNum];
  11.          //记录运行时间
  12.          long l = System.currentTimeMillis();
  13.          for (int i = 0; i < threadNum; i++) {
  14.              threads[i] = new Thread(new Runnable() {
  15.                  @Override
  16.                  public void run() {
  17.                      for (int j = 0; j < loopTimes; j++) {
  18.                          //syn.increaseLock();
  19.                          syn.increase();
  20.                      }
  21.                  }
  22.              });
  23.              threads[i].start();
  24.          }
  25.          //等待所有线程结束
  26.          try {
  27.              for (int i = 0; i < threadNum; i++)
  28.                  threads[i].join();
  29.          } catch (InterruptedException e) {
  30.              e.printStackTrace();
  31.          }
  32.          System.out.println("userSyn" + "-" + syn + " : " + (System.currentTimeMillis() - l) + "ms");
  33.      }
  34.   
  35.      public static void useRea() {
  36.          //线程数
  37.          Syn syn = new Syn();
  38.          Thread[] threads = new Thread[threadNum];
  39.          //记录运行时间
  40.          long l = System.currentTimeMillis();
  41.          for (int i = 0; i < threadNum; i++) {
  42.              threads[i] = new Thread(new Runnable() {
  43.                  @Override
  44.                  public void run() {
  45.                      for (int j = 0; j < loopTimes; j++) {
  46.                          syn.increaseLock();
  47.                          //syn.increase();
  48.                      }
  49.                  }
  50.              });
  51.              threads[i].start();
  52.          }
  53.          //等待所有线程结束
  54.          try {
  55.              for (int i = 0; i < threadNum; i++)
  56.                  threads[i].join();
  57.          } catch (InterruptedException e) {
  58.              e.printStackTrace();
  59.          }
  60.          System.out.println("userRea" + "-" + syn + " : " + (System.currentTimeMillis() - l) + "ms");
  61.      }
  62.     public static void useAto() {
  63.          //线程数
  64.          Thread[] threads = new Thread[threadNum];
  65.          //记录运行时间
  66.          long l = System.currentTimeMillis();
  67.          for (int i = 0; i < threadNum; i++) {
  68.              threads[i] = new Thread(new Runnable() {
  69.                  @Override
  70.                  public void run() {
  71.                      for (int j = 0; j < loopTimes; j++) {
  72.                          Syn.ai.incrementAndGet();
  73.                      }
  74.                  }
  75.              });
  76.              threads[i].start();
  77.          }
  78.          //等待所有线程结束
  79.          try {
  80.              for (int i = 0; i < threadNum; i++)
  81.                  threads[i].join();
  82.          } catch (InterruptedException e) {
  83.              e.printStackTrace();
  84.          }
  85.          System.out.println("userAto" + "-" + Syn.ai + " : " + (System.currentTimeMillis() - l) + "ms");
  86.      }
  87.   
  88.      public static void main(String[] args) {
  89.          SynchronizedTest.userSyn();
  90.          SynchronizedTest.useRea();
  91.          SynchronizedTest.useAto();
  92.      }
  93.  }
  94.   
  95.  class Syn {
  96.      private int count = 0;
  97.      public final static AtomicInteger ai = new AtomicInteger(0);
  98.   
  99.      private Lock lock = new ReentrantLock();
  100.   
  101.      public synchronized void increase() {
  102.          count++;
  103.      }
  104.   
  105.      public void increaseLock() {
  106.          lock.lock();
  107.          count++;
  108.          lock.unlock();
  109.      }
  110.   
  111.      @Override
  112.      public String toString() {
  113.          return String.valueOf(count);
  114.      }
  115.  }

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

二、通信 2.1 数据库连接池的高效问题

一定要在finally中close连接

一定要在finally中release连接

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

结论：我性能有严苛要求下，尽量应该采用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 串行连接，持久连接（长连接），管道化连接

结论：

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

管道化连接使用限制：

1、HTTP客户端无法确认持久化（一般是服务器到服务器，非终端使用）；

2、响应信息顺序必须与请求信息顺序一致；

3、必须支持幂等操作才可以使用管道化连接.

三、数据库操作

必须要有索引（特别注意按时间查询）

单条操作or批量操作

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

四、JVM 4.1 CPU标高的一般处理步骤

top查找出哪个进程消耗的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标高

线程上下文切换频繁

线程太多

锁竞争激烈

4.5 Iowait标高

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

4.6 抖动问题

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

现象：“C2 CompilerThread1” daemon，“C2 CompilerThread0” daemon CPU占用率最高；

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

作者：梁鑫

来源：宜信技术学院

云服务器 GPU云服务器 如何编写高性能的javascript java的编写程序 怎么编写程序代码 如何编写网站代码

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/74508.html

相关文章

  • 《深入理解java虚拟机》学习笔记系列——java内存区域划分

    摘要：运行时数据区域的学习，是学习以及机制的基础，也是深入理解对象创建及运行过程的前提。了解内存区域划分，是学习概念的前提。 Java 运行时数据区域的学习，是学习 jvm 以及 GC 机制的基础，也是深入理解 java 对象创建及运行过程的前提。废话不多说，直接进入正题： 一张图总结 showImg(https://segmentfault.com/img/bVOMAn?w=685&h=5...

    史占广 评论0 收藏0

  • Java基础-模块系统笔记（1）

    摘要：模块系统的前身是项目。最初，该项目仅仅是为设计实现一个模块系统。随着项目的不断深入，平台对标准模块系统的呼求也日益增长，批准该项目升级为平台的一部分，也能服务于和平台的需求。自定义的配置，仅包含一组指定的模块及其所需的模块。 我的博客 转载请注明原创出处。 序 从Java 9开始，在Java的世界里多了一个叫模块（JSR376）的特性。模块系统的前身是Jigsaw项目。最初，该项目仅...

    learning 评论0 收藏0

  • 「Java 8 函数式编程」读书笔记——数据并行化

    摘要：限制编写并行流，存在一些与非并行流不一样的约定。底层框架并行流在底层沿用的框架，递归式的分解问题，然后每段并行执行，最终由合并结果，返回最后的值。 本书第六章的读书笔记，也是我这个系列的最后一篇读书笔记。后面7、8、9章分别讲的测试、调试与重构、设计和架构的原则以及使用Lambda表达式编写并发程序，因为笔记不好整理，就不写了，感兴趣的同学自己买书来看吧。 并行化流操作 关于并行与并发...

    leone 评论0 收藏0

  • Python

    摘要：最近看前端都展开了几场而我大知乎最热语言还没有相关。有关书籍的介绍，大部分截取自是官方介绍。但从开始，标准库为我们提供了模块，它提供了和两个类，实现了对和的进一步抽象，对编写线程池进程池提供了直接的支持。 《流畅的python》阅读笔记 《流畅的python》是一本适合python进阶的书, 里面介绍的基本都是高级的python用法. 对于初学python的人来说, 基础大概也就够用了...

    dailybird 评论0 收藏0

  • 基本方法笔记 - 收藏集 - 掘金

    摘要：探讨判断横竖屏的最佳实现前端掘金在移动端，判断横竖屏的场景并不少见，比如根据横竖屏以不同的样式来适配，抑或是提醒用户切换为竖屏以保持良好的用户体验。 探讨判断横竖屏的最佳实现 - 前端 - 掘金在移动端，判断横竖屏的场景并不少见，比如根据横竖屏以不同的样式来适配，抑或是提醒用户切换为竖屏以保持良好的用户体验。 判断横竖屏的实现方法多种多样，本文就此来探讨下目前有哪些实现方法以及其中的优...

    maochunguang 评论0 收藏0

发表评论

登陆后可评论

0条评论

ky0ncheng

男|高级讲师
我要私信

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<