MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Java并发编程中的调试与测试技巧

2021-10-011.2k 阅读

Java并发编程中的调试技巧

在Java并发编程中，调试是一项极具挑战性但又至关重要的任务。由于多线程程序的不确定性和复杂性，传统的调试方法往往难以应对。下面将介绍一些针对Java并发编程的有效调试技巧。

1. 使用System.out.println

虽然这是一种较为原始的方法，但在某些简单场景下非常有效。通过在关键代码位置添加System.out.println语句，可以输出线程的状态、变量值等信息，辅助理解程序执行流程。例如：

public class SimpleThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread " + getName() + " is starting.");
        for (int i = 0; i < 5; i++) {
            System.out.println("Thread " + getName() + " is running, i = " + i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("Thread " + getName() + " is ending.");
    }
}

public class Main {
    public static void main(String[] args) {
        SimpleThread thread1 = new SimpleThread();
        SimpleThread thread2 = new SimpleThread();
        thread1.start();
        thread2.start();
    }
}

上述代码中，在SimpleThread的run方法中添加了System.out.println语句，输出线程启动、运行和结束的信息。通过观察控制台输出，可以了解线程的执行顺序和大致的执行情况。然而，这种方法在复杂多线程场景下会产生大量输出信息，导致信息杂乱，难以分析。

2. 使用日志框架

相比System.out.println，日志框架如log4j、SLF4J等提供了更强大和灵活的日志记录功能。以SLF4J结合Logback为例，首先在pom.xml中添加依赖：

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.32</version>
</dependency>
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.6</version>
</dependency>

然后在代码中使用：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class LoggingThread extends Thread {
    private static final Logger logger = LoggerFactory.getLogger(LoggingThread.class);

    @Override
    public void run() {
        logger.info("Thread {} is starting.", getName());
        for (int i = 0; i < 5; i++) {
            logger.debug("Thread {} is running, i = {}", getName(), i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                logger.error("Thread {} was interrupted.", getName(), e);
            }
        }
        logger.info("Thread {} is ending.", getName());
    }
}

public class MainWithLogging {
    public static void main(String[] args) {
        LoggingThread thread1 = new LoggingThread();
        LoggingThread thread2 = new LoggingThread();
        thread1.start();
        thread2.start();
    }
}

通过配置logback.xml，可以灵活控制日志输出级别、格式和目标（如文件、控制台等）。例如：

<configuration>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>

    <root level="debug">
        <appender-ref ref="STDOUT" />
    </root>
</configuration>

日志框架的优势在于可以根据不同的场景和需求灵活调整日志记录，不会像System.out.println那样在生产环境中留下大量不必要的输出。

3. 断点调试

在集成开发环境（IDE）如Eclipse、IntelliJ IDEA中，可以使用断点调试功能。在多线程程序中设置断点时，需要注意以下几点：

  • 线程特定断点：某些IDE允许设置针对特定线程的断点。例如在IntelliJ IDEA中，可以在断点的属性中选择“Thread”选项，指定断点只在特定线程触发。这样可以避免在多个线程同时运行时，断点频繁触发导致调试混乱。

  • 条件断点：设置条件断点可以让断点只在满足特定条件时触发。例如，在多线程共享变量的场景下，可以设置断点在变量达到某个特定值时触发。假设存在一个多线程操作共享计数器的场景：

public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

public class CounterThread extends Thread {
    private Counter counter;

    public CounterThread(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            counter.increment();
        }
    }
}

public class MainWithBreakpoint {
    public static void main(String[] args) {
        Counter counter = new Counter();
        CounterThread[] threads = new CounterThread[10];
        for (int i = 0; i < 10; i++) {
            threads[i] = new CounterThread(counter);
            threads[i].start();
        }
        for (int i = 0; i < 10; i++) {
            try {
                threads[i].join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("Final count: " + counter.getCount());
    }
}

在Counter类的increment方法中，可以设置条件断点，当count达到5000时触发（假设10个线程每个线程执行1000次increment操作，预期总计数为10000，5000是中间状态）。这样可以在关键状态下暂停程序，检查线程状态、变量值等，排查潜在的并发问题。

4. 使用Thread.dumpStack()

Thread.dumpStack()方法可以打印当前线程的堆栈跟踪信息，这对于快速定位线程执行位置非常有帮助。例如，在一个复杂的多线程程序中，某个线程出现异常但难以确定具体位置时，可以在适当位置添加Thread.dumpStack()：

public class StackDumpThread extends Thread {
    @Override
    public void run() {
        try {
            // 一些复杂的业务逻辑
            for (int i = 0; i < 5; i++) {
                if (i == 3) {
                    Thread.dumpStack();
                }
                Thread.sleep(100);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class MainWithStackDump {
    public static void main(String[] args) {
        StackDumpThread thread = new StackDumpThread();
        thread.start();
    }
}

当i等于3时，调用Thread.dumpStack()，控制台会输出当前线程的堆栈信息，包括方法调用层级，帮助开发人员确定线程执行到的具体位置。

5. 使用jstack工具

jstack是JDK自带的用于生成Java虚拟机当前时刻的线程快照的工具。线程快照是当前Java虚拟机内每一条线程正在执行的方法堆栈的集合。在调试多线程程序时，通过jstack生成的线程快照可以分析线程的状态（如运行、阻塞、等待等），找出死锁等问题。

假设我们有一个可能产生死锁的程序：

public class DeadlockExample {
    private static final Object lock1 = new Object();
    private static final Object lock2 = new Object();

    public static class Thread1 extends Thread {
        @Override
        public void run() {
            synchronized (lock1) {
                System.out.println("Thread1 acquired lock1");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock2) {
                    System.out.println("Thread1 acquired lock2");
                }
            }
        }
    }

    public static class Thread2 extends Thread {
        @Override
        public void run() {
            synchronized (lock2) {
                System.out.println("Thread2 acquired lock2");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock1) {
                    System.out.println("Thread2 acquired lock1");
                }
            }
        }
    }

    public static void main(String[] args) {
        Thread1 thread1 = new Thread1();
        Thread2 thread2 = new Thread2();
        thread1.start();
        thread2.start();
    }
}

运行该程序后，可以通过以下步骤使用jstack工具：

  1. 首先使用jps命令获取Java进程ID：
jps

假设输出结果中包含DeadlockExample对应的进程ID为12345。

  1. 然后使用jstack命令生成线程快照：
jstack 12345 > deadlock.txt

生成的deadlock.txt文件中会包含详细的线程堆栈信息，通过分析可以发现死锁的迹象。在文件中会有类似如下的信息：

Found one Java-level deadlock:
=============================
"Thread2":
  waiting to lock monitor 0x000000076b0c2898 (object 0x00000007d5b295d8, a java.lang.Object),
  which is held by "Thread1"
"Thread1":
  waiting to lock monitor 0x000000076b0c2b38 (object 0x00000007d5b295e8, a java.lang.Object),
  which is held by "Thread2"

Java stack information for the threads listed above:
===================================================
"Thread2":
        at DeadlockExample$Thread2.run(DeadlockExample.java:25)
        - waiting to lock <0x00000007d5b295d8> (a java.lang.Object)
        - locked <0x00000007d5b295e8> (a java.lang.Object)
        at java.lang.Thread.run(Thread.java:748)
"Thread1":
        at DeadlockExample$Thread1.run(DeadlockExample.java:15)
        - waiting to lock <0x00000007d5b295e8> (a java.lang.Object)
        - locked <0x00000007d5b295d8> (a java.lang.Object)
        at java.lang.Thread.run(Thread.java:748)

Found 1 deadlock.

通过这些信息可以清晰地看到Thread1和Thread2相互等待对方持有的锁，从而确定死锁的发生。

6. 分析内存快照

在多线程环境下，内存泄漏和对象生命周期管理不当也可能导致各种问题。使用工具如VisualVM、YourKit等可以生成内存快照并进行分析。

以VisualVM为例，启动VisualVM后，选择正在运行的Java应用程序。在“监视”选项卡中，可以查看应用程序的内存、CPU等使用情况。在“线程”选项卡中，可以实时查看线程的状态。

要生成内存快照，在“概要”选项卡中点击“堆Dump”按钮，即可生成当前的内存快照。打开内存快照后，可以通过“类”、“实例”等视图分析对象的数量、引用关系等。例如，如果发现某个对象数量不断增加且没有被正确释放，可能存在内存泄漏问题。通过分析对象的引用链，可以找到持有该对象引用导致无法释放的源头，进而解决问题。

Java并发编程中的测试技巧

Java并发编程的测试同样面临诸多挑战，由于线程执行的不确定性，传统的单元测试方法往往不足以发现并发问题。下面介绍一些专门针对Java并发编程的测试技巧。

1. 基本单元测试

虽然并发程序测试有其特殊性，但基本的单元测试仍然是必要的。对于多线程程序中的每个独立组件，如线程安全的类、同步方法等，可以编写单元测试来验证其功能正确性。例如，对于一个简单的线程安全计数器类：

public class ThreadSafeCounter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

可以编写如下单元测试（使用JUnit 5）：

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class ThreadSafeCounterTest {
    @Test
    public void testIncrementAndGetCount() {
        ThreadSafeCounter counter = new ThreadSafeCounter();
        counter.increment();
        assertEquals(1, counter.getCount());
    }
}

这种单元测试可以验证在单线程环境下ThreadSafeCounter的基本功能是否正确。然而，它并不能检测出在多线程环境下可能出现的问题，如竞态条件等。

2. 多线程单元测试

为了测试多线程环境下的代码，可以编写多线程单元测试。一种简单的方法是创建多个线程并让它们同时访问共享资源，然后验证结果是否符合预期。例如，对于上述ThreadSafeCounter类，编写多线程单元测试：

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

import java.util.concurrent.CountDownLatch;

public class ThreadSafeCounterMultiThreadedTest {
    @Test
    public void testMultiThreadedIncrement() throws InterruptedException {
        int threadCount = 10;
        int incrementCount = 1000;
        ThreadSafeCounter counter = new ThreadSafeCounter();
        CountDownLatch latch = new CountDownLatch(threadCount);

        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                for (int j = 0; j < incrementCount; j++) {
                    counter.increment();
                }
                latch.countDown();
            }).start();
        }

        latch.await();
        assertEquals(threadCount * incrementCount, counter.getCount());
    }
}

在上述测试中，创建了10个线程，每个线程对ThreadSafeCounter执行1000次increment操作。通过CountDownLatch确保所有线程执行完毕后，验证counter的最终计数值是否符合预期。如果ThreadSafeCounter的实现不是线程安全的，这个测试可能会失败，提示存在竞态条件等并发问题。

3. 使用ExecutorService进行测试

ExecutorService提供了一种更灵活和可控的方式来管理和执行线程。在测试多线程代码时，可以利用ExecutorService创建线程池并提交任务。例如，对一个多线程计算任务进行测试：

import java.util.concurrent.*;

public class ParallelCalculator {
    public static int sumInParallel(int[] numbers) throws InterruptedException, ExecutionException {
        ExecutorService executorService = Executors.newFixedThreadPool(4);
        try {
            int partSize = numbers.length / 4;
            Future<Integer>[] futures = new Future[4];

            for (int i = 0; i < 4; i++) {
                int start = i * partSize;
                int end = (i == 3)? numbers.length : (i + 1) * partSize;
                futures[i] = executorService.submit(() -> {
                    int sum = 0;
                    for (int j = start; j < end; j++) {
                        sum += numbers[j];
                    }
                    return sum;
                });
            }

            int totalSum = 0;
            for (Future<Integer> future : futures) {
                totalSum += future.get();
            }
            return totalSum;
        } finally {
            executorService.shutdown();
        }
    }
}

对应的测试代码：

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

import java.util.concurrent.ExecutionException;

public class ParallelCalculatorTest {
    @Test
    public void testSumInParallel() throws InterruptedException, ExecutionException {
        int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8};
        int expectedSum = 36;
        assertEquals(expectedSum, ParallelCalculator.sumInParallel(numbers));
    }
}

通过ExecutorService创建线程池并行计算数组元素的和，并在测试中验证计算结果是否正确。这种方式可以更好地模拟实际的多线程并发场景，同时方便控制线程数量和管理任务执行。

4. 压力测试

压力测试用于验证多线程程序在高负载情况下的性能和稳定性。可以使用工具如Apache JMeter、Gatling等对Java多线程应用进行压力测试。以JMeter为例，假设我们有一个简单的Web服务，其中包含多线程处理逻辑：

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@WebServlet("/calculate")
public class CalculateServlet extends HttpServlet {
    private static final ExecutorService executorService = Executors.newFixedThreadPool(10);

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        executorService.submit(() -> {
            try {
                // 模拟一些复杂计算
                Thread.sleep(100);
                PrintWriter out = response.getWriter();
                response.setContentType("text/html");
                out.println("<html><body>Calculation result</body></html>");
            } catch (InterruptedException | IOException e) {
                e.printStackTrace();
            }
        });
    }

    @Override
    public void destroy() {
        executorService.shutdown();
    }
}

在JMeter中，通过创建HTTP请求采样器，设置目标URL为http://localhost:8080/calculate（假设Web应用部署在本地8080端口）。然后可以通过线程组设置并发用户数、循环次数等参数进行压力测试。通过分析JMeter生成的报告，如吞吐量、响应时间、错误率等指标，可以评估多线程程序在高负载下的性能表现，发现潜在的性能瓶颈和稳定性问题。

5. 随机化测试

由于多线程程序执行的不确定性，随机化测试是一种有效的发现潜在并发问题的方法。可以在测试中引入随机因素，如随机的线程执行顺序、随机的延迟等，增加测试的覆盖范围。例如，在多线程访问共享资源的测试中：

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ThreadLocalRandom;

public class RandomizedConcurrentTest {
    private static class SharedResource {
        private int value = 0;

        public synchronized void increment() {
            value++;
        }

        public synchronized int getValue() {
            return value;
        }
    }

    @Test
    public void testRandomizedConcurrentAccess() throws InterruptedException {
        int threadCount = 10;
        int operationCount = 1000;
        SharedResource resource = new SharedResource();
        CountDownLatch latch = new CountDownLatch(threadCount);

        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                for (int j = 0; j < operationCount; j++) {
                    try {
                        Thread.sleep(ThreadLocalRandom.current().nextInt(100));
                        resource.increment();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                latch.countDown();
            }).start();
        }

        latch.await();
        assertEquals(threadCount * operationCount, resource.getValue());
    }
}

在上述测试中，每个线程在执行increment操作前会随机睡眠0到100毫秒，模拟不同的线程执行顺序和延迟。通过多次运行这个随机化测试，可以增加发现竞态条件等并发问题的概率。

6. 使用并发测试框架

有一些专门的并发测试框架可以帮助简化多线程测试，如ConcurrencyUnit。ConcurrencyUnit提供了简洁的API来编写并发测试，支持线程池、同步原语等测试场景。例如，使用ConcurrencyUnit测试一个线程安全的队列：

<dependency>
    <groupId>org.concurrencyunit</groupId>
    <artifactId>concurrencyunit</artifactId>
    <version>1.2.0</version>
</dependency>

import org.concurrencyunit.annotations.Concurrency;
import org.concurrencyunit.annotations.EntryPoint;
import org.concurrencyunit.annotations.InvokedBy;
import org.concurrencyunit.annotations.Repeating;
import org.concurrencyunit.framework.TestCase;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class ThreadSafeQueueTest extends TestCase {
    private BlockingQueue<Integer> queue = new LinkedBlockingQueue<>();

    @EntryPoint
    @Concurrency(10)
    public void producer() throws Exception {
        for (int i = 0; i < 100; i++) {
            queue.put(i);
        }
    }

    @InvokedBy("producer")
    @Repeating(10)
    public void consumer() throws Exception {
        for (int i = 0; i < 100; i++) {
            assertEquals((Integer) i, queue.take());
        }
    }
}

上述代码使用ConcurrencyUnit注解定义了生产者和消费者线程的行为。@Concurrency(10)表示启动10个生产者线程，@Repeating(10)表示启动10个消费者线程。通过这种方式可以方便地编写复杂的并发测试场景，检测线程安全队列在多线程环境下的正确性。

7. 静态分析工具

除了运行时测试，静态分析工具如FindBugs、PMD等也可以帮助发现Java并发编程中的潜在问题。这些工具通过分析代码结构和字节码，检测可能存在的竞态条件、死锁等问题。

以FindBugs为例，在Maven项目中添加插件：

<build>
    <plugins>
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>findbugs-maven-plugin</artifactId>
            <version>3.0.5</version>
            <configuration>
                <effort>Max</effort>
                <threshold>Low</threshold>
            </configuration>
            <executions>
                <execution>
                    <goals>
                        <goal>check</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

运行mvn findbugs:check命令后，FindBugs会分析项目代码，并报告发现的问题。例如，如果代码中存在未正确同步的共享变量访问，FindBugs可能会提示类似于“RCN_REDUNDANT_NULLCHECK_OF_NONNULL_VALUE”的警告，指出可能存在竞态条件的风险。虽然静态分析工具不能完全替代运行时测试，但可以在早期发现一些常见的并发问题，提高代码质量。