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