ICE-1593 Handling thread interrupts in Java

- Added Ice.BackgroundIO property to perform all IO in a non-user
  thread. This makes Ice for Java interrupt safe. This is implemented
  by the QueueRequestHanbler.
- EndpointHostResolver now uses an executor instead of a thread.
- Added java/demo/Ice/interrupt and java/test/Ice/interrupt.
- Made several changes that must be ported to C++ & C#.
  - InvocationTimeout exceptions can hang forever.
  - Connection establishment is always asynchronous.
  - RequestHandler.requestTimeout and asyncRequestTimeout have been
    renamed to requestCancel and asyncRequestCancel.

1 files changed, 91 insertions, 0 deletions

diff --git a/java/demo/Ice/interrupt/Server.java b/java/demo/Ice/interrupt/Server.java
new file mode 100644
index 00000000000..e4575ca77c1
--- /dev/null
+++ b/java/demo/Ice/interrupt/Server.java
@@ -0,0 +1,91 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class Server extends Ice.Application
+{
+    @Override
+    public int
+    run(String[] args)
+    {
+        if(args.length > 0)
+        {
+            System.err.println(appName() + ": too many arguments");
+            return 1;
+        }
+        
+        //
+        // If ^C is pressed we want to interrupt all running upcalls from the
+        // dispatcher and destroy the communicator.
+        //
+        setInterruptHook(new Thread() {
+            @Override
+            public void
+            run()
+            {
+                //
+                // Call shutdownNow on the executor. This interrupts all
+                // executor threads causing any running servant dispatch threads
+                // to terminate quickly.
+                //
+                _executor.shutdownNow();
+                try
+                {
+                    communicator().shutdown();
+                }
+                catch(Ice.LocalException ex)
+                {
+                    ex.printStackTrace();
+                }
+            }
+        });
+
+        Ice.ObjectAdapter adapter = communicator().createObjectAdapter("TaskManager");
+        adapter.add(new TaskManagerI(_executor), communicator().stringToIdentity("manager"));
+        adapter.activate();
+        communicator().waitForShutdown();
+        
+        return 0;
+    }
+
+    public static void
+    main(String[] args)
+    {
+        final Server app = new Server();
+
+        Ice.InitializationData initData = new Ice.InitializationData();
+        initData.properties = Ice.Util.createProperties();
+        initData.properties.load("config.server");
+
+        //
+        // This demo uses a dispatcher to execute any invocations on the server.
+        // By using an executor it is straightforward to interrupt any servant
+        // dispatch threads by using ExecutorService.shutdownNow.
+        //
+        initData.dispatcher = new Ice.Dispatcher() {
+            @Override
+            public void dispatch(Runnable runnable, Ice.Connection con)
+            {
+                app.getExecutor().submit(runnable);
+            }
+        };
+        
+        int status = app.main("Server", args, initData);
+        System.exit(status);
+    }
+    
+    ExecutorService getExecutor()
+    {
+        return _executor;
+    }
+
+    private ExecutorService _executor = Executors.newFixedThreadPool(5);
+}