private void callParserThread(
      String[] sources,
      String[] encodings,
      String[] classPaths,
      ArrayList<String> acceptedFiles,
      ArrayList<String> sharedRevisionEntryList,
      Multimap<String, String> invokers)
      throws IOException {
    try {
      int numOfThreads = Runtime.getRuntime().availableProcessors();

      BlockingQueue<String> toProcess =
          new ArrayBlockingQueue<String>(acceptedFiles.size(), false, acceptedFiles);
      ExecutorService executorService = Executors.newFixedThreadPool(numOfThreads);

      for (int i = 0; i < numOfThreads; ++i) {
        ParserRunnable runnerParser =
            new ParserRunnable(
                sources,
                encodings,
                classPaths,
                toProcess,
                sharedRevisionEntryList,
                invokers,
                numOfThreads);
        executorService.submit(runnerParser);
      }

      executorService.shutdown();
      executorService.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }
Esempio n. 2
0
 public static void main(String[] args) {
   final BlockingQueue<Character> bq;
   bq = new ArrayBlockingQueue<Character>(26);
   final ExecutorService executor = Executors.newFixedThreadPool(2);
   Runnable producer =
       () -> {
         for (char ch = 'A'; ch <= 'Z'; ch++) {
           try {
             bq.put(ch);
             System.out.printf("%c produced by " + "producer.%n", ch);
           } catch (InterruptedException ie) {
           }
         }
       };
   executor.execute(producer);
   Runnable consumer =
       () -> {
         char ch = '\0';
         do {
           try {
             ch = bq.take();
             System.out.printf("%c consumed by " + "consumer.%n", ch);
           } catch (InterruptedException ie) {
           }
         } while (ch != 'Z');
         executor.shutdownNow();
       };
   executor.execute(consumer);
 }
  @Test
  public void testNoApiLimitOnRootAdmin() throws Exception {
    // issue list Accounts calls
    final HashMap<String, String> params = new HashMap<String, String>();
    params.put("response", "json");
    params.put("listAll", "true");
    params.put("sessionkey", sessionKey);
    // assuming ApiRateLimitService set api.throttling.max = 25
    int clientCount = 26;
    Runnable[] clients = new Runnable[clientCount];
    final boolean[] isUsable = new boolean[clientCount];

    final CountDownLatch startGate = new CountDownLatch(1);

    final CountDownLatch endGate = new CountDownLatch(clientCount);

    for (int i = 0; i < isUsable.length; ++i) {
      final int j = i;
      clients[j] =
          new Runnable() {

            /** {@inheritDoc} */
            @Override
            public void run() {
              try {
                startGate.await();

                sendRequest("listAccounts", params);

                isUsable[j] = true;

              } catch (CloudRuntimeException e) {
                isUsable[j] = false;
                e.printStackTrace();
              } catch (InterruptedException e) {
                e.printStackTrace();
              } finally {
                endGate.countDown();
              }
            }
          };
    }

    ExecutorService executor = Executors.newFixedThreadPool(clientCount);

    for (Runnable runnable : clients) {
      executor.execute(runnable);
    }

    startGate.countDown();

    endGate.await();

    int rejectCount = 0;
    for (int i = 0; i < isUsable.length; ++i) {
      if (!isUsable[i]) rejectCount++;
    }

    assertEquals("No request should be rejected!", 0, rejectCount);
  }
 public void stop(final StopContext stopContext) {
   final ServiceController<?> serviceController =
       stopContext
           .getController()
           .getServiceContainer()
           .getService(CommonDeploymentService.getServiceName(jndiName));
   if (serviceController != null) {
     serviceController.setMode(ServiceController.Mode.REMOVE);
   }
   ExecutorService executorService = executor.getValue();
   Runnable r =
       new Runnable() {
         @Override
         public void run() {
           try {
             stopService();
           } finally {
             stopContext.complete();
           }
         }
       };
   try {
     executorService.execute(r);
   } catch (RejectedExecutionException e) {
     r.run();
   } finally {
     stopContext.asynchronous();
   }
 }
 private void findMachinesBasedOnLocalIp() {
   Optional<InetAddress> localhost = getLocalAddress();
   if (localhost.isPresent()) {
     InetAddress inetAddress = localhost.get();
     myIp = inetAddress.getAddress();
     scanningThreadPool.submit(
         new Runnable() {
           @Override
           public void run() {
             if (!isCancelled()) {
               searchForIp(myIp);
             }
           }
         });
     for (int i = 1; i <= MAX_IPS; i++) {
       final int finalI = i;
       scanningThreadPool.submit(
           new Runnable() {
             @Override
             public void run() {
               if (!isCancelled()) {
                 searchForIp(createSubnetAddress(myIp, (byte) finalI));
               }
             }
           });
     }
   }
 }
  public static void main(String[] args) {
    ExecutorService pool = Executors.newFixedThreadPool(2);

    final Vector[] vecs = {
      new Vector(), new Vector(),
    };
    vecs[0].add(vecs[1]);
    vecs[1].add(vecs[0]);

    for (int i = 0; i < 2; i++) {
      final int threadNumber = i;
      pool.submit(
          new Callable() {
            public Object call() throws Exception {
              for (int i = 0; i < 1000 * 1000; i++) {
                ObjectOutputStream out = new ObjectOutputStream(new NullOutputStream());
                out.writeObject(vecs[threadNumber]);
                out.close();
              }
              System.out.println("done");
              return null;
            }
          });
    }
  }
  private static ExecutorService startCommitAnnotationsClientService(
      SystemMain system, AtomicInteger jobCounter) {
    int configuredCount =
        Integer.valueOf(
            system.getConfiguration().getValue(SystemConfiguration.Property.CLIENT_THREADS));
    int threadPoolCount = Math.max(configuredCount, 2);
    ExecutorService service =
        Executors.newFixedThreadPool(
            threadPoolCount,
            new ThreadFactory() {

              AtomicInteger id = new AtomicInteger(0);

              @Override
              public Thread newThread(Runnable r) {
                return new Thread(
                    r, MessageFormat.format("annotationcommitclient-{0}", id.getAndIncrement()));
              }
            });

    for (int i = 0; i < threadPoolCount; i++) {
      service.submit(
          new AnnotationCommitter(
              system.getServiceFactory().getCollectionService(),
              system.getServiceFactory().getMonitorService(),
              jobCounter));
    }
    return service;
  }
 private void testConcurrency(final CollectionHolder<List<Integer>> holder)
     throws InterruptedException, ExecutionException {
   final List<Integer> list = holder.collection;
   // make a big array that takes a long time to toString()
   list.addAll(LIST);
   // Create a thread pool with two threads to cause the most contention on the underlying
   // resource.
   final ExecutorService threadPool = Executors.newFixedThreadPool(2);
   // Consumes toStrings
   Callable<Integer> consumer =
       new Callable<Integer>() {
         public Integer call() {
           for (int i = 0; i < REPEAT; i++) {
             // Calls ToStringStyle
             new ToStringBuilder(holder).append(holder.collection);
           }
           return REPEAT;
         }
       };
   Collection<Callable<Integer>> tasks = new ArrayList<Callable<Integer>>();
   tasks.add(consumer);
   tasks.add(consumer);
   final List<Future<Integer>> futures = threadPool.invokeAll(tasks);
   for (Future<Integer> future : futures) {
     future.get();
   }
 }
Esempio n. 9
0
 public static void shutdown() throws InterruptedException {
   excutor.shutdownNow();
   while (!excutor.awaitTermination(5, TimeUnit.SECONDS)) {
     log.info("await for keyManager shutdown!");
   }
   log.info("keyManager has shutdown!");
 }
Esempio n. 10
0
  public void testSequence() throws Exception {
    final Seq seq = new Seq();

    ExecutorService ex = Executors.newFixedThreadPool(5);

    List<Future> futures = ListUtil.newList();

    for (int i = 0; i < 5; i++) {
      Future<Void> future =
          ex.submit(
              new Callable<Void>() {
                @Override
                public Void call() throws Exception {
                  for (int i = 0; i < 100000000; i++) {
                    seq.increase();
                  }
                  return null;
                }
              });
      futures.add(future);
    }

    for (Future f : futures) {
      f.get();
    }

    assertEquals(5 * 100000000 + 1, seq.increase());
  }
  @Test
  public void testConfirmReceivedAfterPublisherCallbackChannelScheduleClose() throws Exception {
    final CountDownLatch latch = new CountDownLatch(40);
    templateWithConfirmsEnabled.setConfirmCallback(
        new ConfirmCallback() {

          @Override
          public void confirm(CorrelationData correlationData, boolean ack, String cause) {
            latch.countDown();
          }
        });

    ExecutorService executorService = Executors.newCachedThreadPool();
    for (int i = 0; i < 20; i++) {
      executorService.execute(
          new Runnable() {

            @Override
            public void run() {
              templateWithConfirmsEnabled.convertAndSend(
                  ROUTE, (Object) "message", new CorrelationData("abc"));
              templateWithConfirmsEnabled.convertAndSend(
                  "BAD_ROUTE", (Object) "bad", new CorrelationData("cba"));
            }
          });
    }

    assertTrue(latch.await(10, TimeUnit.SECONDS));
    assertNull(templateWithConfirmsEnabled.getUnconfirmed(-1));
  }
  public void start() throws ExecutionException, InterruptedException {

    // Use the default MtGox settings
    Exchange mtGoxExchange = ExchangeFactory.INSTANCE.createExchange(MtGoxExchange.class.getName());

    // Configure BTC/USD ticker stream for MtGox
    ExchangeStreamingConfiguration btcusdConfiguration =
        new MtGoxStreamingConfiguration(10, 10000, Currencies.BTC, Currencies.USD, false);

    // Interested in the public streaming market data feed (no authentication)
    StreamingExchangeService btcusdStreamingMarketDataService =
        mtGoxExchange.getStreamingExchangeService(btcusdConfiguration);

    // Requesting initial order book using the polling service
    PollingMarketDataService marketDataService = mtGoxExchange.getPollingMarketDataService();
    MarketDataRunnable.book = marketDataService.getPartialOrderBook(Currencies.BTC, Currencies.USD);

    // Open the connections to the exchange
    btcusdStreamingMarketDataService.connect();

    ExecutorService executorService = Executors.newSingleThreadExecutor();
    Future<?> mtGoxMarketDataFuture =
        executorService.submit(new MarketDataRunnable(btcusdStreamingMarketDataService));

    // the thread waits here until the Runnable is done.
    mtGoxMarketDataFuture.get();

    executorService.shutdown();

    // Disconnect and exit
    System.out.println(Thread.currentThread().getName() + ": Disconnecting...");
    btcusdStreamingMarketDataService.disconnect();
  }
Esempio n. 13
0
  public static void main(String[] args) throws InterruptedException, ExecutionException {

    List<Future<String>> futures = new ArrayList<>();
    ExecutorService executor = Executors.newFixedThreadPool(5);
    for (int i = 1000; i <= 1010; i++) {
      futures.add(executor.submit(getTask(i)));
    }

    futures.add(executor.submit(getTask(10000000)));

    for (Future<String> future : futures) {
      System.out.println(future.get());
    }

    executor.shutdown();
    executor.awaitTermination(10, TimeUnit.SECONDS);

    /* output
    500500
    501501
    502503
    503506
    504510
    505515
    506521
    507528
    508536
    509545
    510555
    50000005000000
    */
  }
Esempio n. 14
0
  public static void main(String[] args) {
    Callable<Integer> task =
        () -> {
          try {
            TimeUnit.SECONDS.sleep(1);
            return 123;
          } catch (InterruptedException e) {
            throw new IllegalStateException("task interrupted", e);
          }
        };

    ExecutorService executor = Executors.newFixedThreadPool(1);
    Future<Integer> future = executor.submit(task);
    System.out.println("future done? " + future.isDone());
    Integer result = -1;
    try {
      result = future.get();
    } catch (Exception e) {
      e.printStackTrace();
    }
    System.out.println("future done? " + future.isDone());
    System.out.println("result: " + result);

    stop(executor);
  }
  protected synchronized void initializeQueue(String host, String queueName, Integer port)
      throws InterruptedException {
    final String bind = "tcp://" + host + ":" + port;
    _log.warn("binding to " + bind);
    if (_context == null) {
      _context = ZMQ.context(1);
    }
    if (_socket != null) {
      _executorService.shutdownNow();
      _heartbeatService.shutdownNow();
      Thread.sleep(1 * 1000);
      _log.warn("_executorService.isTerminated=" + _executorService.isTerminated());
      _socket.close();
      _executorService = Executors.newFixedThreadPool(1);
      _heartbeatService = Executors.newFixedThreadPool(1);
    }

    _socket = _context.socket(ZMQ.PUB);
    _socket.connect(bind);
    _executorService.execute(new SendThread(_socket, queueName));
    _heartbeatService.execute(new HeartbeatThread(HEARTBEAT_INTERVAL));

    _log.debug("Inference output queue is sending to " + bind);
    _initialized = true;
  }
Esempio n. 16
0
 @SuppressWarnings("finally")
 public boolean importUsers() {
   BufferedReader reader = null;
   try {
     FileInputStream fileInputStream = new FileInputStream(System.getenv("USERS_PATH"));
     InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, "UTF-8");
     reader = new BufferedReader(inputStreamReader);
     String tempString = null;
     ExecutorService fixedThreadPool = Executors.newFixedThreadPool(100);
     while ((tempString = reader.readLine()) != null) {
       ImportUserThread t = new ImportUserThread(tempString);
       fixedThreadPool.execute(t);
     }
     reader.close();
   } catch (Exception e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
     return false;
   } finally {
     if (reader != null) {
       try {
         reader.close();
       } catch (final IOException e) {
         e.printStackTrace();
         return false;
       }
     }
     return true;
   }
 }
Esempio n. 17
0
  // The method executing the task
  @Override
  public void execute() throws BuildException {

    this.log("Starting PlantUML");

    try {
      if (dir != null) {
        final File error = processingSingleDirectory(new File(dir));
        eventuallyFailfast(error);
      }
      for (FileSet fileSet : filesets) {
        final File error = manageFileSet(fileSet);
        eventuallyFailfast(error);
      }
      for (FileList fileList : filelists) {
        final File error = manageFileList(fileList);
        eventuallyFailfast(error);
      }
      if (executorService != null) {
        executorService.shutdown();
        executorService.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS);
      }
      this.log("Nb images generated: " + nbFiles.get());
    } catch (IOException e) {
      e.printStackTrace();
      throw new BuildException(e.toString());
    } catch (InterruptedException e) {
      e.printStackTrace();
      throw new BuildException(e.toString());
    }
  }
Esempio n. 18
0
  public static void main(String[] args) throws Exception {
    if (args.length < 1) {
      System.out.println("java DownloadWeb <output dir>");
      return;
    }

    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

    ExecutorService exec = Executors.newCachedThreadPool();

    final String dir = args[0];
    String url = null;

    while ((url = reader.readLine()) != null) {

      final URI uri = URI.create(url);
      String fileName = new File(uri.getPath()).getName();
      final Path filePath = Paths.get(dir, fileName);

      exec.submit(
          new Runnable() {
            @Override
            public void run() {
              try (InputStream in = uri.toURL().openStream()) {
                Files.copy(in, filePath, StandardCopyOption.REPLACE_EXISTING);
                System.out.printf("completed: %s => %s\n", uri, filePath);
              } catch (Exception ex) {
                System.out.printf("failed: %s\n", uri);
              }
            }
          });
    }

    exec.shutdown();
  }
  private static ExecutorService startAlertClientService(
      SystemMain system, AtomicInteger jobCounter) {
    int configuredCount =
        Integer.valueOf(
            system.getConfiguration().getValue(SystemConfiguration.Property.CLIENT_THREADS));
    int configuredTimeout =
        Integer.valueOf(
            system
                .getConfiguration()
                .getValue(SystemConfiguration.Property.CLIENT_CONNECT_TIMEOUT));
    int threadPoolCount = Math.max(configuredCount, 2);
    int timeout = Math.max(10000, configuredTimeout);
    ExecutorService service =
        Executors.newFixedThreadPool(
            threadPoolCount,
            new ThreadFactory() {

              AtomicInteger id = new AtomicInteger(0);

              @Override
              public Thread newThread(Runnable r) {
                return new Thread(r, MessageFormat.format("alertclient-{0}", id.getAndIncrement()));
              }
            });
    system.getServiceFactory().getMonitorService().startRecordingCounters();
    for (int i = 0; i < threadPoolCount; i++) {
      service.submit(
          new Alerter(system.getServiceFactory().getAlertService(), timeout, jobCounter));
    }
    return service;
  }
  /** {@inheritDoc} */
  @Override
  public void onApplicationEvent(AgentMappingsUpdateEvent event) {
    Map<Long, AgentCacheEntry> agentCacheMap = nextGenInstrumentationManager.getAgentCacheMap();
    // iterate all caches
    for (AgentCacheEntry agentCacheEntry : agentCacheMap.values()) {
      ConfigurationHolder configurationHolder = agentCacheEntry.getConfigurationHolder();
      Environment cachedEnvironment = configurationHolder.getEnvironment();
      PlatformIdent platformIdent = platformIdentDao.load(agentCacheEntry.getId());
      try {
        // see what 's the new environment for the agent
        Environment environment =
            configurationResolver.getEnvironmentForAgent(
                platformIdent.getDefinedIPs(), platformIdent.getAgentName());

        // fire job only if we have new environment or we were not bounded to any
        // environment
        if ((null == cachedEnvironment)
            || !ObjectUtils.equals(cachedEnvironment.getId(), environment.getId())) {
          EnvironmentMappingUpdateJob mappingUpdateJob = mappingUpdateJobFactory.getObject();
          mappingUpdateJob.setEnvironment(environment);
          mappingUpdateJob.setAgentCacheEntry(agentCacheEntry);

          executor.execute(mappingUpdateJob);
        }
      } catch (BusinessException e) {
        // if we have exception by resolving new environment run job with no new
        // environment
        EnvironmentMappingUpdateJob mappingUpdateJob = mappingUpdateJobFactory.getObject();
        mappingUpdateJob.setAgentCacheEntry(agentCacheEntry);

        executor.execute(mappingUpdateJob);
      }
    }
  }
Esempio n. 21
0
 public static void main(String args[]) {
   Semaphore s = new Semaphore(5);
   NumberServer n = new NumberServer();
   ExecutorService executorService = Executors.newFixedThreadPool(10);
   List<Integer> list = Collections.synchronizedList(new ArrayList<Integer>());
   for (int i = 0; i < 10; i++) {
     try {
       s.acquire();
     } catch (InterruptedException e) {
       // TODO Auto-generated catch block
       e.printStackTrace();
     }
     executorService.execute(
         new Runnable() {
           public void run() {
             list.add(n.getNumber());
             s.release();
           }
         });
   }
   executorService.shutdown();
   try {
     s.acquire(5);
   } catch (InterruptedException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
   }
   for (int i = 0; i < 10; i++) {
     System.out.println(list.get(i));
   }
 }
  public static void main(String[] args)
      throws InterruptedException, ExecutionException, TimeoutException {
    ExecutorService executor = Executors.newFixedThreadPool(5);
    CompletableFuture<String> task1 =
        CompletableFuture.supplyAsync(
            () -> {
              try {
                System.out.println(Thread.currentThread().getName() + ": firstTask");
                TimeUnit.SECONDS.sleep(2);
              } catch (Exception e) {
              }
              return "1";
            });
    CompletableFuture<String> task2 =
        CompletableFuture.supplyAsync(
            () -> {
              try {
                System.out.println(Thread.currentThread().getName() + ": secondTask");
                TimeUnit.SECONDS.sleep(3);
              } catch (Exception e) {
              }
              return "2";
            });
    // a new thread from the supplied executor will execute third task
    task1.acceptEitherAsync(
        task2,
        (x) -> {
          System.out.println(Thread.currentThread().getName() + ": thirdTask " + x);
        },
        executor);

    TimeUnit.SECONDS.sleep(5);
    System.out.println(Thread.currentThread().getName() + ": " + task1.get());
    executor.shutdown();
  }
Esempio n. 23
0
  @Override
  public synchronized void close() throws SQLException {
    try {
      closeLock.writeLock().lock();
      if (closed) {
        return;
      }
      closed = true;
    } finally {
      closeLock.writeLock().unlock();
    }

    try {
      Collection<ConnectionQueryServices> connectionQueryServices =
          connectionQueryServicesMap.values();
      try {
        SQLCloseables.closeAll(connectionQueryServices);
      } finally {
        connectionQueryServices.clear();
      }
    } finally {
      if (services != null) {
        try {
          services.close();
        } finally {
          ExecutorService executor = services.getExecutor();
          // Even if something wrong happened while closing services above, we still
          // want to set it to null. Otherwise, we will end up having a possibly non-working
          // services instance.
          services = null;
          executor.shutdown();
        }
      }
    }
  }
  public void engage() {
    System.out.println("Starting the Disruptor");
    // starts the event processors
    final RingBuffer<DemoEvent> ringBuf = disruptor.start();

    // now we start the publishers
    List<Future<?>> futures = new ArrayList<Future<?>>();
    ExecutorService execService = Executors.newFixedThreadPool(NUM_PUBLISHERS);

    try {
      for (DisruptorDemoPublisher pub : pubs) {
        futures.add(execService.submit(pub));
      }

      // wait for each publisher to finish
      for (Future<?> f : futures) {
        f.get();
      }

      // this should wait until all events are processed
      disruptor.shutdown();

    } catch (Exception e) {
      System.out.println(e.toString());
      e.printStackTrace();

    } finally {
      execService.shutdown();
    }
  }
Esempio n. 25
0
 public final void a() {
   try {
     cm.a()
         .b()
         .a(
             "Crashlytics",
             (new StringBuilder("Executing shutdown hook for ")).append(a).toString());
     b.shutdown();
     if (!b.awaitTermination(c, d)) {
       cm.a()
           .b()
           .a(
               "Crashlytics",
               (new StringBuilder())
                   .append(a)
                   .append(
                       " did not shut down in the allocated time. Requesting immediate shutdown.")
                   .toString());
       b.shutdownNow();
     }
     return;
   } catch (InterruptedException interruptedexception) {
     cm.a()
         .b()
         .a(
             "Crashlytics",
             String.format(
                 Locale.US,
                 "Interrupted while waiting for %s to shut down. Requesting immediate shutdown.",
                 new Object[] {a}));
   }
   b.shutdownNow();
 }
Esempio n. 26
0
  private void multicastJoin(int count, final boolean sleep) throws InterruptedException {
    final TestHazelcastInstanceFactory nodeFactory = createHazelcastInstanceFactory(count);

    final Config config = new Config();
    config.setProperty("hazelcast.wait.seconds.before.join", "5");
    config.getNetworkConfig().getJoin().getMulticastConfig().setMulticastTimeoutSeconds(25);
    final ConcurrentMap<Integer, HazelcastInstance> map =
        new ConcurrentHashMap<Integer, HazelcastInstance>();
    final CountDownLatch latch = new CountDownLatch(count);
    final ExecutorService ex = Executors.newCachedThreadPool();
    for (int i = 0; i < count; i++) {
      final int index = i;
      ex.execute(
          new Runnable() {
            public void run() {
              if (sleep) {
                try {
                  Thread.sleep((int) (1000 * Math.random()));
                } catch (InterruptedException ignored) {
                }
              }
              HazelcastInstance h = nodeFactory.newHazelcastInstance(config);
              map.put(index, h);
              latch.countDown();
            }
          });
    }
    assertOpenEventually(latch);
    for (HazelcastInstance h : map.values()) {
      assertEquals(count, h.getCluster().getMembers().size());
    }
    ex.shutdown();
  }
Esempio n. 27
0
      public void actionPerformed(ActionEvent e) {
        for (int i = 0; i < 4; i++) {
          if (e.getSource() == Answer[i]) {
            // Answer[i].setSelected(false);
            Charge(i);
          }
        }
        if (e.getSource() == Sure) {
          ChargeSpell();
        } else if (e.getSource() == Speak) {
          ExecutorService executorService = Executors.newFixedThreadPool(1);
          executorService.execute(
              new Runnable() {
                public void run() {
                  try {
                    Speak.setEnabled(false);
                    WordTextFile.setText(sound.startRec());
                    Speak.setEnabled(true);
                    System.out.println("done");
                  } catch (Exception e2) {

                  }
                }
              });
          //					Dictionary.takeWordSearch.startSearch();
          executorService.shutdown();
        }
      }
 public void unInit() {
   if (mExecutorService != null) {
     mExecutorService.shutdown();
     mExecutorService.shutdownNow();
     mExecutorService = null;
   }
 }
  @Override
  public synchronized void connect(
      String url, RunnableExchangeEventListener runnableExchangeEventListener) {

    log.info("Connecting...");

    // Validate inputs
    Assert.notNull(runnableExchangeEventListener, "runnableMarketDataListener cannot be null");

    // Validate state
    if (eventExecutorService.isShutdown()) {
      throw new IllegalStateException(
          "Service has been stopped. Create a new one rather than reuse a reference.");
    }

    try {
      log.debug(
          "Attempting to open a socketIO against {}:{}", url, exchangeSpecification.getPort());
      this.runnableExchangeEventProducer = new RunnableSocketIOEventProducer(producerEventQueue);
      this.socketIO =
          new SocketIO(url, (RunnableSocketIOEventProducer) runnableExchangeEventProducer);
    } catch (IOException e) {
      throw new ExchangeException("Failed to open socket!", e);
    }

    // Configure the exchange event listener event queue
    runnableExchangeEventListener.setExchangeEventQueue(producerEventQueue);

    // Submit the event threads to their services
    eventExecutorService.submit(runnableExchangeEventProducer);
    eventExecutorService.submit(runnableExchangeEventListener);

    log.info("Socket connected OK. Check queues for events.");
  }
Esempio n. 30
0
  public void close() {
    if (shuttingDown.getAndSet(true)) {
      return;
    }

    mutex.lock();
    try {
      while (backgroundCompaction != null) {
        backgroundCondition.awaitUninterruptibly();
      }
    } finally {
      mutex.unlock();
    }

    compactionExecutor.shutdown();
    try {
      compactionExecutor.awaitTermination(1, TimeUnit.DAYS);
    } catch (InterruptedException e) {
      Thread.currentThread().interrupt();
    }
    try {
      versions.destroy();
    } catch (IOException ignored) {
    }
    try {
      log.close();
    } catch (IOException ignored) {
    }
    tableCache.close();
    dbLock.release();
  }