[commons-jexl] 02/02: JEXL-320: remove dependency on Unsafe in test Task #JEXL-320 - "mvn test" fails with COMPILATION ERROR in SynchronizedArithmetic.java on Java 11

[he...@apache.org]

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

henrib pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-jexl.git

commit de8eb7d2897ebcbfa7d4ff61ed5fce5fa42e20f7
Author: henrib <he...@apache.org>
AuthorDate: Fri Jan 17 16:45:01 2020 +0100

    JEXL-320: remove dependency on Unsafe in test
    Task #JEXL-320 - "mvn test" fails with COMPILATION ERROR in SynchronizedArithmetic.java on Java 11
---
 .../commons/jexl3/SynchronizedArithmetic.java      | 88 ++++++++++++++++------
 .../commons/jexl3/SynchronizedOverloadsTest.java   |  2 +-
 2 files changed, 66 insertions(+), 24 deletions(-)

diff --git a/src/test/java/org/apache/commons/jexl3/SynchronizedArithmetic.java b/src/test/java/org/apache/commons/jexl3/SynchronizedArithmetic.java
index 9938b2b..7c897c0 100644
--- a/src/test/java/org/apache/commons/jexl3/SynchronizedArithmetic.java
+++ b/src/test/java/org/apache/commons/jexl3/SynchronizedArithmetic.java
@@ -16,12 +16,13 @@
  */
 package org.apache.commons.jexl3;
 
-import java.lang.reflect.Field;
+import java.util.IdentityHashMap;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.concurrent.atomic.AtomicInteger;
-import sun.misc.Unsafe;
+//import java.lang.reflect.Field;
+//import sun.misc.Unsafe;
 
 /**
  *
@@ -60,7 +61,6 @@ public class SynchronizedArithmetic extends JexlArithmetic {
          * @param o the monitored object
          */
         protected void monitorEnter(Object o) {
-            UNSAFE.monitorEnter(o);
             enters.incrementAndGet();
         }
 
@@ -69,7 +69,6 @@ public class SynchronizedArithmetic extends JexlArithmetic {
          * @param o the monitored object
          */
         protected void monitorExit(Object o) {
-            UNSAFE.monitorExit(o);
             exits.incrementAndGet();
         }
 
@@ -94,32 +93,75 @@ public class SynchronizedArithmetic extends JexlArithmetic {
     /**
      * You should know better than to use this...
      */
-    private static Unsafe UNSAFE;
-    static {
-        try {
-            Field f = Unsafe.class.getDeclaredField("theUnsafe");
-            f.setAccessible(true);
-            UNSAFE = (Unsafe) f.get(null);
-        } catch (Exception e) {
-            UNSAFE = null;
-        }
-    }
-
+//    private static Unsafe UNSAFE;
+//    static {
+//        try {
+//            Field f = Unsafe.class.getDeclaredField("theUnsafe");
+//            f.setAccessible(true);
+//            UNSAFE = (Unsafe) f.get(null);
+//        } catch (Exception e) {
+//            UNSAFE = null;
+//        }
+//    }
+//
+//    /**
+//     * Using the unsafe to enter & exit object intrinsic monitors.
+//     */
+//    static class UnsafeMonitor extends Monitor {
+//        @Override protected void monitorEnter(Object o) {
+//            UNSAFE.monitorEnter(o);
+//            super.monitorEnter(o);
+//        }
+//
+//        @Override protected void monitorExit(Object o) {
+//            UNSAFE.monitorExit(o);
+//            super.monitorExit(o);
+//        }
+//    }
+    
     /**
-     * Using the unsafe to enter & exit object intrinsic monitors.
+     * Crude monitor replacement...
      */
-    static class UnsafeMonitor extends Monitor {
-        @Override protected void monitorEnter(Object o) {
-            UNSAFE.monitorEnter(o);
-            super.monitorEnter(o);
+    static class SafeMonitor extends Monitor {
+         private final Map<Object, Object> monitored = new IdentityHashMap<Object, Object>();
+
+        @Override
+        protected void monitorEnter(Object o) {
+            Object guard;
+            try {
+                while (true) {
+                    synchronized (monitored) {
+                        guard = monitored.get(o);
+                        if (guard == null) {
+                            guard = new Object();
+                            monitored.put(o, guard);
+                            super.monitorEnter(o);
+                            break;
+                        }
+                    }
+                    synchronized (guard) {
+                        guard.wait();
+                    }
+                }
+            } catch (InterruptedException xint) {
+                // oops
+            }
         }
 
         @Override protected void monitorExit(Object o) {
-            UNSAFE.monitorExit(o);
-            super.monitorExit(o);
+            final Object guard;
+            synchronized(monitored) {
+                guard = monitored.remove(o);
+            }
+            if (guard != null) {
+                synchronized(guard) {
+                    guard.notifyAll();
+                }
+                super.monitorExit(o);
+            }
         }
     }
-
+    
     /**
      * An iterator that implements Closeable (at least implements a close method)
      * and uses monitors to protect iteration.
diff --git a/src/test/java/org/apache/commons/jexl3/SynchronizedOverloadsTest.java b/src/test/java/org/apache/commons/jexl3/SynchronizedOverloadsTest.java
index cf98bce..769da63 100644
--- a/src/test/java/org/apache/commons/jexl3/SynchronizedOverloadsTest.java
+++ b/src/test/java/org/apache/commons/jexl3/SynchronizedOverloadsTest.java
@@ -64,7 +64,7 @@ public class SynchronizedOverloadsTest extends JexlTestCase {
 
     @Test
     public void testUnsafeMonitor() throws Exception {
-        SynchronizedArithmetic.Monitor monitor = new SynchronizedArithmetic.UnsafeMonitor();
+        SynchronizedArithmetic.Monitor monitor = new SynchronizedArithmetic.SafeMonitor();
         Map<String, Object> foo = new TreeMap<String, Object>();
         foo.put("one", 1);
         foo.put("two", 2);