共计 5193 个字符,预计需要花费 13 分钟才能阅读完成。
Java 的线程和线程池的了解
一:概念
在 Java 中,应用线程来异步执行工作。Java 的线程既是工作单元,也是执行机制。从 JDK 5 开始,把工作单元与执行机制拆散开来。工作单元包含 Runnable 和 Callable,而执行机制由 Executor 框架提供。
二:什么是 Executor 框架?
咱们晓得线程池就是线程的汇合,线程池集中管理线程,以实现线程的重用,升高资源耗费,进步响应速度等。线程用于执行异步工作,单个的线程既是工作单元也是执行机制,从 JDK1.5 开始,为了把工作单元与执行机制分来到,Executor 框架诞生了,他是一个用于对立创立与运行的接口。Executor 框架实现的就是线程池的性能
三:Executor 的构造
Executor 框架次要由 3 大部分组成如下。
1. 工作:包含被执行工作须要实现的接口:Runnable 接口或 Callable 接口。
2. 工作的执行:包含工作执行机制的外围接口 Executor,以及继承自 Executor 的 ExecutorService 接口。Executor 框架有两个要害类实现了 ExecutorService 接口(ThreadPoolExecutor 和 ScheduledThreadPoolExecutor)。
3. 异步计算的后果:包含接口 Future 和实现 Future 接口的 FutureTask 类。
Executor 框架蕴含的次要的类与接口如下图所示
四:对框架的了解
Executor 是一个接口,它是 Executor 框架的根底,它将工作的提交与工作的执行拆散开来
// 我了解的这是一个定义线程一个行为,工作执行,具体交由其实现实现
public interface Executor {void execute(Runnable command);
}
ExecutorService 也是一个接口 继承 Executor 接口 扩大 Executor
public interface ExecutorService extends Executor {
// 进行接管新工作,原来的工作继续执行
void shutdown();
// 进行接管新工作,原来的工作进行执行
List<Runnable> shutdownNow();
// 接管的参数不一样 submit()能够承受 runnable 无返回值和 callable 有返回值
execute()承受 runnable 无返回值
<T> Future<T> submit(Callable<T> task);
}
AbstractExecutorService 是一个抽象类 实现 ExecutorService 接口扩大性能
ScheduledExecutorService(提早的线程池服务) 是一个接口 继承 ExecutorService 接口扩大性能
线程池外围类:
ThreadPoolExecutor 继承 AbstractExecutorService 的线程池类
public class ThreadPoolExecutor extends AbstractExecutorService {
// 构造方法
//corePoolSize 外围线程 指定了线程池中的线程数量,它的数量决定了增加的工作是开拓新的线程去执行,还是放到 workQueue 工作队列中去;//maximumPoolSize 指定了线程池中的最大线程数量,这个参数会依据你应用的 workQueue 工作队列的类型,决定线程池会开拓的最大线程数量;//keepAliveTime 当线程池中闲暇线程数量超过 corePoolSize 时,多余的线程会在多长时间内被销毁;(闲暇线程包活工夫)//unit:keepAliveTime 的单位
//workQueue: 工作队列,被增加到线程池中,但尚未被执行的工作;它个别分为间接提交队列、有界工作队列、无界工作队列、优先工作队列几种;(阻塞队列长度设置为 Integer.MAX_VALUE)//threadFactory: 线程工厂,用于创立线程,个别用默认即可;//handler: 回绝策略;当工作太多来不及解决时,如何回绝工作;public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), handler);
}
}
// 例如线程池外围线程数为 1,最大线程数为 10,工作队列容量(阻塞队列)queueCapacity 也就是 BlockingQueue 工作 10 个
默认线程池的数量为 1,当工作不超过 10 个,会在工作队列排队期待线程池里一个线程解决
当工作 >10 个,会创立一个新的线程解决
当线程数达到最大线程数的时候 RejectedExecutionHandler(工作回绝处理器)回绝策略
RejectedExecutionHandler(回绝策略)接口有上面几个实现类 如果没有设置,默认是 AbortPolicy,会抛出异样。
AbortPolicy:抛弃工作,抛运行时异样
CallerRunsPolicy:执行工作
DiscardOldestPolicy:从队列中踢出最先进入队列(最初一个执行)的工作
DiscardPolicy:漠视,什么都不会产生
五:线程池的具体实现类
举例:Glide 的线程池实现类FifoPriorityThreadPoolExecutor 先进先出的策略线程池
// 先进先出的线程池策略的外围线程和最大线程的数量的是一样的
public class FifoPriorityThreadPoolExecutor extends ThreadPoolExecutor {
public FifoPriorityThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAlive, TimeUnit timeUnit,
ThreadFactory threadFactory, UncaughtThrowableStrategy uncaughtThrowableStrategy) {super(corePoolSize, maximumPoolSize, keepAlive, timeUnit, new PriorityBlockingQueue<Runnable>(), threadFactory);
this.uncaughtThrowableStrategy = uncaughtThrowableStrategy;
}
}
FifoPriorityThreadPoolExecutor 的对象有 sourceService 和 diskCacheService 2 个。
和 diskCacheService 的外围线程和最大线程数为 1 个
Glide 外面的会组装成 Engine 负责 EngineJob 工作治理
if (engine == null) {engine = new Engine(memoryCache, diskCacheFactory, diskCacheService, sourceService);
}
再由 Engine 组装成 Glide
return new Glide(engine, memoryCache, bitmapPool, context, decodeFormat);
六:线程池的分类
在 Executors 工厂类中提供了多种线程池,典型的有以下四种
- SingleThreadExecutor 单线程线程池
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
// 测试创立线程
public static void singleThreadPool(){ExecutorService aa= Executors.newSingleThreadExecutor();
// 创立工作
Runnable runnable = new Runnable() {
@Override
public void run() {System.out.println("工作被执行, 线程:" + Thread.currentThread().getName());
}
};
aa.execute(runnable);
}
外围线程数为 1,最大线程数为 1,也就是说 SingleThreadExecutor 这个线程池中的线程数固定为 1。应用场景:当多个工作都须要拜访同一个资源的时候
- FixedThreadPool 固定容量线程池
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
// 栗子:创立线程,固定的线程池
public static void fixedThreadPool(){ExecutorService aa= newFixedThreadPool(2);
// 创立工作
Runnable runnable = new Runnable() {
@Override
public void run() {System.out.println("工作被执行, 线程:" + Thread.currentThread().getName());
}
};
aa.execute(runnable);
}
外围线程数为 n,最大线程数为 n。应用场景:明确同时执行工作数量时。
- CachedThreadPool 缓存线程池
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
// 栗子:缓存线程池
public static void cachedThreadPool(){ExecutorService aa= Executors.newCachedThreadPool();
// 创立工作
Runnable runnable = new Runnable() {
@Override
public void run() {System.out.println("工作被执行, 线程:" + Thread.currentThread().getName());
}
};
aa.execute(runnable);
}
外围线程数为 0,最大线程数无下限,线程超时工夫 60 秒。应用场景:解决大量耗时较短的工作。
- ScheduledThreadPool 定时线程池
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {return new ScheduledThreadPoolExecutor(corePoolSize);
}
public ScheduledThreadPoolExecutor(int corePoolSize) {
super(corePoolSize, Integer.MAX_VALUE,
DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
new DelayedWorkQueue());
}
// 栗子:定时工作的创立线程池
public static void scheduledThreadPool(){ExecutorService aa= Executors.newScheduledThreadPool(1);
// 创立工作
Runnable runnable = new Runnable() {
@Override
public void run() {System.out.println("工作被执行, 线程:" + Thread.currentThread().getName());
}
};
aa.execute(runnable);
}
外围线程数自定,最大线程数无下限。应用场景:解决延时工作