Ho bisogno di un thread separato per ogni attività in esecuzione, quindi cambiare l'architettura non è un'opzione.
Se che è true (ad esempio, effettuare una chiamata a una funzione di bloccaggio esterno), quindi creare thread separati per loro e iniziare. Non è possibile creare un pool di thread con un numero limitato di thread, poiché una funzione di blocco in uno dei thread impedirà l'inserimento di qualsiasi altro eseguibile e non aumenterà molto la creazione di un pool di thread con un thread per attività.
Ho provato a fare la mia taglia threadpool pari a Runtime.getRuntime(). AvailableProcessors(), che ha tentato di eseguire tutte le 500 le discussioni, ma lasciate solo 8 (4xhyperthreading) di eseguirli.
Quando si passano gli oggetti Thread che si stanno creando al pool di thread, si vede solo che implementano Runnable. Pertanto verrà eseguito ogni Runnable per il completamento. Qualsiasi loop che interrompe il metodo run() non consentirà l'esecuzione della successiva attività in coda; ad esempio:
public static void main (String...args) {
ExecutorService executor = Executors.newFixedThreadPool(2);
for (int i = 0; i < 10; ++i) {
final int task = i;
executor.execute(new Runnable() {
private long lastRunTime = 0;
@Override
public void run() {
for (int iteration = 0; iteration < 4;)
{
if (System.currentTimeMillis() - this.lastRunTime > TIME_OUT)
{
// do your work here
++iteration;
System.out.printf("Task {%d} iteration {%d} thread {%s}.\n", task, iteration, Thread.currentThread());
this.lastRunTime = System.currentTimeMillis();
}
else
{
Thread.yield(); // otherwise, let other threads run
}
}
}
});
}
executor.shutdown();
}
stampe fuori:
Task {0} iteration {1} thread {Thread[pool-1-thread-1,5,main]}.
Task {1} iteration {1} thread {Thread[pool-1-thread-2,5,main]}.
Task {0} iteration {2} thread {Thread[pool-1-thread-1,5,main]}.
Task {1} iteration {2} thread {Thread[pool-1-thread-2,5,main]}.
Task {0} iteration {3} thread {Thread[pool-1-thread-1,5,main]}.
Task {1} iteration {3} thread {Thread[pool-1-thread-2,5,main]}.
Task {0} iteration {4} thread {Thread[pool-1-thread-1,5,main]}.
Task {2} iteration {1} thread {Thread[pool-1-thread-1,5,main]}.
Task {1} iteration {4} thread {Thread[pool-1-thread-2,5,main]}.
Task {3} iteration {1} thread {Thread[pool-1-thread-2,5,main]}.
Task {2} iteration {2} thread {Thread[pool-1-thread-1,5,main]}.
Task {3} iteration {2} thread {Thread[pool-1-thread-2,5,main]}.
Task {2} iteration {3} thread {Thread[pool-1-thread-1,5,main]}.
Task {3} iteration {3} thread {Thread[pool-1-thread-2,5,main]}.
Task {2} iteration {4} thread {Thread[pool-1-thread-1,5,main]}.
...
mostrano che il primo (filo dimensioni della piscina) attività vengono eseguite fino al completamento prima i compiti successivi vengono programmate.
Quello che devi fare è creare attività che vengono eseguite per un po ', quindi lasciare eseguire altre attività. Piuttosto come si struttura questi dipende da ciò che si vuole raggiungere
- se si desidera che tutti i compiti da eseguire, allo stesso tempo, il tutto attendere per un minuto, poi tutti corrono allo stesso tempo nuovo, o se il compiti non sono sincronizzati tra loro
- se si voleva davvero ogni attività per l'esecuzione a un intervallo di un minuto
- se i vostri compiti sono potenzialmente bloccando o no, e così in realtà richiedono thread separati
- quale comportamento è previsto se un blocco di attività più lungo della finestra prevista per l'esecuzione
- quale comportamento ci si aspetta se un blocchi di attività più lunghi rispetto al tasso di ripetizione (blocchi per più di un minuto)
A seconda delle risposte a queste, una combinazione di ScheduledExecutorService, semafori o mutex può essere utilizzato per coordinare i compiti. Il caso più semplice è l'attività non bloccante, non sincrona, nel qual caso utilizzare direttamente ScheduledExecutorService per eseguire i runnables una volta al minuto.
C'è qualche ragione particolare per cui non è possibile eseguirli in sequenza contemporaneamente? Ciò significa che sono in esecuzione contemporaneamente e che raccolgono i risultati al termine. Il problema è che richiederà sempre lo stesso tempo se lo fai con 500 thread o se lo fai con 8 thread. –
Quanto dura un calcolo da solo? Quanto dura un calcolo se viene eseguito entro 500 thread? –
Non mi è chiaro cosa vuoi fare. Perché non provi semplicemente a eseguire tutti i tuoi thread? Qualcosa come: for (int i ....) {((Thread) coreAppVector.elementAt (i)). Start(); } –