Android自定义线程池的编程实战-低调大师

Android自定义线程池的编程实战

2017-08-07 574

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

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

结果：

pool-1-thread-1

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

2.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.4、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

总结：

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

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

2.5、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() 方法。这个方法会尝试马上关闭所有正在执行的任务，并且跳过所有已经提交但是还没有运行的任务。但是对于正在执行的任务，是否能够成功关闭它是无法保证的，有可能他们真的被关闭掉了，也有可能它会一直执行到任务结束。这是一个最好的尝试。

作者：赵彦军

来源：51CTO

微信关注我们

原文链接：https://yq.aliyun.com/articles/183121

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

iOS vs Android苹果将重蹈PC业务覆辙？

iPhone凭借着其颠覆式的设计以及极为优秀的体验从诞生以来便吸引了无数人的目光，也成功的奠定了苹果在手机行业的地位。不过随着智能手机行业愈加的趋向于成熟，安卓手机无论是从价位还是功能体验上都给了用户更多的选择，这也让笔者不禁想起了当年苹果在PC市场上败给微软的往事。相信现在很多人心里都有这样一个疑问：苹果的手机业务是否会走上当年PC业务的老路，败给新对手谷歌的Android呢? ● 用户体验方面差距缩小相较于Android，iOS最大的优势就在用户体验上。封闭的iOS系统在智能机发展初期可谓是满具优势，高品质的应用商店、完备的系统功能、流畅的系统优化以及人性化的交互设计是其最大的特色，也是早期甚至现在的安卓都没有办法超越的优点。最早的Android最大的优势就是开源，而开源所带来的好处便是自由和低价。由于谷歌对使用Android系统的厂商的要求比较少，厂商可以根据自己的需求来使用其系统并开发属于自家的Android手机。这也驱使着大量的手机制造商开始通过Android进入到智能手机市场，极大地促进了智能手机行业的发展。对于用户来说，他们可以花费更低的价格来购买一款Android...

2017-08-07

578

SQLite支持的常见数据类型如下所示。 –INTEGER有符号的整数类型 –REAL浮点类型 –TEXT字符串类型,采用UTF-8和UTF-16字符编码 –BLOB二进制大对象类型,能够存放任何二进制数据 (C语言中)使用步骤： 1.新建项目时,先导入系统框架(C语言). （libsqlite3） 2.头文件#import<sqlite3.h> 3. sqlite3_open(fileName.UTF8String, &_db);打开或者创建一个数据 *_db自己定义一个sqlite3的成员变量.进行增删改查时要用 4.sqlite3_exec(_db, sql, NULL, NULL,&error); //不带结果集的语句，只是对表做操作，不会返回出结果 *该函数可进行insert,delete,update操作. 5.查询操作select. //带结果集的查询语句，会返回出结果，从表中查询到的数据都会放到stmt结构体中 *sqlite3_prepare_v2(_db, sql, -1, &stmt, NULL); 做查询前准备...

2017-08-07

562

资源下载

更多资源

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

WebStorm

WebStorm 是jetbrains公司旗下一款JavaScript 开发工具。目前已经被广大中国JS开发者誉为“Web前端开发神器”、“最强大的HTML5编辑器”、“最智能的JavaScript IDE”等。与IntelliJ IDEA同源，继承了IntelliJ IDEA强大的JS部分的功能。