Fix | Fix SharedTimer implementation to use class level lock for thread safety

src/main/java/com/microsoft/sqlserver/jdbc/SharedTimer.java

@@ -8,6 +8,7 @@
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.ScheduledThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
 
 
@@ -16,19 +17,21 @@ class SharedTimer implements Serializable {
      * Always update serialVersionUID when prompted
      */
     private static final long serialVersionUID = -4069361613863955760L;
-    
+
     static final String CORE_THREAD_PREFIX = "mssql-jdbc-shared-timer-core-";
-    private static final AtomicLong CORE_THREAD_COUNTER = new AtomicLong();
-    private static SharedTimer instance;
 
+    private static final AtomicLong CORE_THREAD_COUNTER = new AtomicLong();
+    private static final Object lock = new Object();
     /**
      * Unique ID of this SharedTimer
      */
     private final long id = CORE_THREAD_COUNTER.getAndIncrement();
     /**
      * Number of outstanding references to this SharedTimer
      */
-    private int refCount = 0;
+    private final AtomicInteger refCount = new AtomicInteger();
+
+    private static volatile SharedTimer instance;
     private ScheduledThreadPoolExecutor executor;
 
     private SharedTimer() {
@@ -47,7 +50,7 @@ public long getId() {
     /**
      * @return Whether there is an instance of the SharedTimer currently allocated.
      */
-    static synchronized boolean isRunning() {
+    static boolean isRunning() {
         return instance != null;
     }
 
@@ -56,16 +59,17 @@ static synchronized boolean isRunning() {
      *
      * If the reference count reaches zero then the underlying executor will be shutdown so that its thread stops.
      */
-    public synchronized void removeRef() {
-        if (refCount <= 0) {
-            throw new IllegalStateException("removeRef() called more than actual references");
-        }
-        refCount -= 1;
-        if (refCount == 0) {
-            // Removed last reference so perform cleanup
-            executor.shutdownNow();
-            executor = null;
-            instance = null;
+    public void removeRef() {
+        synchronized (lock) {
+            if (refCount.get() <= 0) {
+                throw new IllegalStateException("removeRef() called more than actual references");
+            }
+            if (refCount.decrementAndGet() == 0) {
+                // Removed last reference so perform cleanup
+                executor.shutdownNow();
+                executor = null;
+                instance = null;
+            }
         }
     }
 
@@ -76,13 +80,15 @@ public synchronized void removeRef() {
      *
      * When the caller is finished with the SharedTimer it must be released via {@link#removeRef}
      */
-    public static synchronized SharedTimer getTimer() {
-        if (instance == null) {
-            // No shared object exists so create a new one
-            instance = new SharedTimer();
+    public static SharedTimer getTimer() {
+        synchronized (lock) {
+            if (instance == null) {
+                // No shared object exists so create a new one
+                instance = new SharedTimer();
+            }
+            instance.refCount.getAndIncrement();
+            return instance;
         }
-        instance.refCount += 1;
-        return instance;
     }
 
     /**