[Java] Threadpool threads hergebruiken

[Crysania]

ik ben bezig een serverprogramma te maken in java, dat een soort requests kan afvangen en uitvoeren, en dit doe ik met behulp van multithreading.

mijn probleem echter is:

de pool werkt, de threads worden na hun run methode goed teruggezet in de pool, en het eruithalen werkt ook. maar als een thread dan voor de 2e keer uit de pool wordt gehaald dan werkt hij de run methode niet meer af.

weet iemand waarom, en hoe ik dit op kan lossen.

ik roep de thread run() methode aan met threadObjectNaam.start()

[Alarmnummer]

[offtopic]
Ik vraag me altijd af hoe handig is om te gaan poolen. De nieuwe vm`s recyclen zelf al objecten, en de vraag is of jij dat beter kan.

[ Voor 3% gewijzigd door Alarmnummer op 13-02-2003 08:46 ]

[Crysania]

Alarmnummer schreef op 13 februari 2003 @ 08:45:
[offtopic]
Ik vraag me altijd af hoe handig is om te gaan poolen. De nieuwe vm`s recyclen zelf al objecten, en de vraag is of jij dat beter kan.

threads creeren kost altijd tijd, tijd die ik wil besparen door te poolen, ik weet niet veel van wat de vm er mee doet, maar als ik ze zelf pool, worden ze zeker hergebruikt en sneller gaat het niet.

[Verwijderd]

Probeer je een Thread voor de 2e keer te starten???

Volgens mijn weten kan dat niet!

[Crysania]

Verwijderd schreef op 13 February 2003 @ 09:18:
Probeer je een Thread voor de 2e keer te starten???

Volgens mijn weten kan dat niet!

weet je ook waarom niet en waar kan ik hier bewijzen van vinden. ik zie toch overal dingen staan over threadpools, en die zouden geen zin hebben dan als je een thread niet 2x kunt gebruiken

[ Voor 6% gewijzigd door Crysania op 13-02-2003 09:27 ]

[DaCoTa]

Ik denk dat je dan met sleep() en interrupt() moet werken. Dit moet dus gebeuren in de run() methode, want zodra deze afgelopen is, is het over met de thread. Het stappenplan: aan het eind van de run() routine zet je een infinite loop met een sleep command in het midden. Dit zet je tevens in een try blok om op de InterruptedException te controlleren. Als je de thread weer wilt gebruiken, roep je interrupt() aan en kun je weer overnieuw beginnen.

[Crysania]

DaCoTa schreef op 13 februari 2003 @ 10:21:
Ik denk dat je dan met sleep() en interrupt() moet werken. Dit moet dus gebeuren in de run() methode, want zodra deze afgelopen is, is het over met de thread. Het stappenplan: aan het eind van de run() routine zet je een infinite loop met een sleep command in het midden. Dit zet je tevens in een try blok om op de InterruptedException te controlleren. Als je de thread weer wilt gebruiken, roep je interrupt() aan en kun je weer overnieuw beginnen.

ik weet dat dit werkt, ik heb deze oplossing ook al eerder gevonden, alleen moet je bij jouw oplossing de infinite loop met een sleep vervangen door een wait(), die doet hetzelfde, maar wacht gewoon tot je een interrupt krijgt. en de interrupt() moet je vervangen door notify() dat is iets netter.

de eigenlijke vraag was waarom ik dan een thread niet 2x mag starten. het zou toch ook moeten kunnen werken, en dat vind ik dan een mooiere oplossing

[ Voor 14% gewijzigd door Crysania op 13-02-2003 10:34 ]

[.oisyn]

THE_CR0SS schreef op 13 februari 2003 @ 10:24:
de eigenlijke vraag was waarom ik dan een thread niet 2x mag starten. het zou toch ook moeten kunnen werken, en dat vind ik dan een mooiere oplossing

dan is je hele optimalisatie weg. De traagheid van het starten van threads zit m niet in het 'new Thread (...)' gebeuren, maar juist in het starten van de thread. Op dat moment alloceert het OS de nodige resources. Dus al zou je een thread voor de 2e keer kunnen starten, dat heeft gewoon simpelweg geen nut

Je moet 'm juist laten lopen, door idd een loop in de run () methode in te bouwen, waar hij wacht op een 'go'. Zoiets zeg maar:

Java:

class PooledThread extends Thread
{
    private Object monitor = new Object ();
    private boolean running = false;
    private Runnable runnable;

    public void startThread (Runnable r)
    {
        runnable = r;
        running = true;
        synchronized (monitor) { monitor.notifyAll (); }
    }

    public void stopThread ()
    {
        running = false;
        synchronized (monitor) { monitor.notifyAll (); }
    }

    public void run ()
    {
        while (true)
        {
            synchronized (monitor) { monitor.wait (); }
            if (!running)
                break;
            runnable.run ();
        }
    }
}

niet getest enzo, gaat meer om het idee

[Crysania]

.oisyn schreef op 13 February 2003 @ 11:09:

[...]


dan is je hele optimalisatie weg. De traagheid van het starten van threads zit m niet in het 'new Thread (...)' gebeuren, maar juist in het starten van de thread. Op dat moment alloceert het OS de nodige resources. Dus al zou je een thread voor de 2e keer kunnen starten, dat heeft gewoon simpelweg geen nut

ow, ok. bedankt voor deze reactie, ik dacht namenlijk dat de traagheid in het aanmaken van de thread zat met new Thread(), en niet in start(), maar nu ga ik het wel op zo'n manier doen, omdat dat toch de enige snelle oplossing is