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