FYI the intent of singleton was literally a singleton, this does break that.
It has limitations and use cases - ack that - so think this commit is wrong
in that regard and is another implementation (I dont see an use case for it
but maybe there is), not a fix.

Romain Manni-Bucau
@rmannibucau <https://x.com/rmannibucau> | .NET Blog
<https://dotnetbirdie.github.io/> | Blog <https://rmannibucau.github.io/> | Old
Blog <http://rmannibucau.wordpress.com> | Github
<https://github.com/rmannibucau> | LinkedIn
<https://www.linkedin.com/in/rmannibucau> | Book
<https://www.packtpub.com/en-us/product/java-ee-8-high-performance-9781788473064>
Javaccino <https://javaccino.dev/> founder (Java/.NET service - contact via
linkedin)


---------- Forwarded message ---------
De : jungm.apache.org via commits <[email protected]>
Date: dim. 15 nov. 2026 à 14:25
Subject: (johnzon) 08/09: Hand out SINGLETON buffer to one user at a time
To: [email protected] <[email protected]>
Cc: <[email protected]>


This is an automated email from the ASF dual-hosted git repository.

jungm pushed a commit to branch johnzon-1.3.x
in repository https://gitbox.apache.org/repos/asf/johnzon.git

commit 9027190285f6d1fb1c4aad2e585b6be253aab2c4
Author: Markus Jung <[email protected]>
AuthorDate: Sun Nov 15 14:09:59 2026 +0100

    Hand out SINGLETON buffer to one user at a time

    (cherry picked from commit 2caea48d1d57cf7d7f50c4578168ce065dfede4e)
---
 .../apache/johnzon/core/BufferStrategyFactory.java | 25 +++++++++-----
 .../johnzon/core/BufferStrategyFactoryTest.java    | 38
++++++++++++++++++++++
 2 files changed, 54 insertions(+), 9 deletions(-)

diff --git
a/johnzon-core/src/main/java/org/apache/johnzon/core/BufferStrategyFactory.java
b/johnzon-core/src/main/java/org/apache/johnzon/core/BufferStrategyFactory.java
index dd092a53..902ec4fe 100644
---
a/johnzon-core/src/main/java/org/apache/johnzon/core/BufferStrategyFactory.java
+++
b/johnzon-core/src/main/java/org/apache/johnzon/core/BufferStrategyFactory.java
@@ -20,6 +20,7 @@ import java.util.HashMap;
 import java.util.Locale;
 import java.util.Map;
 import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.atomic.AtomicReference;

 import org.apache.johnzon.core.util.ClassUtil;

@@ -85,30 +86,36 @@ public class BufferStrategyFactory {
         protected char[] newInstance(int size) {
             return new char[size];
         }
-
-        @Override
-        public void release(final char[] value) {
-            // no-op
-        }
     }

+    // the buffer is handed out to one user at a time, other users get a
new one.
+    // Sharing it would let users holding buffers at the same time
overwrite each other's content, e.g. two
+    // parsers open at once, or one parser whose value spans several value
buffers.
     private static abstract class SingletonProvider<T> implements
BufferStrategy.BufferProvider<T> {
-        protected final T buffer;
+        private final int size;
+        private final T buffer;
+        // holds the buffer while it is not in use
+        private final AtomicReference<T> available;

         public SingletonProvider(final int size) {
-            buffer = newInstance(size);
+            this.size = size;
+            this.buffer = newInstance(size);
+            this.available = new AtomicReference<>(buffer);
         }

         protected abstract T newInstance(int size);

         @Override
         public T newBuffer() {
-            return buffer;
+            final T value = available.getAndSet(null);
+            return value != null ? value : newInstance(size);
         }

         @Override
         public void release(final T value) {
-            // no-op
+            if (value == buffer) {
+                available.set(buffer);
+            }
         }
     }

diff --git
a/johnzon-core/src/test/java/org/apache/johnzon/core/BufferStrategyFactoryTest.java
b/johnzon-core/src/test/java/org/apache/johnzon/core/BufferStrategyFactoryTest.java
index f1226972..4b523728 100644
---
a/johnzon-core/src/test/java/org/apache/johnzon/core/BufferStrategyFactoryTest.java
+++
b/johnzon-core/src/test/java/org/apache/johnzon/core/BufferStrategyFactoryTest.java
@@ -16,17 +16,22 @@
  */
 package org.apache.johnzon.core;

+import java.io.StringReader;
 import java.io.StringWriter;
 import java.util.HashMap;
 import java.util.concurrent.atomic.AtomicInteger;

 import javax.json.spi.JsonProvider;
 import javax.json.stream.JsonGenerator;
+import javax.json.stream.JsonParser;
+import javax.json.stream.JsonParserFactory;

 import org.junit.Test;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;

 public class BufferStrategyFactoryTest {
@@ -71,6 +76,39 @@ public class BufferStrategyFactoryTest {
         assertEquals("{\"age\":27,\"name\":\"karl\"}", sw.toString());
     }

+    @Test
+    public void singletonHandsOutBufferOnce() {
+        final BufferStrategy.BufferProvider<char[]> provider =
BufferStrategyFactory.valueOf("SINGLETON").newCharProvider(4);
+        final char[] first = provider.newBuffer();
+        final char[] second = provider.newBuffer();
+        assertNotSame(first, second);
+
+        provider.release(second);
+        assertNotSame(first, provider.newBuffer());
+
+        provider.release(first);
+        assertSame(first, provider.newBuffer());
+    }
+
+    @Test
+    public void singletonParsersOpenAtSameTime() {
+        final JsonParserFactory factory =
JsonProvider.provider().createParserFactory(new HashMap<String, Object>() {{
+            put(AbstractJsonFactory.BUFFER_STRATEGY, "SINGLETON");
+            put(JsonParserFactoryImpl.BUFFER_LENGTH, 2);
+        }});
+        try (JsonParser first = factory.createParser(new
StringReader("[\"abcdef\",123456]"));
+             JsonParser second = factory.createParser(new
StringReader("[\"uvwxyz\",987654]"))) {
+            for (int i = 0; i < 2; i++) {
+                assertEquals(first.next(), second.next());
+            }
+            assertEquals("abcdef", first.getString());
+            assertEquals("uvwxyz", second.getString());
+            assertEquals(first.next(), second.next());
+            assertEquals(123456, first.getInt());
+            assertEquals(987654, second.getInt());
+        }
+    }
+
     private void verify(Object bufferStrategy) {
         assertNotNull(bufferStrategy);
         assertTrue(bufferStrategy instanceof BufferStrategy);

Reply via email to