diff --git a/build.xml b/build.xml
index 489379c659..df25d59518 100644
--- a/build.xml
+++ b/build.xml
@@ -1240,6 +1240,7 @@ cd ..
       <!-- enable JNI on JDK 24+ -->
       <jvmarg value="--enable-native-access=ALL-UNNAMED" />
       <jvmarg if:set="test.jdwp" value="${test.jdwp}" />
+      <jvmarg value="-Xmx64m" />
       <!-- optionally run headless -->
       <syspropertyset refid="headless"/>
       <!-- avoid VM conflicts with JNA protected mode -->
diff --git a/lib/native/linux-x86-64.jar b/lib/native/linux-x86-64.jar
index d659f63ac1..653423182f 100644
Binary files a/lib/native/linux-x86-64.jar and b/lib/native/linux-x86-64.jar differ
diff --git a/src/com/sun/jna/internal/Cleaner.java b/src/com/sun/jna/internal/Cleaner.java
index a2095937fc..5dff307da0 100644
--- a/src/com/sun/jna/internal/Cleaner.java
+++ b/src/com/sun/jna/internal/Cleaner.java
@@ -27,6 +27,12 @@
 import java.lang.ref.PhantomReference;
 import java.lang.ref.Reference;
 import java.lang.ref.ReferenceQueue;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
@@ -44,65 +50,90 @@ public static Cleaner getCleaner() {
         return INSTANCE;
     }
 
+    // Guard for trackedObjects and cleanerThread. The readlock is utilized when
+    // the trackedObjects are manipulated, the writelock protectes starting and
+    // stopping the CleanerThread
+    private final ReadWriteLock cleanerThreadLock = new ReentrantReadWriteLock();
     private final ReferenceQueue<Object> referenceQueue;
-    private Thread cleanerThread;
-    private CleanerRef firstCleanable;
+    // Count of objects tracked by the cleaner. When >0 it means objects are
+    // being tracked by the cleaner and the cleanerThread must be running
+    private final AtomicLong trackedObjects = new AtomicLong();
+    // Map only serves as holder, so that the CleanerRefs stay hard referenced
+    // and quickly accessible for removal
+    @SuppressWarnings("MismatchedQueryAndUpdateOfCollection")
+    private final Map<CleanerRef,CleanerRef> map = new ConcurrentHashMap<>();
+    // Thread to handle the actual cleaning
+    private volatile Thread cleanerThread;
 
     private Cleaner() {
         referenceQueue = new ReferenceQueue<>();
     }
 
-    public synchronized Cleanable register(Object obj, Runnable cleanupTask) {
+    @SuppressWarnings("EmptySynchronizedStatement")
+    public Cleanable register(Object obj, Runnable cleanupTask) {
         // The important side effect is the PhantomReference, that is yielded
         // after the referent is GCed
-        return add(new CleanerRef(this, obj, referenceQueue, cleanupTask));
+        try {
+            return add(new CleanerRef(this, obj, referenceQueue, cleanupTask));
+        } finally {
+            synchronized (obj) {
+                // Used as a reachability fence for obj
+                // Ensure, that add completes before obj can be collected and
+                // the cleaner is run
+            }
+        }
     }
 
-    private synchronized CleanerRef add(CleanerRef ref) {
-        synchronized (referenceQueue) {
-            if (firstCleanable == null) {
-                firstCleanable = ref;
-            } else {
-                ref.setNext(firstCleanable);
-                firstCleanable.setPrevious(ref);
-                firstCleanable = ref;
-            }
-            if (cleanerThread == null) {
-                Logger.getLogger(Cleaner.class.getName()).log(Level.FINE, "Starting CleanerThread");
-                cleanerThread = new CleanerThread();
-                cleanerThread.start();
+    private CleanerRef add(CleanerRef ref) {
+        runCleanup();
+        map.put(ref, ref);
+        cleanerThreadLock.readLock().lock();
+        try {
+            long count = trackedObjects.incrementAndGet();
+            if (cleanerThread == null && count > 0) {
+                cleanerThreadLock.readLock().unlock();
+                cleanerThreadLock.writeLock().lock();
+                try {
+                    if (cleanerThread == null && trackedObjects.get() > 0) {
+                        Logger.getLogger(Cleaner.class.getName()).log(Level.FINE, "Starting CleanerThread");
+                        cleanerThread = new CleanerThread();
+                        cleanerThread.start();
+                    }
+                } finally {
+                    cleanerThreadLock.readLock().lock();
+                    cleanerThreadLock.writeLock().unlock();
+                }
             }
-            return ref;
+        } finally {
+            cleanerThreadLock.readLock().unlock();
         }
+        return ref;
     }
 
-    private synchronized boolean remove(CleanerRef ref) {
-        synchronized (referenceQueue) {
-            boolean inChain = false;
-            if (ref == firstCleanable) {
-                firstCleanable = ref.getNext();
-                inChain = true;
-            }
-            if (ref.getPrevious() != null) {
-                ref.getPrevious().setNext(ref.getNext());
-            }
-            if (ref.getNext() != null) {
-                ref.getNext().setPrevious(ref.getPrevious());
-            }
-            if (ref.getPrevious() != null || ref.getNext() != null) {
-                inChain = true;
+    private void runCleanup() {
+        if (Boolean.valueOf(System.getProperty("jna.inlinecleanup", "false"))) {
+            for (Reference<? extends Object> cref = referenceQueue.poll(); cref != null; cref = referenceQueue.poll()) {
+                if (cref instanceof CleanerRef) {
+                    ((CleanerRef) cref).clean();
+                }
             }
-            ref.setNext(null);
-            ref.setPrevious(null);
-            return inChain;
+        }
+    }
+
+    private void remove(CleanerRef ref) {
+        map.remove(ref);
+        cleanerThreadLock.readLock().lock();
+        try {
+            trackedObjects.decrementAndGet();
+        } finally {
+            cleanerThreadLock.readLock().unlock();
         }
     }
 
     private static class CleanerRef extends PhantomReference<Object> implements Cleanable {
         private final Cleaner cleaner;
         private final Runnable cleanupTask;
-        private CleanerRef previous;
-        private CleanerRef next;
+        private final AtomicBoolean cleaned = new AtomicBoolean(false);
 
         public CleanerRef(Cleaner cleaner, Object referent, ReferenceQueue<? super Object> q, Runnable cleanupTask) {
             super(referent, q);
@@ -112,26 +143,11 @@ public CleanerRef(Cleaner cleaner, Object referent, ReferenceQueue<? super Objec
 
         @Override
         public void clean() {
-            if(cleaner.remove(this)) {
+            if (!cleaned.getAndSet(true)) {
+                cleaner.remove(this);
                 cleanupTask.run();
             }
         }
-
-        CleanerRef getPrevious() {
-            return previous;
-        }
-
-        void setPrevious(CleanerRef previous) {
-            this.previous = previous;
-        }
-
-        CleanerRef getNext() {
-            return next;
-        }
-
-        void setNext(CleanerRef next) {
-            this.next = next;
-        }
     }
 
     public static interface Cleanable {
@@ -155,22 +171,28 @@ public void run() {
                     if (ref instanceof CleanerRef) {
                         ((CleanerRef) ref).clean();
                     } else if (ref == null) {
-                        synchronized (referenceQueue) {
-                            Logger logger = Logger.getLogger(Cleaner.class.getName());
-                            if (firstCleanable == null) {
-                                cleanerThread = null;
-                                logger.log(Level.FINE, "Shutting down CleanerThread");
-                                break;
-                            } else if (logger.isLoggable(Level.FINER)) {
-                                StringBuilder registeredCleaners = new StringBuilder();
-                                for(CleanerRef cleanerRef = firstCleanable; cleanerRef != null; cleanerRef = cleanerRef.next) {
-                                    if(registeredCleaners.length() != 0) {
-                                        registeredCleaners.append(", ");
+                        cleanerThreadLock.readLock().lock();
+                        try {
+                            if (trackedObjects.get() == 0) {
+                                cleanerThreadLock.readLock().unlock();
+                                cleanerThreadLock.writeLock().lock();
+                                try {
+                                    if (trackedObjects.get() == 0) {
+                                        Logger.getLogger(Cleaner.class.getName()).log(Level.FINE, "Shutting down CleanerThread");
+                                        cleanerThread = null;
+                                        break;
                                     }
-                                    registeredCleaners.append(cleanerRef.cleanupTask.toString());
+                                } finally {
+                                    cleanerThreadLock.readLock().lock();
+                                    cleanerThreadLock.writeLock().unlock();
                                 }
-                                logger.log(Level.FINER, "Registered Cleaners: {0}", registeredCleaners.toString());
                             }
+                        } finally {
+                            cleanerThreadLock.readLock().unlock();
+                        }
+                        Logger logger = Logger.getLogger(Cleaner.class.getName());
+                        if (logger.isLoggable(Level.FINER)) {
+                            logger.log(Level.FINER, "Registered Cleaners: {0}", trackedObjects.get());
                         }
                     }
                 } catch (InterruptedException ex) {
diff --git a/test/com/sun/jna/different_package/CleanerTest.java b/test/com/sun/jna/different_package/CleanerTest.java
new file mode 100644
index 0000000000..5a0f8b15af
--- /dev/null
+++ b/test/com/sun/jna/different_package/CleanerTest.java
@@ -0,0 +1,71 @@
+/* Copyright (c) 2025, Matthias Bläsing, All Rights Reserved
+ *
+ * The contents of this file is dual-licensed under 2
+ * alternative Open Source/Free licenses: LGPL 2.1 or later and
+ * Apache License 2.0. (starting with JNA version 4.0.0).
+ *
+ * You can freely decide which license you want to apply to
+ * the project.
+ *
+ * You may obtain a copy of the LGPL License at:
+ *
+ * http://www.gnu.org/licenses/licenses.html
+ *
+ * A copy is also included in the downloadable source code package
+ * containing JNA, in file "LGPL2.1".
+ *
+ * You may obtain a copy of the Apache License at:
+ *
+ * http://www.apache.org/licenses/
+ *
+ * A copy is also included in the downloadable source code package
+ * containing JNA, in file "AL2.0".
+ */
+
+package com.sun.jna.different_package;
+
+import com.sun.jna.Structure;
+import junit.framework.TestCase;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class CleanerTest extends TestCase {
+    private static final int NUM_THREADS = 16;
+    private static final long ITERATIONS = 10000;
+
+    @Structure.FieldOrder({"bytes"})
+    public static class Dummy extends Structure {
+        public byte[] bytes;
+
+        public Dummy() {}
+
+        public Dummy(byte[] what) { bytes = what; }
+    }
+
+    private static class Allocator implements Runnable {
+        @Override
+        public void run() {
+            for (long i = 0; i < ITERATIONS; ++i) {
+                Dummy d = new Dummy(new byte[1024]);
+                d.write();
+            }
+        }
+    }
+
+    public void testOOM() {
+        List<Thread> threads = new ArrayList<>(NUM_THREADS);
+        for (int i = 0; i < NUM_THREADS; ++i) {
+            Thread t = new Thread(new Allocator());
+            t.start();
+            threads.add(t);
+        }
+        for (Thread t : threads) {
+            while (t.isAlive()) {
+                try {
+                    t.join();
+                } catch (InterruptedException ignore) {}
+            }
+        }
+    }
+}