Android 自定义线程池的实战

最新推荐文章于 2023-07-26 10:58:19 发布

原小明

最新推荐文章于 2023-07-26 10:58:19 发布

阅读量583

点赞数

文章标签： android 线程池

1、Executor 简介

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

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

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

2、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 的例子;

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

    }
}

　结果：

pool-1-thread-1

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

2.2、submit(Runnable)

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

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 的例子：

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.4、inVokeAny()

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

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

总结：

   1、可以看到 Callable 里面的call方法，都是在子线程中运行的，

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

2.5、invokeAll()

方法 invokeAll() 会调用存在于参数集合中的所有 Callable 对象，并且返回一个包含 Future 对象的集合，你可以通过这个返回的集合来管理每个 Callable 的执行结果。需要注意的是，任务有可能因为异常而导致运行结束，所以它可能并不是真的成功运行了。但是我们没有办法通过 Future 对象来了解到这个差异。

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发生异常，程序会崩溃，没有返回值。

2.6 如何关闭 ExecuteService 服务？

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

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