धागे

Question

का उपयोग करके एक साथ दो स्वतंत्र कार्यों को चलाना मैंने जावा में धागे पर कई ट्यूटोरियल का अध्ययन किया है लेकिन मैं अपना जवाब नहीं ढूंढ पा रहा हूं।

मेरा प्रश्न है: एक साथ दो स्वतंत्र धागे कैसे चलाएं?

मेरा मामला है: मेरे पास दो कार्य हैं;

1. डेटाबेस
2. के लिए कुछ डेटा को बचाने के एक मोबाइल डिवाइस पर एक पुश सूचना भेजें।

चूंकि ये दो कार्य स्वतंत्र हैं इसलिए मैं उन्हें एक साथ निष्पादित करना चाहता हूं।

मैंने दो थ्रेड के साथ थ्रेड पूल का उपयोग करने की कोशिश की लेकिन समस्या यह है कि डेटाबेस कार्य जल्दी खत्म हो जाते हैं लेकिन पुश अधिसूचना भेजने में कुछ समय लगता है।

परिणामस्वरूप जब एक कार्य समाप्त हो जाता है जबकि दूसरा अभी भी लंबित है, तो यह अपवाद फेंकता है।

इसके अलावा मेरे कोड में कोई समस्या नहीं है क्योंकि यह धागे का उपयोग किए बिना ठीक चलता है।

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

Answer 1

new Thread(new Runnable() { 
    public void run() { 
     System.out.println("Look ma, no hands"); 
    } 
}).start(); 

new Thread(new Runnable() { 
    public void run() { 
     System.out.println("Look at me, look at me..."); 
    } 
}).start(); 

ठीक काम करता है ...

मैं एक ExecutorService व्यक्तिगत रूप से के उपयोग पसंद करेंगे।

ExecutorService उदाहरण के साथ अद्यतन

तो मैं यह वास्तव में त्वरित उदाहरण लिखा था ...

मूल रूप से यह एक ExecutorService का उपयोग करता है सरल कार्य के एक जोड़े को चलाने के लिए। यह खड़ा के रूप में, दोनों कार्य के साथ एक दूसरे को (एक साथ) समानांतर में चलेंगे

public static void main(String[] args) throws InterruptedException { 
    ExecutorService service = Executors.newFixedThreadPool(2); 
    service.submit(new PathScanner()); 
    service.submit(new Counter()); 

    service.shutdown(); 
    service.awaitTermination(1, TimeUnit.DAYS); 

    System.exit(0); 
} 

public static class PathScanner implements Callable<Object> { 

    @Override 
    public Object call() throws Exception { 
     scan(new File("C:/"), 0); 
     return null; 
    } 

    protected void scan(File path, int deepth) { 
     if (deepth < 15) { 
      System.out.println("Scanning " + path + " at a deepth of " + deepth); 

      File[] files = path.listFiles(); 
      for (File file : files) { 
       if (file.isDirectory()) { 
        scan(file, ++deepth); 
       } 
      } 
     } 
    } 
} 

public static class Counter implements Callable<Object> { 

    @Override 
    public Object call() throws Exception { 
     for (int index = 0; index < 1000; index++) { 
      Thread.sleep(1); 
      System.out.println(index); 
     } 
     return null; 
    } 
} 

भागो यह ...

अब ExecutorService service = Executors.newFixedThreadPool(1); करने के लिए ExecutorService service = Executors.newFixedThreadPool(2); बदल सकते हैं और इसे फिर से चलाने। क्या आप अंतर देखते थे?

यह कतार संसाधित करते समय निष्पादक उपयोग कर सकते हैं कि एक साथ थ्रेड की संख्या को नियंत्रित करने का तरीका है।

कुछ और कार्य करें और उन्हें कतार में जोड़ें और देखें कि आपको क्या मिलता है।

Answer 2

मल्टीथ्रेडिंग का उपयोग करके एकाधिक फ़ोल्डर में फ़ाइल खोजने के लिए मेरे पास उपयोग केस था। इनपुट के रूप में, मेरे पास केवल रूट निर्देशिका पथ था और इसमें कोई भी बाल निर्देशिका हो सकती है। धारणा - फ़ाइल हमेशा बाल निर्देशिका में से एक में उपलब्ध होगी।

import java.io.File; 
import java.io.FileFilter; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 

public class SearchFile implements Runnable { 

    private String dirPath = null; 

    public SearchFile() { 

    } 

    public SearchFile(String dirPath) { 
     this.dirPath = dirPath; 
    } 

    public static void main(String[] args) { 
     long startTime = System.currentTimeMillis(); 
     File dir = new File("D://"); 
     checkRootDirectory(dir); 
     long endTime = System.currentTimeMillis(); 
     System.out.println("Time taken: "+(endTime - startTime) + "ms"); 
    } 

    private static void checkRootDirectory(File root) { 
     File[] list = root.listFiles(new FileFilter() { 

      @Override 
      public boolean accept(File pathname) { 
       return pathname.isDirectory() && !pathname.isHidden(); 
      } 
     }); 

     ExecutorService service = Executors.newFixedThreadPool(list.length); 
     for (File directories : list) { 
      String dirPath = directories.getAbsolutePath(); 
      Thread thread = new Thread(new SearchFile(dirPath)); 
      service.execute(thread); 
     } 
     service.shutdown(); 
     while(!service.isTerminated()) { 

     } 
    } 

    @Override 
    public void run() { 
     checkEachDirectory(new File(dirPath), "Temp.txt"); 
    } 

    private void checkEachDirectory(File root, String fileName) { 
     File[] list = root.listFiles(); 
     if (null != list) { 
      for (File dir : list) { 
       if (dir.isDirectory()) { 
        checkEachDirectory(dir, fileName); 
       } else if (fileName.equalsIgnoreCase(dir.getName())) { 
        System.out.println(
          "Thread name: " + Thread.currentThread().getName() + " Founded @" + dir.getAbsolutePath()); 
       } 
      } 
     } 
    } 
}