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);
