Java服务因CPU亲和性设置错误导致性能不稳定的底层排查技巧 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

好的，让我们开始吧。

Java服务CPU亲和性设置错误导致的性能不稳定问题排查技巧

大家好，今天我们来探讨一个比较隐蔽但又可能严重影响Java服务性能的问题：CPU亲和性设置错误。CPU亲和性，简单来说，就是将一个进程或线程绑定到一个或多个特定的CPU核心上运行。配置得当，可以提升性能；配置不当，反而会适得其反，导致性能不稳定甚至下降。

一、什么是CPU亲和性？

CPU亲和性是一种调度策略，允许我们将进程或线程限制在特定的CPU核心上执行。其目的是减少CPU核心之间的上下文切换，提高缓存命中率，从而提升性能。

上下文切换： 当一个CPU核心从执行一个线程切换到执行另一个线程时，需要保存当前线程的状态，并加载下一个线程的状态。这个过程被称为上下文切换，会消耗CPU资源。
缓存命中率： CPU有高速缓存（Cache），用于存储最近访问的数据。如果一个线程总是在同一个CPU核心上运行，那么它可以更好地利用该核心的缓存，提高缓存命中率，减少从主内存读取数据的次数，从而提升性能。

二、为什么要设置CPU亲和性？

在某些特定的场景下，设置CPU亲和性可以带来性能提升：

NUMA架构优化： NUMA（Non-Uniform Memory Access）架构下，不同的CPU核心访问本地内存的速度比访问其他核心的内存更快。将线程绑定到靠近其访问数据的内存的CPU核心上，可以降低延迟。
减少上下文切换： 对于CPU密集型的任务，将其绑定到特定的CPU核心上，可以减少与其他线程的上下文切换，提高效率。
避免CPU争用： 将不同的任务分配到不同的CPU核心上，可以避免它们争用同一个CPU核心的资源。

三、 CPU亲和性设置错误可能导致的问题

虽然CPU亲和性在某些情况下可以提高性能，但设置不当反而可能导致问题：

资源利用不均： 如果将所有线程都绑定到少数几个CPU核心上，会导致这些核心过载，而其他核心空闲，造成资源浪费。
线程饥饿： 如果将某些线程绑定到繁忙的CPU核心上，可能会导致它们长时间无法获得执行机会，出现线程饥饿。
性能下降： 错误的亲和性设置可能会导致线程频繁地在不同的CPU核心之间迁移，增加上下文切换的开销，反而降低性能。

四、如何检查Java服务的CPU亲和性设置？

在Linux系统中，可以使用taskset命令来设置和查询进程的CPU亲和性。

查看进程的PID：

使用jps或ps -ef | grep java命令找到Java进程的PID。
查看进程的CPU亲和性：

使用taskset -p <PID>命令查看进程的CPU亲和性。例如：
```
taskset -p 12345
pid 12345's current affinity mask: 3
```
这里的affinity mask: 3表示该进程可以运行在CPU 0和CPU 1上（3的二进制表示是11）。
查看线程的CPU亲和性：

Java线程默认继承进程的CPU亲和性。要查看单个线程的CPU亲和性，需要先获取线程的 native ID (NID)。可以通过以下方法获取：
- 使用jstack命令： jstack <PID>可以dump出Java进程的所有线程栈信息，其中会包含线程的NID（native ID）。NID通常以十六进制显示。
```
"MyThread" #123 prio=5 os_prio=0 tid=0x00007f2a80c00000 nid=0x4a3d runnable [0x00007f2a7fc10000]
   java.lang.Thread.State: RUNNABLE
```
  在这个例子中，nid=0x4a3d，需要将其转换为十进制才能用于taskset命令。 (0x4a3d = 19005)
- 转换为十进制： 可以使用 printf "%dn" 0x4a3d 将十六进制的NID转换为十进制。
- 使用taskset命令查看线程的CPU亲和性:
```
taskset -cp <NID>
pid 19005's current affinity list: 0,1
```
  这里的affinity list: 0,1表示该线程可以运行在CPU 0和CPU 1上。

五、如何在Java代码中设置CPU亲和性？

Java本身并没有直接设置CPU亲和性的API。我们需要借助JNI（Java Native Interface）来调用操作系统提供的API。

编写C/C++代码：

编写一个C/C++函数，使用操作系统提供的API来设置线程的CPU亲和性。下面是一个Linux下的例子：

#include <pthread.h>
#include <sched.h>
#include <iostream>
#include <unistd.h> // for syscall

// 定义一个函数，用于设置线程的CPU亲和性
int set_thread_affinity(pthread_t thread, int cpu_id) {
    cpu_set_t cpuset;
    CPU_ZERO(&cpuset);
    CPU_SET(cpu_id, &cpuset);

    int result = pthread_setaffinity_np(thread, sizeof(cpu_set_t), &cpuset);
    if (result != 0) {
        std::cerr << "Error setting thread affinity: " << result << std::endl;
        return -1;
    }
    return 0;
}

//为了获取tid
pid_t gettid() {
    return syscall(SYS_gettid);
}

// 使用示例，可以编译成动态链接库
extern "C" {
    JNIEXPORT jint JNICALL Java_com_example_Affinity_setAffinity(JNIEnv *env, jclass clazz, jint cpuId) {
        pthread_t current_thread = pthread_self();
        return set_thread_affinity(current_thread, cpuId);
    }

    JNIEXPORT jint JNICALL Java_com_example_Affinity_getTid(JNIEnv *env, jclass clazz) {
        return gettid();
    }
}

编译C/C++代码：

将C/C++代码编译成动态链接库（.so文件）。
```
g++ -shared -fPIC affinity.cpp -o libaffinity.so
```

编写Java代码：

编写Java代码，加载动态链接库，并调用C/C++函数来设置CPU亲和性。

package com.example;

public class Affinity {
    static {
        System.loadLibrary("affinity"); // 加载动态链接库
    }

    // 声明native方法，对应C++中的函数
    public static native int setAffinity(int cpuId);
    public static native int getTid();

    public static void main(String[] args) throws InterruptedException {
        // 设置当前线程运行在CPU 0上
        int result = Affinity.setAffinity(0);
        if (result == 0) {
            System.out.println("Successfully set affinity to CPU 0");
        } else {
            System.err.println("Failed to set affinity.");
        }

        System.out.println("Thread ID (TID): " + Affinity.getTid());

        // 模拟一些工作
        Thread.sleep(5000);
        System.out.println("Finished.");
    }
}

运行Java代码：

运行Java代码，确保动态链接库的路径正确。需要确保 libaffinity.so 在java.library.path中。可以通过 -Djava.library.path=/path/to/your/library 来指定。
```
java -Djava.library.path=. com.example.Affinity
```

六、如何排查CPU亲和性导致的性能问题？

监控CPU使用率：

使用top、htop或vmstat等工具监控各个CPU核心的使用率。如果发现某些核心长期处于高负载状态，而其他核心空闲，则可能存在CPU亲和性设置不合理的问题。
监控线程状态：

使用jstack命令dump线程栈信息，分析线程的状态。如果发现大量线程处于BLOCKED或WAITING状态，并且这些线程都绑定到同一个CPU核心上，则可能存在线程饥饿的问题。
性能测试：

通过性能测试工具（如JMeter、LoadRunner）模拟不同的负载，观察系统的响应时间、吞吐量等指标。如果发现性能不稳定，或者随着负载增加性能下降明显，则可能存在CPU亲和性设置不当的问题. 可以尝试不同的亲和性配置，观察性能变化。
GC分析： CPU亲和性设置不当可能会加剧GC压力。观察GC日志，分析GC频率和耗时，判断是否与CPU亲和性有关。尤其是Full GC，可能会导致服务长时间停顿。

七、最佳实践

默认情况下，不要手动设置CPU亲和性。 让操作系统自动调度线程，通常可以获得较好的性能。
只有在特定场景下，并且经过充分的测试和验证，才考虑设置CPU亲和性。
根据应用的特点和硬件配置，选择合适的CPU亲和性策略。 例如，对于CPU密集型的任务，可以将其绑定到特定的CPU核心上；对于I/O密集型的任务，可以避免绑定到繁忙的CPU核心上。
监控CPU使用率和线程状态，及时发现和解决CPU亲和性导致的问题。
使用专业的性能分析工具，例如 perf, 火焰图等，更深入的了解系统瓶颈

八、常见问题及解决方案

问题	可能原因	解决方案
CPU使用率不均衡，某些核心过载，其他核心空闲	CPU亲和性设置不合理，将大量线程绑定到少数几个CPU核心上	重新评估CPU亲和性策略，尝试将线程分散到更多的CPU核心上，或者取消CPU亲和性设置，让操作系统自动调度线程。
线程饥饿，某些线程长时间无法获得执行机会	将某些线程绑定到繁忙的CPU核心上，导致它们无法与其他线程竞争CPU资源	重新评估CPU亲和性策略，避免将线程绑定到繁忙的CPU核心上，或者调整线程的优先级。
性能不稳定，随着负载增加性能下降明显	错误的CPU亲和性设置导致线程频繁地在不同的CPU核心之间迁移，增加上下文切换的开销	重新评估CPU亲和性策略，尝试将线程绑定到更少的CPU核心上，或者取消CPU亲和性设置，让操作系统自动调度线程，减少上下文切换。

九、一个更复杂的NUMA 架构下的亲和性配置例子

假设我们有一个NUMA架构的服务器，有两个NUMA节点，每个节点有16个核心。我们希望将一个Java服务部署到这个服务器上，并且希望充分利用NUMA架构的优势。

分析：
- 需要确定Java服务中的哪些线程对延迟敏感。
- 需要确定这些线程访问的数据主要位于哪个NUMA节点的内存中。
配置策略：
- 将对延迟敏感的线程绑定到靠近其访问数据的内存的NUMA节点的CPU核心上。
- 将其他线程分散到不同的CPU核心上，避免资源争用。

示例代码：

package com.example;

public class NUMAAffinity {
    static {
        System.loadLibrary("affinity"); // 加载动态链接库
    }

    // 声明native方法，对应C++中的函数
    public static native int setAffinity(int cpuId);
    public static native int getTid();

    public static void main(String[] args) throws InterruptedException {
        // 假设我们有两个NUMA节点，每个节点有16个核心
        // 将前8个线程绑定到NUMA节点0的CPU核心上
        for (int i = 0; i < 8; i++) {
            final int cpuId = i;
            new Thread(() -> {
                int result = NUMAAffinity.setAffinity(cpuId);
                if (result == 0) {
                    System.out.println("Thread " + Thread.currentThread().getName() + " successfully set affinity to CPU " + cpuId);
                } else {
                    System.err.println("Failed to set affinity for Thread " + Thread.currentThread().getName());
                }
                System.out.println("Thread ID (TID): " + NUMAAffinity.getTid());

                // 模拟一些工作
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread " + Thread.currentThread().getName() + " finished.");
            }).start();
        }

        // 将后8个线程绑定到NUMA节点1的CPU核心上
        for (int i = 8; i < 16; i++) {
            final int cpuId = i;
            new Thread(() -> {
                int result = NUMAAffinity.setAffinity(cpuId);
                if (result == 0) {
                    System.out.println("Thread " + Thread.currentThread().getName() + " successfully set affinity to CPU " + cpuId);
                } else {
                    System.err.println("Failed to set affinity for Thread " + Thread.currentThread().getName());
                }
               System.out.println("Thread ID (TID): " + NUMAAffinity.getTid());

                // 模拟一些工作
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread " + Thread.currentThread().getName() + " finished.");
            }).start();
        }

        Thread.sleep(10000); // 等待所有线程完成
        System.out.println("All threads finished.");
    }
}

在这个例子中，我们假设服务器有两个NUMA节点，每个节点有16个核心。我们将前8个线程绑定到NUMA节点0的CPU核心上，将后8个线程绑定到NUMA节点1的CPU核心上。需要根据实际情况调整CPU核心的分配。

十、总结: 谨慎配置，持续监控，灵活调整

CPU亲和性是一个强大的工具，但使用不当可能会导致性能问题。请务必谨慎配置，持续监控，并根据实际情况灵活调整。务必进行充分的测试和验证，确保CPU亲和性设置能够真正提升性能。记住，默认情况下，让操作系统自动调度线程通常是最好的选择。

Java服务CPU亲和性设置错误导致的性能不稳定问题排查技巧

发表回复 取消回复

发表回复取消回复