JAVA技术栈，常见生产问题汇总

IT行业中目前java技术栈仍然占据着主导的地位，在生产环境抢修中，还有一些非常常见的生产问题，依然是JVM相关的问题占比非常高，今年我们就来整理探讨一下这方面的问题

常见的JVM问题类型

在参与多年的生产抢修过程中，下面列举的故障都是十分严重的，每一个故障都会导致生产系统不可用，给企业造成不可估量的损失，常见的故障问题主要是如下几种：

OOM内存溢出
CPU资源开销非常高，超过90%
线程死锁
线程等待

CPU资源开销高问题剖析

OOM内存溢出在上篇文章中已经详细分享过，可以查看《JAVA内存溢出问题深入剖析》
CPU资源开销高问题这个问题很好理解，就是操作系统的CPU时间片资源都被java进程占用了，下面是一个代码示例，通过创建多个线程来抢占CPU时间片，来达到消耗光cpu资源的目的。（这里注意单个执行任务的线程无法做到），我们来看下相关的示例代码：


public class Highcpu {

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(() -> {
                System.out.println(Thread.currentThread().getName());
                try {
                    // Thread.sleep(30 * 60 * 1000);
                    int sum = 0;
                    while (true) {
                        // sum++;
                    }

                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
            thread.setName("thread-" + i);
            thread.start();
        }

    }
}

该代码运行后，cpu资源性能立马飙到了100%，只要线程一直运行，占用资源就一直不会被释放

现在我们来看一下，如何从运行中的线程信息中定位到问题代码

主要是如下几步：

确认是java进程占用cpu高
找到java进程下cpu占用高的线程，把十进制线程号转换成十六进制
使用jstack工具打印出java线程堆栈信息，定位问题代码

下面是实操环节

确认是java进程占用cpu高（我的环境是windows，linux系统使用的工具会有区别）

找到java进程下cpu占用高的线程，把十进制线程号转换成十六进制

这里我使用的是process explorer这个工具

这么多线程中找前两个线程进行分析，分别是20312和5900这两个线程，通过计算机转换成16进制数为：4F58和170C

使用jstack工具打印出java线程堆栈信息，定位问题代码 jstack 14432 > d:heapdump2023101601.log

找到问题代码段，搞定！

线程死锁问题剖析

线程死锁问题简单解释如下：两个线程A,B A一直持有资源1，B一直持有资源2。这时A想要再持有资源1，B想要再持有资源2，一直获取不到，导致死锁。下面我们就用程序演示还原一下这个场景


public class DeadLockDemo {

    public static void main(String[] args) {

        Resource resource1 = new Resource("资源1");
        Resource resource2 = new Resource("资源2");

        doSomething(resource1, resource2);
        doSomething(resource2, resource1);
    }

    private static void doSomething(Resource resource1, Resource resource2) {
        new Thread(() -> {
            // 获取资源1的锁
            System.out.println(Thread.currentThread().getName() + "  请求" + resource1 + "的锁");
            synchronized (resource1) {
                System.out.println(Thread.currentThread().getName() + "  获取到" + resource1 + "的锁");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 获取资源2的锁
                System.out.println(Thread.currentThread().getName() + "  请求" + resource2 + "的锁");
                synchronized (resource2) {
                    System.out.println(Thread.currentThread().getName() + "  获取到" + resource2 + "的锁");
                }
            }
        }).start();
    }
}

class Resource {

    private String name;

    public Resource(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return this.name;
    }
}

如上代码运行后，成功的实现了死锁的场景。两个线程都再等待对方资源导致无法继续执行后续任务。

首先使用jps找到对应进程pid

再使用jstack 17908，找到了两个死锁的线程，成功定位到了问题代码段

线程等待问题剖析

线程等待问题是当某一个线程一直持有锁不释放，导致其他线程无法获得该锁，一直处于等待状态。我们来看一下导致该问题的代码：

import java.util.LinkedList;
import java.util.Queue;

public class ObjectMethodTest {

    Queue<String> queue = new LinkedList<String>();

    int MAX_SIZE = 1; // 假设队列长度只有1 ， 只能存放一条数据

    public void produce() {
        synchronized (queue) {

            // 队列满则等待队列空间
            while (queue.size() == MAX_SIZE) {
                // 挂起当前线程，并释放通过同步块获取的queue上的锁，让消费者线程可以获取该锁，然后获取队列里面的元素。
                try {
                    queue.wait();
                    System.out.println("-----等待消费----");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            // 生产元素, 并通知唤醒消费者
            queue.add("hahaha");
            
        }
    }

    public void consume() {
        synchronized (queue) {

            while (queue.size() == 0) {
                // 挂起当前线程，并释放通过同步块获取的queue上的锁，让生产者线程可以获取该锁，然后获取队列里面的元素。
                try {
                    queue.wait();
                    System.out.println("-----等待生产-----");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            // 消费元素, 并通知唤醒生产者
            System.out.println("消费成功:" + queue.poll());
            queue.notifyAll();
        }
    }

    public static void main(String[] args) {

        ObjectMethodTest objectMethodTest = new ObjectMethodTest();

        // 10 个生产线程
        for (int i = 0; i < 10; i++) {
            new Thread(objectMethodTest::produce).start();
        }

        // 10 个消费线程
        for (int i = 0; i < 10; i++) {
            new Thread(objectMethodTest::consume).start();
        }
    }
}