金溪网站建设医疗机构网站以患者做宣传

金溪网站建设,医疗机构网站以患者做宣传,网站建设的初期目标,seo两个域名一个网站有影响吗# JUC#xff08;java.util.concurrent#xff09;完整学习笔记## 整体架构┌─────────────────────────────────────────────────────────────────────────────┐ │ …# JUCjava.util.concurrent完整学习笔记 ## 整体架构┌─────────────────────────────────────────────────────────────────────────────┐│ JUC 四层架构 │├─────────────────────────────────────────────────────────────────────────────┤│ ││ 第四层应用层开箱即用 ││ ┌─────────────────────────────────────────────────────────────────────┐ ││ │ ConcurrentHashMap | CopyOnWriteList | BlockingQueue │ ││ │ ThreadPoolExecutor | ForkJoinPool | CompletableFuture │ ││ └─────────────────────────────────────────────────────────────────────┘ ││ ↑ ││ 第三层同步器基于 AQS 扩展 ││ ┌─────────────────────────────────────────────────────────────────────┐ ││ │ ReentrantLock | Semaphore | CountDownLatch | ReadWriteLock │ ││ └─────────────────────────────────────────────────────────────────────┘ ││ ↑ ││ 第二层AQS 原子类核心框架 ││ ┌─────────────────────────────────────────────────────────────────────┐ ││ │ AbstractQueuedSynchronizerstate CLH队列 模板方法 │ ││ │ AtomicInteger | AtomicReference | LongAdder │ ││ └─────────────────────────────────────────────────────────────────────┘ ││ ↑ ││ 第一层底层原语JVM/硬件级 ││ ┌─────────────────────────────────────────────────────────────────────┐ ││ │ CASCPU指令 | volatile内存屏障 | LockSupport阻塞原语 │ ││ └─────────────────────────────────────────────────────────────────────┘ ││ │└─────────────────────────────────────────────────────────────────────────────┘--- ## 第一层底层原语 ### 1.1 CASCompare And Swap **本质**CPU 硬件指令x86 的 CMPXCHG **语义**if (内存值 预期值) {内存值 新值return true} else {return false}**作用**无锁化编程的基石实现原子性更新 **关联理解** - CAS 是乐观锁思想的具体技术实现 - 数据库乐观锁version 字段是同一思想的另一种实现 ### 1.2 volatile **本质**内存屏障Memory Barrier **保证** - ✅ 可见性一个线程修改其他线程立即看到 - ✅ 有序性禁止指令重排序 - ❌ 原子性不保证 **⚠️ 重点理解**volatile int i 0;i; // 这不是原子的// 因为 i 实际是三步// 1. 读取 i 的值// 2. 计算 i 1// 3. 写回 i// 步骤 1 和 3 之间可能被其他线程打断### 1.3 LockSupport **本质**线程阻塞/唤醒的底层机制每个线程一个许可证 **核心方法** - park() 消耗许可证没有则阻塞 - unpark(thread) 发放许可证如果线程在阻塞则唤醒 **vs wait/notify** | 特性 | wait/notify | LockSupport | |------|-------------|-------------| | 是否需要锁 | 必须在 synchronized 中 | 不需要 | | 调用顺序 | wait 必须先于 notify | unpark 可先于 park | | 唤醒目标 | 随机或全部 | 精确指定线程 | **⚠️ 重点理解** - LockSupport 和 wait/notify 是两套独立机制不是封装关系 - 都最终调用操作系统的线程挂起/唤醒 - AQS 选择 LockSupport 因为可以精确唤醒队列中的下一个线程 ### 1.4 三者配合CAS → 解决如何无锁地原子更新状态volatile → 解决如何让多线程看到最新状态LockSupport → 解决获取不到时如何等待释放时如何唤醒三者组合 → 构建 AQS### 1.5 相关联想进程与线程 **概念澄清** - 进程 资源分配的基本单位JVM 就是一个进程 - 线程 CPU 调度的基本单位JUC 操作的是线程 **CPU 与线程的关系** - 某一瞬间一个核心执行一个线程一对一 - 宏观上通过时间片轮转多核服务多线程多对多 **大核 vs 小核** - 本质一样区别是性能和功耗 - 由操作系统调度器决定分配应用程序无法直接控制 --- ## 第二层AQSAbstractQueuedSynchronizer ### 2.1 AQS 解决的问题 Doug Lea 发现各种同步器有大量重复逻辑提取出 AQSReentrantLock、Semaphore、CountDownLatch 的共同点都需要一个状态获取失败都要排队排队时都要阻塞释放时都要唤醒↓ 提取共同点 ↓AQS一个状态state一个等待队列CLH阻塞/唤醒机制获取/释放的流程控制**这就是 DRY 原则的典范** ### 2.2 AQS 核心组成AQS├── statevolatile int│ └── 用 CAS 修改含义由子类定义│└── CLH 队列双向链表└── 存放等待的线程FIFO 顺序### 2.3 模板方法模式┌─────────────────────────────────────────────────────────────────────┐│ AQS │├─────────────────────────────────────────────────────────────────────┤│ 框架提供固定流程 ││ - acquire()tryAcquire → 失败则入队 → 阻塞 → 被唤醒重试 ││ - release()tryRelease → 成功则唤醒队首 ││ - 队列管理、阻塞/唤醒 │├─────────────────────────────────────────────────────────────────────┤│ 子类实现定义语义 ││ - tryAcquire()什么条件算获取成功 ││ - tryRelease()什么条件算释放成功 │└─────────────────────────────────────────────────────────────────────┘### 2.4 独占模式 vs 共享模式 **⚠️ 重点理解** 区别不是能有几个线程获取而是有没有所有者 | 模式 | 核心特征 | 代表 | |------|----------|------| | 独占 | 有主人谁加锁谁解锁支持重入 | ReentrantLock、写锁 | | 共享 | 无主人获取和释放可以是不同线程 | Semaphore、CountDownLatch、读锁 |Semaphore(1) 效果上像独占但线程 A acquire线程 B 可以 release甚至可以凭空 release增加许可ReentrantLock线程 A lock线程 B unlock → 抛异常必须是同一个线程### 2.5 AQS 总结AQS 本质 抽象队列同步器 一个 state 一个双向队列 利用 CAS 保证原子性 利用 volatile 保证可见性 利用 LockSupport 控制线程阻塞/唤醒 模板方法让子类定义语义--- ## 第三层基于 AQS 的同步器 ### 3.1 ReentrantLock可重入锁 **state 含义**0 无锁0 重入次数 **核心特性** - 可重入同一线程多次获取state 1 - 有所有者记录持有锁的线程 - 公平/非公平可选 **公平 vs 非公平**非公平默认新线程来了先尝试 CAS 抢锁失败才排队公平新线程来了先看队列有没有人有人就乖乖排队非公平性能更好减少线程切换开销**⚠️ 为什么需要可重入** java methodA() { lock.lock(); methodB(); // B 里也要加锁 lock.unlock(); } methodB() { lock.lock(); // 如果不可重入这里会死锁 lock.unlock(); }3.2 Semaphore信号量state 含义剩余许可数工作方式acquire()state 0 则 state - 1否则等待release()state 1唤醒等待者典型场景限流、资源池3.3 CountDownLatch倒计时门闩state 含义剩余计数工作方式countDown()state - 1到 0 时唤醒所有等待者await()state 0 则阻塞 0 则通过特点一次性用完不能重置3.4 CyclicBarrier循环屏障注意不是直接基于 AQS而是基于 ReentrantLock Conditionvs CountDownLatchCountDownLatchCyclicBarrier一次性可重用countDown 和 await 分离所有人都调用 await一方等多方多方互相等待3.5 ReentrantReadWriteLock读写锁state 含义一个 int 拆成两部分高 16 位 读锁持有线程数低 16 位 写锁重入次数⚠️ 重点理解为什么读锁要计数场景3 个线程同时读 线程 A 获取读锁 → 读锁数 1 线程 B 获取读锁 → 读锁数 2 线程 C 获取读锁 → 读锁数 3 线程 A 释放读锁 → 读锁数 2B、C 还在读 线程 B 释放读锁 → 读锁数 1C 还在读 线程 C 释放读锁 → 读锁数 0没人读了写锁可以进来 如果只用 0/1 线程 A 释放 → 读锁 0写锁进来破坏 B、C 正在读的数据读锁计数的作用防止写锁在读的过程中插入读写冲突互斥规则读读并行读写互斥写写互斥与数据库读写锁的关系思想层面一样的实现层面数据库更复杂多粒度、意向锁、MVCC、死锁检测3.6 同步器对比同步器模式可重用典型场景ReentrantLock独占是替代 synchronizedSemaphore共享是限流、资源池CountDownLatch共享否等待 N 个任务完成CyclicBarrier条件变量是多阶段并行计算ReadWriteLock独占共享是读多写少场景第四层应用层4.1 并发集合设计思想演进思路 1全表锁Hashtable → 每个方法加 synchronized并发度 1太慢 思路 2分段锁JDK 1.7 ConcurrentHashMap → 分成 16 段每段一把锁并发度 16 思路 3CAS 细粒度锁JDK 1.8 ConcurrentHashMap → 空桶 CAS 插入非空桶 synchronized 锁头节点 思路 4写时复制CopyOnWriteArrayList → 读无锁写时复制整个数组4.2 ConcurrentHashMapJDK 1.8结构数组 链表 红黑树并发控制场景操作方式锁粒度桶为空CAS 插入无锁桶非空synchronized(头节点)锁单个桶扩容多线程协助分段处理为什么不用 ReentrantLocksynchronized 在 JDK 1.6 后优化很多不需要手动释放内存占用更小4.3 CopyOnWriteArrayList核心思想写时复制读操作直接读取数组不加锁 写操作 1. 加锁ReentrantLock 2. 复制原数组 3. 在新数组上修改 4. 把引用指向新数组 5. 释放锁优缺点✅ 读无锁性能高✅ 读写不阻塞❌ 写要复制内存开销大❌ 弱一致性可能读到旧数据适用场景读多写少配置列表、监听器列表、黑名单4.4 BlockingQueue核心思想生产者-消费者模式实现原理ArrayBlockingQueueReentrantLock 两个 Condition put() while (队列满) notFull.await() 插入元素 notEmpty.signal() take() while (队列空) notEmpty.await() 取出元素 notFull.signal()常见实现实现特点ArrayBlockingQueue数组有界一把锁LinkedBlockingQueue链表可选有界两把锁SynchronousQueue不存储直接传递PriorityBlockingQueue优先级队列DelayQueue延迟队列4.5 ThreadPoolExecutor为什么需要线程池每次 new Thread() 开销大线程数不可控线程用完就销毁浪费核心参数corePoolSize核心线程数maximumPoolSize最大线程数keepAliveTime非核心线程空闲存活时间workQueue任务队列BlockingQueuethreadFactory线程工厂handler拒绝策略执行流程提交任务 ↓ 核心线程有空闲 → 是 → 核心线程执行 ↓ 否 队列未满 → 是 → 放入队列等待 ↓ 否 线程数 最大 → 是 → 创建非核心线程执行 ↓ 否 执行拒绝策略拒绝策略策略行为AbortPolicy抛异常默认CallerRunsPolicy调用者线程执行DiscardPolicy静默丢弃DiscardOldestPolicy丢弃队列最老的4.6 ForkJoinPool两大核心思想1. 分治思想大任务 ↓ fork ┌──────┴──────┐ 子任务1 子任务2 ↓ ↓ 结果1 结果2 └─────┬─────┘ ↓ join 最终结果2. 工作窃取每个线程有自己的双端队列 - 自己的任务从头部取LIFO - 偷别人的任务从尾部偷FIFO - 减少竞争自动负载均衡⚠️ 联想Go 的 GMP 调度工作窃取思想是跨语言的Java ForkJoinPool线程闲了偷别人的任务Go GMPM 闲了偷别人 P 的 G共同的设计哲学本地优先 全局兜底优先处理自己的任务无锁快自己没了去偷别人的有锁频率低都没了去全局队列找兜底4.7 CompletableFuture解决的问题复杂的异步任务编排核心能力创建异步任务supplyAsync() / runAsync()链式处理thenApply() / thenAccept() / thenRun()组合任务allOf() / anyOf() / thenCombine()异常处理exceptionally() / handle()vs CountDownLatch以前 CountDownLatch latch new CountDownLatch(3); // 手动管理... 现在 CompletableFuture.allOf(task1, task2, task3) .thenAccept(result - 处理); 更简洁、更直观本质下层同步器的集大成者封装了 CountDownLatch、Semaphore 等的复杂性4.8 第四层总结线程池 装线程的集合管理、复用、调度 ForkJoinPool 分治思想 工作窃取 CompletableFuture 集大成者 → 封装底层同步器 → 链式调用 → 不用手动写 CountDownLatch、Semaphore 等JUC 核心设计思想1. 分层抽象底层原语 → AQS 框架 → 具体同步器 → 应用组件 每层只关心自己的职责向上提供抽象2. DRYDon’t Repeat YourselfAQS 提取了所有同步器的共同逻辑子类只需定义语义3. 模板方法模式AQS 定义流程骨架子类填空4. 锁粒度细化全表锁 → 分段锁 → 节点锁 → 无锁CAS5. 空间换时间CopyOnWrite复制数组换取读无锁LongAdder多个 Cell 换取减少竞争ThreadLocal每线程一份换取无竞争6. 工作窃取本地优先 闲时帮忙自动负载均衡易错点和重点标注⚠️ volatile 不保证原子性i 是三步操作volatile 无法保证原子性⚠️ LockSupport 不是 wait/notify 的封装两套独立机制LockSupport 解决了 wait/notify 的痛点⚠️ 独占 vs 共享的核心区别不是几个线程能获取而是有没有所有者⚠️ 读写锁为什么读锁要计数防止写锁在读的过程中插入只有读锁数 0 写锁才能进来⚠️ ForkJoinPool 的工作窃取和 Go GMP 调度思想一致是跨语言的设计智慧整体关系图┌─────────────────────────────────────────────────────────────────────────────┐ │ │ │ CompletableFuture / ThreadPoolExecutor / ConcurrentHashMap │ │ ↑ │ │ 依赖/组合 │ │ │ │ │ ReentrantLock / Semaphore / CountDownLatch / BlockingQueue │ │ ↑ │ │ 继承 │ │ │ │ │ AQS │ │ (state CLH队列) │ │ ↑ │ │ 基于 │ │ │ │ │ CAS volatile LockSupport │ │ ↑ │ │ 依赖 │ │ │ │ │ Unsafe / JVM / CPU │ │ │ └─────────────────────────────────────────────────────────────────────────────┘学习心得好的设计思想是跨语言的理解底层原理比记住 API 更重要。