编写高性能的Java代码需要注意的4个问题_jvm代码注意-程序员宅基地

技术标签: Java技术  编程语言  IT行业  

一、并发

无法创建新的本机线程…

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

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

问题2:一台机器可以创建多少线程?

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

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

//线程池和非线程池的区别
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线程池中核心线程数
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(“说点什么吧…”);
}
});
}
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

结论:不要新的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的条目,就没有办法访问这些键为null的条目的值,如果当前线程再迟迟不结束的话,这些键为null的条目的值就会一直存在一条强引用链:线程参考 - >线程 - > ThreaLocalMap - >条目 - >值永远无法回收,造成内存泄漏。

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

//ThreadLocal应用实例
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的死锁问题

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

//死锁的示例
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 基于洁悠神的优化示例

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

//示例代码
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);
}
}
结论:在并发量高,循环次数多的情况,可重入锁的效率高于同步,但最终原子性能最好。

二、通信

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

一定要在最后接近中连接
一定要在最后发布中连接
2.2 OIO / NIO / AIO

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

结论:当性能有严苛要求时,应该尽量采用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 串行连接,持久连接(长连接),管道化连接

程序员笔记|编写高性能的Java代码需要注意的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占比。

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/qf2019/article/details/104232531

智能推荐

【LInux软件--星际译王安装、词库下载】_stardict 词库-程序员宅基地

文章浏览阅读4.1k次,点赞3次,收藏8次。安装sudo apt-get install stardict词库下载http://download.huzheng.org/zh_CN/下载朗道词典在下载目录。将下载好的压缩包解压并添加到stardict的文件夹里面(管理员身份运行)$ tar -vjxf stardict-langdao-ec-gb-2.4.2.tar.bz2 -C/usr/share/stardict/dic..._stardict 词库

再不用担心Sci-Hub不能用了_sci-hub怎么不能用了-程序员宅基地

文章浏览阅读2.8k次。再不用担心Sci-Hub不能用了https://www.medsci.cn/article/show_article.asp?id=826f14493163_sci-hub怎么不能用了

5G NR标准 第2章 5G标准化_itu-r m.2410-0-程序员宅基地

文章浏览阅读2.5k次。5G NR标准 第2章 5G标准化移动通信系统的研究,开发,实施和部署是由无线行业在国际协调一致的努力下完成的,通过该协议,人们共同商定了定义完整的移动通信系统的通用行业规范。 这项工作在很大程度上取决于全球和区域法规,特别是对于频谱使用而言,频谱使用是所有无线电技术的基本组成部分。 本章描述了对于定义移动通信系统至关重要的监管和标准化环境。2.1 标准化和监管概述有许多组织参与创建技术规范和标准以及移动通信领域的法规。 这些可以大致分为三类:标准化组织,监管机构以及产业论坛。标准化组织(SDO) _itu-r m.2410-0

无node环境如何在js中引入JSON、txt、md等文件_不使用node 开发md技术文档-程序员宅基地

文章浏览阅读1k次。解决的问题后端接口未实现时,直接调用JSON定义好的模拟数据信息,从而继续开发其他功能。解决方案使用ajax请求要获取的模拟数据,url是json文件的相对路径,返回值就是json文件内容。代码示例项目使用mui构建,以为为mui语法的ajax请求。// get mock datamui.get('../mock/template.json', res => { ..._不使用node 开发md技术文档

程序员之路:Linux用户登录查看_linux 查看登录-程序员宅基地

文章浏览阅读1k次。1、查看登录用户信息# w输出:USER:登录的用户名 TTY:登录终端 FROM:从哪个ip登录 LOGIN@:登录时间IDLE:用户闲置时间JCPU:指的是和该终端连接的所有进程占用的时间,这个时间里并不包括过去后台作业时间,但却包括当前正在运行的后台作业所占用的时间PCPU:指当前进程所占用的时间WHA..._linux 查看登录

哈希表及其基础(java详解)_java 哈希表篇-程序员宅基地

文章浏览阅读1.3k次,点赞30次,收藏21次。这么详细你还拿不下哈希表?我不信。_java 哈希表篇

随便推点

Android AIDL创建Service_aidl自动生成service-程序员宅基地

文章浏览阅读7.9k次。简述:1. Android开发中会用到Service这个类,Service用于实现进程间方法的调用,UI中调用音乐播放服务就用到Service,起到跨进程通信的作用2. AIDL: Android Interface Definition Language,Android内部进程通信接口的描述语言,通过他可以定义进程间通信接口,结合service在后台运作,暴露接口用来和当前程序通信_aidl自动生成service

【零基础学习】手工SQL注入——MySQL、Access、SqlServer......_356f589a7df439f6f744ff19bb8092c0-程序员宅基地

文章浏览阅读978次。原文地址:https://mozhe.cn/news/detail/324SQL注入介绍SQL注入,其实就是用户浏览器提交的变量内容,应用程序(代码可能是asp、aspx、php、jsp等)对浏览器提交过来的数据未过滤,直接去数据库查询,导致把数据库里面其他内容(如管理账户和密码)查询返回到页面上。先看个《墨者学院故事会》的一个小故事: 某个镇子里,银行保险柜做为一个公共区域帮居..._356f589a7df439f6f744ff19bb8092c0

加密算法之MD5与SAH-1_sah一1-程序员宅基地

文章浏览阅读578次。示例代码:package com.java.test;import java.security.MessageDigest;public class Demo3 { public static void main(String[] args) { Demo3 demo = new Demo3(); System.out.println(demo.digestString("_sah一1

Mysql 其中一个字段去重,显示所有信息_mysql中distinct去重的同时查询所有的字段-程序员宅基地

文章浏览阅读2.1k次。Mysql 其中一个字段去重,显示所有信息使用 DISTINCT 关键字可以去掉查询中某个字段的重复记录。(无法显示改记录的其他信息)SELECT DISTINCT(name) FROM tb_name思路先查询重复的记录,根据最新记录id获取所有信息(比较耗时)SELECT * FROM tb_name WHERE ID IN ( SELECT max(ID) FROM tb_name GROUP BY name)..._mysql中distinct去重的同时查询所有的字段

解决哈希冲突,拉链法,开地址法等_哈希冲突拉链法,链拉的很长的时候怎么办-程序员宅基地

文章浏览阅读1.1k次。本文转自https://blog.csdn.net/lyp_558/article/details/49499035哈希冲突详解我喜欢用问答的形式来学习,这样可以明确许多不明朗的问题。 什么是哈希冲突? 比如我们要去买房子,本来已经看好的房子却被商家告知那间房子已经被其他客户买走了。这就是生活中实实在在的冲突问题。同样的当数据插入到哈希表时,不同key值产生的..._哈希冲突拉链法,链拉的很长的时候怎么办

Linux 编译出错“CMake Error at lin_sys/direct/qdldl/CMakeLists.txt:2 (add_subdirectory):“_cmake error at cmakelists.txt:62 (add_subdirectory-程序员宅基地

文章浏览阅读2.8k次,点赞6次,收藏10次。问题如下:CMake Error at lin_sys/direct/qdldl/CMakeLists.txt:2 (add_subdirectory):The source directory/home/ly/osqp/lin_sys/direct/qdldl/qdldl_sourcesdoes not contain a CMakeLists.txt file.问题原因git clone的时候子存储库丢失解决方案使用以下指令克隆代码,增加–recursive参数git clone -_cmake error at cmakelists.txt:62 (add_subdirectory):