Hallo,
habe mal, um den Umgang mit Threads zu lernen, versucht, eine Multi Threading Dateisuche zu schreiben.
Der Informationsaustausch läuft über eine BlockedQueue, in welche die zu durchsuchenden Verzeichnisse (durch die Threads) eingetragen werden.
1. Benutzer legt das Suchverzeichnis und die Suchmaske fest
2. Threads werden erstellt und beginnen, die in der Queue definierten Verzeichnisse zu durchsuchen und mit dem Filter abzugleichen.
3. Falls ein Thread ein Verzeichnis findet, trägt er dieses in die Queue ein.
4. Ist das Verzeichnis vollständig analysiert worden, holt sich der Thread, sofern vorhanden, dass nächste Verzeichnis aus der Queue, sonst wartet er auf neue Verzeichnisse.
5. PROBLEM: Wie stelle ich fest, wann die Suche abgeschlossen ist (Ist ja eigentlich der Fall, wenn ALLE Threads am warten sind...?). Habs mit nem Zähler versucht, welcher in der Queue für jeden wartenden Thread incrementiert und für jedes entfernte Verzeichnis wieder decrementiert wird. Hat aber nicht funktioniert...
6. FEHLER: Das Ergebnis der Suche ist unvollständig. In einem TestCase habe ich meine OS Partition durchsucht (ca 23000) Dateien, die Suche findet aber maximal 3000 Elemente. Außerdem variiert die Anzahl der gefundenen Dateien erheblich zwischen 15 und den angesprochenen 3000 (immer noch die OS Partition). (Möglicherweise ein Synchronisationsproblem???)
btw. es treten keine Exceptions auf...
Und nun ein bischen QT
Die Benutzerschnittstelle:
Die Queue
Und der Thread
habe mal, um den Umgang mit Threads zu lernen, versucht, eine Multi Threading Dateisuche zu schreiben.
Der Informationsaustausch läuft über eine BlockedQueue, in welche die zu durchsuchenden Verzeichnisse (durch die Threads) eingetragen werden.
1. Benutzer legt das Suchverzeichnis und die Suchmaske fest
2. Threads werden erstellt und beginnen, die in der Queue definierten Verzeichnisse zu durchsuchen und mit dem Filter abzugleichen.
3. Falls ein Thread ein Verzeichnis findet, trägt er dieses in die Queue ein.
4. Ist das Verzeichnis vollständig analysiert worden, holt sich der Thread, sofern vorhanden, dass nächste Verzeichnis aus der Queue, sonst wartet er auf neue Verzeichnisse.
5. PROBLEM: Wie stelle ich fest, wann die Suche abgeschlossen ist (Ist ja eigentlich der Fall, wenn ALLE Threads am warten sind...?). Habs mit nem Zähler versucht, welcher in der Queue für jeden wartenden Thread incrementiert und für jedes entfernte Verzeichnis wieder decrementiert wird. Hat aber nicht funktioniert...
6. FEHLER: Das Ergebnis der Suche ist unvollständig. In einem TestCase habe ich meine OS Partition durchsucht (ca 23000) Dateien, die Suche findet aber maximal 3000 Elemente. Außerdem variiert die Anzahl der gefundenen Dateien erheblich zwischen 15 und den angesprochenen 3000 (immer noch die OS Partition). (Möglicherweise ein Synchronisationsproblem???)
btw. es treten keine Exceptions auf...
Und nun ein bischen QT
Die Benutzerschnittstelle:
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);
}
// Versuch, das Ende der Suche herauszufinden...
// 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;
}
}Die Queue
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;
}
}Und der Thread
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;
}
}
