/蚂蚁课堂第九期/' o6 p6 ]+ Y; c2 k+ S
├──000.第九期-开班相关说明 # E" {6 c" H. {3 f4 L4 L
| ├──01.第一节-每特教育第九期上课时间安排_ev.mp4 46.42M$ m. C. k+ _& Y& O, a4 Q- |
| ├──02.第二节-常用开发的工具整理_ev.mp4 23.62M
9 d, `/ @' [+ E| ├──03第三节-程序员如何选择电脑配置_ev.mp4 14.96M
$ w5 b- T) r4 n& W| ├──04.第四节-腾讯课堂上课标题不一致的问题_ev.mp4 15.43M E, S0 I: }3 y* K( n& z1 G
| ├──05.第五节-第九期新增了哪些知识点01_ev.mp4 51.65M0 ]" K$ X. b; i- g
| ├──06.第六节-第九期新增了哪些知识点02_ev.mp4 94.98M
/ {! ^* _- J/ D- f| ├──07.第七节-程序员开发资料如何下载_ev.mp4 14.52M
1 a4 v R) Y+ _' ~| └──09.00每特教育第九期开班相关说明_ev.mp4 261.55M
# q- {% ?" R4 R. s/ i5 B/ {├──001.第九期-基础知识回顾之掌握Java反射自定义注解底层设计原理与封装限流的框架 $ R" x+ T) e1 g! k' e9 \6 D
| ├──01.第一节-反射与自定义原理课程安排_ev.mp4 13.74M
% q, u$ @. C% y* h" e7 ^+ E/ U| ├──02.第二节-什么是反射&反射基本概念_ev.mp4 35.03M
! f0 m! x( x* h) Q% O| ├──03.第三节-反射的应用场景_ev.mp4 12.23M
o7 a S& f2 e| ├──04.第四节-反射机制使用的三种方式_ev.mp4 53.71M
& I: ~+ F/ O( z) I$ c| ├──05.第五节-使用反射机制初始化对象_ev.mp4 24.12M
* u- l' C: l9 R4 C. n3 ^| ├──06.第六节-反射如何给属性赋值_ev.mp4 34.06M7 P+ P+ ]! @5 B" @" Q$ ~4 f4 g
| ├──07.第七节-使用反射机制调用方法_ev.mp4 29.83M0 S! a# U+ _4 T2 G. h
| ├──08.第八节-反射如何越过泛型检查_ev.mp4 19.40M. H2 w: r! O$ g, v- `; }
| ├──09.第九节-注解的基本概念与介绍_ev.mp4 60.26M4 O$ g+ @+ g% Y, R
| ├──10.第十节-使用guava对微服务接口实现限流_ev.mp4 18.25M% v) {4 z3 E+ L! H& |1 w3 Y7 B
| ├──11.第十一节-使用aop环绕通知拦截目标方法01_ev.mp4 36.20M
! m) Q# U# Y4 v4 C7 x| ├──12.第十二节-使用aop环绕通知拦截目标方法02_ev.mp4 73.28M N# Z) _4 ?, R; _' @ U3 i
| ├──13.第十三节-使用aop+反射+自定义注解实现限流框架_ev.mp4 58.76M) L2 u4 y4 f7 p, g3 k
| └──资料.zip 195.75kb, v l. v; v- L
├──002.第九期-基础知识回顾之多线程快速入门与实际项目如何整合多线程
# O6 s0 s5 n# i6 n| ├──01.第一节-多线程第一次课程内容安排.mp4 72.27M
/ @1 \( }' h9 r6 k3 [& y| ├──02.第二节-什么是线程、进程.mp4 73.12M1 H' c/ Y/ X; ]7 R* i% R& n
| ├──03.第三节-为什么在进程中还需要线程呢.mp4 19.45M
+ ?8 g, n& R' p |7 e/ P! O1 D| ├──04.第四节-为什么需要使用多线程与单与并行区别.mp4 70.28M1 \* `! m& J2 l: A8 y% B
| ├──05.第五节-使用多线程一定提高效率吗.mp4 117.94M9 Q. s2 O2 W1 K& A2 V) M
| ├──06.第六节-多线程的应用场景有哪些呢.mp4 33.20M1 ~9 |* m8 G+ ~6 O- x9 ^; ^; z
| ├──07.第七节-同步与异步之间的区别.mp4 19.40M
5 P: G7 `8 V' E! P% a, q3 j ?| ├──08.第八节-继承Thread类创建线程.mp4 62.27M
8 a/ p$ o5 s( x1 Z| ├──09.第九节-实现Runnable接口创建线程.mp4 36.71M! I2 j8 N1 U( [6 ?* z
| ├──10.第十节-使用Callable和Future创建线程.mp4 126.13M2 W5 w) u1 @ D7 i: D) |0 G$ z
| ├──11.第十一节-使用线程池的方式创建线程.mp4 22.31M
3 `+ z0 \" y3 X% @0 y# c& y| ├──12.第十二节-@Async异步注解创建线程.mp4 85.50M, q b! a" V3 y5 w
| └──13.第十三节-手写@Async异步注解.mp4 126.41M! T* F9 _4 U( q2 h
├──003.每特教育第九期-基础知识回顾之synchronized锁使用与线程之间如何实现通讯 2 h& j! u' I8 x C
| ├──01.第一节-什么是线程安全问题.mp4 105.82M
1 m( Z: O$ [8 i" O1 N! k| ├──02.第二节-如何解决线程安全问题.mp4 110.17M9 ^* d, ~3 a3 y( j
| ├──03.第三节-synchronized锁基本的用法01.mp4 67.59M5 u% ~& u# ]4 f
| ├──04.第四节-synchronized锁基本的用法02.mp4 63.04M
/ R% w# ~, i1 b# e" H| ├──05.第五节-synchronized死锁问题.mp4 74.18M
( x5 a6 T5 t* p+ X* X' X0 N| ├──06.第六节-如何诊断synchronized死锁问题.mp4 25.14M' |. W0 A2 O6 Q2 o. n9 {, y
| ├──07.第七节-如何保证线程同步问题.mp4 21.51M5 h4 `( s/ ~8 A; l/ p- a
| ├──08.第八节-springmvc接口中使用synchronized.mp4 72.19M; E6 Y- U" b* ?3 |5 [) }) j/ P) {
| ├──09.第九节-使用wait、notify注意事项.mp4 60.46M ^6 T# ?% L, o( L& Z
| ├──10.第十节-wait、notify生产者与消费者模型01.mp4 89.50M
# {5 x* f; g$ l& K| ├──11.第十一节-wait、notify生产者与消费者模型02.mp4 104.08M
& ^' U/ m [2 L b. H" Y| └──code.zip 810.47kb
7 w, a1 N* K/ x9 p6 C* e4 V1 Y├──004.第九期-基础知识回顾之多线程核心API与Lock锁使用
; k$ {) M- y' |7 v. b) A| ├──01.第一节-画图分析wait与notify实现原理.mp4 225.03M3 I' t8 t% c J+ m) U) s3 P
| ├──02.第二节-join方法底层的设计原理.mp4 123.76M
1 \; {, M" J9 t$ c' D| ├──03.第三节-多线程底层七种状态.mp4 95.29M$ x9 b+ b3 D/ u2 f; L1 _3 B
| ├──04.第四节-sleep防止CPU占用100%.mp4 45.25M
) a$ p6 j/ ]; z# x: Y5 H| ├──05.第五节-守护与用户线程的区别.mp4 31.01M" O2 S* j6 L& x9 O1 q
| ├──06.第六节-如何安全的停止一个线程.mp4 66.24M
6 E3 c& L1 \. @+ U7 X| ├──07.第七节-lock与synchronized的区别.mp4 26.09M! v9 B; F( j0 X
| ├──08.第八节-简单演示lock锁使用方式01.mp4 76.73M
* w* y7 I8 X7 ^9 C| ├──09.第九节-简单演示lock锁使用方式02.mp4 22.20M
6 p4 X5 _) G0 u$ D$ {1 Z" J/ a| ├──10.第十节-lock的condition用法.mp4 44.71M9 t& ?0 M# \7 B. E& [9 p+ r
| ├──11.第十一节-多线程的yield方法使用.mp4 29.52M
; ^: g. o1 l& @6 v| ├──12.第十二节-多线程的优先级.mp4 34.72M
0 U( R# c' u# I6 ` E8 D& Z| ├──13.第十三节-wait与sleep之间的区别.mp4 31.54M; Q: `$ ~7 m/ W
| └──14.第十四节-为什么wait和notify在object父类中.mp4 19.68M f' m! o$ P& @: \1 ^7 Y
├──005.第九期-基础知识回顾之多线程综合实战案例与纯手写日志框架
( u7 v; r, z( s+ A: K1 K* e| ├──01.第一节-字节码指令角度分析线程安全问题.mp4 134.05M h$ ^. p, T! n: e# S6 B+ ^: V
| ├──02.第二节-画图分析字节码指令角度分析线程安全问题.mp4 60.39M9 ?+ u# v( U* ]* C; I6 q5 U( A
| └──03.第三节-Callable与FutureTask原理分析01.mp4 3.38M
$ K5 S& n0 }0 Z+ K. f' h* A├──006.第九期-JUC并发编程之CAS原子类底层原理
6 r$ F: u" {: l2 \% p- u, n| └──01.第一节-什么是悲观锁.mp4
. d! l8 P4 q4 I( ]* O├──007.第九期-JUC并发编程之基于cas+LockSupport锁手写锁的升级过程 5 K/ ? H; l- c/ n2 r
| ├──01.第一节-如何手写重入锁.mp4 139.08M! P8 k/ S: o( G3 x3 y
| ├──02.第二节-代码纯手写重入锁.mp4 94.05M: L0 e* M. X1 g4 z/ S# o3 d
| ├──03.第三节-偏向锁轻量级锁重量级锁应用场景01.mp4 100.96M4 U7 x! o! n# D) h9 d, ^
| ├──04.第四节-偏向锁和轻量锁和重量锁引用场景02.mp4 104.22M1 q' B: p/ I3 M# b
| ├──05.第五节-画图分析手写cas锁底层原理.mp4 53.34M( C- s# o$ ~8 U# e/ H7 z7 s$ L
| ├──06.第六节-手写轻量锁升级的过程.mp4 86.87M& v7 g$ Q$ H$ C+ {
| ├──07.第七节-源码调试手写轻量锁升级过程.mp4 98.88M
- A( l& o$ w4 t# g7 n| ├──08.第八节-纯手写轻量锁升级过程课程疑问总结.mp4 18.00M
7 \( K+ v2 w: O0 X* s. c/ ^% L0 g; Q| ├──09.第九节-偏向锁与重入锁之间的区别.mp4 60.84M. o1 O. Y2 b1 N5 Z1 Q2 D o
| ├──10.第十节-公平锁与非公平锁的区别.mp4 99.69M- B, j1 v3 a6 g
| └──资料.zip 195.75kb) O8 e( l% P8 W! _* C+ O. s! N2 c# o
├──008.第九期-JUC并发编程之从对象角度获取synchronized升级过程 1 I: c |* Z, |9 R
| ├──01.第一节-偏向锁轻量级锁重量级锁应用场景.mp4 100.96M
4 l' ^8 Z: D6 ^$ s+ G; P| ├──02.第二节-java对象的布局底层实现原理.mp4 159.15M x1 p0 h7 k' _
| ├──03.第三节-new出一个对象至少占用多少字节.mp4 41.60M
4 `6 u8 s) L0 \, r+ o! M| ├──04.第四节-对象内存中offset作用.mp4 69.37M5 E; G2 ]( i* j# d! @$ c3 {( O
| ├──05.第五节-通过对象头获取锁的升级信息.mp4 129.76M D+ J, u& G! |) f
| ├──06.第六节-如何在对象头获取HashCode.mp4 80.04M. b' n7 f% d& U- @; y
| ├──07.第七节-如何从对象头获取偏向锁.mp4 67.54M
' T! b8 M) c( X6 Z+ n/ G7 ^| ├──08.第八节-如何从对象头获取轻量锁.mp4 67.50M
8 h$ M2 C; `. I4 Z| ├──09.第九节-完整链演示锁的升级过程.mp4 98.03M
, O3 T) u( J: O% Q! l* I4 \| ├──10.第十节-如何从对象头锁的信息课程总结.mp4 40.32M9 Z; ~3 |4 e, _5 o% M K: T+ n& i; _# s
| └──资料.zip 195.75kb
! ~0 l6 r! N0 k. _/ n├──009.第九期-JUC并发编程之synchronized锁升级过程原理分析 . r: ~) ~/ u. U; E i2 G
| ├──01.第一节-简单回顾对象头与锁的升级过程.mp4 75.54M9 N7 [1 H& L3 X* U8 o5 @% x
| ├──02.第二节-画图分析synchronized轻量锁获取锁实现原理.mp4 126.88M
2 c% z9 _, y5 P0 O _8 e| ├──03.第三节-画图分析synchronized轻量锁释放锁原理.mp4 182.59M) A4 r0 w7 D* S" G' j
| ├──04.第四节-画图分析synchronized轻量锁释放锁原理.mp4 20.13M
2 U- C( a5 h% F4 k% n| ├──05.第五节-字节码角度分析Monitor指令.mp4 96.66M
3 y) K% m2 {" `| ├──06.第六节-Monitor指令分析.mp4 66.26M* \9 K7 ~6 ~- P; a% m
| ├──07.第七节-Monitor虚拟机源码解读分析.mp4 105.59M" n4 d; X/ L6 R3 [, X. Y
| └──资料.zip 195.75kb* E- y; m- K0 f2 h
├──010.第九期-JUC并发编程之画图分析synchronized锁的升级过程
# w0 S$ h, `. d2 o& _| ├──01.第一节-synchronized终极底层原理总结介绍.mp4 29.59M
1 w, j9 q' a4 A: ]| ├──02.第二节-画图分析synchronized偏向锁原理01.mp4 113.32M
' P; B4 ~$ G+ K# L" o7 i| ├──03.第三节-画图分析synchronized撤销原理.mp4 53.70M
8 z6 q$ C6 e& L$ u* h| ├──04.第四节-画图分析synchronized轻量级锁原理.mp4 117.94M( D3 S1 B1 A: W7 L8 ]& @: l
| ├──05.第五节-画图分析synchronized重量级锁原理.mp4 53.03M
3 M# z3 z0 b: w. N8 t4 R7 f: ^| ├──06.第六节-画图分析synchronized批量重偏向锁.mp4 144.78M3 M, t0 }( h. W3 V8 Z+ Y- a
| ├──07.第七节-画图分析synchronized批量撤销.mp4 65.36M0 K3 Y) N" `+ C$ h
| ├──08.第八节-synchronized锁的粗化.mp4 16.57M5 e- z" |- [; G$ i7 Y: ~
| ├──09.第九节-synchronized锁的消除.mp4 23.10M
, u% i& o; Y* l/ [( z0 `| └──09.第十节-完整文字版本总结synchronized原理.mp4 130.39M. {6 P0 H- A6 U) s, j: o
├──011.第九期-JUC并发编程之Threadlocal如何避免内存泄漏问题
" ^3 e( g% p/ j4 z9 h( ]" b| ├──01.第一节-Threadlocal原理解析课程内容安排.mp4 18.68M
# z/ `$ K; d y/ l Y) @* }2 P| ├──02.第二节-Threadlocal基本的用法.mp4 40.69M
: Y7 d, |7 O& U# K' E5 h. b2 O| ├──03.第三节-Threadlocal应用场景有哪些..mp4 49.72M# K6 C/ D. A2 [4 H% Q. G: R
| ├──04.第四节-Threadlocal真实例子讲解..mp4 112.83M
: S2 i* F3 X) v& \8 ?. B& m# J| ├──05.第五节-内存泄漏与内存溢出区别.mp4 27.33M9 p& W1 A- a5 B5 O: M# d: ?# J
| ├──06.第六节-什么是强引用.mp4 52.39M
1 e/ c& g/ Z% C! `4 P" u- a, s( y' W/ v| ├──07.第七节-什么是软引用.mp4 62.72M
" g1 J- I, z% q5 `# o' w3 `1 U. N| ├──08.第八节-什么是弱引用.mp4 26.65M0 b# s& i' D2 T0 K6 K. X) {
| ├──09.第九节-Threadlocal底层源码解读.mp4 116.00M9 T6 c6 Z$ { Y A, m* b s
| ├──10.第十节-Threadlocal内存泄漏原因分析01.mp4 108.27M
. Z: s/ E" n5 T; N+ n| ├──11.第十一节-Threadlocal内存泄漏原因分析.mp4 77.47M
k3 w' g6 U9 h5 w2 S$ l| └──12.第十二节-Threadlocal课程内容总结.mp4 45.19M
2 j. b7 U. z% I4 u* e├──012.第九期-JUC并发编程之Java内存模型底层原理 , W3 o% A/ m* e
| ├──01.第一节-为什么需要加上Volatile.mp4 66.14M; `4 G9 e2 O, [. u. ?9 N9 A
| ├──02.第二节-Volatile关键字基本概述.mp4 28.95M6 ^' j# m" P, H s) @ Q4 {
| ├──03.第三节-Volatile基本用法.mp4 43.80M
; V" C# W! h h8 k5 k6 }! C: k| ├──04.第四节-cpu多级缓存的作用.mp4 67.52M+ x3 e/ p% Y8 Q r" L# R4 x- G
| ├──05.第五节-为什么会发生线程可见性.mp4 66.93M
- N! x8 C, B9 m7 t" z6 {| ├──06.第六节-什么是java内存模型.mp4 59.49M) P1 m% w) j+ i! @( A/ K% g
| └──07.第七节-JMM八大同步规范.mp4 128.58M8 I& ?9 C( t4 B( D
├──013.第九期-JUC并发编程之Volatile关键字底层原理
" @9 x3 G, g# A" q| ├──01.第一节-volatile关键底层实现原理.mp4 115.97M
* l! G0 F5 O7 ?6 C+ [( D| ├──02.第二节-mesi缓存一致性协议原理.mp4 79.47M' s! l0 P1 q. ~
| ├──03.第三节-为什么volatile不能够保证原子性.mp4 65.48M& a; i/ X( W1 m) G$ M* B
| ├──04.第四节-为什么System.out.println保证线程的可见性.mp4 70.83M
2 L; A! g9 r: \| ├──05.第五节-什么是重排序.mp4 27.98M
3 d5 g& V ]- S8 L6 [% N| ├──06.第六节-多线程的情况下发生重排序结果会有哪些影响.mp4 67.93M
2 u5 a' R. f R( e& L# C9 e- Z; e| └──07.第七节-演示多线程情况下重排序产生的问题.mp4 110.29M4 q) J1 ]1 n, k3 s7 a: K, O9 N
├──014.第九期-JUC并发编程之单例模式七种写法与如何破解单例
3 j+ F/ c6 @0 F- z/ @| ├──01.第一节-什么是单例模式.mp4 21.38M& w0 \; c, b4 d& F; ?1 L1 u6 m8 X# `
| ├──02.第二节-懒汉式线程不安全.mp4 38.62M
1 W4 U* j' f' ~# k% ?( b" u| ├──03.第三节-懒汉式线程安全.mp4 34.46M
; C; N4 B* n0 b4 \, F4 ^| ├──04.第四节-懒汉式双重检验锁.mp4 61.68M$ k1 |* h- B8 E0 Y
| ├──06.第六节-饿汉式.mp4 37.00M
- b* @/ t- H& |; g5 P| ├──07.第七节-静态代码单例.mp4 12.83M
' k" `. k+ [7 t/ q; B| ├──08.第八节-静态内部类的形式.mp4 48.44M E* y7 Q- ]9 v9 ]9 z" U
| ├──09.第九节-枚举单例.mp4 52.32M, E( `7 o1 z5 v8 \8 [- d, K2 w1 b/ ~
| ├──10.第十节-反射如何破解单例模式.mp4 138.96M
8 t3 S) K' X5 U5 |0 c9 W| ├──11.第十一节-序列化如何破解单例.mp4 43.07M' j3 @0 v& ^$ M- t0 j! W
| ├──12.第十二节-序列化如何防止单例破解.mp4 98.67M. T/ |6 A. {: W1 L
| ├──13.第十三节-java真的能够实现真正意义上单例吗.mp4 16.90M
; q: C1 |4 K( V) Z* W| ├──14.第十四节-反射破解枚举单例.mp4 80.85M4 O3 }1 `9 ~' m3 ^9 Y8 }- c
| └──15.第十五节-枚举如何防御反射破解单例.mp4 68.00M# C- X: `0 p. @8 y9 s& Z0 M
├──015.第九期-JUC并发编程之内存屏障实现原理 ( W; `3 \- A' b @- t
| ├──01.第一节-什么是缓存行.mp4 105.03M- k: x" u) a) ^& q0 e" u7 A, V
| ├──02.第二节-为什么加上Volatile效率变低01.mp4 36.13M; b4 S% ^/ L: e) _$ v) ]" c: M( V
| ├──02.第二节-为什么加上Volatile效率变低02.mp4 157.13M% X5 e/ M3 j& v1 t
| ├──03.第三节-@sun.misc.Contended.mp4 21.88M' E$ t8 D; ~* b6 e
| ├──04.第四节-重排序有哪些好处.mp4 29.82M
7 ?) x0 N4 A( m! B9 J9 b| ├──05.第五节-编译与处理器重排序.mp4 181.91M
- u! z Y: h' w4 \| ├──06.第六节-双重检验锁单例为什么需要加上Volatile.mp4 129.80M
8 N; k' L X0 {7 ^3 R| ├──07.第七节-内存屏障如何保证可见性和禁止重排序.mp4 132.53M
' X6 a3 T" B$ J2 d1 k| ├──08.第八节.unsafe类调用内存屏障实现禁止重排序.mp4 73.86M
- Q- X7 S$ M: V. p9 O t| ├──09.第九节-写内存屏障的疑问.mp4 16.62M* D" i$ i/ K5 f7 W# S
| ├──10.第十节-happens-before规则.mp4 47.00M8 G( ^4 y. r' s m' q' K& \
| └──资料.zip 195.75kb
" N: m3 \! z! t& ~├──016.第九期-JUC并发编程之BlockingQueue实现原理
4 ]; o% e' V" ~# d9 p; u% U+ ]| ├──01.第一节-队列模型的架构设计.mp4 58.38M3 z- M9 \% s2 U; M- T
| ├──02.第二节-数组与链表结构模型.mp4 88.81M) s6 I7 U$ ]( h; o. t2 ~
| ├──03.第三节-基于链表实现队列原理.mp4 70.13M/ @/ O9 f W( Q- ~; o9 T' m
| ├──04.第四节-简单回顾lock锁的使用.mp4 29.03M
. C" n8 I4 E3 Z| ├──05.第五节-Arrayblockingqueue的用法01.mp4 143.44M
% p3 \9 u3 b% ]- R/ T| ├──06.第六节-Arrayblockingqueue的用法02.mp4 66.14M5 u! y& d! C( r! |3 e0 O$ O) x
| ├──07.第六节-Arrayblockingqueue的用法03.mp4 30.21M* n& ?$ U/ y1 n; h: u0 q3 N8 u
| ├──08.第八节-纯手写Arrayblockingqueue存储功能.mp4 95.97M0 X& }/ I+ I! ?) B' N( l I" n* \+ G0 b: R: ^
| ├──09.第九节-基于Arrayblockingqueue实现生产者与消费者模型.mp4 117.37M
1 P2 }' p9 U2 H# `, W! K$ w1 F* A; i| ├──10.第十节-Arrayblockingqueue阻塞功能如何实现.mp4 116.21M7 Z$ J5 O9 ?' e3 k6 `/ j. K' _' \! K
| ├──11.第十一节-完善手写Arrayblockingqueue.mp4 59.09M( p( S' U4 B4 F8 y d
| └──12.第十二节-Linked与arraylBlockingQueue区别.mp4 102.53M
@; o6 S& D# u4 i├──017.第九期-JUC并发编程之线程池底层实现原理 0 N- M; w3 e9 q D' F
| ├──01.第一节-为什么使用线程池.mp4 110.47M1 k5 {1 v1 D3 J: _
| ├──02.第二节-线程池的作用有哪些.mp4 76.25M7 L: m$ u; I- e# b) d/ `
| ├──03.第三节-线程池四种创建方式.mp4 53.44M
0 ?7 ^$ B& z0 G$ Y| ├──04.第四节-线程池之可定长度和单例线程池.mp4 29.03M; ` y* f; x" x+ u" O4 m
| ├──05.第五节-可定时线程池.mp4 11.49M6 o3 v0 W5 x, F
| ├──06.第六节-手写线程池底层实现原理思路.mp4 83.17M& L9 g! k% E* P+ X) {
| ├──07.第七节-代码纯手写线程池.mp4 84.77M
5 c& M0 \9 a1 @+ l| ├──08.第八节-代码手写线程池之如何停止线程池.mp4 53.67M
( E- f0 ^1 \- E Y. R/ E| ├──09.第九节-手写线程池如何避免cpu飙高的问题.mp4 173.31M: B2 L. M4 m" u6 M
| ├──10.第十节-threadpoolexcutor核心参数.mp4 69.30M
( \) Z; Q0 x, J o5 g; M' s4 C* T| ├──11.第十一节-如何自定义线程池.mp4 149.56M
" _& |, Y* F2 g. J1 s! _7 x; t u| ├──12.第十二节-为什么阿里巴巴Java开发手册中强制要求线程池不允许使用Executor.mp4 27.67M
- s, r: l8 j1 b& O J| ├──13.第十三节-线程池队列满了如何处理呢拒绝策略.mp4 73.96M; C3 ~& K1 {" F% v
| ├──14.第十四节-如何自定义线程池名称.mp4 38.96M5 [+ ?$ M0 v( S* t0 ?% v
| ├──15.第十五节-线程池五种状态.mp4 48.67M' Y3 b) Q. {8 n U
| ├──16.第十六节-线程池内部底层实现原理.mp4 108.76M
) s4 k: C& }& ?; x# T0 P- F' T/ ~| ├──17.第十七节-线程池内部工作线程如何一直运行状态.mp4 35.04M
- |9 ~3 H- f. W9 I/ q| ├──18.第十八节-线程池核心线程数如何配置.mp4 116.52M
- n5 t, d+ p l# [% N| └──19.第十九节-SpringBoot如何整合线程池.mp4 21.34M
1 z. P; Z( W- |( a9 Y4 @├──018.第九期-JUC并发编程之AQS底层实现原理
% _$ z* |+ q8 ?4 x) a| ├──01.第一节-什么是AQS.mp4 46.94M
* ~1 w" W7 }0 D7 i" \| ├──02.第二节-简单回顾AQS设计知识点.mp4 40.95M
% P5 J7 U0 s# v) E| ├──03.第三节-简单回顾CAS底层原理.mp4 50.95M
2 [* J9 e9 E" c" B8 e6 V; v| ├──04.第四节-简单回顾locksupport.mp4 25.21M3 k3 n: i! w9 @
| ├──05.第五节-lock锁源码解读.mp4 124.17M& _! x9 a, {8 Y8 |
| ├──06.第六节-非公平锁源码解读01.mp4 43.87M* L: s+ f) E( G8 h# C
| ├──07.第七节-非公平锁源码解读02.mp4 329.45M3 d5 N8 d# z6 P
| ├──08.第八节-lock双向链表结构疑问.mp4 30.40M, V& e `3 ^% G& w* R
| ├──09.第九节-AQS中为什么头结点是为空的01.mp4 40.61M4 K8 @# X' o! ~5 S. v* Z7 t, K, ~
| ├──10.第十节-AQS中为什么头结点是为空的02.mp4 8.11M4 f: n4 F6 I g- B$ k; H
| ├──11.第十一节-简单回顾AQS基本实现原理.mp4 163.20M5 ]* J$ q- H8 j8 r$ w
| ├──12.第十二节-AQS源码分析之如何阻塞一个线程01.mp4 151.25M
: I" j7 I) v; G' z| ├──13.第十三节-AQS源码分析之如何阻塞一个线程02.mp4 107.83M
0 [6 ?$ L ?6 ~% j( I7 g- B8 E| ├──14.第十四节-AQS源码之重入锁如何实现.mp4 38.64M
% s- Q0 c; V$ s" T) E4 o$ F| ├──15.第十五节-Lock锁如何释放锁的.mp4 157.70M
6 t& A1 Q6 ?7 x5 O: L: X, a| ├──16.第十六节-Lock底层公平与非公平锁实现区别.mp4 31.09M; \; B- |( a2 q8 w
| └──17.第十七节-AQS源码总结.mp4 11.67M2 ~% D# i5 r0 I! w! L+ H" j
├──019.第九期-JUC并发编程之Lock锁的condition源码解读 & ^0 B6 k) P& K: I( A& Y# r
| ├──01.第一节-回顾等待池与锁池之间的区别.mp4 118.41M
3 B9 i) @8 H' F' i* j: w( |% [| ├──02.第二节-等待池源码解读.mp4 57.07M% A" v7 i) Y9 U2 ]+ H" u- Z; a
| ├──03.第三节-await方法底层源码解读01.mp4 102.70M
$ Y' P. p8 {- w| ├──04.第四节-await方法底层源码解读02.mp4 149.64M5 W1 p/ H( i& Y+ u' X: Z5 e
| └──05.第五节-如何唤醒等待池中的线程.mp4 94.99M0 O% U& H1 {* z9 l. r7 v: d+ P( @: N
├──020.第九期-JUC并发编程之Semaphore源码解读 - }; Z0 L1 N1 S, ?' B& m! _* d% ~5 j
| ├──01.第一节-Semaphore基本用法.mp4 146.38M
4 \2 |; _5 o9 G0 Z7 W. D" e8 S| ├──02.第二节-Semaphore如何实现限流.mp4 70.42M# `+ r' p9 z( D6 e/ H3 n7 B
| ├──03.第三节-Semaphore源码解读01.mp4 340.08M
2 n+ K! [' n3 z$ v6 X! P; q| ├──04.第四节-Semaphore源码解读02.mp4 108.15M
# G: u: @/ e0 u: r) _% q9 T| └──资料.zip 195.75kb' p; n" ]7 `2 K; K5 e1 G
├──021.第九期-JUC并发编程之CyclicBarrier源码解读
9 o# q5 G7 Z* a2 e| ├──01.第一节-CyclicBarrier用法.mp4 115.10M' v8 K! N Y4 S" z7 c+ f4 f
| ├──02.第二节-CyclicBarrier源码解读.mp4 147.63M Z' L6 b: Z _4 G. Q1 A3 s7 P
| ├──03.第三节-CountDownLatch用法.mp4 58.93M2 @' {+ R# {+ b# k9 X
| ├──04.第四节-CountDownLatch源码解读01.mp4 67.84M
: G5 K' C& Q: j3 Q: N| ├──05.第五节-CountDownLatch源码解读02.mp4 102.67M
. z0 d. I& }% G" R| ├──06.第六节-AQS源码总结01.mp4 156.02M
P. Q* n% c1 U$ s1 D5 V4 W# I/ s7 _| ├──07.第七节-AQS源码总结02.mp4 56.82M
( b o1 j) e7 g2 F| └──08.第八节-AQS源码总结03.mp4 107.12M0 P3 j" C3 H; i6 a& ` ?' n
├──022.第九期-JUC并发编程之forkjoin底层原理
( Q( P8 }+ C% i d; q8 l| └──视频正在努力讲解中，后期讲解完毕会更新的.txt 0.08kb( z5 j) s, T! l$ z) Y% ~! g& @
├──023.每特教育第九期-JUC并发编程之disruptor原理 $ V( s: {2 L* i8 w, y
| └──视频正在努力讲解中，后期讲解完毕会更新的.txt 0.06kb
) [: h% k2 X. P) ]# Y$ T; h├──024.第九期-JVM专题之类加载器设计原理 7 W4 A* m9 b- G% Q( l$ t0 k
| ├──01.第一节-类加载概念引入.mp4 68.54M/ ]- s- H3 e, P
| ├──02.第二节-class文件读取的来源.mp4 12.71M1 [5 O. d4 u) X. s
| ├──03.第三节-类加载器的分类.mp4 177.72M U! ^" z6 Z- O* s, {7 `: d% A
| ├──04.第四节-什么是双亲委派机制.mp4 108.04M
! S v& C# g7 a3 m5 k: L| ├──05.第五节-双亲委派机制案例演示.mp4 45.99M0 n; N9 I! C3 R1 T
| ├──06.第六节-双亲委派机制源码解读01.mp4 102.39M
4 I/ {5 a9 }6 Q$ O( c7 A| ├──07.第七节-双亲委派机制源码解读02.mp4 22.76M
+ ^( M; @) C& _) `| ├──08.第八节-双亲委派机制源码解读03.mp4 133.77M
# p# V8 Z& m3 x: C' [- k4 g| ├──09.第九节-new一个对象class如何被加载.mp4 33.39M; d t3 e; W* H( H0 x6 b1 m
| ├──10.第十节-双亲委派机制原理细节分析.mp4 143.69M! v- Z0 S" v+ B. M) o7 }
| ├──11.第十一节-如何自定义一个类加载器.mp4 264.36M
* w4 f/ Z8 Q+ P p2 }1 _# C }9 q* N| ├──12.第十二节-如何手写一个热部署插件.mp4 71.67M% C7 H, x5 a! d; E
| ├──13.第十三节-代码一步一步手写热部署插件01.mp4 157.07M
0 L( n8 k7 a7 j3 r$ ^. o| ├──14.第十四节-代码一步一步手写热部署插件02.mp4 149.31M
' N. t6 E5 M( |* B+ ~1 h| └──15.第十五节-手写热部署插件的演示.mp4 42.19M* S9 Q, m4 x( b9 f7 W6 E
├──025.第九期-JVM专题之SPI破解双亲委派机制
) v7 A0 O& T: E* Z1 `+ S| ├──视频正在努力讲解中，后期讲解完毕会更新的.txt 0.04kb8 J' v& j$ g. X
| └──资料.zip 195.75kb+ q1 V2 d2 V/ y# c; x/ B) r
├──026.第九期-JVM专题之栈帧内部结构分析 : Q: i- u+ w* V6 e8 I1 f# s
| ├──01.第一节-什么是程序计数器.mp4 107.16M
% P; }. j9 a2 `| ├──02.第二节-什么是栈01.mp4 58.22M( \: L# S, P7 s/ W& Z8 o
| ├──02.第二节-什么是栈02.mp4 20.74M/ F: @1 f9 {/ y: [3 E0 j2 L
| ├──03.第三节-什么是栈帧.mp4 59.25M) G, I s2 A+ E' t h
| ├──04.第四节-什么是局部变量表01.mp4 139.85M2 r' f- a' b% s! a2 N1 I
| ├──04.第四节-什么是局部变量表02.mp4 10.96M4 ?# M5 i8 M# x' a% O% y+ e
| ├──06.第六节-站帧-局部变量表中-槽的概念.mp4 120.27M4 u0 k8 D E9 i6 b+ @9 d0 d
| ├──07.第七节-栈帧-局部变量表总结.mp4 11.05M
$ o; h8 u: \# s| ├──08.第八节-栈帧-操作数栈分析01.mp4 171.89M
: N3 r. o8 d+ B4 J. l% S1 A| ├──08.第八节-栈帧-操作数栈分析02.mp4 44.08M
' L# B& M' Z. H# J0 p% J0 _| ├──09.第九节-I++和++i的底层原理01.mp4 75.95M: u( g* H* s( C* y) o/ a
| ├──09.第九节-I++和++i的底层原理02.mp4 67.21M6 ?# `' x# I, b
| ├──10.第十节-什么是栈溢出01.mp4 7.03M
4 |" g$ }% \8 w/ N% X3 A8 R| ├──10.第十节-什么是栈溢出02.mp4 39.42M
6 D0 `8 s7 I% \9 K+ Y8 }$ g+ N| ├──10.第十节-什么是栈溢出03.mp4 37.79M
; m z2 C. t7 [) {| └──10.第十节-什么是栈溢出04.mp4 38.97M
: M7 H' _" i2 a% o b├──027.第九期-JVM专题之字符串常量池原理
/ U) ]- M5 O9 J# S| ├──01.第一节-什么是常量池.mp4 156.98M
( s" {$ K; W' X5 l| ├──02.第二节-局部表与常量池关系.mp4 66.92M$ M# v$ T/ j" @7 Q* p! K6 x
| ├──04.第四节-什么是动态连接.mp4 87.50M, {- I! T8 A+ J+ d2 h" t
| ├──05.第五节-常量池分类.mp4 63.91M, ~9 j& J* x5 `! F! H2 ~8 M
| ├──06.第六节-JDK7之前的常量池.mp4 49.43M
' Y9 i, i; ] p) q: B7 k, f, x1 [ m u| ├──07.第七节-String类源码解读.mp4 28.65M
3 H/ K4 H' E9 O, f8 E2 {5 h% F. {| ├──08.第八节-JDK1.7之前和1.8开始字符串常量池存储位置.mp4 33.56M
! e/ Y; |; _) [| ├──09.第九节-string常见面试题.mp4 111.08M
8 J" \) x) |& ]1 g| ├──10.第十节-字符串修改会创建几个对象.mp4 66.44M
: _0 W# _3 @) c: I- {1 ?| ├──11.第十一节-字符串在编译阶段自动优化.mp4 43.89M1 ?# U/ Y8 B$ ^0 l' U7 P3 e& j: K
| ├──12.第十二节-变量字符串相加的原理.mp4 116.42M9 \2 T- U9 }0 t+ w2 X6 d
| ├──13.第十三节-stringbuilder底层实现原理.mp4 218.09M; I8 u2 v" @8 x* V, m' J
| ├──14.第十四节-stringbuilder扩容原理.mp4 69.95M
2 g5 l( D6 B1 }( T| ├──15.第十五节-字符串常见面试题总结.mp4 17.13M; G* Z" J0 p) v+ L7 A+ Z
| ├──16.第十六节-字符串的延迟加载.mp4 57.96M/ X1 V6 |% ]8 ?6 z7 e* r
| └──17.如何证明字符串常量池是存放在堆中.mp4 48.69M/ z% I9 M+ x7 [. [, m
├──028.第九期-JVM专题之堆内存溢出&cpu飙高的问题
7 Y- ~9 U% _2 \- v| ├──01.第一节-new一个对象底层如何存放.mp4 29.06M
! S# e6 c9 ]* H9 [ u0 V| ├──02.第二节-什么是内存泄漏问题.mp4 91.13M7 E; a7 P) J; L- Y" q
| ├──03.第三节-堆内存溢出解决办法.mp4 103.78M
y4 {/ @! K5 ]3 ^3 L| ├──04.第四节-jps&jmap指令分析堆内存01.mp4 121.65M
* I9 w$ u/ W/ j| ├──04.第四节-jps&jmap指令分析堆内存02.mp4 9.28M
7 i# ^5 y. {5 y: }: f# W' X| ├──05.第五节-如何分析GC回收多次对象无法释放内存.mp4 133.92M2 Z$ j2 b# E; i1 V* h0 c" i7 k- {, O
| ├──06.第六节-代码模拟内存泄漏问题.mp4 70.83M6 d+ c( a: @ H1 Q/ i# D
| ├──07.第七节-如何排查内存泄漏问题.mp4 72.46M& g* T( [& x' V+ O4 k& ^
| ├──08.第八节-如何在linux环境下执行jps.mp4 41.38M3 {0 q0 v- Y+ r
| ├──09.第九节-什么是cpu飙高的问题01.mp4 169.54M. l1 {2 \$ m, J1 z# G2 S# \1 i
| ├──10.第十节-演示windows环境cpu飙高的问题.mp4 20.24M: ^7 ~8 q" L6 \' r! ?
| ├──11.第十一节-如何在linux环境排查cpu飙高的问题.mp4 130.58M
5 c/ \& W: a, r+ O| ├──12.第十二节-使用阿里巴巴Arthas排查linux环境cpu飙高的问题.mp4 78.86M4 s2 W" u6 o) ]" X- Y8 O9 @$ B) Y
| └──13.第十三节-实际生产环境中如何排查cpu飙高的问题.mp4 77.36M8 F" A: r3 `, C" }5 ~: D8 [
├──029.第九期-堆内分代设计与GC日志分析
5 |( F8 y9 V5 H' |0 }| ├──01.第一节-堆内存细节内容安排.mp4 11.94M
5 u% }/ b; U# v# u| ├──02.第二节-JDK7和JDK8中堆内存变化.mp4 43.17M
8 m; [7 [8 G" z9 e* q+ _' s" n" H| ├──03.第三节-jps指令分析堆内存情况.mp4 83.86M
$ Z1 Q! R, E6 b1 I: k& W| ├──04.第四节--XXNewRatio新生代余与老年代比例配置.mp4 39.29M/ H8 k. E0 D( X
| ├──06.第六节-StoptheWorld机制.mp4 21.41M
; T% t7 O# V: i" k2 Q! I' I) B% ^ W* A| ├──08.第八节-GC的分类.mp4 36.35M
6 u7 u; J2 _3 k. a" Y| ├──09.第九节-对象晋升的细节流程.mp4 128.16M/ o7 h4 H3 `. C& ~7 ~" k9 S) d
| ├──10.第十节-演示新生代MinorGC回收过程.mp4 92.18M- e/ h: B# }% l" I6 {3 O6 i
| ├──11.第十一节-演示老年代FullGC回收过程.mp4 140.74M4 R" R( ~" b! R/ x3 Y( C# y$ v
| ├──12.第十二节-新生代GC日志分析.mp4 170.76M
0 r1 A. P+ ?1 Y| ├──13.第十三节-老年代GC日志分析.mp4 37.05M
$ I. i8 f0 b7 {' Z| ├──14.第十四节-元空间GC日志分析.mp4 7.75M
6 F3 ?' \" O- s l$ b# r3 a; K: A! w6 U| ├──15.第十六节-在线工具分析GC日志01.mp4 152.90M
( E9 u- g# S$ b, U; { g| ├──16.第十五节-在线工具分析GC日志02.mp4 127.48M
/ n7 O! ^& p- G) S| └──资料.zip 195.75kb2 Y2 T0 H" z# z! F7 {/ t
├──030.第九期-内存逃逸分析 B6 W" Q- J' p* l$ q+ d3 {
| ├──01.第一节-.new对象一定存放在堆中吗.mp4 53.63M) f A+ ^2 i1 W
| ├──02.第二节-为什么new对象需要存放在栈中.mp4 80.12M
6 F) T$ n0 c+ X6 w! g- k3 |1 j| ├──03.第三节-.jlt内存逃逸作用域.mp4 70.46M
; y/ L2 b% N( b) c9 ^ e8 F| ├──04.第四节-逃逸分析代码演示.mp4 111.92M
/ i2 f _/ N" }& C) ?1 S" P/ ~! A| ├──05.第五节-逃逸分析案例演示.mp4 37.16M
8 |. q, {8 h8 M% x3 {| ├──06.第六节-锁的消除.mp4 43.47M" \9 y, \/ v9 v2 Q4 Z
| └──07.第七节-.标量替换.mp4 106.73M
7 |% ^& @. X4 Y# A├──031.第九期-永久代(元空间分析)---待整理视频
1 H& p% {5 [# ]0 y- ^: d% S, J; S2 Z1 H├──032.第九期-JVM专题之引用技术法与GCRoot（可达分析算法） , u7 s3 ?% i" T- O w
| ├──01.第一节-如何定义垃圾对象.mp4 72.46M
" {7 ^* b3 V8 q! C| ├──02.第二节-什么是引用技术算法.mp4 83.38M
% ^+ P# K& c* m8 @: K+ O8 j. z| ├──03.第三节-什么是引用计数法-循环依赖问题.mp4 100.30M
9 a C( i% x2 x; `/ x9 p| ├──04.第四节-GCRoot可达分析算法.mp4 82.90M, s0 }) `6 t2 g7 A( b/ v
| ├──05.第五节-GCRoot如何解决循环依赖问题.mp4 60.09M" Y' |! r1 w: Z: J9 F
| ├──06.第六节-哪些对象可以作为GCRoot.mp4 9.48M
& z# O9 ], D0 Y4 ~8 |4 l| ├──07.第七节-通过mat分析GCRoot.mp4 104.76M
3 M' f; O: ]9 ~& f j4 O* V/ F2 F' I6 || ├──08.第八节-通过MAT分析GCRoot循环依赖对象.mp4 63.22M
) k U( I! @- f# \% v$ U6 F Q4 N| ├──09.第七引用技术法与可达分析算法区别.mp4 33.65M8 \1 n5 ~0 J6 j& L7 Z B. c
| ├──10.第十节-finalize复活对象.mp4 142.01M
- P$ ?1 k, |- q% X! k! Z/ s| └──11.第十一节-finalize方法的总结.mp4 62.05M
3 _% i9 W" {, R* M2 E) a4 Z├──033.第九期-JVM专题之垃圾回收的算法（后期会修订）
: p' ^) H! p" M9 d4 R+ \| ├──01.第一节-指针碰撞与空闲列表.mp4 67.65M% U4 O7 m% D9 ?+ W1 m) P
| ├──02.第二节-标记清除算法01----改.mp4 43.92M3 i. _* `& P6 K$ a& r
| ├──03.第三节-标记清除算法疑问.mp4 55.10M
9 N& K4 R4 |2 n6 l| ├──04.第四节-标记复制算法01.mp4 74.11M
/ \. W$ ^; U- ^ G, b9 S| ├──04.第四节-标记复制算法02.mp4 17.13M
! B% h# E% ^% i2 l| ├──04.第四节-标记复制算法03.mp4 46.06M
8 s# M8 T$ F; @; G+ t) M0 U| ├──04.第四节-标记复制算法04.mp4 11.68M
: a4 l. h/ H) a2 a; R/ A| ├──04.第五节-标记复制算法应用场景.mp4 15.34M$ m* j# m: R6 g" `
| ├──05.第五节-标记压缩算法.mp4 44.74M5 G; i! e8 p2 h; d7 ~( T9 ]
| ├──06.第六节-垃圾回收算法总结.mp4 44.82M8 ~6 b% k0 t9 z( y+ A0 A
| ├──09.033.mp4 347.59M
0 ]! S4 [6 H8 p2 X| └──新增移动对象&从新录制标记复制算法移动内存地址.txt
. M, E8 ~$ V7 p├──034.第九期-JVM专题之对象定位访问与句柄池和直接引用 # k6 T) j8 _4 V
| ├──01.第一节-new对象晋升细节内容.mp4 128.16M
: i! l) [2 b$ j| ├──02.第二节-new对象晋升细节内容总结.mp4 12.34M
* k" r a% F1 X| ├──03.第三节-通过工具分析对象晋升的过程.mp4 81.58M$ K0 L" s+ }% a& D1 I+ s! @
| └──04.第四节-对象的定位访问句柄池与直接引用.mp4 62.88M( J1 ^0 c5 `! S! e1 x0 ]
├──035.第九期-JVM专题之串行&并行收集器
8 }3 p1 {7 Z( C) _* L% {| ├──01.第一节-为什么不建议调用System.gc();.mp4 22.29M
) ^4 [" I; L0 r' j% y| ├──02.第二节-垃圾收集器与可达分析算法区别.mp4 22.45M' w( ]% d7 P5 G8 x$ Q C
| ├──03.第三节-并行与并发收集器区别.mp4 60.08M
) q* F: M- O% s. {- ]| ├──04.第四节-评估GC性能指标.mp4 97.37M
4 _' ~6 |& \/ z0 W| ├──05.第五节-垃圾回收期发展历史.mp4 51.35M
, [6 r& o: B9 `$ m( f( y+ w| ├──06.第六节-七款经典收集器组合.mp4 93.30M7 v% O8 ?6 ?3 F ?8 y
| ├──07.第七节-如何查看默认垃圾收集器.mp4 41.29M7 G- b% T) v$ }! H$ E
| ├──08.第八节-串行收集器特点.mp4 47.02M" j8 V+ v. D2 Z) o
| ├──09.第九节-画图形式展示串行收集器.mp4 7.53M
K7 d" B# M3 U1 `$ M: a| ├──10.第十节-parnew新生代gc回收原理.mp4 55.75M
* v; h M9 e6 A) L- K5 i0 h0 K; f| ├──11.第十一节-串行与并行收集器之间区别.mp4 26.96M$ N- \* d( J; ^3 h: c
| ├──12.第十二节-配置parnew新生代gc参数.mp4 13.24M' h/ I9 e: y3 X5 ~4 y* ?" j0 I# G
| └──13.第十三节-并行回收的原理.mp4 54.63M8 q$ e( u7 } |% h' s/ ^' T a
├──036.第九期-JVM专题之CMS收集器原理
i( Y) |6 Q) y5 Y4 c% w% M| ├──01.第一节-为什么需要使用CMS收集器.mp4 75.89M, i% O* [7 z R: ]2 C
| ├──03.第三节-CMS之初始标记.mp4 62.84M
8 X; S7 r0 c% w| ├──04.第四节-CMS之并发标记.mp4 58.96M
% k& x( x9 q. U; K/ q: \| ├──05.第五节-CMS之重新标记.mp4 43.38M v5 a1 Z5 R' q0 M8 X. D
| ├──06.第六节-CMS并发清除.mp4 15.48M
0 b0 b2 u$ ^5 N+ o| ├──07.第七节-CMS四次标记总结01.mp4 37.79M7 p) Y& i# \/ }( {
| ├──08.第八节-CMS在什么时候清理堆内存垃圾.mp4 18.51M4 q: |" w0 B9 P
| ├──09.第九节-CMS收集器的优缺点.mp4 49.27M
' U! [; t% Z' N% H& z- v, d| ├──10.第十节-CMS收集器并发清除阶段缺陷.mp4 33.74M* W+ ?( D4 r0 e! t& C
| └──11.第十一节-CMS收集器参数设置.mp4 109.23M
8 `9 k; y) j5 U0 S" w$ B1 G9 Y├──043.第九期-性能优化-MySQL实战分表分库 3 j0 h3 T' R) Q2 @* Q
| ├──01.第一节-什么是垂直拆分.mp4 27.13M
, v4 r' o4 c' A9 o% e| ├──02.第二节-什么是水平拆分.mp4 134.25M
+ k9 D; ^ {' `. T v; n3 `| ├──03.第三节-shadingjdbc与mycat之间的区别.mp4 38.56M: b, A. f" k- F, e
| ├──04.第四节-shadingjdbc分配策略.mp4 63.64M
5 w7 o7 ~" a7 ^* W| ├──05.第五节-SpringBoot项目整合shadingjdbc.mp4 143.93M* X1 k; t0 }3 {9 V8 b8 ~ V1 I
| ├──06.取余分片算法优缺点.mp4 91.27M
. Q# h( r* H3 [+ f% {| ├──07.日期分片算法优缺点.mp4 30.23M
. P/ \- h$ q+ }3 a" H s| ├──08.其他分片算法优缺点.mp4 44.14M2 A) Q7 ? g' c3 U% Y3 g+ ^# C
| ├──11.shadingjdbc整合范围分片算法.mp4 136.25M; @" y7 L! G8 b2 T8 R
| ├──12.单张表数量达到多少分表分库.mp4 13.13M8 d, P {7 F+ S. T$ c
| ├──13.分表分库后shadingjdbc底层查询语句.mp4 101.31M
5 m# \+ d2 B: B, _( _+ s' x| └──14.分表分库后分页如何查询.mp4 81.34M
1 X6 D! Z: S+ A8 |( o0 p( `├──044.第九期-性能优化-MySQLBinlog原理
0 q) D) b/ m7 F& q: ]| ├──01.第一节-什么是binlog01.mp4 71.98M) \: l, [4 V% W
| ├──02.第二节-MySql集群架构设计原理.mp4 104.81M
+ `% ~! n; P, H| ├──03.第三节-基于docker安装mysql主节点.mp4 123.85M- E$ P! k: a- R: R' l& [* A8 L
| ├──04.第四节-基于docker安装mysql从节点.mp4 37.08M
C W/ v6 N7 S. z; M| ├──05.第五节-演示mysql集群环境.mp4 173.76M# c7 n0 p3 G9 ]( v6 Q& B
| ├──06.第六节-如果发生mysql主从数据不一致怎么办.mp4 84.23M
+ n2 }$ F W2 p" U \| └──07.第七节-误删除mysql数据如何恢复.mp4 80.76M
# H- A. x0 p# S3 h, F. V5 d├──045.第九期-性能优化-Binlog实现数据同步
, _0 L% h% S) a# Q- P) B6 k| ├──01.第一节-mysql与Redis如何实现数据同步.mp4 60.76M0 Y( q6 k$ `3 [* _: E: W
| ├──02.第二节-canal同步数据原理.mp4 104.09M
}$ ?! r& q0 |3 c| ├──03.第四节-启动canal监听binlog.mp4 155.34M
& r0 D% E; A. I; g% d; ?- \| ├──04.第四节-如何将canal的数据同步到redis.mp4 118.75M' ~; q, p- I2 a; w
| ├──05.第五节-演示canal同步数据删除操作.mp4 65.30M
8 Q3 q& Q( ?$ x5 l| └──06.第六节-canal与mysql同步数据延迟问题.mp4 57.91M5 f0 Y' f! w0 a" t2 q; F; C
├──047.第九期-性能优化-MySQLB+树索引细节问题 / ^% A$ \% x a# L, Y& |
| ├──01.第一节-innodb为什么插入数据会根据主键索引排序.mp4 67.71M) h1 ]2 C* @' }$ c- X8 ^6 o
| ├──02.第二节-innodb页的概念.mp4 197.68M1 P: p0 j) e" A% b( R H0 j
| ├──03.第三节-innodb页与页之间如何关联.mp4 45.67M
; ^- w5 w5 v. ^) _ l3 M| ├──04.第四节-innodb页的分组概念.mp4 68.74M
( y8 _, c9 _) b| └──05.第五节-一颗B+树三层可以存放多少条key.mp4 90.83M
8 W6 R. m# t5 ]; l" B├──048.第九期-性能优化-MySQL查询语句优化
. b/ w7 m% i6 \& y3 B' F| ├──02.第二节-explain中的列select列.mp4 110.44M* m# E- d* ^3 [7 C) j `
| ├──03.第三节-explain的type列all与index之间区别.mp4 75.94M* k! A* K1 [; {5 G3 s! [% M
| ├──04.第四节-EXPLAINType需要达到什么级别.mp4 262.93M/ Z/ R& v7 `- N8 [( o
| ├──05.第五节-EXPLAINkey的长度如何计算.mp4 107.11M9 S" ]# z& L6 F2 O) f8 m
| ├──06.第六节-mysql索引需要遵循遵循最佳左前缀法则.mp4 41.48M
8 [, G5 j% P& L( B( c& p( o- A4 Q, `| ├──07.第七节-mysql索引列上不要使用函数或.mp4 40.03M, x% }. W2 o9 y) u# Z
| ├──08.第八节-尽量使用覆盖索引返回数据.mp4 92.45M5 O4 d9 Z$ R8 E$ K! ?4 f$ |
| ├──09.第九节-索引上使用like注意事项.mp4 55.20M
4 [* v* S- _/ K1 O9 B2 [0 e| └──10.第十节-explain扩展列usingwhere与usingindex区别.mp4 157.74M
5 [9 u3 v8 W9 Z; G1 M├──049.第九期-性能优化-MySQL排序如何优化
% w: C" o) ]9 P9 j. p" \7 O| ├──01.第一节-排序需要注意filesort.mp4 77.92M) V& V5 y0 H% q1 @: ]) ]2 d
| ├──02.第二节.filesort排序设计原理.mp4 32.70M. a! k" \7 u! E& ^/ L5 _
| ├──03.第三节-排序如何避免filesor.mp4 102.72M
6 f5 W/ L" @5 {" s| ├──04.第四节-单路与双路排序设计原理.mp4 94.19M
* \6 N& l$ t- ~; a1 f! V| ├──05.第五节-optimizer_trace（优化器跟踪）.mp4 128.45M' I" j3 p# _+ K6 N( A; S
| ├──06.第六节-optimizer_trace分析单路与双路排序.mp4 48.13M
% r/ }) K) D6 k. a| └──资料.zip 195.75kb
2 d2 t J, K" a6 O├──050.第九期-性能优化-MySQL表连接join和分页优化
& ?( U8 A2 V$ I* a4 c| ├──01.第一节-表连接join引入.mp4 106.60M
1 ]3 w" ~7 v2 b' d) R| ├──02.第二节-左、右、内连接区别.mp4 95.50M
0 p$ A1 S) b" c# [. f- x& d' M| ├──03.第三节-左连接设计原理.mp4 66.57M& g- @5 E' |9 u, e$ d
| ├──04.第四节-右连接设计原理.mp4 26.65M. w6 a& f6 z i: B
| ├──05.第五节-内连接设计原理.mp4 24.82M
5 n, `' I* s6 h, p/ D| ├──06.第六节-表连接必须要加上索引.mp4 100.87M
, W+ B2 U: U$ b7 y- d| ├──07.第七节-in关键字需要遵循小表驱动大表.mp4 27.34M
3 j* r$ s* D- i$ `) b| ├──08.第八节-exists关键字需要遵循小表驱动大表.mp4 20.35M' V: h2 u) z s) ~- ]# H
| └──09.第九节-分页如何查询优化.mp4 131.55M
3 P4 Z! Q+ H+ \$ l7 X├──051.第九期-性能优化-MySQL行锁与表锁原理
/ N1 \! v V+ `0 Z1 _# h: t| ├──01.第一节-MySQL事务基本概念.mp4 113.76M
. M# K, R# m, ]: F$ e! f. G* Q) T| ├──02.第二节-MyISAM和InnoDB的区别有哪些？.mp4 73.44M' V8 P+ C; H! q, T9 T' `+ M% m
| ├──03.第三节-myisam存储引擎表锁与InnoDB行锁概念.mp4 107.70M
2 V: U% O( p9 R$ t/ t+ }1 T| ├──04.第四节-mysql中的行锁和表锁.mp4 79.98M; T/ r; ]$ q- l& @8 H
| ├──05.第五节-myisam存储引擎表读锁演示.mp4 92.67M
: i- i! [- h. ~/ B5 L# c| ├──06.第六节-myisam存储引擎表写锁演示.mp4 51.39M
& }" I X9 M( Z- S7 h4 |# w7 m- || ├──07.第七节-演示InnoDB行锁.mp4 168.22M
. U& l7 T. G! S; M8 w; l| └──08.第八节-forupdate演示.mp4 50.01M) L1 g# l3 c+ c) c& R6 }
├──052.第九期-性能优化-MySQL间隙锁&悲观锁&乐观锁 ; b1 m6 ^& f/ O; Q: K
| ├──01.第一节-简单回顾forupdate用法.mp4 74.06M$ c5 H) _. s+ a& T7 t; [
| ├──02.第二节-悲观锁的用法.mp4 31.80M
5 [1 Y$ I/ ~) a% R& A; H' I" M; N| ├──03.第三节.乐观锁实现原理.mp4 246.88M# V6 J s' @4 ^% x) q: p1 C
| ├──04.第四节-什么是间隙锁.mp4 38.86M
, |& E' Z1 h( E+ L- }( }0 X9 @| └──05.第五节-注意行锁升级表锁.mp4 49.44M
7 M& s' C8 L! _" b# I├──053.第九期-性能优化-事务隔离级别&MVCC原理 0 Y& j( I! h, L, T9 X: P
| ├──01.第一节-事务隔离级别与mvcc课程安排_ev.mp4 20.20M; A6 N6 J3 p2 ~- s( F
| ├──02.第二节-mysql事务隔离级别引入_ev.mp4 40.64M% p- d N& L# A) i8 l. g1 f' H
| ├──03.第三节-mysql事务隔离级别之读取未提交_ev.mp4 52.20M# c) q1 D1 a/ T9 J
| ├──04.第四节-mysql事务隔离级别之读已提交数据_ev.mp4 62.46M, w3 l$ A+ \2 K+ n7 D `3 K
| ├──05.第五节-mysql事务隔离级别之可重复读_ev.mp4 46.51M
6 \& R$ a3 f" T; p" w% m& Q| ├──06.第六节-mysql幻读的基本概念_ev.mp4 23.65M% _& W+ o! D# [) H
| ├──07.第七节-mysql可重复读实现思路_ev.mp4 19.06M* G* v; u: V0 V. M& h
| ├──08.第八节-mysql可重复能否解决幻读问题_ev.mp4 86.29M; P$ H6 e! J# G* x
| ├──09.第九节-mysql事务隔离级别之串行化_ev.mp4 32.11M+ c4 q b0 z1 k6 U$ {0 [
| ├──10.第十节-MVCC基本的概念_ev.mp4 30.20M6 b* s5 K2 S6 U9 |
| ├──11.第十一节-MVCC链表结构原理分析_ev.mp4 76.05M/ D! j# z/ E7 K+ L8 h6 R# O7 v
| ├──12.第十二节-readview视图四个不同的属性_ev.mp4 67.97M) r/ Q" e. r" U' l3 B1 K) N
| ├──13.第十三节-mvcc版本链判断规则之为什么当前session修改数据能够立即查看？_ev.mp4 24.83M
9 d4 O$ ~% g6 N" K" T| ├──14.第十四节-mvcc版本链判断规则之读取提交或者未提交数据原理_ev.mp4 83.76M" ~! ^0 o3 X6 c: d+ W# o9 b+ D
| ├──15.第十五节-mvcc版本链判断规则之可重复读设计原理_ev.mp4 31.28M% x3 a6 R3 q. z
| └──16.第十六节mvcc能否可以解决幻读问题？_ev.mp4 7.19M
1 y* t# |0 ] m- S) |) d5 y, D; L. I8 P& m8 ]3 q+ p
. S# a9 ^0 c' g( {, O% G. n; k: y3 E/ U! a
永久至尊VIP回复即可下载学习，非至尊VIP暂不支持下载此资源！3 B. L, d$ x5 q I' h
1 T+ g7 k, ?) N( n7 ~) l. i
7 \# }, C+ D! J
|
/1 
