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