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