Thinking about this some more I’ll probably revert it (and a316738, which is the reason i touched the singleton strategy to be a “maybe” singleton instead of a real singleton)
The whole idea of a316738 was basically to prevent OOM errors when a user configures an absurdly large number length limit. Nobody should be doing that anyways IMO > On 15. Nov 2026, at 15:57, Romain Manni-Bucau <[email protected]> wrote: > > 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);
