使用線程同時運行兩個獨立的任務

Question

我已經研究了很多關於java中的線程的教程，但我無法找到我的答案。

我的問題是：如何同時運行兩個獨立的線程？

我的情況是：我有兩個任務;

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(2);到ExecutorService service = Executors.newFixedThreadPool(1);並重新運行。你有沒有看到差異？

這是控制執行程序在處理隊列時可以使用的同時線程數的方法。

組成一些更多的任務，並將它們添加到隊列中，看看你得到了什麼。

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()); 
       } 
      } 
     } 
    } 
}