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