Java中線程的終止條件

Question

我編寫了一個多線程Java應用程序，該應用程序從目錄中讀取了一堆.jar文件。 該應用程序產生多個線程，每個線程讀取一堆jar文件。 我在確定此應用程序的停止條件時遇到麻煩。 如何識別所有文件已被讀取？

以下是一個片段函數，該片段函數從每個線程的run（）方法中調用。

    import java.io.*;
import java.util.Enumeration;
import java.util.jar.*;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipException;
import java.io.FilenameFilter;

public class ArchiveFileTest implements Runnable {
     private static boolean stopAll = false;
     private static int threadNumber = 0;
     private int myNumber = 0;

     public ArchiveFileTest () {
            myNumber = threadNumber;
            threadNumber++;
     }

     public static boolean setStopAll () {
            return setStopAll(true);
     }

     public static boolean setStopAll (boolean b) {
            stopAll = b;
            return stopAll;
     }

     public static String[] listFiles (File parentDir,final String ext1,final String ext2,final String ext3,final String ext4) {
            String allFiles[] = parentDir.list(new FilenameFilter() { 
                 public boolean accept(File pDir, String fName) {
                        if (fName.endsWith("."+ext1) || fName.endsWith("."+ext2) || fName.endsWith("."+ext3) || fName.endsWith("."+ext4)) return true;
                        else return false;
                 }
            });
            for (int i=0; i<allFiles.length; i++)
                 allFiles[i] = parentDir.getAbsolutePath() + File.separator +  allFiles[i];
            return allFiles;
     }

     public ZipFile getMyZipFile (File parentDir) {
            String fn[] = listFiles(parentDir, "jar", "zip", "war", "rar");
            int fileNum = myNumber % fn.length;
            ZipFile zFile = null;
            for (int i=0; i<fn.length; i++) {
                 String jFile = fn[(fileNum + i)%fn.length];
                 try {
                        zFile = new ZipFile(jFile);
                        break;
                 } catch  (IOException e) {
                     setStopAll();
                 }
            }
            return zFile;
     }

     public void doStuff() throws Exception {
            File dName = new File("/home/sqatest/chander/sample-files");
          final int N_TIMES = 15;
            final int N_FILES = 500;
          int counter = 0;
            int fCount  = 0;
            if (!dName.isDirectory() || !dName.exists()) {
                 System.err.println("The parent directory given should point to an existing directory...");
                 setStopAll();
                 return;
            }
          while (counter < N_TIMES) { 
                 ZipFile zipFile = getMyZipFile(dName);
                 if (zipFile == null) {
                        System.err.println("No zip file entry for the Thread-" + myNumber);
                        break;
                 }
                 try {
                        Enumeration <? extends ZipEntry> zipEntries = zipFile.entries(); 
                        fCount = 0;
                        ZipEntry ze = null;
                        while (zipEntries.hasMoreElements()) {
                             ze = zipEntries.nextElement();

                             if (ze.isDirectory()) continue; // if it is a directory go to next entry

                             InputStream is = zipFile.getInputStream(ze); 
                             fCount++;
                             int readCount = 0;
                             try {
                                    while(is.read((new byte[50])) != -1 && readCount != 200) readCount++;
                                    System.out.println("Successfully Read " + zipFile.toString());

                                    //is.close();
                             } catch (IOException e) {
                                    e.printStackTrace();
                             }
                             if (fCount == N_FILES) break;  // read maximum of N_FILES
                        }
                        if (stopAll) break;
                 } catch (Exception e) {
                     e.printStackTrace();
                 } finally {
                        counter++; 
                 }
          } 
     }

     public void run () {
            try {
                 doStuff();
            } catch (IOException e) {
                 e.printStackTrace();
                 setStopAll();
            } catch (Exception e) {
                 e.printStackTrace();
            }
     }

     public static void main (String[] args) throws Exception { 
          final int MAX_THREADS = 500;
          final int MAX_HOLDING_THREADS = 5;
            int loopCount = 0;
            Thread mainThread = Thread.currentThread();
            for (int m=0; ; m++) {
                 Thread t[] = new Thread[MAX_HOLDING_THREADS];
                 for (int n=0; n<t.length; n++) {
                        t[n] = new Thread(new ArchiveFileTest());
                        t[n].start();
                        if ((m+1)*(n+1)==MAX_THREADS) {
                             System.out.println("\n" + MAX_THREADS + " reached... \nMain Sleeping for some mins..."); 
                             loopCount++;
                             try {
                                    t[n].join();
                                    System.out.println("\nMain is back... (" + loopCount + ")");
                             } catch (InterruptedException e) {
                                    e.printStackTrace();
                                    setStopAll();
                             }
                             m = 0;
                        }
                 }
            }
     }
}

Answer 1

1. 在啟動線程的類中，為正在運行的線程提供一個volatile計數器。
2. 在您的線程構造函數中，傳遞對啟動類的引用。
3. 有一個同步的方法可以讓線程通知啟動類它們已經完成。

4. 實例化並啟動線程后，等待計數器變為0；否則，計數器變為0。

    while(getRunningThreads() > 0) // getRunningThreads must be synchronized too Thread.sleep(500); // Check every half second. 

Answer 2

如果通過停止表示終止，則應用程序將在所有非守護程序特殊情況的線程結束時停止。

Answer 3

我認為您的應用程序永遠都不會停止。 您在main方法中遇到了無限循環：

for (int m=0; ; m++) {
    ....
}

注意，在體內設置m=0不會破壞循環，因此即使您沒有文件，我也認為您永遠不會結束。 然后，它將連續讀取目錄中的所有zip / jar / war / rar文件（基於旋轉計數器myNumber的選擇不是很myNumber維護），但是永遠不會退出循環。

如果您需要使用多個線程讀取ZIP文件，那么我將采用另一種方式。

1. 創建一組要查看的文件。
2. 創建一個ThreadPoolExecutor以創建5個線程的固定池
3. 遍歷文件集並創建一個新的Runnable來執行Zip提取（盡管我不確定為什么您要讀取ZIP條目的前10000個字節，然后對其不執行任何操作），然后調用execute方法。 這將使用線程池一次處理5個文件。
4. 提交所有可運行對象后，請使用shutdown方法，該方法將等待所有提交的任務完成，然后關閉線程池。