Tag: executorservice

Abstract: Habe ich eine Feder @Component verwendet autowired ExecutorService als Arbeit-pool. Ich bin mit JUnit und Mockito zum testen der Funktionalität der Komponente und ich müssen zu verspotten, die Executor Service. Dies wurde trivial für andere autowired

In der JavaDoc für ThreadPoolExecutor ist unklar, ob es akzeptabel ist, fügen Sie die Aufgaben direkt auf die BlockingQueue sichern der Vollstrecker. Die docs sagen aufrufen executor.getQueue() "soll in Erster Linie für debugging und monitoring". Ich Baue

Welche Vorteile gibt es durch die Verwendung Testamentsvollstrecker über nur Threads in einem Java-Programm. Wie ExecutorService pool = Executors.newFixedThreadPool(2); void someMethod() { //Thread new Thread(new SomeRunnable()).start(); //vs //Executor pool.execute(new SomeRunnable()); } Macht ein Testamentsvollstrecker nur beschränken Sie

Bin Programm erstellen, das, basierend auf der Mischung und macht Störung in einer population mit Lösungen Vector. So habe ich eine for loop Stoppt nach einer bestimmten Zeit, die vom Benutzer gegeben. Innerhalb der Schleife, bin nenne

Ich bin mit cached thread pool ExecutorService zu laufen einige asynchrone hintergrund-tasks. Ich habe meine ThreadFactory, die Hände threads zu den ExecutorService (wenn es Sie braucht). Mein Verständnis von der Cache-thread-pool ist, dass, nachdem der thread ist

Ich habe eine web-Anwendung unter Verwendung der Feder(4.2.x) Artefakte spring-webmvc, spring-messaging -, spring-websocket - Habe ich die unten @Freigabe* Anmerkungen in meine Frühlings-config java-Klasse @EnableWebMvc @EnableWebSocketMessageBroker @EnableAsync @EnableMBeanExport WebSocket verwendet für die übertragung von Nachrichten auf browser-clients.

Bin ich mit dem lernen von ExectorService zu pool threads aus und senden Sie Aufgaben. Ich habe ein einfaches Programm unter import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; class Processor implements Runnable { private int id; public Processor(int

Macht die ExecutorService garantieren die Threadsicherheit ? Werde ich senden von Aufträgen aus verschiedenen threads zu dem gleichen ThreadPoolExecutor, muss ich Sie synchronisieren, Zugang zu der Vollstrecker vor der Interaktion/Einreichen von Aufgaben? InformationsquelleAutor leeeroy | 2009-11-09

Ich vorgelegt haben, eine Aufgabe, die Vollzieher und ich brauche es halt nach einiger Zeit (z.B. 5 Minuten). Ich habe versucht zu tun, wie diese: for (Future<?> fut : e.invokeAll(tasks, 300, TimeUnit.SECONDS)) { try { fut.get(); }

Gibt es eine Möglichkeit zur Nutzung von ExecutorService pausieren/fortsetzen einen bestimmten thread? private static ExecutorService threadpool = Executors.newFixedThreadPool(5); Vorstellen, dass ich aufhören will zu dem thread wich wie die id=0 (unter der Annahme, dass zu jedem einer

Wie kann ich überprüfen, ob ein thread ausgeführt wird, in den pool der thread ExecutorService? Hintergrund: Ich möchte die Synchronisation zwischen den threads im Thread-pool, falls es ein flag gesetzt. Also, wenn das flag auf true festgelegt

Habe ich den untenstehenden code-Schnipsel, die gut läuft. Aber das problem ist, es schafft und über 2000 Aufgaben auf die queue executor rechts von der Fledermaus. Muss ich haben überprüft, ob die Aufgaben, die bereits in der

Hier ist mein code-snippet. ExecutorService executor = Executors.newFixedThreadPool(ThreadPoolSize); while(conditionTrue) { ClassImplementingRunnable c = new ClassImplementingRunnable(); executor.submit(c); } Nun, nachdem dies zu tun executor.shutdown(); Was ich erreichen möchte ist hier, dass ich will warten, bis alle threads im

Habe ich den folgenden Java-code: final Future future = exeService.submit( new Runnable() { public void run() { myObject.doSomething(); } } ); future.get(); wo exeService ist eine Instanz von java.util.concurrent.ExecutorService Das problem ist, dass myObject.doSomething() kehrt nie zurück,

Mein code: String torrentFiles = new File("/root/torrents/").list(); if(torrentFiles.length == 0 || torrentFiles == null) { System.exit(0); } ex = Executors.newFixedThreadPool(3); for(String torrentFile : torrentFiles) { ex.submit(new DownloadTorrent("/root/torrents/" + torrentFile)); } ex.shutdown(); try { ex.awaitTermination(30, TimeUnit.MINUTES); } catch(InterruptedException

import java.util.Arrays; import java.util.Iterator; import java.util.List; import java.util.concurrent.Callable; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; class Task implements Callable<String> { public String call() throws Exception { String s = "initial"; try { System.out.println("Started.."); /*for (int i=0;i<10000;i++)

Habe ich ein Szenario, wo ich auf ausführen 5 thread asynchron zum gleichen aufrufbar. Soweit ich das verstehe, gibt es zwei Optionen: 1) mit submit(Callable) ExecutorService executorService = Executors.newFixedThreadPool(5); List<Future<String>> futures = new ArrayList<>(); for(Callable callableItem: myCallableList){

Habe ich ein paar Testamentsvollstrecker Dienstleistungen, die planen lokale Aufgaben wie das Lesen einer Datei, Verbindung zu db etc. Diese Prozesse haben enorme Ausmaß der Protokollierung, die umfangreiche basiert auf der Tatsache, dass es viele threads gleichzeitig

I ' V bekam ConcurrentLinkedDeque, die ich für synchron, push/pop-Elementen, und I ' V bekam einige asynchrone Aufgaben, die sich ein element vom stack und wenn dieses element hat Nachbarn, Es drückt, es zu stapeln. Beispiel-code: private

Ich ausführen müssen eine Reihe von AsyncTasks und dann sammeln Sie alle Ihre Ergebnisse konsolidieren und dann wieder das endgültige Ergebnis für meine user. Ich bin auf der Suche nach einer Möglichkeit zum verwalten mehrerer AsyncTasks in

Angenommen ich habe eine Aufgabe, die das ziehen von Elementen aus einer von java.util.gleichzeitige.BlockingQueue und Verarbeitung. public void scheduleTask(int delay, TimeUnit timeUnit) { scheduledExecutorService.scheduleWithFixedDelay(new Task(queue), 0, delay, timeUnit); } Wie kann ich das planen /umplanen von der

ExecutorService pool=Executors.newFixedThreadPool(7); List<Future<Hotel>> future=new ArrayList<Future<Hotel>>(); List<Callable<Hotel>> callList = new ArrayList<Callable<Hotel>>(); for(int i=0;i<=diff;i++){ String str="2013-"+(liDates.get(i).get(Calendar.MONTH)+1)+"-"+liDates.get(i).get(Calendar.DATE); callList.add(new HotelCheapestFare(str)); } future=pool.invokeAll(callList); for(int i=0;i<=future.size();i++){ System.out.println("name is:"+future.get(i).get().getName()); } Nun möchte ich den pool zu invokeAll alle die Aufgabe bekommen, bevor die for-Schleife,

Ich habe eine grundlegende Frage über, wie ExecutorService funktioniert in Java. Ist es Recht schwer, den Unterschied zu sehen zwischen einfach erstellen Threads Aufgaben parallel und Zuordnung von einzelnen Aufgaben zu den ThreadPool. Den ExecutorService sieht auch

Habe ich umgesehen, aber habe noch keine Antwort gefunden, deshalb wollte ich, um dies zu bestätigen. Sagen, dass ich eine Feste Größe der Faden - pool - ExecutorService pool = Executors.newFixedThreadPool(5); Und ich habe einige code: pool.execute(new

Ich versuche, herauszufinden, wie man richtig mit Java - Vollzieher. Ich merke Einreichen von Aufgaben auf ein ExecutorService hat seinen eigenen overhead. Allerdings bin ich überrascht zu sehen, er ist so hoch wie es ist. Meinem Programm