IOIO: fix lock dead-lock

Author: chrisws

ioio/src/main/java/net/sourceforge/smallbasic/ioio/DigitalOutputImpl.java

@@ -1,14 +1,16 @@
 package net.sourceforge.smallbasic.ioio;
 
+import java.util.concurrent.atomic.AtomicBoolean;
+
 import ioio.lib.api.DigitalOutput;
 import ioio.lib.api.IOIO;
 import ioio.lib.api.exception.ConnectionLostException;
 import ioio.lib.spi.Log;
 
 public class DigitalOutputImpl extends IOTask implements DigitalOutput {
   private static final String TAG = "DigitalOutput";
+  private final AtomicBoolean value = new AtomicBoolean(false);
   private DigitalOutput output;
-  private volatile boolean value;
 
   public DigitalOutputImpl() {
     super();
@@ -24,7 +26,7 @@ public void close() {
 
   @Override
   public void loop() throws InterruptedException, ConnectionLostException {
-    output.write(value);
+    output.write(value.get());
   }
 
   @Override
@@ -40,6 +42,6 @@ public void setup(IOIO ioio) {
 
   @Override
   public void write(boolean value) throws ConnectionLostException {
-    this.value = value;
+    this.value.set(value);
   }
 }

ioio/src/main/java/net/sourceforge/smallbasic/ioio/IOLock.java

@@ -13,60 +13,51 @@ public class IOLock<I> {
   private Consumer<I> consumer;
 
   public float invoke(Function<Float, I> function) {
-    CountDownLatch latch = getLatch();
+    CountDownLatch latch = beginLatch();
     lock.writeLock().lock();
     AtomicReference<Float> result = new AtomicReference<>();
     try {
       this.consumer = (i) -> {
         result.set(function.apply(i));
         latch.countDown();
       };
-      latch.await();
-    }
-    catch (InterruptedException e) {
-      throw new RuntimeException(e);
     }
     finally {
       lock.writeLock().unlock();
     }
+    endLatch(latch);
     return result.get();
   }
 
   public void invoke(Consumer<I> consumer) {
-    CountDownLatch latch = getLatch();
+    CountDownLatch latch = beginLatch();
     lock.writeLock().lock();
     try {
       this.consumer = (i) -> {
         consumer.accept(i);
         latch.countDown();
       };
-      latch.await();
-    }
-    catch (InterruptedException e) {
-      throw new RuntimeException(e);
     }
     finally {
       lock.writeLock().unlock();
     }
+    endLatch(latch);
   }
 
   public int invokeInt(Function<Integer, I> function) {
-    CountDownLatch latch = getLatch();
+    CountDownLatch latch = beginLatch();
     lock.writeLock().lock();
     AtomicReference<Integer> result = new AtomicReference<>();
     try {
       this.consumer = (i) -> {
         result.set(function.apply(i));
         latch.countDown();
       };
-      latch.await();
-    }
-    catch (InterruptedException e) {
-      throw new RuntimeException(e);
     }
     finally {
       lock.writeLock().unlock();
     }
+    endLatch(latch);
     return result.get();
   }
 
@@ -89,7 +80,18 @@ public void process(I input) {
   /**
    * CountDownLatch ensures the calling method returns once process has completed
    */
-  private static CountDownLatch getLatch() {
+  private CountDownLatch beginLatch() {
     return new CountDownLatch(1);
   }
+
+  /**
+   * Wait for the looper to process the next consumer
+   */
+  private void endLatch(CountDownLatch latch) {
+    try {
+      latch.await();
+    } catch (InterruptedException e) {
+      throw new RuntimeException(e);
+    }
+  }
 }