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