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