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