AGB  ·  Datenschutz  ·  Impressum  







Anmelden
Nützliche Links
Registrieren

[Java] Multi-Threading Datei Suche

Ein Thema von Dunedain · begonnen am 6. Mai 2007
Antwort Antwort
Dunedain
(Gast)

n/a Beiträge
 
#1

[Java] Multi-Threading Datei Suche

  Alt 6. Mai 2007, 11:43
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;
    }
   
}
  Mit Zitat antworten Zitat
Themen-Optionen Thema durchsuchen
Thema durchsuchen:

Erweiterte Suche
Ansicht

Forumregeln

Es ist dir nicht erlaubt, neue Themen zu verfassen.
Es ist dir nicht erlaubt, auf Beiträge zu antworten.
Es ist dir nicht erlaubt, Anhänge hochzuladen.
Es ist dir nicht erlaubt, deine Beiträge zu bearbeiten.

BB-Code ist an.
Smileys sind an.
[IMG] Code ist an.
HTML-Code ist aus.
Trackbacks are an
Pingbacks are an
Refbacks are aus

Gehe zu:

Impressum · AGB · Datenschutz · Nach oben
Alle Zeitangaben in WEZ +1. Es ist jetzt 21:38 Uhr.
Powered by vBulletin® Copyright ©2000 - 2024, Jelsoft Enterprises Ltd.
LinkBacks Enabled by vBSEO © 2011, Crawlability, Inc.
Delphi-PRAXiS (c) 2002 - 2023 by Daniel R. Wolf, 2024 by Thomas Breitkreuz