带你快速搞定java并发库
更新时间：2021年07月15日 10:11:06 作者：香菜聊游戏
本文主要介绍了java高并发写入用户信息到数据库的几种方法，具有很好的参考价值。下面跟着小编一起来看下吧，希望能给你带来帮助
一、总览
计算机程序 = 数据 + 算法。
并发编程的一切根本原因是为了保证数据的正确性，线程的效率性。
Java并发库共分为四个大的部分，如下图
Executor 和 future 是为了保证线程的效率性
Lock 和数据结构 是为了维持数据的一致性。
Java并发编程的时候，思考顺序为，
对自己的数据要么加锁。要么使用提供的数据结构，保证数据的安全性
调度线程的时候使用Executor更好的调度。
二、Executor总览
Executor 提供一种将任务提交与每个任务将如何运行的机制（包括线程使用的细节、调度等）分离开来的方法。
相当于manager,老板让manager去执行一件任务，具体的是谁执行，什么时候执行，就不管了。
看上图的继承关系，介绍几个
内置的线程池基本上都在这里
newScheduledThreadPool 定时执行的线程池
newCachedThreadPool 缓存使用过的线程
newFixedThreadPool 固定数量的线程池
newWorkStealingPool 将大任务分解为小任务的线程池
三、继承结构
构造函数
包含一个定时的service
public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
return new DelegatedScheduledExecutorService
(new ScheduledThreadPoolExecutor(1));
}
static class DelegatedScheduledExecutorService
extends DelegatedExecutorService
implements ScheduledExecutorService {
private final ScheduledExecutorService e;
DelegatedScheduledExecutorService(ScheduledExecutorService executor) {
super(executor);
e = executor;
}
四、怎么保证只有一个线程
定时执行的时候调用这个方法，调用过程如下，注意看其中的注释，由上往下的调用顺序
public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
long initialDelay,
long delay,
TimeUnit unit) {
if (command == null || unit == null)
throw new NullPointerException();
if (delay <= 0)
throw new IllegalArgumentException();
ScheduledFutureTask<Void> sft =
new ScheduledFutureTask<Void>(command,
null,
triggerTime(initialDelay, unit),
unit.toNanos(-delay));
RunnableScheduledFuture<Void> t = decorateTask(command, sft);
sft.outerTask = t;
// 延迟执行
delayedExecute(t);
return t;
}
private void delayedExecute(RunnableScheduledFuture<?> task) {
if (isShutdown())
reject(task);
else {
// 加入任务队列
super.getQueue().add(task);
if (isShutdown() &&
!canRunInCurrentRunState(task.isPeriodic()) &&
remove(task))
task.cancel(false);
else
// 确保执行
ensurePrestart();
}
}
// 如果worker数量小于corePoolSize,创建新的线程，其他情况不处理
void ensurePrestart() {
int wc = workerCountOf(ctl.get());
if (wc < corePoolSize)
addWorker(null, true);
else if (wc == 0)
addWorker(null, false);
}
五、怎么保证时间可以定时执行
public ScheduledFuture<?> schedule(Runnable command,
long delay,
TimeUnit unit) {
if (command == null || unit == null)
throw new NullPointerException();
RunnableScheduledFuture<?> t = decorateTask(command,
new ScheduledFutureTask<Void>(command, null,
triggerTime(delay, unit)));
delayedExecute(t);
return t;
}
在每次执行的时候会把下一次执行的时间放进任务中
private long triggerTime(long delay, TimeUnit unit) {
return triggerTime(unit.toNanos((delay < 0) ? 0 : delay));
}
/**
* Returns the trigger time of a delayed action.
*/
long triggerTime(long delay) {
return now() +
((delay < (Long.MAX_VALUE >> 1)) ? delay : overflowFree(delay));
}
FutureTask 定时是通过LockSupport.parkNanos(this, nanos);LockSupport.park(this);
private int awaitDone(boolean timed, long nanos)
throws InterruptedException {
final long deadline = timed ? System.nanoTime() + nanos : 0L;
WaitNode q = null;
boolean queued = false;
for (;;) {
if (Thread.interrupted()) {
removeWaiter(q);
throw new InterruptedException();
}
int s = state;
if (s > COMPLETING) {
if (q != null)
q.thread = null;
return s;
}
else if (s == COMPLETING) // cannot time out yet
Thread.yield();
else if (q == null)
q = new WaitNode();
else if (!queued)
queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
q.next = waiters, q);
else if (timed) {
nanos = deadline - System.nanoTime();
if (nanos <= 0L) {
removeWaiter(q);
return state;
}
//注意这里
LockSupport.parkNanos(this, nanos);
}
else //注意这里
LockSupport.park(this);
}
}
总结：Executor是通过将任务放在队列中，生成的futureTask。然后将生成的任务在队列中排序，将时间最近的需要出发的任务做检查。如果时间不到，就阻塞线程到下次出发时间。
注意：newSingleThreadScheduledExecutor只会有一个线程，不管你提交多少任务，这些任务会顺序执行，如果发生异常会取消下面的任务，线程池也不会关闭，注意捕捉异常
六、使用
ScheduledExecutorService single = Executors.newSingleThreadScheduledExecutor();
Runnable runnable1 = () -> {
try {
Thread.sleep(4000);
System.out.println("11111111111111");
} catch (InterruptedException e) {
e.printStackTrace();
}
};
Runnable runnable2 = () -> {
try {
Thread.sleep(4000);
System.out.println("222");
} catch (InterruptedException e) {
e.printStackTrace();
}
};
single.scheduleWithFixedDelay(runnable1,0,1, TimeUnit.SECONDS);
single.scheduleWithFixedDelay(runnable2,0,2, TimeUnit.SECONDS);
11111111111111 222 11111111111111 222 11111111111111
在项目中要注意关闭线程池
actionService = Executors.newSingleThreadScheduledExecutor();
actionService.scheduleWithFixedDelay(() -> {
try {
Thread.currentThread().setName("robotActionService");
Integer robotId = robotQueue.poll();
if (robotId == null) {
// 关闭线程池
actionService.shutdown();
} else {
int aiLv = robots.get(robotId);
if (actionQueueMap.containsKey(aiLv)) {
ActionQueue actionQueue = actionQueueMap.get(aiLv);
actionQueue.doAction(robotId);
}
}
} catch (Exception e) {
// 捕捉异常
LOG.error("",e);
}
}, 1, 1, TimeUnit.SECONDS);
总结
本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注脚本之家的更多内容！
相关文章
这篇文章主要介绍了java Unicode和UTF-8之间转换实例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧2020-09-09
这篇文章主要通过两个例题为大家介绍一下Java合并两个及以上有序链表的实现方法，文中的示例代码讲解详细，具有一定的学习价值，需要的可以参考一下2023-04-04
在项目开发中,经常会引入很多未使用的import包,这不仅增加了编译时间,还会使代码可读性变差,设置IDEA自动清理未使用的import包,可以提高代码的可读性,本文给大家介绍IDEA自动清理类中未使用的import包的方法,感兴趣的朋友一起看看吧2024-09-09
本示例教程介绍了如何使用SpringBoot框架结合MinIO服务实现文件的上传和下载功能,并将文件信息存储在数据库的file表中,文中通过代码介绍的非常详细,需要的朋友可以参考下2024-09-09
Java并发编程深入理解之Synchronized的使用及底层原理详解 上
在并发编程中存在线程安全问题，主要原因有：1.存在共享数据 2.多线程共同操作共享数据。关键字synchronized可以保证在同一时刻，只有一个线程可以执行某个方法或某个代码块，同时synchronized可以保证一个线程的变化可见（可见性），即可以代替volatile2021-09-09
idea中MavenWeb项目不能创建Servlet的解决方案
这篇文章主要介绍了idea中MavenWeb项目不能创建Servlet的解决方案,本文给大家介绍的非常详细，具有一定的参考借鉴价值，需要的朋友可以参考下2020-02-02
java公众平台通用接口工具类HttpConnectUtil实例代码
下面小编就为大家分享一篇java公众平台通用接口工具类HttpConnectUtil实例代码，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧2018-01-01
springboot+mybatis拦截器方法实现水平分表操作
这篇文章主要介绍了springboot+mybatis拦截器方法实现水平分表操作，文章围绕主题展开详细的内容介绍，具有一定的参考价值，需要的朋友可以参考一下2022-08-08
目前做项目中有一个需求是这样的,需要通过Java发送url请求,查看该url是否有效,这时我们可以通过获取状态码来判断,下面这篇文章主要给大家介绍了关于JAVA发送HTTP请求的多种方式总结的相关资料,需要的朋友可以参考下2023-01-01
这篇文章主要介绍了JavaSwing FlowLayout 流式布局的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧2019-12-12
最新评论