Thread Pool

Jeg får samme problem med den kode.

Jeg tror ikke at den er for god den kode.

Den bruger bl.a. finalizer til at interrupte trådene med.

Jeg lavede en ny metode udfra finalizeren:

public void stopAll() 
{
  done.reset();
  for (int i=0;i<threads.length;i++) {
  threads[i].interrupt();
  done.workerBegin();
  }
  done.waitDone();
}
}

og når jeg kalder den så afsluttes programmet.

Men jeg tror at den thread pool kan laves bedre.

Ja det virker med din stopAll. Det er altså threads[i].destroy(); det får den til at hænge?
Har du et eksempel på en bedre pool ?

Nej - den hænger fordi finalizeren aldrig bliver kaldt.

Jeg har fjernet threads destroy fordi det giver en exception.

De har samme problem men en anden løsning her:

http://www.informit.com/discussion/index.asp?postid=9f51a750-0190-4e67-bc05-fb3124d17185#9f51a750-0190-4e67-bc05-fb3124d17185

Der er en anden implementation her:
  http://www-106.ibm.com/developerworks/library/j-jtp0730.html
men den terminerer heller ikke (dette er dog per design).

Men jeg tror da hurtigt at jeg kunne lave en simpel thread pool som er nem
at få til at terminere.

Skal jeg ?

Kunne man bygge et flag ind i den og så hejse det når alle tråde var færdige ?

Meget gerne, ellers leger jeg lidt med den du postede, tror også godt jeg kan få den til at terminere, hvis ikke du gider. Den virker meget simplere

import java.util.LinkedList;

public class ThreadPool {
    private LinkedList queue;
    private ThreadWorker[] t;
    public ThreadPool(int nthreads) {
        queue = new LinkedList();
        t = new ThreadWorker[nthreads];
        for (int i = 0; i < t.length; i++) {
            t[i] = new ThreadWorker(queue);
            t[i].start();
        }
    }
    public void addTask(Runnable r) {
        synchronized (queue) {
            queue.add(r);
            queue.notify();
        }
    }
    public void stop() {
        for (int i = 0; i < t.length; i++) {
            t[i].finish();
        }
        for (int i = 0; i < t.length; i++) {
            try {
                t[i].join();
            } catch (InterruptedException e) {
                // should never happend
            }
        }
    }
    public int queueSize() {
        int n;
        synchronized(queue) {
            n = queue.size();
        }
        return n;
    }
}

class ThreadWorker extends Thread {
    private LinkedList queue;
    private boolean done;
    public ThreadWorker(LinkedList queue) {
        this.queue = queue;
        done = false;
    }
    public void run() {
        while (!done) {
            Runnable r = null;
            synchronized (queue) {
                if (queue.size() == 0) {
                    try {
                        queue.wait(10000);
                    } catch (InterruptedException e) {
                        // should never happend
                    }
                }
                if(queue.size() > 0) {
                    r = (Runnable) queue.removeFirst();
                }
            }
            if (r != null) {
                try {
                    r.run();
                } catch (RuntimeException e) {
                    // do not stop
                }
            }
        }
    }
    public void finish() {
        done = true;
    }
}

public class TestThreadPool {
    public static void main(String[] args) throws Exception {
        ThreadPool tp = new ThreadPool(1000);
        int[] a = new int[100000];
        for(int i = 0; i < a.length; i++) {
            tp.addTask(new Test(a, i));
        }
        while(tp.queueSize() > 0) {
            System.out.println(tp.queueSize());
            Thread.sleep(5000);
        }
        tp.stop();
        for(int i = 0; i < a.length; i++) {
            if(a[i] != i) {
                System.out.println("Error in task " + i);
            }
        }
       
    }
}

class Test implements Runnable {
    private int[] a;
    private int ix;
    public Test(int[] a, int ix) {
        this.a = a;
        this.ix = ix;
    }
    public void run() {
        try {
            Thread.sleep((int)(1000*Math.random()));
        } catch (InterruptedException e) {
        }
        a[ix] = ix;
    }
}

Det var det bedste jeg lige kunne finde på en søndag eftermiddag.

og et svar

Smukt .. hvordan er LinkedList i forhold til et HashMap, har det nogen performance forskel ?

Umiddelbart synes jeg ikke at HashMap egner sig til at lave en kø i.

Ok, mange tak.