一、并发

Unable to create new native thread ……

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

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

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

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

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

//线程池和非线程池的区别
public class ThreadPool { public static int times = ;//100,1000,10000 public static ArrayBlockingQueue arrayWorkQueue = new ArrayBlockingQueue();
public static ExecutorService threadPool = new ThreadPoolExecutor(, //corePoolSize线程池中核心线程数
,
,
TimeUnit.SECONDS,
arrayWorkQueue,
new ThreadPoolExecutor.DiscardOldestPolicy()
); public static void useThreadPool() {
Long start = System.currentTimeMillis();
for (int i = ; 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 = ; 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毫秒 28ms
10000次 1329ms 164ms

结论:不要new Thread(),采用线程池

非线程池的缺点:

  • 每次创建性能消耗大

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

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

避免死锁,请尽量使用CAS

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

public class CASLock {

     public static int money = ;

     public static boolean add2(int oldm, int newm) {
try {
Thread.sleep();
} 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();
} catch (InterruptedException e) {
e.printStackTrace();
}
money = money + newm;
} public static void add(int newm) {
try {
Thread.sleep();
} 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, )) {
break;
}
}
}
};
Thread two = new Thread() {
public void run() {
//add(7000)
while (true) {
if (add2(money, )) {
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永远无法回收,造成内存泄漏。

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

//ThreadLocal应用实例
public class ThreadLocalApp { public static final ThreadLocal threadLocal = new ThreadLocal(); public static void muti2() {
int i[] = (int[]) threadLocal.get();
i[] = i[] * ;
threadLocal.set(i);
} public static void muti3() {
int i[] = (int[]) threadLocal.get();
i[] = i[] * ;
threadLocal.set(i);
} public static void muti5() {
int i[] = (int[]) threadLocal.get();
i[] = i[] * ;
threadLocal.set(i);
} public static void main(String args[]) {
for (int i = ; i < ; i++) {
new Thread() {
public void run() {
int start = new Random().nextInt();
int end[] = {, , , };
end[] = start;
threadLocal.set(end);
ThreadLocalApp.muti2();
ThreadLocalApp.muti3();
ThreadLocalApp.muti5();
//int end = (int) threadLocal.get();
System.out.println(end[] + " " + end[] + " " + end[] + " " + end[]);
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 = ; i < ; i++) {
hash.put(new Integer(i), i);
}
System.out.println("t1 over");
}
}; Thread t2 = new Thread() {
public void run() {
for (int i = ; i < ; 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 = ; i < ; i++) {
new HashMapDeadLoop();
}
System.out.println("end");
}
}
https://coolshell.cn/articles/9606.html

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

/HashMap死循环产生的线程栈
Thread-" #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:)
at java.util.HashMap.resize(HashMap.java:)
at java.util.HashMap.putVal(HashMap.java:)
at java.util.HashMap.put(HashMap.java:)
at com.example.demo.HashMapDeadLoop$.run(HashMapDeadLoop.java:)

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

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

//死锁的示例
public class DeadLock {
public static Integer i1 = ;
public static Integer i2 = ;
public static synchronized Integer getI2() {
try {
Thread.sleep();
} 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();
} 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();
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (i1) {
System.out.println(i1 + i2);
}
}
}
};
two.start();
}
}

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

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

1.3 基于JUC的优化示例

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

//示例代码
public class SynchronizedTest { public static int threadNum = ;
public static int loopTimes = ; public static void userSyn() {
//线程数
Syn syn = new Syn();
Thread[] threads = new Thread[threadNum];
//记录运行时间
long l = System.currentTimeMillis();
for (int i = ; i < threadNum; i++) {
threads[i] = new Thread(new Runnable() {
@Override
public void run() {
for (int j = ; j < loopTimes; j++) {
//syn.increaseLock();
syn.increase();
}
}
});
threads[i].start();
}
//等待所有线程结束
try {
for (int i = ; 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 = ; i < threadNum; i++) {
threads[i] = new Thread(new Runnable() {
@Override
public void run() {
for (int j = ; j < loopTimes; j++) {
syn.increaseLock();
//syn.increase();
}
}
});
threads[i].start();
}
//等待所有线程结束
try {
for (int i = ; 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 = ; i < threadNum; i++) {
threads[i] = new Thread(new Runnable() {
@Override
public void run() {
for (int j = ; j < loopTimes; j++) {
Syn.ai.incrementAndGet();
}
}
});
threads[i].start();
}
//等待所有线程结束
try {
for (int i = ; 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 = ;
public final static AtomicInteger ai = new AtomicInteger(); 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

  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占比。

作者:梁鑫

来源:宜信技术学院

程序员笔记|如何编写高性能的Java代码的更多相关文章

  1. JAVA程序员必看的15本书-JAVA自学书籍推荐

    作为Java程序员来说,最痛苦的事情莫过于可以选择的范围太广,可以读的书太多,往往容易无所适从.我想就我自己读过的技术书籍中挑选出来一些,按照学习的先后顺序,推荐给大家,特别是那些想不断提高自己技术水 ...

  2. 每个Java程序员需要了解的8个Java开发工具

    每个Java程序员需要了解的8个Java开发工具 Java是计算机应用程序编程语言,被广泛用于创建Web应用.服务器处理.用户端的API开发乃至数据库等多个领域.下面列出了8个有助于你开发Java应用 ...

  3. Java程序员最常用的8个Java日志框架

    转自:http://www.codeceo.com/article/8-java-log-framework.html 作为一名Java程序员,我们开发了很多Java应用程序,包括桌面应用.WEB应用 ...

  4. 【原文】前端程序员必须知道的高性能Javascript知识

    原文:前端程序员必须知道的高性能Javascript知识 想必大家都知道,JavaScrip是全栈开发语言,浏览器,手机,服务器端都可以看到JS的身影. 本文会分享一些高效的JavaScript的最佳 ...

  5. 转:Java程序员最常用的8个Java日志框架

    作为一名Java程序员,我们开发了很多Java应用程序,包括桌面应用.WEB应用以及移动应用.然而日志系统是一个成熟Java应用所必不可少的,在开发和调试阶段,日志可以帮助我们更好更快地定位bug:在 ...

  6. 学Java的前景与就业,资深程序员教你怎么开始学Java!

    IT行业一直是就业的热门岗位,程序员这个职业稳定性和收入比都有着不错的前景,那么学Java的前景和就业是什么样的呢?随着入行Java的准程序员越来越多,各种学习Java的流派也层出不穷!其实在编程的世 ...

  7. <2014 05 09> 程序员:从C++转到Java需注意的地方

    最近想玩玩Android的APP开发,从C++角度来学习Java.Java可以说是一个优化精简版的C++,去除了底层C的很多特性.找了这篇文章. --------------------------- ...

  8. Java基础学习总结(40)——Java程序员最常用的8个Java日志框架

    作为一名Java程序员,我们开发了很多Java应用程序,包括桌面应用.WEB应用以及移动应用.然而日志系统是一个成熟Java应用所必不可少的,在开发和调试阶段,日志可以帮助我们更好更快地定位bug:在 ...

  9. [转]编写高性能的Lua代码

    昨天晚上闲来无事,看室友在电脑上挂机玩游戏,用的一个辅助脚本,以为是lua写的脚本在跑,实际调查发现是按键精灵的脚本. 于是在网上找相关Lua开发游戏脚本的案例,看到一个人的博客,内容很不错,学到了很 ...

随机推荐

  1. Knockout v3.4.0 中文版教程-9-计算监控-API参考

    5.参考 下面的内容描述了如何构建和使用计算监控. 1. 构建一个计算监控 可以用如下的形式构建一个计算监控: ko.computed( evaluator [, targetObject, opti ...

  2. kali-xfce的简单配置

    1.更新 设置kali的更新源 在终端中打开sources.list root@kali:~# vim /etc/apt/sources.list 删除里面的注释,清空. 然后输入下面的更新源地址: ...

  3. NYOJ 1023 还是回文

    还是回文 时间限制:2000 ms  |  内存限制:65535 KB 难度:3   描述 判断回文串很简单,把字符串变成回文串也不难.现在我们增加点难度,给出一串字符(全部是小写字母),添加或删除一 ...

  4. shell-001

    for: shell_test #!/bin/bash var= var=$var+ echo $var mkdir only_a_joke shell_joke #!/bin/bash ./shel ...

  5. xtrabackup实现全量备份和增量备份

    mysql增量和完全备份innobackupex2.1.9版本1 yum安装: 官网地址:https://www.percona.com/doc/percona-xtrabackup/LATEST/i ...

  6. Ubuntu 终端命令整理

    一.文件目录类 1.建立目录:mkdir 目录名 2.删除空目录:rmdir 目录名 3.无条件删除子目录: rm -rf 目录名 4.改变当前目录:cd 目录名 (进入用户home目录:cd ~:进 ...

  7. HDU 1423 Greatest Common Increasing Subsequence ——动态规划

    好久以前的坑了. 最长公共上升子序列. 没什么好说的,自己太菜了 #include <map> #include <cmath> #include <queue> ...

  8. msp430入门学习42

    msp430的其他十 msp430入门学习

  9. Linux下学习王爽老师的汇编语言

    坐起来非常容易,找到这条路确实非常曲折,为了后来的同志们不再纠结,特记录如下: 这几天看汇编语言时,很多人都推荐王爽老师的<汇编语言>,老师的书的确写的很好,但是讲的是ms的汇编,但是总不 ...

  10. 【笔记】Linux内核中的循环缓冲区

    1. 有关ring buffer的理解 1)  ring buffer位首尾相接的buffer,即类似生活中的圆形跑道: 2)  空闲空间+数据空间=ring buffer大小 3)  ring bu ...