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