Fil de Java simple file d'attente

Je suis en train de créer une simple file d'attente avec le Fil de Java qui permettrait une boucle, dire d'une boucle for avec 10 itérations, l'itération n (< 10) les threads à la fois et attendre jusqu'à ce que ces fils sont terminé avant de continuer à itérer.

Voici une meilleure façon d'illustrer mon problème:

for (int i = 1; i <= 10; i++) {
    new Thread ( do_some_work() );

    if ( no_available_threads ) {
        wait_until_available_threads();
    }
}

do_some_work() {
    //do something that takes a long time
}

Fondamentalement, ce que je veux faire une copie de ce: Fil et la File d'attente

Comment puis-je les obtenir, c'est la plus indolore?

docs.oracle.com/javase/7/docs/api/java/util/concurrent/... seront parfaites pour de tels travaux

OriginalL'auteur ioni | 2012-03-28

  1. 11

    Je voudrais utiliser le Java 5 Exécuteurs au lieu de rouler votre propre. Quelque chose comme ce qui suit:

    ExecutorService service = Executors.newFixedThreadPool(10);
//now submit our jobs
service.submit(new Runnable() {
    public void run() {
        do_some_work();
    }
});
//you can submit any number of jobs and the 10 threads will work on them
//in order
...
//when no more to submit, call shutdown
service.shutdown();
//now wait for the jobs to finish
service.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);

    OriginalL'auteur Gray

  2. 2

    Utiliser les Exécuteurs testamentaires, comme recommandé par les autres. Toutefois, si vous voulez le plaisir de faire vous-même, essayez quelque chose comme ça. (Prendre soin. Je l'ai écrit dans le bloc-notes et il y a quelques Exceptions, vous aurez besoin de les attraper, même si j'ai réussi à tout autre droit. Le bloc-notes pauvres à la capture des erreurs de codage.) Ce n'est plus un concept qu'une réelle solution à quoi que ce soit, mais l'idée pourrait être généralement utile.

    private ConcurrentLinkedQueue<MyThread>  tQueue =
             new ConcurrentLinkedQueue<MyThread>();

class MyThread  extends Thread  {
    public Runnable  doSomething;

    public void run()  {
        //Do the real work.
        doSomething();
        //Clean up and make MyThread available again.
        tQueue.add( mythread );
        //Might be able to avoid this synch with clever code.
        //(Don't synch if you know no one's waiting.)
        //(But do that later.  Much later.)
        synchronized (tQueue)  {
            //Tell them the queue is no longer empty.
            tQueue.notifyAll();
        }
    }
}

    Ailleurs:

    //Put ten MyThreads in tQueue.
for (int i = 0; i < 10; i++)  tQueue.add( new MyThread() );

//Main Loop.  Runs ten threads endlessly.
for (;;)  {
    MyThread  t = tQueue.poll();
    if (t == null)  {
        //Queue empty.  Sleep till someone tells us it's not.
        do  {
            //There's a try-catch combo missing here.
            synchonized( tQueue )  { tQueue.wait() };
            t = tQueue.poll();
        }  while (t == null)  break;  //Watch for fake alert!
    }
    t.doSomething = do_some_work;
    t.start();
}

    Notez également l'utilisation intelligente de ConcurrentLinkedQueue. Vous pouvez utiliser quelque chose comme ArrayList ou LinkedList, mais vous auriez besoin de les synchroniser.

    Sine vous utilisez ConcurrentLinkedQueue, pourquoi êtes-vous de la synchronisation?

    OriginalL'auteur RalphChapin

  3. 0

    voir java.util.concurrent et surtout les Exécuteurs testamentaires et les ExecutorService

    OriginalL'auteur ControlAltDel

  4. 0

    Caisse Logger.class :

    public class Logger extends Thread {
    List<String> queue = new ArrayList<String>();
    private final int MAX_QUEUE_SIZE = 20;
    private final int MAX_THREAD_COUNT = 10;

    @Override
    public void start() {
        super.start();
        Runnable task = new Runnable() {
            @Override
            public void run() {
                while (true) {
                    String message = pullMessage();
                    Log.d(Thread.currentThread().getName(), message);
                    //Do another processing
                }
            }
        };
        //Create a Group of Threads for processing
        for (int i = 0; i < MAX_THREAD_COUNT; i++) {
            new Thread(task).start();
        }
    }

    //Pulls a message from the queue
    //Only returns when a new message is retrieves
    //from the queue.
    private synchronized String pullMessage() {
        while (queue.isEmpty()) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
        return queue.remove(0);
    }

    //Push a new message to the tail of the queue if
    //the queue has available positions
    public synchronized void pushMessage(String logMsg) {
        if (queue.size() < MAX_QUEUE_SIZE) {
            queue.add(logMsg);
            notifyAll();
        }

    }
}

    Puis insérez-soufflet de code dans votre classe principale :

    Logger logger =new Logger();
logger.start();
for ( int i=0; i< 10 ; i++) {
    logger.pushMessage(" DATE : "+"Log Message #"+i);
}

    OriginalL'auteur