蚂蚁java架构师九期完结

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

  R9 p' K! k% |, |1 U# x

游客，如果您要查看本帖隐藏内容请回复

66666666666666666666666666666

学习学习再学习

非常感谢

太给力的学习资源，非常感谢 www.cx1314.cn

太给力的学习资源，非常感谢 www.cx1314.cn

楼主加油，看好你哦，我会常来，此 www.cx1314.cn 源码论坛是我每天必逛的网站！

自从开了永久VIP，全站资源下的太爽了！哎呦我去，快存不下了，QAQ

不错收下了，www.cx1314.cn 在这里开会员确实值

IT学习资源还是 www.cx1314.cn 程序源码论坛 的最好！