zoukankan      html  css  js  c++  java
  • 垃圾回收基本算法 内存管理 GC大统一理论

    《垃圾收集》 (豆瓣) https://book.douban.com/subject/1157908/

    第1章 简介
    1.1 内存分配的历史
    1.1.1 静态分配
    1.1.2 栈分配
    1.1.3 堆分配
    1.2 状态、存活性和指针可到达性
    1.3 显式堆分配
    1.3.1 一个简单的例子
    1.3.2 垃圾
    1.3.3 悬挂引用
    1.3.4 共享
    1.3.5 失败
    1.4 为什么需要垃圾收集
    1.4.1 语言的需求
    1.4.2 问题的需求
    1.4.3 软件工程的课题
    1.4.4 没有银弹
    1.5 垃圾收集的开销有多大
    1.6 垃圾收集算法比较
    1.7 记法
    .1.7.1 堆
    1.7.2 指针和子女
    1.7.3 伪代码
    1.8 引文注记
    第2章 经典算法
    2.1 引用计数算法
    2.1.1 算法
    2.1.2 一个例子
    2.1.3 引用计数算法的优势和弱点
    2.1.4 环形数据结构
    2.2 标记一清扫算法
    2.2.1 算法
    2.2.2 标记—清扫算法的优势和弱点
    2.3 节点复制算法
    2.3.1 算法
    2.3.2 一个例子
    2.3.3 节点复制算法的优势和弱点
    2.4 比较标记—清扫技术和节点复制技术
    2.5 需要考虑的问题
    2.6 引文注记
    第3章 引用计数
    3.1 非递归的释放
    3.1.1 算法
    3.1.2 延迟释放的优点和代价
    3.2 延迟引用计数
    3.2.1 deutsch-bobrow算法
    3.2.2 一个例子
    3.2.3 zct溢出
    3.2.4 延迟引用计数的效率
    3.3 计数域大小受限的引用计数
    3.3.1 “粘住的”计数值
    3.3.2 追踪式收集恢复计数值
    3.3.3 仅有一位的计数值
    3.3.4 恢复独享信息
    3.3.5 “ought to be two”缓冲区
    3.4 硬件引用计数
    3.5 环形引用计数
    3.5.1 函数式程序设计语言
    3.5.2 bobrow的技术
    3.5.3 弱指针算法
    3.5.4 部分标记—清扫算法
    3.6 需要考虑的问题
    3.7 引文注记
    第4章 标记—清扫垃圾收集
    4.1 与引用计数技术的比较
    4.2 使用标记栈
    4.2.1 显式地使用栈来实现递归
    4.2.2 最小化栈的深度
    4.2.3 栈溢出
    4.3 指针反转
    4.3.1 deutsch-schorr-waite算法
    4.3.2 可变大小节点的指针反转
    4.3.3 指针反转的开销
    4.4 位图标记
    4.5 延迟清扫
    4.5.1 hughes的延迟清扫算法
    4.5.2 boehm-demers-weiser清扫器
    4.5.3 zorn的延迟清扫器
    4.6 需要考虑的问题
    4.7 引文注记
    第5章 标记—缩并垃圾收集
    5.1 碎片现象
    5.2 缩并的方式
    5.3 “双指针”算法
    5.3.1 算法
    5.3.2 对“双指针”算法的分析
    5.3.3 可变大小的单元
    5.4 lisp 2 算法
    5.5 基于表的方法
    5.5.1 算法
    5.5.2 间断表
    5.5.3 更新指针
    5.6 穿线方法
    5.6.1 穿线指针
    5.6.2 jonkers的缩并算法
    5.6.3 前向指针
    5.6.4 后向指针
    5.7 需要考虑的问题
    5.8 引文注记
    第6章 节点复制垃圾收集
    6.1 cheney的节点复制收集器
    6.1.1 三色抽象
    6.1.2 算法
    6.1.3 一个例子
    6.2 廉价地分配
    6.3 多区域收集
    6.3.1 静态区域
    6.3.2 大型对象区域
    6.3.3 渐进的递增缩并垃圾收集
    6.4 垃圾收集器的效率
    6.5 局部性问题
    6.6 重组策略
    6.6.1 深度优先节点复制与广度优先节点复制
    6.6.2 不需要栈的递归式节点复制收集
    6.6.3 近似于深度优先的节点复制
    6.6.4 层次分解
    6.6.5 哈希表
    6.7 需要考虑的问题
    6.8 引文注记
    第7章 分代式垃圾收集
    7.1 分代假设
    7.2 分代式垃圾收集
    7.2.1 一个简单例子
    7.2.2 中断时间
    7.2.3 次级收集的根集合
    7.2.4 性能
    7.3 提升策略
    7.3.1 多个分代
    7.3.2 提升的闽值
    7.3.3 standard ml of new jersey收集器
    7.3.4 自适应提升
    7.4 分代组织和年龄记录
    7.4.1 每个分代一个半区
    7.4.2 创建空间
    7.4.3 记录年龄
    7.4.4 大型对象区域
    7.5 分代间指针
    7.5.1 写拦截器
    7.5.2 入口表
    7.5.3 记忆集
    7.5.4 顺序保存缓冲区
    7.5.5 硬件支持的页面标记
    7.5.6 虚存系统支持的页面标记
    7.5.7 卡片标记
    7.5.8 记忆集还是卡片
    7.6 非节点复制的分代式垃圾收集
    7.7 调度垃圾收集
    7.7.1 关键对象
    7.7.2 成熟对象空间
    7.8 需要考虑的问题
    7.9 1 文注记
    第8章 渐进式和并发垃圾收集
    8.1 同步
    8.2 拦截器方案
    8.3 标记—清扫收集器
    8.3.1 写拦截器
    8.3.2 新单元
    8.3.3 初始化和终止
    8.3.4 虚存技术
    8.4 并发引用计数
    8.5 baker的算法
    8.5.1 算法
    8.5.2 baker算法的延迟的界限
    8.5.3 baker的算法的局限
    8.5.4 baker算法的变种
    8.5.5 动态重组
    8.6 appel-ellis-li收集器
    8.6.1 各种改进
    8.6.2 大型对象
    8.6.3 分代
    8.6.4 性能
    8.7 应变复制收集器
    8.7.1 nettle的应变复制收集器
    8.7.2 huelsbergen和larus的收集器
    8.7.3 doligez-leroy-gonthier收集器
    8.8 baker的工作环收集器
    8.9 对实时垃圾收集的硬件支持
    8.10 需要考虑的问题
    8.11 引文注记
    第9章 c语言的垃圾收集
    9.1 根不确定收集的一个分类
    9.2 保守式垃圾收集
    9.2.1 分配
    9.2.2 寻找根和指针
    9.2.3 内部指针
    9.2.4 保守式垃圾收集的问题
    9.2.5 识别错误
    9.2.6 效率
    9.2.7 渐进式、分代式垃圾收集
    9.3 准复制式收集
    9.3.1 堆的布局
    9.3.2 分配
    9.3.3 垃圾收集
    9.3.4 分代式垃圾收集
    9.3.5 无法精确识别的数据结构
    9.3.6 准复制式收集的效率
    9.4 优化的编译器是“魔鬼”
    9.5 需要考虑的问题
    9.6 引文注记
    第10章 c++语言的垃圾收集
    10.1 用于面向对象语言的垃圾收集
    10.2 对c++垃圾收集器的需求
    10.3 在编译器中还是在库中
    10.4 保守式垃圾收集
    10.5 准复制式收集器
    10.6 智能指针
    10.6.1 在没有智能指针类层次的情况下进行转换
    10.6.2 多重继承
    10.6.3 不正确的转换
    10.6.4 某些指针无法“智能化”
    10.6.5 用const和volatile修饰的指针
    10.6.6 智能指针的“泄漏”
    10.6.7 智能指针和引用计数
    10.6.8 一个简单的引用计数指针
    10.6.9 用于灵活的垃圾收集的智能指针
    10.6.10 用于追踪式垃圾收集的智能指针
    10.7 为支持垃圾收集而修改c++
    10.8 ellis和deters的建议
    10.9 终结机制
    10.10 需要考虑的问题
    10.11 引文注记
    第11章 垃圾收集与cache
    11.1 现代处理器体系结构
    11.2 cache的体系结构
    11.2.1 cache容量
    11.2.2 放置策略
    11.2.3 写策略
    11.2.4 特殊的cache指令
    11.3 内存访问的模式
    11.3.1 标记 —清扫技术,使用标记位图和延迟清扫
    11.3.2 节点复制垃圾收集
    11.3.3 渐进式垃圾收集
    11.3.4 避免读取
    11.4 改进cache性能的标准方法
    11.4.1 cache的容量
    11.4.2 块大小
    11.4.3 相联度
    11.4.4 特殊指令
    11.4.5 预取
    11.5 失误率和总体cache性能
    11.6 专用硬件
    11.7 需要考虑的问题
    11.8 引文注记
    第12章 分布式垃圾收集
    12.1 需求
    12.2 虚拟共享存储器
    12.2.1 共享虚拟存储器模型
    12.2.2 共享数据对象模型
    12.2.3 分布式共享存储器之上的垃圾收集
    12.3 与分布式垃圾收集有关的课题
    12.3.1 分类原则
    12.3.2 同步
    12.3.3 鲁棒性
    12.4 分布式标记—清扫
    12.4.1 hudak和keller
    12.4.2 ali的算法
    12.4.3 hughes的算法
    12.4.4 liskov-ladin算法
    12.4.5 augusteijn的算法
    12.4.6 vestal的算法
    12.4.7 schelvis-bledoeg算法
    12.4.8 emerald收集器
    12.4.9 ik收集器
    12.5 分布式节点复制
    12.6 分布式引用计数
    12.6.1 lermen-maurer协议
    12.6.2 间接引用计数
    12.6.3 mancini-shrivastava算活
    12.6.4 spg协议
    12.6.5 “garbage collecting the world”
    12.6.6 网络对象
    12.6.7 带权引用计数
    12.6.8 世代引用计数
    12.7 对actor进行垃圾收集
    12.7.1 halstead算法
    12.7.2 标记算法
    12.7.3 逻辑上集中式的收集器
    12.8 引文注记
    术语表
    参考文献
    索引
    算法列表

    《代码的未来》(豆瓣) https://book.douban.com/subject/24536403/

    第一章 编程的时间和空间
    1.1  编程的本质  3
    编程的本质是思考  4
    创造世界的乐趣  4
    快速提高的性能改变了社会  5
    以不变应万变  8
    摩尔定律的局限  9
    社会变化与编程  10
    1.2  未来预测  13
    科学的未来预测  14
    IT 未来预测  14
    极限未来预测  16
    从价格看未来  16
    从性能看未来  17
    从容量看未来  18
    从带宽看未来  19
    小结  20
    第二章 编程语言的过去、现在和未来
    2.1  编程语言的世界  23
    被历史埋没的先驱  25
    编程语言的历史  26
    编程语言的进化方向  30
    未来的编程语言  32
    20 年后的编程语言  34
    学生们的想象  34
    2.2  DSL(特定领域语言)  36
    外部DSL  37
    内部DSL  38
    DSL 的优势  39
    DSL 的定义  39
    适合内部DSL 的语言  40
    外部DSL 实例  42
    DSL 设计的构成要素  43
    Sinatra  46
    小结  47
    2.3  元编程  48
    Meta, Reflection  48
    类对象  51
    类的操作  52
    Lisp  53
    数据和程序  54
    Lisp 程序  56
    宏  56
    宏的功与过  57
    元编程的可能性与危险性  59
    小结  60
    2.4  内存管理  61
    看似无限的内存  61
    GC 的三种基本方式  62
    术语定义  62
    标记清除方式  63
    复制收集方式  64
    引用计数方式  65
    引用计数方式的缺点  65
    进一步改良的应用方式  66
    分代回收  66
    对来自老生代的引用进行记录  67
    增量回收  68
    并行回收  69
    GC 大统一理论  69
    2.5  异常处理  71
    “一定没问题的”  71
    用特殊返回值表示错误  72
    容易忽略错误处理  72
    Ruby 中的异常处理  73
    产生异常  74
    更高级的异常处理  75
    Ruby 中的后处理保证  76
    其他语言中的异常处理  77
    Java 的检查型异常  77
    Icon 的异常和真假值  78
    Eiffel 的Design by Contract  80
    异常与错误值  80
    小结  81
    2.6  闭包  82
    函数对象  82
    高阶函数  83
    用函数参数提高通用性  84
    函数指针的局限  85
    作用域:变量可见范围  87
    生存周期:变量的存在范围  88
    闭包与面向对象  89
    Ruby 的函数对象  89
    Ruby 与JavaScript 的区别  90
    Lisp-1 与Lisp-2  91
    第三章 编程语言的新潮流
    3.1  语言的设计  97
    客户端与服务器端  97
    向服务器端华丽转身  98
    在服务器端获得成功的四大理由  99
    客户端的JavaScript  100
    性能显著提升  101
    服务器端的Ruby  102
    Ruby on Rails 带来的飞跃  102
    服务器端的Go  103
    静态与动态  104
    动态运行模式  105
    何谓类型  105
    静态类型的优点  106
    动态类型的优点  106
    有鸭子样的就是鸭子  107
    Structural Subtyping  108
    小结  108
    3.2  Go  109
    New(新的)  109
    Experimental(实验性的)  109
    Concurrent(并发的)  110
    Garbage-collected(带垃圾回收的)  110
    Systems(系统)  111
    Go 的创造者们  111
    Hello World  112
    Go 的控制结构  113
    类型声明  116
    无继承式面向对象  118
    多值与多重赋值  120
    并发编程  122
    小结  124
    3.3  Dart  126
    为什么要推出Dart ?  126
    Dart 的设计目标  129
    代码示例  130
    Dart 的特征  132
    基于类的对象系统  132
    非强制性静态类型  133
    Dart 的未来  134
    3.4  CoffeeScript  135
    最普及的语言  135
    被误解最多的语言  135
    显著高速化的语言  136
    对JavaScript 的不满  138
    CoffeeScript  138
    安装方法  139
    声明和作用域  139
    分号和代码块  141
    省略记法  142
    字符串  143
    数组和循环  143
    类  145
    小结  146
    3.5  Lua  148
    示例程序  149
    数据类型  149
    函数  150
    表  150
    元表  151
    方法调用的实现  153
    基于原型编程  155
    和Ruby 的比较(语言篇)  157
    嵌入式语言Lua  157
    和Ruby 的比较(实现篇)  158
    嵌入式Ruby  159
    第四章 云计算时代的编程
    4.1  可扩展性  163
    信息的尺度感  163
    大量数据的查找  164
    二分法查找  165
    散列表  167
    布隆过滤器  169
    一台计算机的极限  170
    DHT(分布式散列表)  171
    Roma  172
    MapReduce  173
    小结  174
    4.2  C10K 问题  175
    何为C10K 问题  175
    C10K 问题所引发的“想当然”  177
    使用epoll 功能  180
    使用libev 框架  181
    使用EventMachine  183
    小结  185
    4.3  HashFold  186
    HashFold 库的实现(Level 1)  187
    运用多核的必要性  190
    目前的Ruby 实现所存在的问题  191
    通过进程来实现HashFold(Level 2)  191
    抖动  193
    运用进程池的HashFold(Level 3)  194
    小结  197
    4.4  进程间通信  198
    进程与线程  198
    同一台计算机上的进程间通信  199
    TCP  IP 协议  201
    用C 语言进行套接字编程  202
    用Ruby 进行套接字编程  204
    Ruby 的套接字功能  205
    用Ruby 实现网络服务器  208
    小结  209
    4.5 Rack 与Unicorn  210
    Rack 中间件  211
    应用程序服务器的问题  212
    Unicorn 的架构  215
    Unicorn 的解决方案  215
    性能  219
    策略  220
    小结  221
    第五章 支撑大数据的数据存储技术
    5.1  键- 值存储  225
    Hash 类  225
    DBM 类  226
    数据库的ACID 特性  226
    CAP 原理  227
    CAP 解决方案——BASE  228
    不能舍弃可用性  229
    大规模环境下的键- 值存储  230
    访问键- 值存储  230
    键- 值存储的节点处理  231
    存储器  232
    写入和读取  233
    节点追加  233
    故障应对  233
    终止处理  235
    其他机制  235
    性能与应用实例  236
    小结  236
    5.2  NoSQL  237
    RDB 的极限  237
    NoSQL 数据库的解决方案  238
    形形色色的NoSQL 数据库  239
    面向文档数据库  240
    MongoDB 的安装  241
    启动数据库服务器  243
    MongoDB 的数据库结构  244
    数据的插入和查询  244
    用JavaScript 进行查询  245
    高级查询  246
    数据的更新和删除  249
    乐观并发控制  250
    5.3  用Ruby 来操作MongoDB  251
    使用Ruby 驱动  251
    对数据库进行操作  253
    数据的插入  253
    数据的查询  253
    高级查询  254
    find 方法的选项  256
    原子操作  257
    ActiveRecord  259
    OD Mapper  260
    5.4  SQL 数据库的反击  264
    “云”的定义  264
    SQL 数据库的极限  264
    存储引擎Spider  265
    SQL 数据库之父的反驳  265
    SQL 数据库VoltDB  268
    VoltDB 的架构  269
    VoltDB 中的编程  270
    Hello VoltDB!  271
    性能测试  273
    小结  275
    5.5  memcached 和它的伙伴们  276
    用于高速访问的缓存  276
    memcached  277
    示例程序  278
    对memcached 的不满  279
    memcached 替代服务器  280
    另一种键- 值存储Redis  282
    Redis 的数据类型  284
    Redis 的命令与示例  285
    小结  289
    第六章 多核时代的编程
    6.1  摩尔定律  293
    呈几何级数增长  293
    摩尔定律的内涵  294
    摩尔定律的结果  295
    摩尔定律所带来的可能性  296
    为了提高性能  297
    摩尔定律的极限  302
    超越极限  303
    不再有免费的午餐  304
    6.2  UNIX 管道  305
    管道编程  306
    多核时代的管道  308
    xargs——另一种运用核心的方式  309
    注意瓶颈  311
    阿姆达尔定律  311
    多核编译  312
    ccache  313
    distcc  313
    编译性能测试  314
    小结  315
    6.3  非阻塞I/O  316
    何为非阻塞I  O  316
    使用read(2) 的方法  317
    边沿触发与电平触发  319
    使用read(2) + select 的方法  319
    使用read+O_NONBLOCK 标志  321
    Ruby 的非阻塞I  O  322
    使用aio_read 的方法  323
    6.4  node.js  330
    减负  330
    拖延  331
    委派  332
    非阻塞编程  333
    node.js 框架  333
    事件驱动编程  334
    事件循环的利弊  335
    node.js 编程  335
    node.js 网络编程  337
    node.js 回调风格  339
    node.js 的优越性  340
    EventMachine 与Rev  341
    6.5  ZeroMQ  342
    多CPU 的必要性  342
    阿姆达尔定律  343
    多CPU 的运用方法  343
    进程间通信  345
    管道  345
    SysV IPC  346
    套接字  347
    UNIX 套接字  349
    ZeroMQ  349
    ZeroMQ 的连接模型  350
    ZeroMQ 的安装  352
    ZeroMQ 示例程序  352
    小结  354
    版权声明  356

    https://www.zhihu.com/question/20018826/answer/28964152

  • 相关阅读:
    没有好的数据可视化分析工具,如何做好数据洞察,如何助力企业数据化转型
    8个可靠的开源数据可视化工具-你的选择是?
    数据可视化赋能大数据价值释放,助力大数据价值应用落地 echarts,d3.js
    (五).NET Core中过滤器Filter的使用介绍
    (四).NET Core中使用OOM框架,AutoMapper的使用介绍
    (三).NET Core WebAPI集成JWT,实现身份验证
    (二)集成Swagger接口文档分组配置.net core
    (一).NET Core WebAPI集成Swagger做接口管理
    要使数据分析真正有价值和有洞察力,就需要高质量的可视化工具
    基于echarts组件制作数据可视化大屏
  • 原文地址:https://www.cnblogs.com/rsapaper/p/10476920.html
Copyright © 2011-2022 走看看