Android 自定义线程池的实战 Android AsyncTask 深度理解、简单封装、任务队列分析、自定义线程池

时间  2019-12-09
标签 android 自定义 线程 实战 asynctask 深度 理解 简单 封装 任务 队列 分析 栏目 Android 繁體版
原文   原文链接

前言：在上一篇文章中咱们讲到了AsyncTask的基本使用、AsyncTask的封装、AsyncTask 的串行/并行线程队列、自定义线程池、线程池的快速建立方式。html

对线程池不了解的同窗能够先看 Android AsyncTask 深度理解、简单封装、任务队列分析、自定义线程池 java

 

-------------------------------------------------------------------------------------------------------编程

一、Executor 简介

     在Java 5以后，并发编程引入了一堆新的启动、调度和管理线程的API。Executor框架即是Java 5中引入的，其内部使用了线程池机制，它在java.util.cocurrent 包下，经过该框架来控制线程的启动、执行和关闭，能够简化并发编程的操做。所以，在Java 5以后，经过Executor来启动线程比使用Thread的start方法更好，除了更易管理，效率更好（用线程池实现，节约开销）外，还有关键的一点：有助于避免this逃逸问题——若是咱们在构造器中启动一个线程，由于另外一个任务可能会在构造器结束以前开始执行，此时可能会访问到初始化了一半的对象用Executor在构造器中。并发

   Executor框架包括：线程池，Executor，Executors，ExecutorService，CompletionService，Future，Callable等。app

   在java代码中 Executor是一个接口，只有一个方法。框架

public interface Executor {

    /**
     * Executes the given command at some time in the future.  The command
     * may execute in a new thread, in a pooled thread, or in the calling
     * thread, at the discretion of the {@code Executor} implementation.
     *
     * @param command the runnable task
     * @throws RejectedExecutionException if this task cannot be
     * accepted for execution
     * @throws NullPointerException if command is null
     */
    void execute(Runnable command);
}

　　

二、ExecutorService 

     ExecutorService 是一个接口，继承 Executor ，除了有execute( Runnable command) 方法外，还拓展其余的方法：    异步

public interface ExecutorService extends Executor {

}
  • void shutdown();
  • List<Runnable> shutdownNow();
  • boolean isShutdown();
  • boolean isTerminated();
  • boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;
  • <T> Future<T> submit(Callable<T> task);             //提交一个任务
  • <T> Future<T> submit(Runnable task, T result);      //提交一个任务
  • Future<?> submit(Runnable task);                    //提交一个任务
  • <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;
  • <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                  long timeout, TimeUnit unit)
        throws InterruptedException;
  • <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException;
  • <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                    long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;

   2.1 execute(Runnable)

        接收一个 java.lang.Runnable 对象做为参数，而且以异步的方式执行它。以下是一个使用 ExecutorService 执行 Runnable 的例子ide

package com.app;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExecutorTest {
	
	public static void main(String[] args) {
		
		//建立一个线程数固定大小为10的线程池
		ExecutorService executorService = Executors.newFixedThreadPool( 10 ) ;
		
		//执行一个任务  该任务是 new Runnable() 对象
		executorService.execute( new Runnable() {
			
			@Override
			public void run() {
              Log.d( Thread.currentThread().getName() );				
			}
		});
		
		//关闭线程池
		executorService.shutdown();

	}
}

　　结果：post

pool-1-thread-1this

     使用这种方式没有办法获取执行 Runnable 以后的结果，若是你但愿获取运行以后的返回值，就必须使用 接收 Callable 参数的 execute() 方法，后者将会在下文中提到。

 

     2.二、submit(Runnable)

        方法 submit(Runnable) 一样接收一个 Runnable 的实现做为参数，可是会返回一个 Future 对象。这个 Future 对象能够用于判断 Runnable 是否结束执行。以下是一个 ExecutorService 的 submit() 方法的例子：

package com.app;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ExecutorTest {
	public static void main(String[] args) {

		//建立一个线程数固定大小为10的线程池
		ExecutorService executorService = Executors.newFixedThreadPool( 10 ) ;

		//执行一个任务  该任务是 new Runnable() 对象
		Future future = executorService.submit( new Runnable() {
			@Override
			public void run() {
				Log.d( Thread.currentThread().getName() );	

			}
		});

		try {
			//若是任务结束执行则返回 null
			Log.d( ""+ future.get() );	
		} catch (Exception e) {
			e.printStackTrace();
		} 

		//关闭线程池
		executorService.shutdown();

	}
}

　　结果：

pool-1-thread-1
null

   

     2.3 submit(Callable)

       方法 submit(Callable) 和方法 submit(Runnable) 比较相似，可是区别则在于它们接收不一样的参数类型。Callable 的实例与 Runnable 的实例很相似，可是 Callable 的 call() 方法能够返回壹個结果。方法 Runnable.run() 则不能返回结果。

      Callable 的返回值能够从方法 submit(Callable) 返回的 Future 对象中获取。以下是一个 ExecutorService Callable 的例子：

package com.app;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ExecutorTest {
	public static void main(String[] args) {

		//建立一个线程数固定大小为10的线程池
		ExecutorService executorService = Executors.newFixedThreadPool( 10 ) ;

		//执行一个任务  该任务是 new Callable() 对象
		Future future  = executorService.submit( new Callable<String>() {

			@Override
			public String call() throws Exception {
				return "执行完了" ;
			}
		}) ;
	
		try {
			//若是任务结束执行则返回 
			Log.d( "结果是： "+ future.get() );	
		} catch (Exception e) {
			e.printStackTrace();
		} 

		//关闭线程池
		executorService.shutdown();

	}
}

　　结果：

结果是： 执行完了

 

   2.四、inVokeAny()

       方法 invokeAny() 接收一个包含 Callable 对象的集合做为参数。调用该方法不会返回 Future 对象，而是返回集合中某一个 Callable 对象的结果，并且没法保证调用以后返回的结果是哪个 Callable，只知道它是这些 Callable 中一个执行结束的 Callable 对象。若是一个任务运行完毕或者抛出异常，方法会取消其它的 Callable 的执行。

package com.app;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExecutorTest {
	public static void main(String[] args) {

		//建立一个线程数固定大小为10的线程池
		ExecutorService executorService = Executors.newFixedThreadPool( 10 ) ;


		List<Callable<String>> list = new ArrayList<>() ;
		
		//建立第一个 Callable
		Callable<String> callable1 = new Callable<String>() {

			@Override
			public String call() throws Exception {
				Log.d( "callable 1 线程是： "+ Thread.currentThread().getName()  );	
				return "执行完了 callable 1" ;
			}
		};
		
		//建立第二个 Callable
		Callable<String> callable2 = new Callable<String>() {

			@Override
			public String call() throws Exception {
				Log.d( "callable 2 线程是： "+ Thread.currentThread().getName()  );	
				return "执行完了 callable 2" ;
			}
		};
		
		list.add( callable1 ) ;
		list.add( callable2 ) ;
		
		try {
		 String result = executorService.invokeAny( list ) ;
		 Log.d( "结果是： "+ result  );	
		} catch (InterruptedException e1) {
			
			e1.printStackTrace();
		} catch (ExecutionException e1) {
			e1.printStackTrace();
		}
	
		//关闭线程池
		executorService.shutdown();

	}
}

　　结果：

callable 1 线程是： pool-1-thread-1

callable 2 线程是： pool-1-thread-2
结果是： 执行完了 callable 2

     总结：

       一、能够看到 Callable 里面的call方法，都是在子线程中运行的，

         二、 executorService.invokeAny( list ) ;返回值是任意一个 Callable 的返回值 。具体是哪个，每一个都有可能。

 

    2.五、invokeAll()

 方法 invokeAll() 会调用存在于参数集合中的全部 Callable 对象，而且返回一个包含 Future 对象的集合，你能够经过这个返回的集合来管理每一个 Callable 的执行结果。须要注意的是，任务有可能由于异常而致使运行结束，因此它可能并非真的成功运行了。可是咱们没有办法经过 Future 对象来了解到这个差别。

package com.app;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ExecutorTest {
	public static void main(String[] args) {

		//建立一个线程数固定大小为10的线程池
		ExecutorService executorService = Executors.newFixedThreadPool( 10 ) ;


		List<Callable<String>> list = new ArrayList<>() ;

		//建立第一个 Callable
		Callable<String> callable1 = new Callable<String>() {

			@Override
			public String call() throws Exception {
				Log.d( "callable 1 线程是： "+ Thread.currentThread().getName()  );	
				return "执行完了 callable 1" ;
			}
		};

		//建立第二个 Callable
		Callable<String> callable2 = new Callable<String>() {

			@Override
			public String call() throws Exception {
				Log.d( "callable 2 线程是： "+ Thread.currentThread().getName()  );	
				return "执行完了 callable 2" ;
			}
		};

		list.add( callable1 ) ;
		list.add( callable2 ) ;


		List<Future<String>> result;
		try {
			result = executorService.invokeAll( list );

			for (Future<String> future : result) {
				Log.d( "结果是： "+ future.get()  );	
			}	
		} catch (Exception e) {
			e.printStackTrace();
		}

		//关闭线程池
		executorService.shutdown();

	}
}

　　结果

callable 1 线程是： pool-1-thread-1
callable 2 线程是： pool-1-thread-2
结果是： 执行完了 callable 1
结果是： 执行完了 callable 2

    注意：1：Callable 的call方法都是执行在子线程中的

            2： executorService.invokeAll( list ) 是返回值。 可是必须是全部的 Callable对象执行完了，才会返回，返回值是一个list, 顺序和 List<Callable>同样 。在执行的过程当中，若是任何一个Callable发生异常，程序会崩溃，没有返回值。

       

     2.6 如何关闭 ExecuteService 服务 ？

当使用 ExecutorService 完毕以后，咱们应该关闭它，这样才能保证线程不会继续保持运行状态。 举例来讲，若是你的程序经过 main() 方法启动，而且主线程退出了你的程序，若是你还有一个活动的 ExecutorService 存在于你的程序中，那么程序将会继续保持运行状态。存在于 ExecutorService 中的活动线程会阻Java虚拟机关闭。 

为了关闭在 ExecutorService 中的线程，你须要调用 shutdown() 方法。ExecutorService 并不会立刻关闭，而是再也不接收新的任务，一旦全部的线程结束执行当前任务，ExecutorServie 才会真的关闭。全部在调用 shutdown() 方法以前提交到 ExecutorService 的任务都会执行。 
若是你但愿当即关闭 ExecutorService，你能够调用 shutdownNow() 方法。这个方法会尝试立刻关闭全部正在执行的任务，而且跳过全部已经提交可是尚未运行的任务。可是对于正在执行的任务，是否可以成功关闭它是没法保证 的，有可能他们真的被关闭掉了，也有可能它会一直执行到任务结束。这是一个最好的尝试。 

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程