A DESCRIPTION OF THE PROBLEM :
**Summary**

Inconsistent AffineTransform Output with Logging Configuration



**Description:**

When running the provided Java code, the output for the `AffineTransform` instance differs depending on the HotSpot JVM version (jdk11-dev, jdk11, and jdk17). During debugging, I identified that this inconsistency is caused by concurrent access to the `transform` method from two threads. Furthermore, the inconsistency appears to be linked to the presence of a specific logging configuration.



JDK versions:

HotSpot-jdk11-dev -version
```
openjdk version "11.0.27-internal" 2025-04-15
OpenJDK Runtime Environment (build 11.0.27-internal+0-adhoc.root.jdk11u-dev)
OpenJDK 64-Bit Server VM (build 11.0.27-internal+0-adhoc.root.jdk11u-dev, mixed mode)
```

HotSpot-jdk11
```
openjdk version "11.0.25-internal" 2024-10-15
OpenJDK Runtime Environment (build 11.0.25-internal+0-adhoc.root.jdk-11.0.259)
OpenJDK 64-Bit Server VM (build 11.0.25-internal+0-adhoc.root.jdk-11.0.259, mixed mode)
```


HotSpot-jdk17
```
openjdk version "17.0.13-internal" 2024-10-15
OpenJDK Runtime Environment (build 17.0.13-internal+0-adhoc.root.jdk-17.0.1311)
OpenJDK 64-Bit Server VM (build 17.0.13-internal+0-adhoc.root.jdk-17.0.1311, mixed mode, sharing)
```



**Steps to Reproduce**

Compile and run the provided Java code.



**Expected Result**

The output should be consistent across all JVM versions.



**Actual Result**

HotSpot-jdk11-dev:

```
AffineTransform[[0.866025403784439, -0.5, 0.0], [0.5, 0.866025403784439, 0.0]]
```

HotSpot-jdk11, HotSpot-jdk17:

```
AffineTransform[[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]
```



**Test Case Code**

```
import java.awt.geom.AffineTransform;
import java.util.logging.Level;
import java.util.logging.Logger;

public class MultiThreads {
    static AffineTransform transform = null;
    private static final Logger MODELMBEAN_LOGGER = Logger.getLogger(MultiThreads.class.getName());
    static {
        MODELMBEAN_LOGGER.setLevel(Level.ALL);
    }
    
    AffineTransform getTransform() throws Exception {
        final AffineTransform at;
        synchronized (MultiThreads.class) {
            at = (transform != null) ? new AffineTransform(transform) : new AffineTransform();
        }
        return at;
    }

    public static void main(String[] args) throws Exception {
        new Thread(() -> {
            try {
                synchronized (MultiThreads.class) {
                    transform = AffineTransform.getRotateInstance(Math.toRadians(45));
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();

        System.out.println(new MultiThreads().getTransform());
    }
}
```