Android 多线程之判断线程结束

Android 多线程之判断线程结束

最近在做多线程断点线程的时候，遇到一个问题，因为需要在多线程下载完成时候，对文件进行处理，而处理肯定是在文件下载完成时候，而下载完成时候肯定是多线程都完成时候，所以怎么判断多线程完成呢？也是百度了很多文章，也都试了试。但是都发现不能解决自己的问题。

没有解决问题的方案

1.线程池 然后shutdown 然后判断是否terminate，如果terminate返回为true，就是完成了。
例子代码如下

exe.shutdown();  
        System.out.println("shutdown()：启动一次顺序关闭，执行以前提交的任务，但不接受新任务。");  
        while(true){  
            if(exe.isTerminated()){  
                System.out.println("所有的子线程都结束了！");  
                break;  
            }  
            Thread.sleep(1000);    
        } 

这个方案在Android不行，不知道在java那边可以不，因为shutdown会让线程自动关闭，但是它的关闭，不是等线程正常的做完事情关闭，而是暴力的让他关闭了。如果我们的线程是下载东西的话，他就是在还没有下载完成或者在下载中就让关闭了，这个不是我们想要的。
2.CountDownLatch 先初始化，线程数的声明。然后在每个线程结束时候。线程数方法减一，然后在外面等待，当线程数减为0的时候，等待后面的代码执行。
这个方法也试了试，可惜在Android还是不行，因为会在等待的那个地方报错，说你需要锁住线程，但是CountDownLatch 这个类没有什么锁住方法，无奈也不行。

思考

经过上面2个失败的解决例子后，我有了点启发尤其是针对第一种方式，因为在上次面试的时候，有个面试官，问了一个我没有遇到的问题，就是如何取消一个线程池的方法，我当时没有答出来，后来回去百度了下，原来在线程池声明的时候，是可以使用future这个对象来得到线程对象的。所以这里的突破口也觉得是应该在线程池这里。
查阅线程池方法时候，的确是有返回线程池状态的方法，可惜不是熟悉的thread和runable对象而是callable，其实callable和runable几乎差不多，就是能够返回一个值，而runable不能，这个值就是我们想要的，如果我们的每个线程在结束时候返回我们定义的结束的值，那么我们在线程结束时候，判断他们的值不是就知道，我们的线程是否结束了吗？思路有了就开始，实现。

1.首先把runable接口换成callable接口，然后在定义返回的值。
2.判断线程结束时候的线程状态，然后取出每个值，判断值是不是我们正常结束的。（这里还有一个点是，怎么判断这个时间点呢？我们找到了future对象的get方法。他返回值的时候就是说明线程结束时候。无论是正常结束还是异常结束。)
代码如下（这里是下载的代码和只是思路）：下载代码的改造

    public static class DownLoadThread implements Callable {

        private int threadId;
        private int startBlock;
        private int endBlock;

        private String downUrl;
        private String storePath;
        private String version;//解决下载中断，不同版本的切换问题


        public DownLoadThread(int i, int startBlock, int endBlock, String url, String storePath, String version) {
            this.threadId = i;
            this.startBlock = startBlock;
            this.endBlock = endBlock;
            this.downUrl = url;
            this.storePath = storePath;
            this.version = version;
        }

        @Override
        public Integer call() {
            try {
                URL url = new URL(downUrl);
                HttpURLConnection con = (HttpURLConnection) url.openConnection();
                con.setRequestMethod("GET");
                con.setConnectTimeout(10 * 1000);
                File file = new File(storePath.substring(0, storePath.lastIndexOf("/")), version + "_" + threadId + ".txt");
                RandomAccessFile downLoadAss = null;
                if (file != null && file.exists()) {
                    downLoadAss = new RandomAccessFile(file, "rwd");
                    String lastPositon = downLoadAss.readLine();
                    if (null == lastPositon || "".equals(lastPositon)) {
                        this.startBlock = startBlock;
                    } else {
                        if (lastPositon != null && !"".equals(lastPositon)) {
                            startBlock = Integer.parseInt(lastPositon) - 1;
                        }
                    }
                } else {
                    downLoadAss = new RandomAccessFile(file, "rwd");
                }
                con.setRequestProperty("Range", "bytes=" + startBlock + "-" + endBlock);
                if (con.getResponseCode() == 206) {//请求部分成果
                    InputStream input = con.getInputStream();
                    RandomAccessFile randomAccessFile = new RandomAccessFile(new File(storePath), "rwd");
                    randomAccessFile.seek(startBlock);
                    byte[] bytes = new byte[1024 * 4];
                    int length = -1;
                    int total = 0;
                    while ((length = input.read(bytes)) != -1) {
                        randomAccessFile.write(bytes, 0, length);
                        total += length;
                        downLoadAss.seek(0);
                        downLoadAss.write(String.valueOf(startBlock + total).getBytes("UTF-8"));
                    }
                    downLoadAss.close();
                    randomAccessFile.close();
                    input.close();
//                    Log.e("show", "线程" + threadId + "下载关闭");
                    File f = new File(storePath.substring(0, storePath.lastIndexOf("/")), version + "_" + threadId + ".txt");
                    f.delete();//删除记录下载的文件
                    return 1;
                }
            } catch (MalformedURLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                return 0;
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                return 0;
            }
            return 1;

        }

    }

判断线程状态和读取每个future对象返回的值。

ExecutorService executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors()+1);
List downLoadThreads = new ArrayList<>();
for (int i = 0; i < threadCount; i++) {
    int startBlock = i * blockSize;
    int endBlock = (i + 1) * blockSize - 1;
    if (i == threadCount - 1) {//如果是最后一个线程，下载完
        endBlock = fileLength - 1;
    }
    downLoadThreads.add(new DownLoadThread(i, startBlock, endBlock, downUrl, storePath, version));
}
try {
    List> futures = executorService.invokeAll(downLoadThreads);
    for (Future future : futures) {
        if (future.get() == 1) {//这里会等待 阻塞线程 1是成功的标识
            currentRunThreadCount = currentRunThreadCount - 1;//还没有完成的进程
        }
    }
    if (currentRunThreadCount == 0) {
        return 1;
    }

使用了线程池对象，然后使用invokeAll方法得到线程池每个线程的future列表，然后循环读取future列表的方法值，时机是future的get方法，这个点会一直等到当前线程做完结束，如果是我们值，我们把判断线程数的值减一,当线程数判断值为零时候，就是说所有线程都完成时候。