SonarLint错误：非线程安全字段不应为静态，求代码解决方案

Great question! The SonarLint warning is spot-on here—SimpleDateFormat is not thread-safe, and marking it as a static field means every thread in your app will share the same instance. This can cause all sorts of hard-to-debug issues: incorrect date values, race conditions, or even runtime exceptions when multiple threads access the formatter at the same time.

Let's go through the best ways to fix this thread safety problem:

Option 1: Use Java 8+ DateTimeFormatter (Recommended) #

Java 8 introduced the new date/time API in java.time, which includes DateTimeFormatter—an immutable, thread-safe alternative to SimpleDateFormat. This is the cleanest and most reliable solution.

Here's how to refactor your code:

import java.io.Serializable;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class Util implements Serializable {
    private static final DateTimeFormatter DATE_KEY_FORMAT = DateTimeFormatter.ofPattern("yyyyMMdd");
    private static final DateTimeFormatter EUS_WS_DATE_FORMAT = DateTimeFormatter.ofPattern("yyyy-MM-dd");
    private static final DateTimeFormatter DATETIME_KEY_FORMAT = DateTimeFormatter.ofPattern("yyyyMMddHHmmssSSS");
    public static final String TIME_ZONE_GMT = "GMT";

    /**
     * Returns date in the format yyyyMMdd
     * @return
     */
    public static int getYyyyMMdd() {
        return Integer.parseInt(LocalDate.now().format(DATE_KEY_FORMAT));
    }

    // Example method for datetime format
    public static String getDatetimeKey() {
        return LocalDateTime.now().format(DATETIME_KEY_FORMAT);
    }
}

Since DateTimeFormatter is immutable, you can safely keep it as a static field—no thread safety issues at all.

Option 2: Use ThreadLocal (For Java 7 or earlier) #

If you're stuck on an older Java version, wrap your SimpleDateFormat instances in ThreadLocal. This ensures each thread gets its own copy of the formatter, so there's no shared state between threads.

Refactored code:

import java.io.Serializable;
import java.text.SimpleDateFormat;

public class Util implements Serializable {
    private static final ThreadLocal<SimpleDateFormat> DATE_KEY_FORMAT = 
        ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyyMMdd"));
    private static final ThreadLocal<SimpleDateFormat> EUS_WS_DATE_FORMAT = 
        ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd"));
    private static final ThreadLocal<SimpleDateFormat> DATETIME_KEY_FORMAT = 
        ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyyMMddHHmmssSSS"));
    public static final String TIME_ZONE_GMT = "GMT";

    /**
     * Returns date in the format yyyyMMdd
     * @return
     */
    public static int getYyyyMMdd() {
        return Integer.parseInt(DATE_KEY_FORMAT.get().format(new java.util.Date()));
    }
}

When you call DATE_KEY_FORMAT.get(), it returns the formatter instance specific to the current thread. In most cases, you don't need to explicitly call remove()—ThreadLocal automatically cleans up when the thread is garbage collected.

Option 3: Synchronize Access (Not Recommended) #

You could add synchronized blocks around every use of the formatter, but this will hurt performance in high-concurrency scenarios. It creates a bottleneck where threads have to wait for each other to use the formatter. Avoid this unless you have no other choice.

Example (not ideal):

public static int getYyyyMMdd() {
    synchronized (DATE_KEY_FORMAT) {
        return Integer.parseInt(DATE_KEY_FORMAT.format(new java.util.Date()));
    }
}

内容的提问来源于stack exchange，提问作者user3766619