Replace synchronized with locks in JTL (#2725)

Author: vy

log4j-layout-template-json-test/src/test/java/org/apache/logging/log4j/layout/template/json/JsonTemplateLayoutNullEventDelimiterTest.java

@@ -25,6 +25,8 @@
 import java.net.ServerSocket;
 import java.net.Socket;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
 import org.apache.commons.codec.binary.Hex;
 import org.apache.logging.log4j.Level;
 import org.apache.logging.log4j.Logger;
@@ -108,11 +110,13 @@ public Result filter(LogEvent event) {
 
     private static final class TcpServer extends Thread implements AutoCloseable {
 
+        private final Lock lock = new ReentrantLock();
+
         private final ServerSocket serverSocket;
 
         private final ByteArrayOutputStream outputStream;
 
-        private volatile int totalReadByteCount = 0;
+        private int totalReadByteCount = 0;
 
         private volatile boolean closed = false;
 
@@ -136,9 +140,12 @@ public void run() {
                         final int readByteCount = inputStream.read(buffer);
                         if (readByteCount != -1) {
                             LOGGER.info("Received bytes {}.", () -> Hex.encodeHex(buffer, 0, readByteCount, false));
-                            synchronized (this) {
+                            lock.lock();
+                            try {
                                 totalReadByteCount += readByteCount;
                                 outputStream.write(buffer, 0, readByteCount);
+                            } finally {
+                                lock.unlock();
                             }
                         } else {
                             break;
@@ -159,16 +166,35 @@ public int getPort() {
             return serverSocket.getLocalPort();
         }
 
-        public synchronized byte[] getReceivedBytes() {
-            return outputStream.toByteArray();
+        public byte[] getReceivedBytes() {
+            lock.lock();
+            try {
+                return outputStream.toByteArray();
+            } finally {
+                lock.unlock();
+            }
         }
 
-        public synchronized int getTotalReadByteCount() {
-            return totalReadByteCount;
+        public int getTotalReadByteCount() {
+            lock.lock();
+            try {
+                return totalReadByteCount;
+            } finally {
+                lock.unlock();
+            }
         }
 
         @Override
-        public synchronized void close() {
+        public void close() {
+            lock.lock();
+            try {
+                unsynchronizedClose();
+            } finally {
+                lock.unlock();
+            }
+        }
+
+        private void unsynchronizedClose() {
             if (closed) {
                 throw new IllegalStateException("shutdown has already been invoked");
             }

log4j-layout-template-json/src/main/java/org/apache/logging/log4j/layout/template/json/resolver/TimestampResolver.java

@@ -18,6 +18,8 @@
 
 import java.util.Locale;
 import java.util.TimeZone;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
 import org.apache.logging.log4j.core.LogEvent;
 import org.apache.logging.log4j.core.time.Instant;
 import org.apache.logging.log4j.core.time.MutableInstant;
@@ -257,14 +259,25 @@ private static TimeZone readTimeZone(final TemplateResolverConfig config) {
 
     private static final class PatternResolver implements EventResolver {
 
+        private final Lock lock = new ReentrantLock();
+
         private final PatternResolverContext patternResolverContext;
 
         private PatternResolver(final PatternResolverContext patternResolverContext) {
             this.patternResolverContext = patternResolverContext;
         }
 
         @Override
-        public synchronized void resolve(final LogEvent logEvent, final JsonWriter jsonWriter) {
+        public void resolve(final LogEvent logEvent, final JsonWriter jsonWriter) {
+            lock.lock();
+            try {
+                unsynchronizedResolve(logEvent, jsonWriter);
+            } finally {
+                lock.unlock();
+            }
+        }
+
+        private void unsynchronizedResolve(final LogEvent logEvent, final JsonWriter jsonWriter) {
 
             // Format timestamp if it doesn't match the last cached one.
             final boolean instantMatching = patternResolverContext.formatter.isInstantMatching(
@@ -337,10 +350,21 @@ private EpochResolutionRecord() {
 
     private abstract static class EpochResolver implements EventResolver {
 
+        private final Lock lock = new ReentrantLock();
+
         private final EpochResolutionRecord resolutionRecord = new EpochResolutionRecord();
 
         @Override
-        public synchronized void resolve(final LogEvent logEvent, final JsonWriter jsonWriter) {
+        public void resolve(final LogEvent logEvent, final JsonWriter jsonWriter) {
+            lock.lock();
+            try {
+                unsynchronizedResolve(logEvent, jsonWriter);
+            } finally {
+                lock.unlock();
+            }
+        }
+
+        private void unsynchronizedResolve(final LogEvent logEvent, final JsonWriter jsonWriter) {
             final Instant logEventInstant = logEvent.getInstant();
             if (logEventInstant.equals(resolutionRecord.instant)) {
                 jsonWriter.writeRawString(resolutionRecord.resolution, 0, resolutionRecord.resolutionLength);