代码拉取完成，页面将自动刷新
1.3.1 一般开启线程的操作如下所示
new Thread(new Runnable() {
@Override
public void run() {
//做一些任务
}
}).start();
1.3.2 主要的弊端有这些，可能总结并不全面
compile 'cn.yc:YCThreadPoolLib:1.3.3'
public class App extends Application{
private static App instance;
private PoolThread executor;
public static synchronized App getInstance() {
if (null == instance) {
instance = new App();
}
return instance;
}
public App(){}
@Override
public void onCreate() {
super.onCreate();
instance = this;
//初始化线程池管理器
initThreadPool();
}
/**
* 初始化线程池管理器
*/
private void initThreadPool() {
// 创建一个独立的实例进行使用
executor = PoolThread.ThreadBuilder
.createFixed(5)
.setPriority(Thread.MAX_PRIORITY)
.setCallback(new LogCallback())
.build();
}
/**
* 获取线程池管理器对象，统一的管理器维护所有的线程池
* @return executor对象
*/
public PoolThread getExecutor(){
return executor;
}
}
//自定义回调监听callback，可以全局设置，也可以单独设置。都行
public class LogCallback implements ThreadCallback {
private final String TAG = "LogCallback";
@Override
public void onError(String name, Throwable t) {
Log.e(TAG, "LogCallback"+"------onError"+"-----"+name+"----"+Thread.currentThread()+"----"+t.getMessage());
}
@Override
public void onCompleted(String name) {
Log.e(TAG, "LogCallback"+"------onCompleted"+"-----"+name+"----"+Thread.currentThread());
}
@Override
public void onStart(String name) {
Log.e(TAG, "LogCallback"+"------onStart"+"-----"+name+"----"+Thread.currentThread());
}
}
PoolThread executor = App.getInstance().getExecutor();
executor.setName("最简单的线程调用方式");
executor.setDeliver(new AndroidDeliver());
executor.execute(new Runnable() {
@Override
public void run() {
Log.e("MainActivity","最简单的线程调用方式");
}
});
PoolThread executor = App.getInstance().getExecutor();
executor.setName("延迟时间执行任务");
executor.setDelay(2, TimeUnit.SECONDS);
executor.setDeliver(new AndroidDeliver());
Future<String> submit = executor.submit(new Callable<String>() {
@Override
public String call() throws Exception {
Log.d("PoolThreadstartThread4","startThread4---call");
Thread.sleep(2000);
String str = "小杨逗比";
return str;
}
});
try {
String result = submit.get();
Log.d("PoolThreadstartThread4","startThread4-----"+result);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
PoolThread executor = App.getInstance().getExecutor();
executor.setName("异步回调");
executor.setDelay(2,TimeUnit.MILLISECONDS);
// 启动异步任务
executor.async(new Callable<Login>(){
@Override
public Login call() throws Exception {
// 做一些耗时操作
return null;
}
}, new AsyncCallback<Login>() {
@Override
public void onSuccess(Login user) {
Log.e("AsyncCallback","成功");
}
@Override
public void onFailed(Throwable t) {
Log.e("AsyncCallback","失败");
}
@Override
public void onStart(String threadName) {
Log.e("AsyncCallback","开始");
}
});
//设置为当前的任务设置线程名
executor.setName("延迟时间执行任务");
//设置当前任务的延迟时间
executor.setDelay(2, TimeUnit.SECONDS);
//设置当前任务的线程传递
executor.setDeliver(new AndroidDeliver());
//关闭线程池操作
executor.stop();
//销毁的时候可以调用这个方法
executor.close();
executor.setCallback(new ThreadCallback() {
@Override
public void onError(String threadName, Throwable t) {
}
@Override
public void onCompleted(String threadName) {
}
@Override
public void onStart(String threadName) {
}
});
public final class RunnableWrapper implements Runnable {
private String name;
private NormalCallback normal;
private Runnable runnable;
private Callable callable;
public RunnableWrapper(ThreadConfigs configs) {
this.name = configs.name;
this.normal = new NormalCallback(configs.callback, configs.deliver, configs.asyncCallback);
}
/**
* 启动异步任务，普通的
* @param runnable runnable
* @return 对象
*/
public RunnableWrapper setRunnable(Runnable runnable) {
this.runnable = runnable;
return this;
}
/**
* 异步任务，回调用于接收可调用任务的结果
* @param callable callable
* @return 对象
*/
public RunnableWrapper setCallable(Callable callable) {
this.callable = callable;
return this;
}
/**
* 自定义xxRunnable继承Runnable，实现run方法
* 详细可以看我的GitHub：https://github.com/yangchong211
*/
@Override
public void run() {
//获取线程
Thread current = Thread.currentThread();
//重置线程
ThreadToolUtils.resetThread(current, name, normal);
//开始
normal.onStart(name);
//注意需要判断runnable，callable非空
// avoid NullPointException
if (runnable != null) {
runnable.run();
} else if (callable != null) {
try {
Object result = callable.call();
//监听成功
normal.onSuccess(result);
} catch (Exception e) {
//监听异常
normal.onError(name, e);
}
}
//监听完成
normal.onCompleted(name);
}
}
public interface ThreadCallback {
/**
* 当线程发生错误时，将调用此方法。
* @param threadName 正在运行线程的名字
* @param t 异常
*/
void onError(String threadName, Throwable t);
/**
* 通知用户知道它已经完成
* @param threadName 正在运行线程的名字
*/
void onCompleted(String threadName);
/**
* 通知用户任务开始运行
* @param threadName 正在运行线程的名字
*/
void onStart(String threadName);
}
public interface AsyncCallback<T> {
/**
* 成功时调用
* @param t 泛型
*/
void onSuccess(T t);
/**
* 异常时调用
* @param t 异常
*/
void onFailed(Throwable t);
/**
* 通知用户任务开始运行
* @param threadName 正在运行线程的名字
*/
void onStart(String threadName);
}
Copyright 2017 yangchong211（github.com/yangchong211）
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
此处可能存在不合适展示的内容，页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容，可点击提交进行申诉，我们将尽快为您处理。