@Override
public void dispose() {
if (!hasAlreadyShutdown.getAndSet(true) && executorService != null) {
for (final Future<?> job : jobs) {
if (!job.isCancelled() && !job.isDone()) {
job.cancel(true);
}
}
executorService.shutdown(); // Disable new tasks from being submitted
try {
// Wait a while for existing tasks to terminate
if (!executorService.awaitTermination(AWAIT_TERMINATION_TIMEOUT, TimeUnit.SECONDS)) {
executorService.shutdownNow(); // Cancel currently executing tasks
// Wait a while for tasks to respond to being cancelled
if (!executorService.awaitTermination(AWAIT_TERMINATION_TIMEOUT, TimeUnit.SECONDS)) {
LOG.error("Thread pool did not terminate.");
}
}
} catch (InterruptedException ie) {
// (Re-)Cancel if current thread also interrupted
executorService.shutdownNow();
// Preserve interrupt status
Thread.currentThread().interrupt();
}
executorService.shutdown();
}
}
/** Stop the RPC service */
@LogMessageDocs({
@LogMessageDoc(
level = "WARN",
message = "Failed to cleanly shut down RPC server",
explanation = "Could not close all open sockets cleanly"),
@LogMessageDoc(
level = "WARN",
message = "Interrupted while shutting down RPC server",
explanation = "Could not close all open sockets cleanly")
})
public void shutdown() {
shutDown = true;
try {
if (!cg.close().await(5, TimeUnit.SECONDS)) {
logger.warn("Failed to cleanly shut down RPC server");
return;
}
if (clientBootstrap != null) clientBootstrap.releaseExternalResources();
clientBootstrap = null;
if (serverBootstrap != null) serverBootstrap.releaseExternalResources();
serverBootstrap = null;
if (pipelineFactory != null) pipelineFactory.releaseExternalResources();
pipelineFactory = null;
if (bossExecutor != null) bossExecutor.shutdown();
bossExecutor = null;
if (workerExecutor != null) workerExecutor.shutdown();
workerExecutor = null;
} catch (InterruptedException e) {
logger.warn("Interrupted while shutting down RPC server");
}
logger.debug("Internal floodlight RPC shut down");
}
@Override
public BxDocument segmentDocument(BxDocument document) throws AnalysisException {
Map<BxPage, List<Component>> componentMap = new HashMap<BxPage, List<Component>>();
ExecutorService exec = Executors.newFixedThreadPool(PdfNLMContentExtractor.THREADS_NUMBER);
ArrayList<Callable<NumBxPage>> tasks = new ArrayList<Callable<NumBxPage>>();
for (BxPage page : document.getPages()) {
tasks.add(new ComponentCounter(page));
}
List<Future<NumBxPage>> results;
try {
results = exec.invokeAll(tasks);
exec.shutdown();
for (Future<NumBxPage> result : results) {
NumBxPage p = result.get();
componentMap.put(p.page, p.components);
}
} catch (ExecutionException ex) {
throw new AnalysisException("Cannot segment pages!", ex);
} catch (InterruptedException ex) {
throw new AnalysisException("Cannot segment pages!", ex);
}
this.computeDocumentOrientation(componentMap);
BxDocument output = new BxDocument();
BxPage[] pages = new BxPage[document.getPages().size()];
exec = Executors.newFixedThreadPool(PdfNLMContentExtractor.THREADS_NUMBER);
tasks = new ArrayList<Callable<NumBxPage>>();
int i = 0;
for (BxPage page : document.getPages()) {
tasks.add(new SingleSegmenter(page, i++));
}
try {
results = exec.invokeAll(tasks);
exec.shutdown();
for (Future<NumBxPage> result : results) {
NumBxPage p = result.get();
pages[p.index] = p.page;
}
for (BxPage p : pages) {
if (p.getBounds() != null) {
output.addPage(p);
}
}
return output;
} catch (ExecutionException ex) {
throw new AnalysisException("Cannot segment pages!", ex);
} catch (InterruptedException ex) {
throw new AnalysisException("Cannot segment pages!", ex);
}
}
public static void main(String[] args) throws Exception {
Date date = new Date();
inputString = new ArrayList<String>();
ans = new ArrayList();
ans2 = new ArrayList();
if (args.length == 0) {
System.err.println("[-iu] [-t THREAD_COUNT] [-o OUTPUT] [FILES...]");
System.exit(1);
}
try {
readKeys(args);
} catch (Exception e) {
System.err.println("Error in set keys :" + e.getMessage());
System.exit(1);
}
queue = new LinkedBlockingQueue();
service = Executors.newFixedThreadPool(numberThreads);
Sorter sorter[] = new Sorter[numberThreads];
try {
reader(inputString);
} catch (Exception e) {
System.err.println("Error in reader");
System.exit(1);
}
for (int i = 0; i < numberThreads; i++) {
sorter[i] = new Sorter(i);
sorter[i].start();
}
for (int i = 0; i < numberThreads; i++) {
sorter[i].join();
}
service.shutdown();
service.awaitTermination(1, TimeUnit.DAYS);
Merge merge = new Merge(ans2, 0);
merge.run();
merge.join();
service.shutdown();
service.awaitTermination(1, TimeUnit.DAYS);
try {
printAnswer(outputFile);
} catch (Exception e) {
System.err.println("Error in print answer");
System.exit(1);
}
Date date2 = new Date();
System.out.println(date2.getTime() - date.getTime());
}
@Test
public void 用途_ワークキュー() throws Exception {
o.l1("【どういうこと？】").e();
o.l2("キューイングされたタスクを、順にデキューして、順に別のスレッドで実行。").e();
o.l1("【どうすれば？】").e();
o.l2("java.util.concurrent.Executors.newSingleThreadExecutor()ファクトリメソッドを使用。").e();
o.l1("【たとえば？】").e();
o.l2("newSingleThreadExecutor()でワークキューを作成。").e();
o.l3("タスクがRunnableの場合").e();
NameDecorateRunner runTask1 = new NameDecorateRunner("task1", 2);
NameDecorateRunner runTask2 = new NameDecorateRunner("task2", 1);
// executeされたタスクは1つの別スレッドで順々に処理される。
ExecutorService executor = Executors.newSingleThreadExecutor();
// 呼び出し順に処理が行われる
executor.execute(runTask1);
executor.execute(runTask2);
// （ゆるやかな）終了指示
executor.shutdown();
// エグゼキューターの完了を待つ
executor.awaitTermination(10 /* timeout */, TimeUnit.SECONDS);
assertThat(runTask1.name, is("***task1***"));
assertThat(runTask2.name, is("***task2***"));
o.l3("タスクがCallableの場合").e();
NameDecorateCaller callTask1 = new NameDecorateCaller("task1", 2);
NameDecorateCaller callTask2 = new NameDecorateCaller("task2", 1);
executor = Executors.newSingleThreadExecutor();
Future<String> future1 = executor.submit(callTask1);
Future<String> future2 = executor.submit(callTask2);
executor.shutdown();
// 処理の完了を待つ
String result1 = future1.get();
String result2 = future2.get();
assertThat(result1, is("###task1###"));
assertThat(result2, is("###task2###"));
{
/** 【補】invokeAllメソッドとinvokeAnyメソッド */
// あるタスクの集まりの完了を待つことができるメソッド。
// invokeAllメソッドは、タスクをすべて実行し、すべての完了を待つ。
// invokeAnyメソッドは、タスクをすべて実行し、どれか１つでも完了することを待つ。
}
}
@Issue("JENKINS-15816")
@SuppressWarnings({"unchecked", "rawtypes"})
@Test
public void timezoneOfID() throws Exception {
TimeZone origTZ = TimeZone.getDefault();
try {
final Run r;
String id;
TimeZone.setDefault(TimeZone.getTimeZone("America/Chicago"));
ExecutorService svc = Executors.newSingleThreadExecutor();
try {
r =
svc.submit(
new Callable<Run>() {
@Override
public Run call() throws Exception {
return new Run(new StubJob(), 1234567890) {};
}
})
.get();
TimeZone.setDefault(TimeZone.getTimeZone("America/Los_Angeles"));
id = r.getId();
assertEquals(
id,
svc.submit(
new Callable<String>() {
@Override
public String call() throws Exception {
return r.getId();
}
})
.get());
} finally {
svc.shutdown();
}
TimeZone.setDefault(TimeZone.getTimeZone("America/New_York"));
svc = Executors.newSingleThreadExecutor();
try {
assertEquals(id, r.getId());
assertEquals(
id,
svc.submit(
new Callable<String>() {
@Override
public String call() throws Exception {
return r.getId();
}
})
.get());
} finally {
svc.shutdown();
}
} finally {
TimeZone.setDefault(origTZ);
}
}
public static void main(String[] args) {
/////////////////////////////////////////////////////////////////////////////
// FixedThreadPool
/////////////////////////////////////////////////////////////////////////////
{
// 常に10スレッドをプールするExecutorServiceを生成
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);
// タスクを実行
fixedThreadPool.execute(new TestThread());
fixedThreadPool.execute(new TestThread());
// すべてのタスクが終了したらExecutorServiceをシャットダウン
fixedThreadPool.shutdown();
}
/////////////////////////////////////////////////////////////////////////////
// CachedThreadPool
/////////////////////////////////////////////////////////////////////////////
{
// 必要に応じてスレッドのプール数が変化するExecutorServiceを生成
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
// タスクを実行
cachedThreadPool.execute(new TestThread());
cachedThreadPool.execute(new TestThread());
// すべてのタスクが終了したらExecutorServiceをシャットダウン
cachedThreadPool.shutdown();
}
/////////////////////////////////////////////////////////////////////////////
// ScheduledThreadPool
/////////////////////////////////////////////////////////////////////////////
{
// 実行間隔を指定してタスクを実行可能なScheduledExecutorServiceを生成
// （プールするスレッドの最小数は5に指定）
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
// タスクを実行
scheduledThreadPool.schedule(
new Runnable() {
@Override
public void run() {
System.out.println("Executed");
}
},
3,
TimeUnit.SECONDS);
// すべてのタスクが終了したらScheduledExecutorServiceをシャットダウン
scheduledThreadPool.shutdown();
}
}
public boolean shutdown(int timeout) {
requestExecutor.shutdown();
timeoutExecutor.shutdown();
try {
return requestExecutor.awaitTermination(timeout, TimeUnit.SECONDS)
&& timeoutExecutor.awaitTermination(timeout, TimeUnit.SECONDS);
} catch (InterruptedException e) {
return false;
}
}
@Override
public void unregistered(SelectionKey key) {
serverHelperExecutor.shutdown();
storageHelperExecutor.shutdown();
try {
serverHelperExecutor.awaitTermination(5000, TimeUnit.MILLISECONDS);
} catch (InterruptedException ex) {
logger.debug("Executor Termination", ex);
}
logger.info("Server stopped listening at {}", address);
}
@Override
public void dispose() {
myDisposed = true;
cancelAllRequests();
if (myThreadToUse == ThreadToUse.POOLED_THREAD) {
myExecutorService.shutdown();
} else if (myThreadToUse == ThreadToUse.OWN_THREAD) {
myExecutorService.shutdown();
((ThreadPoolExecutor) myExecutorService).getQueue().clear();
}
}
@Override
@After
public void tearDown() throws Exception {
destroy(buffer);
if (controller != null) {
try {
controller.close();
} catch (Exception e) {
// ignored
}
}
executor.shutdown();
pollerExecutor.shutdown();
super.tearDown();
}
@Override
public CompletableFuture<Void> destroy() {
destroyed = true;
executor.shutdown();
backgroundExecutor.shutdown();
communicationExecutor.shutdown();
listeners.clear();
clusterCommunicator.removeSubscriber(updateMessageSubject);
clusterCommunicator.removeSubscriber(updateRequestSubject);
clusterCommunicator.removeSubscriber(antiEntropyAdvertisementSubject);
return CompletableFuture.completedFuture(null);
}
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();
}
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();
}
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();
}
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 stop_() {
synchronized (this) {
isContinue = false;
watchDataThreadPool.shutdown();
submitDataThreadPool.shutdown();
}
}
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 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();
}
}
public String GetKnnAsString(String featureVector) {
// System.err.println(featureVector);
// System.err.println(trainingVectors.size());
FeatureVector fv = new FeatureVector(featureVector, 32);
PriorityBlockingQueue<CategoryDistances> pbq = new PriorityBlockingQueue<>();
ExecutorService pool = Executors.newFixedThreadPool(NumWorkers);
String outp = "";
for (FeatureVector elem : trainingVectors) {
pool.execute(new EuclideanWorker(elem, fv, pbq));
}
pool.shutdown();
while (!pool.isTerminated()) {;
}
for (int i = 0; i < K; i++) {
CategoryDistances cd = pbq.poll();
if (cd == null) {
break;
}
outp += cd.toString() + VectorDelim;
}
// System.out.println(outp);
return outp.substring(0, outp.length() - 1);
}
public void unInit() {
if (mExecutorService != null) {
mExecutorService.shutdown();
mExecutorService.shutdownNow();
mExecutorService = null;
}
}
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();
}
// 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());
}
}
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();
}
}
@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();
}
}
}
}
@Override
public void doTraverse(Poset gPoset) {
DefaultPoset poset = (DefaultPoset) gPoset;
@SuppressWarnings("unchecked")
final Queue<VectorClock> ques[] = new Queue[2];
for (int i = 0; i < 2; ++i) ques[i] = new ConcurrentLinkedQueue<VectorClock>();
ques[0].add(new VectorClock(poset.width(), 0));
final AtomicInteger curQue = new AtomicInteger(0);
final CyclicBarrier barrier = new CyclicBarrier(poolSize, new Tripper(ques, curQue));
final ExecutorService pool = Executors.newFixedThreadPool(poolSize);
for (int i = 0; i < poolSize; ++i) {
pool.submit(new Worker(poset, ques, curQue, barrier, enumerator.fork()));
}
pool.shutdown();
try {
if (!pool.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS)) {
pool.shutdownNow();
if (!pool.awaitTermination(1, TimeUnit.SECONDS))
logger.error("Thread pool did not terminate.");
}
} catch (InterruptedException e) {
pool.shutdownNow();
logger.warn("Thread pool is forced to shutdown.");
}
}
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();
}
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
*/
}
@Override
public String test(FailureDetector failureDetector) throws Exception {
Node node = Iterables.get(failureDetectorConfig.getCluster().getNodes(), 0);
CountDownLatch countDownLatch = new CountDownLatch(1);
Listener listener = new Listener(failureDetectorConfig.getTime());
failureDetector.addFailureDetectorListener(listener);
ExecutorService threadPool = Executors.newFixedThreadPool(11);
for (int i = 0; i < 10; i++)
threadPool.submit(
new NodeAccessorRunnable(failureDetector, node, countDownLatch, null, null, null, 0, 10));
threadPool.submit(new TimedUnavailability(failureDetector, node, countDownLatch));
threadPool.shutdown();
// If we get stuck, we should give the user the opportunity to get a
// thread dump.
if (!threadPool.awaitTermination(60, TimeUnit.SECONDS)) {
System.out.println("Threads appear to be stuck");
threadPool.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS);
}
return Class.forName(failureDetectorConfig.getImplementationClassName()).getSimpleName()
+ ", "
+ listener.getDelta();
}
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();
}