मैं सीखने के लिए एक ग्राफिकल ब्राउज़र बनाने की कोशिश कर रहा हूं और अभी मैं खोजकर्ता के साथ हूं, लेकिन कुछ समस्याएं उत्पन्न हुई हैं जिन्हें मैं हल करने में असमर्थ हूं।

खोज समाप्त होने की प्रतीक्षा करते समय मुख्य कार्यक्रम फ़्रीज हो जाता है। मैं इसे कैसे ठीक कर सकता था? मैं जो चाहता हूं वह पृष्ठभूमि में खोज के दौरान चलने के लिए मुख्य कार्यक्रम है।

एक और चीज जो मैं पूछना चाहता हूं, मैं एक धागा बना रहा हूं लेकिन यह वास्तव में धीमा है, मैं समानांतर में काम करने वाले कई धागे बनाना चाहता हूं और इसलिए सबकुछ खोजने में कम समय लगता है (लेकिन एक साथ धागे की सीमा के साथ इसलिए यह बहुत अधिक प्रसंस्करण शक्ति को समाप्त नहीं करता है)।

यह वह कोड है जो मेरे पास है

FilenameFilter textoFiltrado = new FilenameFilter() {
 @Override
 public boolean accept(File dir, String name) {
      String lowercaseName = name.toLowerCase();
      return StringUtils.containsIgnoreCase(lowercaseName, nombreBuscado);
  }
};

ArrayList<File> archivos = new ArrayList();
Thread buscar = new Thread(new Runnable() {
@Override
public void run() {
   buscador.setEnabled(false);
   archivos.addAll(u.busqueda(new File(ruta), textoFiltrado, true));
}

});

buscar.start();
buscar.join();

और इस विधि को कहा जा रहा है

public static Collection busqueda(File directory, FilenameFilter filter, boolean recurse) {

Vector files = new Vector();

File[] entries = directory.listFiles();

for (File entry : entries) {

    String s = entry.getName();

    if (s.indexOf(".") > 0) {

        s = s.substring(0, s.lastIndexOf("."));

    }

    if (filter == null || filter.accept(directory, s)) {
        files.add(entry);
    }


    if (recurse && entry.isDirectory()) {
        files.addAll(busqueda(entry, filter, recurse));
    }
}

return files;
}

अग्रिम में धन्यवाद!

0
Seru 7 जून 2018, 22:13

2 जवाब

सबसे बढ़िया उत्तर

आप एक वर्ग बना सकते हैं जो लागू करता है

Callable<Vector<File>>

जैसे कि...

import java.io.File;
import java.util.Vector;
import java.util.concurrent.Callable;

public class ThreadFiles implements Callable<Vector<File>> {

    @Override
    public Vector<File> call() throws Exception {
        File[] files = new File("C:/PathToFiles").listFiles();
        Vector<File> vectorFiles = new Vector<File>();

        for (File file : files) {
            vectorFiles.add(file);
        }
        return vectorFiles; 
    }
}

और फिर उस वर्ग को कॉल करते समय थ्रेड से अपनी फाइलों का मूल्यांकन करें:

import java.io.File;
import java.util.Vector;

public class CallThreadFiles {

    public static void main (String[] args) {

        final ThreadFiles  task = new ThreadFiles();                
        Vector<File> files = null;

        try {
            files = task.call();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        for (File f: files) {
            System.out.println(f.getName());            
        }

    }
}
0
Adam 7 जून 2018, 23:35

यदि आप Java 8 का उपयोग करते हैं तो आप { का उपयोग कर सकते हैं CompletableFuture, Path के स्थान पर File और (समानांतर) Stream जो आप चाहते हैं उसे पूरा करने के लिए। Files कक्षा में एक walk विधि जो फाइलों और सबफ़ोल्डर्स से होकर गुजरेगी।

जब CompletableFuture समाप्त हो जाए तो आप इसके thenAccept यूजर इंटरफेस के अपडेट को चेन करने की विधि। ध्यान रखें कि यह कोड उपयोगकर्ता इंटरफ़ेस थ्रेड पर नहीं है, इसलिए आपको UI थ्रेड पर UI के अपडेट को फिर से शेड्यूल करने की आवश्यकता है। यदि आप JavaFX (जो आपको इम्हो करना चाहिए) का उपयोग करते हैं तो आप ऐसा करते हैं Platform क्लास का इस्तेमाल करके . यदि आप स्विंग से चिपके रहते हैं तो यह SwingUtilities.invokeLater होगा

Path directory = ....;
CompletableFuture.supplyAsync(() -> Files.walk(directory)
                             .parallelStream()
                             .filter(p -> /* your filter condition goes here */)
                             .collect(Collectors.asList()))
                  .thenAccept(l -> Platform.runLater(() -> /* update UI with List<Path>*/);
0
M. le Rutte 7 जून 2018, 23:55