[Java] Multi-Threading Datei Suche

[Dunedain]

Hallo,
wollte zur Übung mit Threads mal ne Multi-Threading Dateisuche in Java schreiben. Was in der Theorie eigentlich gar nicht so schwer war/ist, raubt mir in der Praxis den letzten Nerv...

Theorie:
Die "Übung" besteht aus 3 Klassen

• DirectoryScanner, welcher die Schnittstelle zum Benutzer darstellt
• DirectoryQueue, welche die zu durchsuchenden Verzeichnisse aufnimmt
• DirectoryThread, welcher sich die Verzeichnisse aus der Queue nimmt, durchsucht und gegebenenfalls auch weitere zu durchsuchende Verzeichnisse hinzufügt

Praxis:
Es läuft (nicht so richtig...), aber leider kriege ich für das Durchsuchen meiner Systempartition immer wieder andere Ergebnisse. D.h. Die Anzahl der gefundenen Dateien variiert erheblich zwischen 15 und 3000, wobei selbst 3000 nicht im entferntesten an die Realität heranreicht (Die Windows Suche findet 22780 Dateien) ...

Fragen:
Wie stelle ich am besten fest, wann die Suche abgeschlossen ist?
Ist die Kontroll-Schleife in DirectoryScanner.startSearch der richtige Weg?
Oder wäre es möglich, die startSearch sofort zu verlassen (ja, das ist möglich ) und dann später, auf welche Art auch immer, einen boolschen Wert im DirectoryScanner zu aktualisieren, wenn die Suche abgeschlossen ist (Dieser Wert könnte von außen periodisch geprüft werden, ist warscheinlich die bessere Variante, da man während des suchens eine Progressbar(indeterminate) zur Visualisierung verwenden könnte, so lange die Suche aktiv ist)


QT Kommentare sind seit meinen letzten Versuchen leider nicht mehr auf dem aktuellesten Stand, aber ich denke, das sollte dem Verständnis nicht im Wege stehen...



Hat vielleicht jemand ne Idee, wo sich der Fehlerteufel rumtreibt, oder, was warscheinlicher ist , wo mein Fehler liegt?



Zum Abschluss noch ein "bischen" QT:
[DirectoryScanner]

Code:

package net.aragorn.nio;

import java.io.File;
import java.io.FileFilter;
import java.util.ArrayList;
import java.util.Queue;

/**
 *
 * @author Aragorn
 */
public class DirectoryScanner
{
    
/* ========================================================================== *
 *                               Konstanten
 * ========================================================================== */
    
    /** Minimale Worker-Thread Anzahl */
    public static final int MIN_THREADS =  2;
    
    /** Maximale Worker-Thread Anzahl */
    public static final int MAX_THREADS = 10;
    
    
/* ========================================================================== *
 *                                Attribute
 * ========================================================================== */
    
    /** Gruppiert alle Such-Threads in einer eigenen Thread Gruppe*/
    private ThreadGroup SearchGroup;
    
    /** Anzahl aktiver Threads zu Beginn der Suche */
    private int InitiationThreadCount;
    
    /** Anzahl der Worker-Threads */
    private int ThreadCount;
    
    
/* ========================================================================== *
 *                               Konstruktor
 * ========================================================================== */
    
    
    /**
     * Erstellt einen neuen DirectoryScanner und speichert die übergebenen
     * Parameter für die Suche
     * @param ThreadCount Die Anzahl der Worker Threads
     */
    public DirectoryScanner (
            int ThreadCount )
    {
        
        setThreadCount ( ThreadCount );        
        
        SearchGroup = new ThreadGroup ( "DirectoryScanner" );
        
    }
    
    
/* ========================================================================== *
 *                          Worker/Schnittstellen
 * ========================================================================== */
    
    
    /**
     * Startet die Suche. Erstellt die zuvor definierte Anzahl an Worker-Threads
     * und beginnt damit, die Aufgabenliste abzuarbeiten.


     * Die Funktion kehrt erst nach abgeschlossener Suche zurück
     * @param Filter Der Datei Filter
     */
    public void startSearch (
            DirectoryQueue Queue,
            FileFilter Filter )
    {
        
        InitiationThreadCount = SearchGroup.activeCount ();
        
        
        for( int i = 0 ; i < ThreadCount ; i = i + 1 )
        {
            new DirectoryThread (SearchGroup,"Thread-"+i,Queue,Filter);
        }
        
        
        while( InitiationThreadCount != SearchGroup.activeCount () )
            ;
        
    }    
    
/* ========================================================================== *
 *                            Accessor/Modifier
 * ========================================================================== */
    
    
    public void setThreadCount (int WorkerThreadCount)
    {
        
        if( WorkerThreadCount < MIN_THREADS )
            WorkerThreadCount = MIN_THREADS;
        else if( WorkerThreadCount > MAX_THREADS )
            WorkerThreadCount = MAX_THREADS;
        
        this.ThreadCount = WorkerThreadCount;
        
    }
    
}

[DirectoryThread]

Code:

package net.aragorn.nio;

import java.io.File;
import java.io.FileFilter;
import java.util.ArrayList;

/**
 *
 * @author Aragorn
 */
public class DirectoryThread
        extends Thread
{
    
/* ========================================================================== *
 *                                Attribute
 * ========================================================================== */
    
    /** Die zu bearbeitende Queue */
    private DirectoryQueue Queue;
    
    /** Das interne Ergebnisfeld */
    private ArrayList<File> InternalResult;
    
    /** Filter zum Dateivergleich */
    private FileFilter Filter;
    
    
/* ========================================================================== *
 *                               Konstruktor
 * ========================================================================== */
    
    /**
     * Erstellt einen neuen Thread in der Gruppe [b]Group[/b] mit dem Namen
     * [b]Name[/b] und übergibt ihm die Aufgabenliste
     * @param Group Die Threadgroup, welcher der Thread zugeordnet werden soll
     * @param Name Der Name des Threads
     * @param Queue Die abzuarbeitende Aufgabenliste
     */
    public DirectoryThread (
            ThreadGroup Group,
            String Name,
            DirectoryQueue Queue,
            FileFilter Filter )
    {
        
        /** Thread initialisieren */
        super ( Group, Name );        
        
        
        /** Queue speichern (!Referenz) */
        setQueue ( Queue );
        setFilter ( Filter );
        
        /** Listen Speicher anfordern */
        InternalResult = new ArrayList<File> ( 50 );
        
                
        start ();
        
    }
    
    
/* ========================================================================== *
 *                          Worker/Schnittstellen
 * ========================================================================== */
    
    public void run ()
    {
        
        /** Deklaration */
        File Dir;
        File Content[];
        
        
        /** ...wegen getWork () */
        try
        {
            
// // // // // // // // // // // // // // // // // // // // // // // // // // //
            
            /** Thread Endlosschleife */
            while( true )
            {
                
                /** Zu durchsuchendes Verzeichnis holen */
                Dir = Queue.nextDirectory ();
                
                /** Queue wurde terminiert */
                if( Dir == Queue.QUEUE_DELEMITER )
                    break;
                
                
                /** Verzeichnis durchsuchen */
                Content = Dir.listFiles ( Filter );
                
                /** Prüfen, ob die Suche erfolgreich war */
                if( Content == null || Content.length < 1 )
                    break;
                
                
                /** Gefundene Dateien weiterverarbeiten */
                for( int i = 0 ; i < Content.length ; i = i + 1 )
                {
                    
                    if( Content[ i ].isDirectory () )
                    {
                        Queue.addDirectory ( Content[ i ] );
                    }
                    else
                    {
                        InternalResult.add ( Content[ i ] );
                    }
                    
                }
                
                
                /**
                 * Sucheergebnis dieser Session in das Gesamtergebnis kopieren.
                 * Danach das interne Suchergebnis zurücksetzten
                 */
                Queue.mergeResult ( InternalResult );
                InternalResult.clear ();
                
            }
            
// // // // // // // // // // // // // // // // // // // // // // // // // // //
            
        }
        catch( InterruptedException ex )
        {
            
            ex.printStackTrace ();
            
        }
        
    }
    
    
/* ========================================================================== *
 *                            Accessor/Modifier
 * ========================================================================== */
    
    public DirectoryQueue getQueue ()
    {
        return Queue;
    }
    
    public void setQueue (DirectoryQueue Queue)
    {
        this.Queue = Queue;
    }

    public FileFilter getFilter ()
    {
        return Filter;
    }

    public void setFilter (FileFilter Filter)
    {
        this.Filter = Filter;
    }
    
    
}

[DirectoryQueue]

Code:

package net.aragorn.nio;

import java.io.File;
import java.util.ArrayList;
import java.util.LinkedList;

/**
 *
 * @author Aragorn
 */
public class DirectoryQueue
{
    
/* ========================================================================== *
 *                               Konstanten
 * ========================================================================== */
    
    public static final File QUEUE_DELEMITER = new File ( "://queueeueuq\\:" );
    
    
/* ========================================================================== *
 *                                Attribute
 * ========================================================================== */
    
    /**
     * Enthält alle noch zu durchsuchenden Verzeichnisse
     */
    private LinkedList<File> Queue;
    
    /**
     * Enthält alle mit dem Filter übereinstimmenden Dateien
     */
    private ArrayList<File> Result;
    
    
/* ========================================================================== *
 *                               Konstruktor
 * ========================================================================== */
    
    /**
     * <u>Konstruktor</u>
     * Erstellt und initialisiert eine DirectoryQueue
     * @param ThreadCount Die Anzahl der Threads, welche die Queue bearbeiten
     */
    public DirectoryQueue ()
    {
        
        Queue  = new LinkedList<File> ();
        Result = new ArrayList<File> ( 50 );
        
    }
    
    
/* ========================================================================== *
 *                          Worker/Schnittstellen
 * ========================================================================== */
    
    /**
     * Hängt einen neuen Arbeitsauftrag an die Queue an. Es wird ein wartender
     * Thread über "neue" Arbeit informiert.
     * @param Directory Das hinzuzufügende Verzeichnis, welches durchsucht werden
     * soll
     */
    public synchronized void addDirectory (
            File Directory )
    {
        
        /** Verzeichnis in die Queue eintragen */
        Queue.add ( Directory );
        
        /** Einen wartenden Thread benachrichtigen */
        notify ();
        
    }
    
    
    /**
     * Hängt das ENDE Flag an die Queue an. Es werden ALLE wartenden Threads
     * informiert.
     */
    public synchronized void terminateQueue ()
    {
        
        /** Ende Flag in die Queue eintragen */
        Queue.add ( QUEUE_DELEMITER );
        
        /** Alle wartenden Threads informieren */
        notifyAll ();
        
    }
    
    
    /**
     * Holt den nächsten Arbeitsauftrag aus der Queue. Falls die Queue leer
     * sein sollte, wartet der Thread auf das "eintreffen" eines neuen Arbeits-
     * auftrages
     * @return Das zu durchsuchende Verzeichnis
     */
    public synchronized File nextDirectory ()
    throws InterruptedException
    {
        
        /** Falls die Queue leer ist, auf neue Aufgaben warten */
        while( Queue.isEmpty () )
        {
            wait ();
        }
        
        /**
         * Prüfen, ob das nächste Element das Ende Flag ist. Dieses darf NICHT
         * entfernt werden.
         */
        if( Queue.getFirst ().equals ( DirectoryQueue.QUEUE_DELEMITER ) )
            return DirectoryQueue.QUEUE_DELEMITER;
        else
            return Queue.removeFirst ();
        
    }
    
    
//    /**
//     * Hängt den übergebenen Parameter an die Ergebnisliste an
//     * @param Name Der einzufügende Name
//     */
//    public synchronized void mergeResult (
//            File Name )
//    {
//        
//        getResult ().add ( Name );
//        
//    }
    
    
    /**
     * Hängt die übergebene Liste an die Ergebnisliste an.
     * @param List Die anzuhängende Teilliste
     */
    public synchronized void mergeResult (
            ArrayList<File> List )
    {
        
        getResult ().addAll ( List );
        
    }
    
    
/* ========================================================================== *
 *                            Accessor/Modifier
 * ========================================================================== */
    
    public ArrayList<File> getResult ()
    {
        return Result;
    }
    
}