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