Java电子书：虚拟机设计与实现 以JVM为例 PDF 电子书 Java吧 java8.com
4 N* T y a6 Q) v7 o
2 m R& w, ]7 q1 J: Q7 V* h作者:[中]李晓峰（Xiao-Feng Li）出版社:人民邮电出版社出版时间:2020年01月% d! d7 \6 |( K) p
; p6 N" w# J" ?
编号：166-Java吧资源免费-X0234【Java吧 java8.com】+ S& U; T1 Z; t, r: M, o4 I
$ E7 a+ l! x% z4 g( \
1 o( z4 {* H2 u
e* U: e7 `* I7 {目录：9 k1 J% t! e" e/ N( C( f! {
第 一部分 虚拟机基础
8 o8 a2 |3 `7 w/ g. e& }, x$ V4 N, W, ]
第 1章 虚拟机简介 2
8 j0 p8 M; C) I/ h
5 [) T2 ]' _7 h% K2 Y1.1 虚拟机类型 2
$ D c$ L) n: ^8 f3 r3 m! a4 V1 [ z, O
1.2 为什么需要虚拟机 3
. P0 x3 P7 ~8 T3 a
+ f" ]1 ~5 Y3 k' y1.3 虚拟机示例 4
0 U0 { V. Y! \0 i) q) Q" Y
. I/ ^0 J: U0 X8 e0 s, K( j2 @1.3.1 JavaScript引擎 4
% K2 b9 c9 v v/ f$ l3 Q$ z
, r7 _$ T' M7 E+ H; h9 v4 m1.3.2 Perl引擎 5
" W5 Q( O. o( a( x8 g6 K
& Z, h- ` g% J$ u5 b" J1.3.3 Android Java VM 5
: z! I# Z l; d# ]2 z4 Y2 I: M1 j" t! |+ u z; ]. W# L( K3 t
1.3.4 Apache Harmony 6
; d0 N2 h4 N+ g* H
6 r$ N$ n0 q i9 W& o0 T. D0 i7 J第 2章 虚拟机内部组成 7
! p) y4 P ~$ b" ^0 u
( ~* J8 V% c( T1 \' T9 s8 d4 W2.1 虚拟机核心组件 7! M) q+ r6 P* H& s; {3 D
+ d+ o! ~3 {& S* P! ~7 I
2.1.1 加载器与动态链接器 77 v: S$ y4 K- U( H0 M i
9 d* S6 m8 v! |: c. T2 q
2.1.2 执行引擎 8
, [# k, t N' e, g7 Z2 d! E2 {
) g: C. g& q [. W2.1.3 内存管理器 8$ E K Z# c! w% |* m7 e3 o
2 w& ?0 I1 i& t- A: D @* l: N
2.1.4 线程调度器 9
3 Q J* [4 Z' Q! q
9 z; y* S8 o, D9 h2.1.5 语言扩展 94 u S) ?) a; w$ l; \2 C/ e5 f
; F! M+ s' ^( y$ K; j+ h2.1.6 传统模型与虚拟机模型 10( _+ u$ `2 W$ q
4 ]9 K! X/ Q" J* g* J2.2 虚拟ISA 11
8 u# v0 y# D, }# V- o6 w3 y, E7 F, ]3 Y" D
2.2.1 JVM 12
. c4 C: O; c* p; p+ \5 G6 d$ D+ h) t) E% e/ M4 q/ Q) s
2.2.2 JVM与CLR 15
- b, O& }% J7 q
4 ]5 P& T) { w0 `" |& k第3章 虚拟机中的数据结构 17& k7 Y: P( i/ R/ J
: J8 X V N' U
3.1 对象与类 17
. O( j+ T' a5 S, x3 @: B1 ~# G3 n' t
" n" s8 c w) D8 ?7 V3.2 对象表示 18
/ ~1 b p6 m% L+ ]% z: M$ R; L: ?0 ^* `) `
3.3 方法描述 18
! l F" I% h0 Z8 p1 d1 ^
% s9 x& V* t+ S0 }+ K* p第二部分 虚拟机设计
6 W n; H3 b1 E: ~
s* J2 n- A& ?5 l9 u% @第4章 执行引擎设计 22
$ U# ~1 \) T2 }0 K5 _$ r3 g% j/ |) F2 V$ A6 l0 n- n; j
4.1 解释器 22' R6 b. C3 a: y4 O
, q( o9 e# \( M; S2 H/ S: D3 A
4.1.1 超级指令 23
. O8 x; `$ n; a0 Z. V0 x) E- |/ o+ ?; R8 z1 u
4.1.2 选择性内联 23
9 B" K% ]9 d5 g! C1 {3 w. b$ @- E% V9 M" z3 n0 U: f5 W: K8 \
4.2 JIT编译 237 ]: [2 `/ A, v& l% c6 g$ }3 b- j7 _
) x6 n5 Q0 U* d5 Z7 O; B$ D4.2.1 基于方法的JIT 24. `6 k- u. L5 X! {7 q
; j; f3 @: B! ]" R C6 Q; j4.2.2 基于踪迹的JIT 26
/ i9 [9 t( D3 R3 D8 X: y& @5 R/ h R, T: I6 \: F
4.2.3 基于区域的JIT 29. G3 W# m! A1 O' _/ z2 {
* J$ i9 Z- p/ P$ `! D6 H
4.3 解释器与JIT编译器的关系 306 x$ u: E/ H3 i+ h% C
2 V9 `- L1 Z7 M5 U3 j; ^5 D4.4 AOT编译 312 _# `! ^3 o8 k3 A# D" {
6 ^, x& I5 {) p! l! O4.5 编译时与运行时 33
9 [8 j' v1 M) |: Y- d* t9 l ?) y- Y; n2 {2 V
第5章 垃圾回收设计 375 X7 q+ f# I. B' S1 m+ q; U
8 j( k* X' P0 {# J
5.1 对象生存期 37* J2 R' \' h, A
3 u0 O/ j$ p0 c2 c: y4 w1 C$ X
5.2 引用计数 38
0 V0 p. Y0 I# D% o% G& d
( `% K$ U' B" N J5.3 对象追踪 40
% f. ]1 w1 f/ o; i8 {% l
% K+ e( i, u0 H6 S5.4 RC与对象追踪 42
, y: ?' ^2 Z- y$ h, o# ^* T- {: ?: \% r. w4 K3 W3 A
5.5 GC安全点 43' W* |1 o3 M; P! P5 i( t
& ] o& Q' ]7 J% A# M9 X
5.6 常用追踪GC算法 45
2 L& A& g" L; d$ @$ y. O2 u6 t" d
4 T9 F4 @4 P' d! E; K* j5.6.1 标记清除 46
Z/ O% ^ T% Y d' w" l5 y: B4 p% _( O7 y4 f
5.6.2 追踪复制 46
6 l1 J2 n3 B) k/ @# }
2 P. o+ j& c6 @( h4 K1 [- T4 f5.7 常用追踪GC变体 48
8 @6 S' G- @& H) N7 L H5 i1 q1 V$ o- Z7 Y: f2 Z* `
5.7.1 标记压缩 48
; \5 b9 j8 b& }/ d1 e1 b6 o8 t
$ n! n$ ?$ h$ I f' M6 ?5.7.2 滑动压缩 48
- q% f, j8 ^- S% }0 ^( \
- k! ? m2 \4 P! {+ E5.7.3 追踪转发 49* ?- R+ k% @0 J0 l8 _$ S) S+ l8 ^
: E E0 S" l4 O) _; x
5.7.4 标记复制 50
0 Y9 _! k4 E. ^% r
1 f! R/ }! x" R( S5.7.5 分代式GC 50; I! {! e+ A2 P4 o" P! `9 t [5 u
: p+ |" a* R1 f5 X: y5.8 移动式GC与非移动式GC 53
3 m1 P% K/ B7 L9 z$ T+ Y1 i1 I- z, t$ e- U0 q+ a" f) M4 ]/ r
5.8.1 数据局部性 53$ N8 F! {! j- S/ \9 K( @9 ~8 c
" Z j+ M3 k) i( ]% H
5.8.2 跳增指针分配 537 W, h3 a$ b# g. f3 A$ i
) u9 r! m% m0 E6 I5.8.3 空闲列表与分配位图 53( i- P% k k4 X7 e8 _
0 y( F( j) f! w9 ` @; Q* b, b5.8.4 离散大小列表 54
- W( p% ^7 s* C* r. O
. y) }9 w1 t+ Q) u: I2 e" B5.8.5 标记位与分配位 54: D* i' N# c! r J
$ t. s$ z# [: w8 j$ I& s4 }- M5.8.6 线程局部分配 55
7 d* |( r1 G: ?: Y+ H) ?' k& S4 B) r
5.8.7 移动式GC与非移动式GC的混合 56
6 {& X: e) J, r+ S: a( S& p
0 P) r- b; s0 _第6章 线程设计 581 u: \& q! K9 ^/ i
& e; V* y& a7 s" c' {6 R4 W8 B6.1 什么是线程 58
9 O$ e, Q- Q, G }+ T+ k/ I4 ~9 u3 o( _' Y
6.2 内核线程与用户线程 59+ f: l* P P7 z( U$ N
; W% s7 W/ Y7 @+ B0 s$ C0 h6.3 VM线程到OS线程的映射 61% R7 t: ]3 I& k' I$ t. s8 v8 }
+ y( W( \; z' O0 F; r6 Z+ g
6.4 同步构件 63
/ d: Q1 N1 y+ q+ D H. u5 ^' |, p2 D+ n% `
6.5 monitor 65* }, X( j$ q6 b' Y5 c
" V" v7 n E0 Y# p
6.5.1 互斥 657 C% l2 S8 t8 ^) U% d
/ X9 [1 T/ o& A# Z" r
6.5.2 条件变量 66
$ C; L+ z9 }; g2 \( }" O( g, P8 Q% S, V' z; R- ?
6.5.3 monitorenter 66
8 u% v1 \4 e/ H
2 I: l# c# |- B# u% v8 L6 p- R. \/ n6.5.4 monitorexit 69$ M% |) [+ q8 |, \' i
8 C/ e2 W8 O. \" m G. Z) T6.5.5 Object.wait() 71
1 ^1 z. G, c* i9 G5 r) S G4 J9 q: \
6.5.6 Object.notify() 71
$ B: _. b% x E0 w, a% f# h; q/ u
6.6 原子 73
1 ?* B6 p4 E2 L- L7 Q3 z7 B
& C+ o& @% q- J7 v% a6.7 monitor与原子 75
6 v9 a' W: r" r, F G! n+ b" J1 X/ I9 J. E- c
6.7.1 阻塞与非阻塞 758 l! J3 z" N2 B3 x
2 }& |+ M% m9 v5 D# y6.7.2 中央控制点 75; h3 N+ @/ }2 B
2 m4 E% t# f! r* O6.7.3 锁与非锁 75* O% U* ]; [. p [' O! @+ p5 p; a" k. S7 d
& r8 a% D) D, S% ?
6.7.4 非阻塞之上的阻塞 76
+ l& u r3 ?, Z/ C( N: c( x4 O: j0 H& L& m) W0 X7 J
6.8 回收器与修改器 77! n0 U& _4 _2 Y0 ?7 w
$ C- L* r, N" @9 T9 Z- I" q' P6.9 线程局部数据 78! s6 f8 `% J' m
" A; r5 g- U" c0 |( J' }
6.10 GC的线程暂停支持 81
- H* f9 s% J# D" W& u5 v6 M* e( w9 a8 i
6.10.1 GC安全点 81
0 y0 t K0 C9 G9 _- m; m, \& C: j- F# I/ h0 R: |" Q8 B5 Y
6.10.2 GC安全区域 83$ w- v, m; \: X5 |
" P6 e. i4 t2 u4 R1 X/ k# o
6.10.3 基于锁的安全点 865 e" u1 I; L. Z k* }2 Q5 W
2 b0 \$ N- F K" u1 C7 n+ ~
6.10.4 回收中的线程交互 87
4 C# K Z$ r. ^. s$ O% b
( `2 V3 b2 E; Z' ^8 [第三部分 虚拟机内部支持
/ c+ p) k9 N( W4 U0 }& c5 H5 ~& A2 n- `7 }7 A
第7章 本地接口 92
) _/ ~6 V5 [: `7 M- J/ i) b$ D7 y8 s7 S
7.1 为何需要本地接口 92
! \; j: h* g$ ^+ n/ L3 d5 p3 I$ n2 T. J4 h% x/ j+ H
7.2 从托管代码到本地代码的转换 93+ ]7 o4 O2 N8 i8 k9 I: T1 d
+ ]& A. g# s5 a9 D) u
7.2.1 本地方法封装 942 o- H" y% e9 m* P0 F) X" v- w' i& j
4 s) r8 J s/ t# o; q7.2.2 封装代码的GC支持 96
- `& X# C+ D% G2 e1 d3 Z8 r
( D1 }' M; q7 {# D6 A7.2.3 封装代码的同步支持 98
! z3 ~/ n+ h' [9 r9 R$ T0 b# s# R0 f; D) g: |
7.3 本地方法实现的绑定 99
3 c4 f4 O( h! K. f4 A$ U9 q" Z& c' {- ` Z
7.4 本地代码到托管代码的转换 999 j& E7 _7 n/ T# E* v- C* j. i/ }9 m
0 W; H9 _! M) Z& o7.5 本地代码到本地代码的转换 1021 x: ^8 {. h' P/ N) x+ n, L" `6 u: P
' |$ @; R! a, K" r5 I7.5.1 通过JNI API的本地到本地转换 102
( s1 r0 y' M5 N1 \6 D6 i+ X1 H9 e
4 ~3 h) ]# N. x( ]5 h/ I' F* \7.5.2 为什么在本地到本地转换中使用JNI API 1054 q: P! i( b0 d! J
& q, e5 T2 b2 Q Q/ P6 C. q第8章 栈展开 107
5 |% Q; }" }* b9 C' u# L# H
1 h4 i5 J+ z% l/ r/ ?& Y. k5 e8.1 为何需要栈展开 107( G" [ j9 r5 q1 s- U8 y4 n, m0 Z- N& _
1 i6 h1 `9 S% M! b% X% m# Y
8.2 Java方法帧的栈展开 108
0 d7 M. W8 Y9 _3 \% C9 L( s5 B. s. }, y3 U! k% n' L& A3 L
8.2.1 栈展开设计 108
6 t( K9 ~2 g, C+ w, r/ j) J6 |0 C
: f. w# ^# T2 x D1 M8.2.2 栈展开实现 1104 }4 S: P8 Z+ b2 \
3 f( n, W7 z, R8.3 本地方法帧的栈展开 112
0 N* I$ x# ~* q% l# Q D) I6 l6 B$ O( `! Q" i6 E3 ]) H5 v: P' O7 ]! O
8.3.1 栈展开设计 112
; _2 H1 [* X7 d0 g# C- i# |' s
2 s- `9 v4 I8 T& Q/ J8.3.2 Java到本地封装设计 1140 B2 {) Z. f8 l) Z6 a$ j) d
9 j* ]: J2 Y7 i6 o; z( Y
8.3.3 栈展开实现 116+ `/ o6 }( p% }, Q+ c3 ?
( J- l% V* Q( q" @, p, g- B1 \6 i8.3.4 本地帧与C帧 1177 @) i' c+ f0 l, Y7 G+ K ]& {7 b
0 D+ s* D6 I: T$ q6 v
第9章 垃圾回收支持 119
6 T: }1 X- r4 q% p& I7 x2 p4 h$ [5 T ~, q
9.1 为何需要垃圾回收支持 119# |! Z# f5 A2 {, z8 \
8 b' H$ s+ W5 Z& ?9.2 在Java代码中支持垃圾回收 1210 N9 L3 c& R1 C5 S: d
' D0 L* i" l+ C4 l
9.2.1 GC-map 121 K; j7 \* ?0 W( V( B. I& W
. m& ^. @. T2 ]% ?5 l9.2.2 带寄存器的栈展开 124
6 f6 J: K1 a# F/ L) Y& b, x2 e$ i! w) b E5 T
9.3 在本地代码中支持垃圾回收 1265 i; W8 P: H$ O" A6 c# y- l
6 r- v! ?0 t4 P9 J, I$ l0 p
9.3.1 对象引用访问 127
1 v) u% b$ O' n/ k. } t2 f" U; A6 k
9.3.2 对象句柄实现 129" j: ~4 @8 F! _
0 Q: {2 n" v- u* {" K, \$ a j
9.3.3 GC安全性维护 132
% l Q4 _; e* Y' T, J) P- o3 I8 M+ ?& N9 E# c
9.3.4 对象体访问 133
" d' s3 R+ T, b; ^3 r& \+ B6 D2 |; G
9.3.5 对象分配 1353 w; P/ C2 ]# q. y4 ~: ?
! J' C$ H* l& L7 y9.4 在同步方法中支持垃圾回收 136! U2 i! |3 M, j. t; J' j# T8 i
' Q. n7 Z5 H1 N5 c- d/ T% U
9.4.1 同步Java方法 136
! i" T! L+ z( ?1 T8 [5 `
1 H- J L9 I1 `9.4.2 同步本地方法 1387 ^$ h7 V' d9 W8 p. B" h, W# \( X
7 K5 V v- `! @- T) e9.5 Java与本地代码转换中的GC支持 140
) R; e; I. M! n$ g5 s9 K: @% q- Z$ n6 S" \) }
9.5.1 本地到Java 140
0 l. J' O" a) e U# W4 j# o# W1 X5 t2 r
9.5.2 Java到本地 142
: \. N, T9 F& N. G( b: m% L) P2 W* i% @/ I
9.5.3 本地到本地 142
* `& Q* r6 w8 H# [& B+ `" T! ], ?2 t: Z. h! `& \/ v
9.6 全局根集 144; Q& Y1 r3 s; o ^4 c
( ?2 T; K- P k6 R% \+ e- I2 m
第 10章 运行时辅助 1451 r3 M& e( z( o2 i3 v$ ~
3 C9 X8 [ G/ M; k- H& v/ b* u6 Y10.1 为何需要运行时辅助 145
1 i) x: {+ s' y# F
8 s% U7 x3 a6 M W/ x H% H3 j10.2 带运行时辅助的VM服务设计 147+ Q* j7 e' Z% F7 s& Z4 t% y" q# |
/ b! I7 ?: D- v, Y. u- W( u! e10.2.1 运行时辅助操作 147
3 s) Y+ u* z7 ]) `7 C% b
3 D; n: P# N! Q9 Y& L/ s10.2.2 运行时辅助实现 148
$ S' y, F" B) E" k, X$ R4 p
% V j: B; `! ^* n; Y) q# t) z, A10.2.3 JNI API作为运行时辅助 1507 j7 H7 q: W) w/ e, Y. i0 g7 p6 e
4 D( A4 A2 n5 k+ j) z' _
10.3 没有运行时辅助的VM服务设计 151
! {$ t5 q; {3 A. b2 r; o
4 r' n, r" V$ s10.3.1 运行时辅助的快速路径 153
. v8 L0 \5 z' G8 c& G# w8 @$ X
, ]8 k: N! j* T+ N, m10.3.2 快速路径VM服务编程 154
0 G# y5 S" \/ Z) O( E4 v* C" [' ^, Z3 P$ q
10.4 主要VM服务 154* D! T [% C3 y9 g) W1 `& [
: _. p( x8 `, V, ^3 n$ F0 Y" t9 L
第 11章 异常抛出 157: t4 \% v& r$ u6 M
* K) j, S6 w# \$ B2 C' S7 {: {11.1 保存异常抛出上下文 157% P9 C5 I1 F8 a
7 j+ i$ I. P& U5 X- N
11.1.1 VM保存的上下文 158, X0 a1 U3 m2 Z2 t* t6 L
k% s% s Z+ F5 W. Y {4 d; J11.1.2 Linux中OS保存的上下文 158
/ W* Q5 f1 t5 @. C; y4 j. ?4 P3 l9 j8 z% P$ d
11.1.3 Windows中OS保存的上下文 159 d3 v7 O' H) N2 D( V8 r9 Y+ E1 _5 j9 o
" C# A2 `! w$ E3 A% O9 x5 N
11.1.4 同步与异步异常 160
% V4 a3 V, g: Q; }0 d8 V0 e
& E- S8 ?& E( D4 K$ p* R0 f2 N11.2 本地代码内与跨本地代码异常处理 161" O4 V" X7 I" } I/ a
8 _1 H7 u7 H. a
11.2.1 本地代码内的异常处理 161$ j" b5 X$ M- E
5 s9 O/ I1 G' M6 j, m2 q7 Y& ^& o3 u
11.2.2 带异常Java代码返回到本地代码 162
: r T8 i9 n4 B2 P3 N( q9 s% w6 v' m0 D: I# Y
11.2.3 带异常的本地代码返回到Java代码 166# d: @9 n- L! a& {7 B; c
( j; |0 e0 d4 W* u) M) G
11.3 保存栈轨迹 1678 U0 J; I( e- g, e/ Z0 v, S
, b5 n# @% [6 l. f6 _" Z11.4 找到异常处理器 169* B0 M! ^. k6 |( t3 J% E
/ V2 w0 G( ~ f* i, o
11.5 控制转移 172
! s0 {8 I6 N: F% h
8 U2 h0 _+ @$ a. f6 e3 _11.5.1 控制转移操作 172% a' m x( `; _ W* f
9 M, `4 V7 l4 v G11.5.2 用于控制转移的寄存器 173
8 C9 q! M: a/ V* d9 P6 l
; C" ^ t$ A* P: E& y11.5.3 数据寄存器恢复 174- \4 f$ i0 V0 V
9 s. s* I& F8 K: a2 B8 d; k
11.5.4 控制寄存器修正 176
. [, Q* _8 `' E" J i K& L( `( V$ t# m. Z0 S1 ?8 @
11.5.5 执行恢复 176
/ o. G$ A2 z9 I. J
+ S3 ~5 \* x& y; m# A$ T1 P9 w1 y, ~11.5.6 未捕获异常 179
% f7 _; ?/ T. e2 [- s* x' A1 Y8 u; A6 ~3 S" ?% R9 U
第 12章 终结与弱引用 180
4 B* p' B! y- ?6 Y! E, _( {
$ N" Z9 ]* z$ [1 a- A4 m7 V4 K12.1 终结 180
# l' G1 S% [- R' E& X k, b. Q7 d4 ]# v4 A
12.2 为何需要弱引用 182
6 d8 v1 q2 ~5 k7 h+ w8 r
+ o5 ?( m/ l- S$ B3 ]12.3 对象生存期状态 184% W9 M. c* o! A9 d4 t
7 b3 t# n2 G6 N12.3.1 对象状态转换 185) n1 ~3 Q' o1 [0 {2 l& n x( X
' ] P" L3 k: e1 u e$ x12.3.2 引用队列 187
. Y1 u# y o; P: m, y. Y5 I6 h5 v2 v
12.3.3 引用对象状态转换 187
# B! F6 \3 ` Y; x* F% B
) y5 ^0 e+ h2 `8 _12.4 引用对象实现 189
: I& [8 S- ^3 ?* A2 f
4 ?; x/ A2 V9 F* c7 D6 j! n12.5 引用对象处理顺序 191" `0 \7 u @4 W6 x' E: v& A$ a5 `; H8 T
' b0 Q* \. f9 Z, V% B, V第 13章 虚拟机模块化设计 194" `* [2 n0 ?& s+ |) Q; ^5 G
+ \! @! C# {8 m4 A
13.1 VM组件 194
" t# N; p- s2 ^: G( K0 h+ Y# g# U
' l6 i4 b/ Y- J' l2 w13.2 对象信息暴露 197
- T2 p- i5 o5 M. p! F2 S7 i1 b4 \3 j, k6 p0 i3 U
13.3 垃圾回收器接口 1990 B# Z8 O5 L6 C3 a6 ^; `6 X
) V; G5 f+ z; D0 Y: F
13.4 执行引擎接口 202
2 [5 t L' F5 ~' L z& w# h7 l9 ~# j: n9 \
13.5 跨组件优化 203) W0 \2 j$ I' q* c2 Z9 ]3 W
" k8 I$ A* W+ ~* V第四部分 垃圾回收优化2 _' b" n" y6 w- L! D8 j
& ?4 d3 e1 I, L. w. ]: Q
第 14章 针对吞吐量的GC优化 208
" I! M2 k' P/ Q% H: E0 V
6 a- O, I* Y2 z! h/ C, s6 D14.1 部分堆回收与全堆回收之间的适应性调整 2088 \4 u' l% n x4 c' W
8 O# h J' _8 `0 C
14.2 分代式与非分代式算法之间的适应性调整 213
- p* P& o" |* ~$ H. n0 h' Q
- Y2 g& [5 x: a1 n14.3 堆的空间大小的适应性调整 217
$ ?6 G! M2 p0 {
- R$ T) w3 z, H5 W% c0 g14.3.1 空间大小扩展 218
$ S$ h# h4 ?9 T, j5 w3 l0 [
7 f% b6 q) ^: d7 U14.3.2 NOS大小 219
" j A! W. y0 Y- A# r
% [# g. h8 t) W8 ^+ s) U14.3.3 部分转发NOS设计 221
1 C# W" w% G: r3 _& O2 R g& d; M% [; C& g) p) Y* F5 X1 R* G
14.3.4 半空间NOS设计 221
& P. L: b: e1 @- W( j& u4 D0 \$ ]1 _- s: ^! m5 Z$ m4 b, g# |
14.3.5 aged-mature NOS设计 223
* \5 W+ @# c" c$ D. n
0 ` d5 U8 F: |+ g4 g5 \14.3.6 回退回收 225
. m, Q0 p, b2 Q. G6 t; y! C: \4 o6 q, b8 i; o
14.4 分配空间之间的适应性调整 225( d2 G! ~ X2 w7 ], t' f# t0 c2 \
; s& [2 O% B. b. P& X2 p% z0 @14.5 大OS页与预取 2301 F. v4 U9 [ E# m ?
3 W6 l" E! L/ p9 ~( F' I6 E
第 15章 针对可扩展性的GC优化 232' l0 y- ]" B. K( h8 v5 Z, t% T8 t
( x( m) n7 B8 q6 O2 i* S
15.1 回收阶段 232
* q3 ~8 ^6 m) c: C6 m2 A& U0 r& Q' C5 ^
15.2 并行对象图遍历 2335 U6 j3 P/ l; Z9 b& ?4 p4 }! O
( M! G) H) D& T/ \
15.2.1 任务共享 234
. h, \ r$ g: i* i9 B- G$ d
8 T9 i$ a+ L& Y" z. T t% u15.2.2 工作偷取 234
z4 N! c2 x2 P. \ f7 N" f" m
" a, m0 }" s1 q' Y8 s6 Y! F3 j. P15.2.3 任务推送 2359 N# F+ b$ }3 g
. _1 X+ d) ` }1 o% u/ U1 M6 p" K
15.3 并行对象标记 2384 D2 s% J" N, r7 K
! g# e& R7 P2 u, A/ k% _+ ?* v15.4 并行压缩 2390 X8 c* T. ?) b# J( K- c
9 V( ]2 i" ]9 \& x& [
15.4.1 并行LISP2压缩器 239( `: t/ Q+ h: _4 u l! E
) i1 r7 E6 y0 i, S15.4.2 对象依赖树 241
8 t, M; N; \. I8 V8 V8 |% }
* F2 q0 Q |2 T7 C: x/ p& B15.4.3 带用于转发指针的目标表的压缩器 244
+ K" Z% V. q% I' j) Z% G! G2 m7 `4 H
15.4.4 基于对象节的压缩器 246! G/ h5 j3 z6 S& I6 O
. l5 {* }! s# b15.4.5 单趟就地压缩器 247( G ~! a8 o/ g/ ~) L- R3 g
4 t6 F% V9 ]- X8 n4 R
第 16章 针对响应性的GC优化 249
$ a4 L% G& _/ C9 v" o, [3 O- W# {3 P7 i/ S( N
16.1 区域式GC 2497 U4 a. \, [ G6 ?3 O
/ P8 D& o! _5 O+ J
16.2 并发追踪 252' v8 r. W5 W9 L; }
. N3 l. `8 \: s% e16.2.1 起始快照 252" {5 H4 x* ~2 X5 i8 H h
; L+ h3 e/ z2 h' G4 L/ g16.2.2 增量更新 256
, I* ^$ G: W% r* J2 d! [( p( m+ W/ n- E
16.2.3 用三色术语表示并发追踪 259
' S) y" y9 D; { A- w P. s) q+ Z8 d$ B* ?; s2 B- Y
16.2.4 使用读屏障的并发追踪 260
2 k: d# m0 m& ^ L; X. h+ C' q6 G- F( k% d v
16.3 并发根集枚举 261
6 n8 N9 w6 |0 c! a6 J/ F$ a
! }' _ s5 r+ W( v+ z16.3.1 并发根集枚举设计 262/ Q- s; k3 f6 Z }
8 y$ Q6 E' ^+ L8 C16.3.2 在根集枚举过程中追踪堆 265
4 _ B" `* J$ [$ p4 `/ q! n0 |) U$ V+ E# |
16.3.3 并发栈扫描 266
3 Q$ E. F+ j; [. v- Z8 Y. W& C% a b, @- |. I$ p* u. R: N
16.4 并发回收调度 267* f. D" z1 K/ W8 f
$ [3 |( \7 v+ c+ h- l- f- i1 ~/ B
16.4.1 调度并发根集枚举 2673 N8 X r* ?0 N( | u
* N# [1 t/ { a
16.4.2 调度并发堆追踪 269, _. U h$ k. a0 A6 I$ T0 j. |1 E
+ g0 u9 \% }: q2 P9 V16.4.3 并发回收调度 2716 O; h+ _* Z" |: V+ m2 w5 w! A6 ^
, S; ?2 P) \ O( O: ^ i16.4.4 并发回收阶段转换 272( I. v2 ~$ s5 I" C* R& i
, g1 t: a% e* ^5 K( z8 F4 j第 17章 并发移动式回收 277! V7 `6 {: X+ j$ w* H/ Q
2 e5 i8 [! Y/ T" H
17.1 并发复制：“目标空间不变” 2776 i& `& N" {$ }$ y
) K7 N' `* r! B& l1 \
17.1.1 基于槽位的“目标空间不变”算法 277- O1 N1 O" S0 H3 h" X- i: V
% S' ]7 B9 S0 X- l3 K% |, l) {17.1.2 “目标空间不变”性 2803 P! V: T/ m$ ?$ J7 U, O* A
8 @- ]8 _6 o# p; s1 z7 s4 P. h17.1.3 对象转发 282
3 _ s% M ^2 U+ J! k1 S8 c8 h. j& v3 \
17.1.4 基于对象的“目标空间不变”算法 283& q+ S; s4 w# _$ y9 K3 I& h5 a
+ s0 L# ` h p
17.1.5 基于虚拟内存的“目标空间不变”算法 285
) ^& v' g% x9 \9 K- `, A
' m# \- Q) b9 X$ v) A( ]2 e17.2 并发复制：“当前副本不变” 286/ {: D4 W8 R( ?& q8 j
% u6 j) _- K9 Y8 W6 T
17.2.1 对象移动风暴 2868 o, K. u: T+ j8 y* Y6 h% }5 p' X* B
8 N6 J/ Z! q3 v5 y4 D8 v- p, {9 Z. R
17.2.2 “当前副本不变”设计 287
( s7 @* V3 z: |% I* T$ T3 H7 `0 Z' w& h* g
17.2.3 并发复制与并发堆追踪的关系 289! d1 I7 A8 `, G# }0 p3 A
0 b2 {, G& a- ]) M! d17.3 并发复制：“源空间不变” 2929 z# Q M! K' J4 v7 p* n- T
+ ^& o1 n- j4 P. \5 x
17.3.1 “源空间不变”设计 292* p) ^+ [9 z; y; m9 x9 X
+ Y' d+ \2 G, M3 W# K* ]
17.3.2 部分转发“源空间不变”设计 294
; O, g4 S2 O0 O3 s. z. ^& C3 t- @" s5 u/ v( K1 V- a/ x
17.4 无STW的完整并发移动 295
6 T5 A- c4 g7 v2 Z! z7 Q- ~
+ C0 a _' g( u17.5 并发压缩回收 296
1 M" t6 j! n6 {( o2 m+ _# n* C
+ _) W* t% c2 _+ W0 `; B& d17.5.1 并发区域复制式回收 296- n# _" K* l) S# X
0 h/ a' |2 v$ R, s5 |
17.5.2 基于虚拟内存的并发压缩 2993 a4 J6 c1 K1 K. m+ [
! j: V; [( w2 H& k) j& A第五部分 线程交互优化8 u9 {% n# `' Q {1 i
% S' g6 A) V U" {/ V% _5 b3 T+ l第 18章 monitor性能优化 308* D4 l$ U4 w! y+ ]# V% A0 E
. O0 }) F$ C7 |9 |/ ]; Y! d
18.1 惰性锁 308
: h* Z) k9 S; \7 ^8 H
0 `4 Z. i# g, `/ \9 ?0 n! G |' s, v18.2 瘦锁 3104 E: W: }7 D% k# x
; V9 M' s& k6 ?% I% B& j# w+ v
18.2.1 瘦锁锁定路径 310
' z3 Q' B: i6 {: I+ I% J9 [/ g9 V8 u# |! E2 j* ~; q# K3 Z4 v
18.2.2 瘦锁解锁路径 313/ I# }& u3 V/ o* ]5 ]+ b z
y6 V2 j& Z2 u# W! q
18.2.3 竞争标志重置支持 316" W3 d6 T) [7 y1 j8 D) g* n, t
- b1 i6 v* t6 f# p5 }9 u18.3 胖锁 3183 h) C) y& N+ Q: ]: S
8 q. Z: [8 d8 A) Y: u8 f! O3 G
18.3.1 整合monitor数据结构 318
6 z, g! T# W. }. m# b2 C/ x
" u$ _# R7 \0 L2 c4 [' d9 M6 `18.3.2 交由OS来支持 319- t( i+ {7 f( R/ f' [
2 {7 X; A: ^7 C7 w V3 {18.3.3 瘦锁膨胀为胖锁 321( |4 ]* W7 A" V3 D0 ~: ~0 P8 m- D! R
' W% S" \! v8 h! Y
18.3.4 休眠等待被竞争瘦锁 324
& M! b9 Y* T3 [+ _* @( j* ~0 L! H5 u" S9 @. ~. Z
18.4 Tasuki锁 3270 _) j- `' F1 E7 U
8 b- {0 w; d0 R18.4.1 将同一个胖锁monitor用于竞争控制 327* ?' |8 U6 T" w7 K, h$ P7 z
* t- Z: [: p/ X4 z9 @3 Z
18.4.2 胖锁收缩为瘦锁 331
0 ~4 ^6 S1 r) z' c9 [! ~! h6 X! v! M; t' V7 S V) l" |# k
18.5 线程局部锁 334* d6 J! i+ O( V# N
% N9 z I7 K" t9 D18.5.1 锁保留 335
6 ^" _5 K7 _; }& `- c; O5 P5 R
2 s9 d$ Y) S5 n; u" f2 C4 J18.5.2 线程亲密锁 339: a* D7 V9 j( e1 b* h. B
# ~5 m8 |0 |7 F4 D, P, V3 l第 19章 基于硬件事务内存的设计 346: A2 `$ I4 Z1 p! k/ q2 }
5 t" z4 p1 I' P" `+ H1 `5 @/ f& v. f- z
19.1 硬件事务内存 3469 o+ E+ M7 W) _& M2 J2 _
3 W% l/ t- B3 L# U& c
19.1.1 从事务数据库到事务内存 346
& {5 k a& t: o% [/ x3 Z* N( @
8 p. F) z& [' X1 B0 T% T19.1.2 Intel的HTM实现 347
f) L5 A1 w: Hjava8.com0 F/ t; p7 Z. B# Z, h8 B/ Q
19.2 使用HTM的monitor实现 348& T7 l3 }3 Y2 y7 U8 ^, f5 b
- l: c; q1 b+ T6 K7 [" A) o9 t/ _
19.2.1 基于HTM的monitor的正确性问题 349
- Q" d9 n n% ~1 O! `' s- M8 J7 y5 r3 q( y0 J- c
19.2.2 基于HTM的monitor的性能问题 352
4 T1 a6 X0 x, `" q. z. U
; c! w o. S r I; p" v19.3 使用HTM的并发垃圾回收 355
) y+ G" e% j1 U/ c/ g
+ ]8 y5 d) t* M9 q19.3.1 GC中HTM的机会 355
& l! a# `. j& k% K/ ]7 v. Z) n% |! H, z' k. f% Y# p! H
19.3.2 复制式回收 3577 m( n0 H) R) Z+ I
3 H: X7 S% Y% [: h! m1 _; x
19.3.3 压缩式回收 360. l4 x8 W* b8 w3 d R+ t3 ^5 S. m2 N
: w+ ]1 j: ]/ r参考文献 364% V) l# @: @! W* ]$ s) G
* Z, Q) S* F& B
P' o& W# ~/ g- F
百度云盘下载地址(完全免费-绝无套路)：" o: } `* M% g+ z4 C
) Z# ]! j" @/ D: a" M. @
本资源由Java吧收集整理【www.java8.com】
7 q: k: n" [2 F
, t+ \% q3 i q' ^9 T. m( l3 x6 q9 i% q
! F+ {' v' b6 I" P. b
{2 b2 Y) D6 x- }5 E! C' W
! B3 B) Y9 h: E
/ e( H i; e+ f+ A$ F
|
电子书
104 人阅读
|
16 人回复
|
2024-05-07
