我的部署方案

• 运行环境：站点解析采用境内和境外分开解析的方案，境内解析到腾讯云的 CDN 节点，境外解析到 Vercel 的 CDN 节点，虽然站点的主要访问由于就是国内用户，但毕竟谷歌、必应等等搜索引擎都是国外的，而国内 CDN 对于境外的加速又比较贵，所以就分开解析啦。
  • 境内：腾讯云 COS 对象存储 + 腾讯云 CDN 加速
  • 境外：Vercel 静态网站托管
• 自动化部署：由于站点的源码托管在 GitHub 上面，所以使用 GitHub Actions 进行自动化部署，写完文章直接 push 上去就可以自动部署到多个平台，简直不要太方便。

GitHub Actions 自动部署到腾讯云 COS

腾讯云提供了非常好用的 cli 工具，执行一些简单的命令就可以快速上传文件到 COS 对象存储。在 Git 工程的根目录下创建.github/workflows/xxx.yml文件，就可以创建一个 Actions 配置。
使用下面的配置可以将 Hexo 部署到腾讯云 COS 对象存储：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

# workflow
name: Blog

on:
  push:
    branches:
      - master

jobs:
  deploy:
    name: Deploy Blog
    runs-on: ubuntu-latest
    env:
      TZ: Asia/Shanghai

    steps:
    # check it to your workflow can access it
    # from: https://github.com/actions/checkout
    - name: Checkout Repository master branch
      uses: actions/checkout@v2
      with: 
        ref: 'master'
        submodules: true

  # from: https://github.com/actions/setup-node
    - name: Setup Node.js
      uses: actions/setup-node@master
      with: 
        node-version: "14.x"

    - name: Yarn Install Cache
      uses: c-hive/gha-yarn-cache@v1

    - name: Install Dependencies
      run: yarn install

    ## generate files
    - name: Generate Hexo Site Public Files & Create Files for Blog Assets
      run: yarn build

    ## deploy to tencent cos
    - name: Deploy to Tencent COS
      env:
        SECRET_ID: ${{ secrets.TENCENT_SECRET_ID }}
        SECRET_KEY: ${{ secrets.TENCENT_SECRET_KEY }}
        BUCKET: ${{ secrets.TENCENT_COS_BUCKET }}
        REGION: ap-shanghai
      run: |
        sudo pip install coscmd
        coscmd config -a ${SECRET_ID} -s ${SECRET_KEY} -b ${BUCKET} -r ${REGION}
        coscmd upload -rs --delete ./public/ / -f

其中：

• ${{ secrets.TENCENT_SECRET_ID }}、${{ secrets.TENCENT_SECRET_KEY }}、${{ secrets.TENCENT_COS_BUCKET }}需要在 github 仓库的 secrets 设置中进行配置。
• 命令coscmd upload -rs --delete ./public/ / -f的意思是比较当前 COS 存储桶内的文件，如果发生变更则更新，如果存储桶中存在但 public 目录中不存在，则删除对应的文件，coscmd的具体使用方法可以参考腾讯云官方文档。

开启 COS 静态网站功能

将网站文件上传到 COS 还不够，需要开启 COS 的静态网站功能，打开存储桶 -> 基础配置 -> 静态网站，按照下图所示进行配置：

这时就可以通过图中的访问节点提供的域名来访问网站了，当然也可以绑定自定义域名，前提是域名已经备案。

腾讯云 CDN 加速

创建域名

如果你的域名有备案的话，同时可以使用腾讯云 CDN 加速 COS 静态网站，配置十分简单，在 CDN 页面中创建一个域名，按下图所示进行配置：

配置缓存

缓存配置十分重要，由于站点是静态站点，网站的内容变化比较少，为了降低 CDN 的回源请求，一定要配置节点缓存策略，可以参考我的配置如下，其中浏览器缓存可以按需配置：

注意：这里不用担心节点缓存时间配置的过长会导致页面无法更新，后面我会讲如何配置缓存的自动刷新。

关于 CDN 配置的更多细节就不讲了，都很简单，一看就懂。

CDN 节点缓存自动刷新

官方方案

由于上一步中配置了 CDN 节点的缓存策略，请求只要能够命中缓存，就不会进行回源请求了，这会导致我们的页面更新不能及时的展现给用户，因此需要考虑如何进行 CDN 节点的缓存自动刷新。

腾讯云官方给我们提供了一个解决方案，可以在 COS 存储桶的函数计算 ->CDN 缓存刷新函数中配置一个函数，可参考下图所示配置：

但这个方案存在一个问题，由于我们的静态网站有默认索引页面 index.html，而官方提供的这个函数只会刷新对应的文件的 URL，而不会刷新索引 URL，例如http://www.bytelife.net/index.html这个文件，通常我们的请求是http://www.bytelife.net/，因此官方的方案针对于静态网站来说不算完美。

优化方案

可以通过简单修改官方的函数来解决这个问题，点击刚刚创建的CDN缓存刷新函数列表中的函数名称，可以跳转的函数的编辑页面：

将 index.js 文件内容替换为下面的代码，最后点击右上角的 “部署” 按钮即可：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

'use strict'

const CosSdk = require('cos-nodejs-sdk-v5')
const CdnSdk = require('./common/CdnSdk')
const CdnRefreshTask = require('./common/CdnRefreshTask')
const {
  getParams,
  getObjectUrl,
  logger,
  getLogSummary
} = require('./common/utils')

exports.main_handler = async (event, context, callback) => {
  /**
   * parse param from event and process.env
   */
  const { objects, cdnHosts, secretId, secretKey, token } = getParams(event)

  logger({
    title: 'param is parsed success, param as follow: ',
    data: { objects, cdnHosts, event }
  })
  /**
   * init cos instance
   */
  if (!secretId || !secretKey || !token) {
    throw new Error(`secretId, secretKey or token is missing`)
  }

  const cdnSdkInstance = new CdnSdk({ secretId, secretKey, token })
  const cosInstance = new CosSdk({
    SecretId: secretId,
    SecretKey: secretKey,
    XCosSecurityToken: token
  })

  const taskList = objects.map(({ bucket, region, key }) => {
    const purgeUrls = [];
    // 主要变更内容在这个位置
    cdnHosts.forEach(host => {
      const tempUrl = getObjectUrl({
        cosInstance,
        bucket,
        region,
        key,
        origin: `${/^(http\:\/\/|https\:\/\/)/.test(host) ? '' : 'https://'}${host}`
      });
      purgeUrls.push(tempUrl);
      // 如果以 /index.html 结尾，则增加目录首页/
      // 例如 https://www.xxxx.com/index.html, 则增加 https://www.xxxx.com/
      if(tempUrl.lastIndexOf('/index.html') == (tempUrl.length - 11)){
        purgeUrls.push(tempUrl.substr(0, tempUrl.length - 10))
      }
    });
    return new CdnRefreshTask({
      cdnSdkInstance,
      urls: purgeUrls
    })
  })

  const taskResults = []
  for (const task of taskList) {
    const results = await task.runPurgeTasks()
    taskResults.push(...results)
  }

  logger({
    title: 'cdn refresh full logs:',
    data: taskResults
  })

  const { status, messages } = getLogSummary(taskResults)

  logger({
    messages: messages.map(item => item.replace(/\,\ /g, '\n'))
  })

  if (status === 'fail') {
    throw messages.join('; ')
  } else {
    return messages.join('; ')
  }
}

本文章内容仅为展示使用，不保证内容更新，最新版本 EFI 文件请前往我的 GitHub 仓库：https://github.com/huzhanfei/ASUS-PRIME-Z370M-PLUS-II-OPENCORE-EFI

华硕 ASUS Prime Z370M-PLUS II 黑苹果 Hackintosh OpenCore EFI 文件，支持核显 + 独显共同硬解，OpenCore 版本：0.6.7

功能

• 声卡（板载）/ 网卡（板载）
• 显卡（核显 + 独显）/ 硬解 4K（HEVC + H.264）
• WiFi（PCI-E 设备） / 蓝牙（PEI-E 载 USB 设备）
• 隔空投送 / 接力 / 随航
• FaceTime / iMessage
• 睿频 / HWP 变频 / 原生电源管理
• 睡眠 / 键盘、鼠标唤醒
• 其他白果功能（99%）

硬件

我的配置

使用

BIOS 设置

关闭

• 快速启动
• 安全启动
• VT-d（如果DisableIoMapper设置为 True，则可以开启）
• CSM
• Intel SGX
• Intel Platform Trust
• CFG Lock

开启

• VT-x
• 大于 4G 解码（Above 4G decoding）
• EHCI/XHCI Hand-off
• 操作系统类型：Windows 8.1/10 UEFI Mode
• DVMT Pre-Allocated(iGPU Memory): 64MB
• SATA Mode: AHCI
• ErP：S4+S5

核显配置

修改 config.plist 的 DeviceProperties > Add > PciRoot (0x0)/Pci (0x2,0x0) > AAPL,ig-platform-id 值为下面任意一个，均可开启核显满频：

• 0300913E：适用于有独立显卡，不使用核显驱动显示器，只用作计算。系统报告中不显示核显信息，但可使用核显加速。

• 00009B3E：适用于没有独立显卡，使用核显驱动显示器，系统报告中显示核显信息（有独立显卡也可使用此配置，但开机速度略慢）

HWP 变频

Kexts 中的CPUFriendDataProvider.kext为 9600K 专用文件，如果你使用的是其它型号的 CPU，需要自行更换

USB 映射

映射端口如图所示，应该可以满足绝大多数情况，如果和你的 USB 端口情况不符，请自行映射替换 USBPorts.kext

修改 SMBIOS

自行生成 SMBIOS 替换图中所示内容：

截图

关于本机

显卡信息

变频

硬解

iMessage

隔空投送

更新记录

2021-03-15

• 升级 OpenCore 0.6.7
• 升级 AppleALC 1.5.8
• 升级 Lilu 1.5.1
• 升级 WhateverGreen 1.4.8
• 升级 VirtualSMC 1.2.1
• 升级 CPUFriend 1.2.3
• 升级 IntelMausiEthernet 1.0.5

2020-11-17

• 升级 OpenCore 0.6.3
• 升级 AppleALC 1.5.4
• 升级 Lilu 1.4.9
• 升级 WhateverGreen 1.4.4
• 升级 VirtualSMC 1.1.8
• 升级 CPUFriend 1.2.2
• 升级 IntelMausiEthernet 1.0.4

2020-09-22

• 升级 OpenCore 0.6.1
• 升级 AppleALC 1.5.2
• 升级 Lilu 1.4.7
• 升级 WhateverGreen 1.4.2
• 升级 VirtualSMC 1.1.6

2020-08-11

• 升级 AppleALC 1.5.1
• 升级 Lilu 1.4.6
• 升级 WhateverGreen 1.4.1
• 升级 CPUFriend 1.2.1
• 升级 VirtualSMC 1.1.5

加速方案

• Netlify：与 Github 配合使用很方便，但国内访问速度不佳，需要搭配国内 CDN 使用
• Vercel：与 Netlify 类似，国内访问速度不错，域名没有备案的话是个不错的选择
• 对象存储：使用阿里云 OSS 或类似的对象存储服务，国内访问速度不错，也可搭配国内 CDN 使用，速度最好，但要求你的域名有备案号
• 境内对象存储 + 境外 Vercel/Netlify：我所采用的方案，应该是最佳的方案了

创建 Bucket

首先要做的事情就是去阿里云 (https://aliyun.com) 创建一个 Bucket:

• Bucket 名称：随便起，只要不重复就行
• 地域：按你的需求，阿里云的节点国内访问速度都可以，如果你不打算使用 CDN 服务的话，可以选择华东节点，全国访问速度都能兼顾。如果使用 CDN 服务的话，那就没区别了，选哪都行。
• 存储类型：一般选择标准存储就可以了，当然如果访问量很小的话，选择低频访问存储也可以，可以省一点钱。
• 同城冗余存储：不需要
• 版本控制：不需要
• 读写权限：这里要注意，我们选择公共读，切记不能选择私有，一方面如果不开启 CDN 的话，私有权限无法在公网访问。另一方面，如果开启 CDN，阿里云的 CDN 私有回源功能与 OSS 的静态页面功能冲突（别问我是怎么知道的，都是坑）
• 服务端加密方式：无
• 实时日志查询：看需求，有免费 7 天的实时日志查询，但有 900GB / 天的限制
• 定时备份：不开通

开启静态页面功能

进入 Bucket 的配置页面，选择 “基础设置 - 静态页面”：

按照图中的内容进行配置：

• 默认首页：index.html
• 默认 404 页：404.html（按照你实际的 404 页面地址填写）
• 子目录首页：开通，这里由于 Hexo 的分类、标签等页面，都是子目录的形式（例如：/tags/），如果不开通这个功能，不会自动定位到对应目录的 index.html
• 文件 404 规则：Index

创建 AccessKey 并授权

其实现在就可以在阿里云的管理页面上传文件部署网站了，但实在是太麻烦，我们希望的是一个自动化的方案。这里我们需要创建一个 API 的授权 AccessKey：

阿里云现在开启了子账户授权的功能，因此我们可以选择跳转到子账户管理的页面：

首先创建一个子账户：

这里注意，由于我们这个账户是给 API 使用的，所以必须开启编程访问权限：

返回以后，点击刚创建的账户右侧的 “添加权限”：

这里搜索 “OSS”，选择添加AliyunOSSFullAccess权限：

返回列表，点击刚创建的账户名称，创建一个 AccessKey，这里要注意，创建完 AccessKey 后，会显示一个 AccessKey 和一个 SecretKey，一定要保存好，只会显示一次：

安装一键部署脚本

我编写了一个可以一键部署 Hexo 到阿里云 OSS 的 hexo 插件，并支持配置浏览器缓存 HTTP 响应头。
源码地址：https://github.com/huzhanfei/hexo-deployer-ali-oss-extend

使用很简单，在 hexo 项目下执行安装命令：

1

npm i hexo-deployer-ali-oss-extend

在 hexo 项目配置文件_config.yml中添加如下配置：

1
2
3
4
5
6
7
8
9
10
11
12

deploy:
- type: ali-oss
  region: "<您的oss 区域代码>"
  accessKeyId: "<您的oss  accessKeyId>"
  accessKeySecret: "<您的oss accessKeySecret>"
  bucket: "<您的bucket name>"
  cacheControl:
    images: "<图片文件HTTP响应头Cache-Control>，留空为no-cache"
    css: "<CSS文件HTTP响应头Cache-Control>，留空为no-cache"
    js: "<JS文件HTTP响应头Cache-Control>，留空为no-cache"
    html: "<HTML文件HTTP响应头Cache-Control>，留空为no-cache"
    other: "<其它文件HTTP响应头Cache-Control>，留空为no-cache"

其中区域代码，可以在 OSS 的 Bucket 概览当中找到，如下图所示：

另外，这里增加 Cache-Control 功能，是由于 OSS 对象存储并没有针对常见的网页文件（如 css、js、图片等）进行默认 HTTP 响应头的设置，这些不常更新的文件不缓存，会导致流量大量浪费，后面如果使用 CDN 的时候，CDN 获取不到缓存配置也会进行不断的回源，产生回源流量浪费。

配置就这么简单，然后执行部署命令：

1

hexo d

即可将项目部署到 OSS 中，默认情况下将文件上传到 bucket 的根目录下，如果需要部署到其他目录，请在 deploy 下添加 remotePath 选项进行指定

1

remotePath: "<您要部署的目录>"

当然，如果你使用了 GitHub 的 Actions 功能，可以配置自动执行 hexo d，提交源码的时候自动执行部署脚本，简直不要太方便，具体配置方式不是本文讨论的重点内容，可自行研究。

配置自定义域名

其实做到这一步，就已经可以访问你的网站了，可以在 Bucket 概览页面找到你的访问域名，当然我们大概率需要使用自己的域名访问，如果你的域名已经进行了备案，可以添加自定义域名。

可以在 “传输管理 - 域名管理” 中配置域名：

点击 “绑定域名”，在如图所示的内容中填入自己的域名，如果你的域名解析服务器是阿里云的话，可以点击 “自动添加 CNAME 记录” 快速设置域名解析：

如果你的域名不在阿里云解析的话，请根据页面提示手动设置域名解析。

后话

到此，就可以通过你的域名访问站点了，你也可以上传 SSL 证书以开启 HTTPS 访问。
当然，如果你有更高的要求，也可以选择更多的优化：

• 开启 CDN 服务：开启 CDN 服务后，相当于在全国多地部署你了的镜像站，以获取更快的访问速度，同时可以通过 CDN 服务开启图片压缩、页面优化等等功能
• 分区域解析：设置 DNS 解析将国内解析到阿里云 OSS 或 CDN，国外解析到 Netlify、Vercel 甚至直接解析到 GitHub Pages 服务

ClassNotFoundException

这个异常我们遇到的频率还是很高的，先来看看官方文档中的定义：

当应用程序试图使用以下方法通过字符串名加载类时，抛出该异常：

• Class 类中的 forName 方法。
• ClassLoader 类中的 findSystemClass 方法。
• ClassLoader 类中的 loadClass 方法。

但是没有找到具有指定名称的类的定义。 从 1.4 版本开始，此异常已经更新，以符合通用的异常链机制。在构造时提供并通过 getException() 方法访问的 “加载类时引发的可选异常”，现在被称为原因，它可以通过 Throwable.getCause() 方法以及与上面提到的 “遗留方法” 来访问。

也就是说在类加载阶段，通过类全名加载类时，如果不能找到这个类，就会抛出 ClassNotFoundException，当然，通常在开发中可能出现该异常的情况总结如下：

1. 所需要的支持类库放错了地方，并没有放在类路径 (CLASSPATH 环境变量) 里面。
2. 使用了重复的类库，且版本不一致。导致低版本的被优先使用。
3. 类名错了，一般是使用 Class.forName 的时候，手工指定了类名的情况。
4. 没有导入纯 JAVA 驱动包。

当然啦，我经常遇到这个异常，尤其是在使用 JDBC 加载驱动的时候，驱动类的类全名真的是很难记的有木有！

NoClassDefFoundError

可以看到这个错误的类名以 Error 结尾，因此它属于 JVM 虚拟机错误，不需要程序员捕获，下图是它的继承结构：

还是同样先来看下官方文档中的定义：

当 Java 虚拟机或 ClassLoader 实例试图在类的定义中加载（作为通常方法调用的一部分或者作为使用 new 表达式创建的新实例的一部分），但无法找到该类的定义时，抛出此异常。 当前执行的类被编译时，所搜索的类定义存在，但无法再找到该定义。

通俗的说，就是编译的时候有这个类，而运行期的时候，这个类找不到了！就会抛出 NoClassDefFoundError 异常。 想要演示这个异常的出现很简单，只需要在编译好的 class 文件中将对应类的 class 文件删除，运行的时候就会抛出这个异常啦！ 那么在实际开发中，通常会在哪些情况遇到该异常呢？通常我们在开发过程中，肯定不会刻意的去删除某个 class 文件，但仍然有出现该异常的情况。 比如我们在使用第三方 jar 包时，有些 SDK 也会设定自己的 Classpath。编译过程结束后在运行的过程中就要将已开发的应用和所有引入的 jar 包拷贝到应用服务器的相应目录下才可以运行，而应用服务器使用的 Classpath 也很有可能与 SDK 的不同，在这个过程中就有很大的几率造成双方环境不一致。所以很多开发者就会遇到在 SDK 中可以编译，运行也没有问题，但是同样的程序放到应用服务器上就出现 NoClassDefFoundErr 这个异常这种情况。

参考文章： 1. JavaTM Platform Standard Edition 6 的 API 规范 2. NoClassDefDoundErr 与 ClassNotFoundException 区别

早在 JDK 1.2 的版本中就提供 Java.lang.ThreadLocal，ThreadLocal 为解决多线程程序的并发问题提供了一种新的思路。使用这个工具类可以很简洁地编写出优美的多线程程序。
当使用 ThreadLocal 维护变量时，ThreadLocal 为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。
从线程的角度看，目标变量就象是线程的本地变量，这也是类名中 “Local” 所要表达的意思。
所以，在 Java 中编写线程局部变量的代码相对来说要笨拙一些，因此造成线程局部变量没有在 Java 开发者中得到很好的普及。 　　

ThreadLocal 的接口方法

ThreadLocal 类接口很简单，只有 4 个方法，我们先来了解一下：

• void set (Object value)：设置当前线程的线程局部变量的值。
• public Object get ()：该方法返回当前线程所对应的线程局部变量。
• public void remove ()：将当前线程局部变量的值删除，目的是为了减少内存的占用，该方法是 JDK 5.0 新增的方法。需要指出的是，当线程结束后，对应该线程的局部变量将自动被垃圾回收，所以显式调用该方法清除线程的局部变量并不是必须的操作，但它可以加快内存回收的速度。
• protected Object initialValue ()：返回该线程局部变量的初始值，该方法是一个 protected 的方法，显然是为了让子类覆盖而设计的。这个方法是一个延迟调用方法，在线程第 1 次调用 get () 或 set (Object) 时才执行，并且仅执行 1 次。ThreadLocal 中的缺省实现直接返回一个 null。

　　值得一提的是，在 JDK5.0 中，ThreadLocal 已经支持泛型，该类的类名已经变为 ThreadLocal。API 方法也相应进行了调整，新版本的 API 方法分别是 void set (T value)、T get () 以及 T initialValue ()。 　　 　　ThreadLocal 是如何做到为每一个线程维护变量的副本的呢？其实实现的思路很简单：在 ThreadLocal 类中有一个 Map，用于存储每一个线程的变量副本，Map 中元素的键为线程对象，而值对应线程的变量副本。我们自己就可以提供一个简单的实现版本：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

package com.test;
public class TestNum {
    // ①通过匿名内部类覆盖ThreadLocal的initialValue()方法，指定初始值
    private static ThreadLocal<Integer> seqNum = new ThreadLocal<Integer>() {
        public Integer initialValue() {
            return 0;
        }
    };
    // ②获取下一个序列值
    public int getNextNum() {
        seqNum.set(seqNum.get() + 1);
        return seqNum.get();
    }
    public static void main(String[] args) {
        TestNum sn = new TestNum();
        // ③ 3个线程共享sn，各自产生序列号
        TestClient t1 = new TestClient(sn);
        TestClient t2 = new TestClient(sn);
        TestClient t3 = new TestClient(sn);
        t1.start();
        t2.start();
        t3.start();
    }
    private static class TestClient extends Thread {
        private TestNum sn;
        public TestClient(TestNum sn) {
            this.sn = sn;
        }
        public void run() {
            for (int i = 0; i < 3; i++) {
                // ④每个线程打出3个序列值
                System.out.println("thread[" + Thread.currentThread().getName() + "] --> sn["
                         + sn.getNextNum() + "]");
            }
        }
    }
}

　　通常我们通过匿名内部类的方式定义 ThreadLocal 的子类，提供初始的变量值，如例子中①处所示。TestClient 线程产生一组序列号，在③处，我们生成 3 个 TestClient，它们共享同一个 TestNum 实例。运行以上代码，在控制台上输出以下的结果：

thread[Thread-0] --> sn[1]thread[Thread-1] --> sn[1]thread[Thread-2] --> sn[1]thread[Thread-1] --> sn[2]thread[Thread-0] --> sn[2]thread[Thread-1] --> sn[3]thread[Thread-2] --> sn[2]thread[Thread-0] --> sn[3]thread[Thread-2] --> sn[3]

　　考察输出的结果信息，我们发现每个线程所产生的序号虽然都共享同一个 TestNum 实例，但它们并没有发生相互干扰的情况，而是各自产生独立的序列号，这是因为我们通过 ThreadLocal 为每一个线程提供了单独的副本。

Thread 同步机制的比较

　　ThreadLocal 和线程同步机制相比有什么优势呢？ThreadLocal 和线程同步机制都是为了解决多线程中相同变量的访问冲突问题。 　　 　　
　　在同步机制中，通过对象的锁机制保证同一时间只有一个线程访问变量。这时该变量是多个线程共享的，使用同步机制要求程序慎密地分析什么时候对变量进行读写，什么时候需要锁定某个对象，什么时候释放对象锁等繁杂的问题，程序设计和编写难度相对较大。 　　 　　
　　而 ThreadLocal 则从另一个角度来解决多线程的并发访问。ThreadLocal 会为每一个线程提供一个独立的变量副本，从而隔离了多个线程对数据的访问冲突。因为每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了。ThreadLocal 提供了线程安全的共享对象，在编写多线程代码时，可以把不安全的变量封装进 ThreadLocal。 　　 　　
　　由于 ThreadLocal 中可以持有任何类型的对象，低版本 JDK 所提供的 get () 返回的是 Object 对象，需要强制类型转换。但 JDK 5.0 通过泛型很好的解决了这个问题，在一定程度地简化 ThreadLocal 的使用，代码清单 9 2 就使用了 JDK 5.0 新的 ThreadLocal 版本。 　　 　　
　　概括起来说，对于多线程资源共享的问题，同步机制采用了 “以时间换空间” 的方式，而 ThreadLocal 采用了 “以空间换时间” 的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。 　　 　　
　　spring 使用 ThreadLocal 解决线程安全问题我们知道在一般情况下，只有无状态的 Bean 才可以在多线程环境下共享，在 Spring 中，绝大部分 Bean 都可以声明为 singleton 作用域。就是因为 Spring 对一些 Bean（如 RequestContextHolder、TransactionSynchronizationManager、LocaleContextHolder 等）中非线程安全状态采用 ThreadLocal 进行处理，让它们也成为线程安全的状态，因为有状态的 Bean 就可以在多线程中共享了。 　　 　　
　　一般的 Web 应用划分为展现层、服务层和持久层三个层次，在不同的层中编写对应的逻辑，下层通过接口向上层开放功能调用。在一般情况下，从接收请求到返回响应所经过的所有程序调用都同属于一个线程，如图 9‑2 所示： 　　 　　
　　　
　　同一线程贯通三层这样你就可以根据需要，将一些非线程安全的变量以 ThreadLocal 存放，在同一次请求响应的调用线程中，所有关联的对象引用到的都是同一个变量。 　　
　　下面的实例能够体现 Spring 对有状态 Bean 的改造思路： 　　　　

1
2
3
4
5
6
7
8
9
10
11
12
13
14

package com.test;

import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;

public class TestDao {
    private Connection conn;// ①一个非线程安全的变量

    public void addTopic() throws SQLException {
        Statement stat = conn.createStatement();// ②引用非线程安全变量
        // …
    }
}

　　由于①处的 conn 是成员变量，因为 addTopic () 方法是非线程安全的，必须在使用时创建一个新 TopicDao 实例（非 singleton）。下面使用 ThreadLocal 对 conn 这个非线程安全的 “状态” 进行改造： 　　　　

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

package com.test;

import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;

public class TestDaoNew {
    // ①使用ThreadLocal保存Connection变量
    private static ThreadLocal<Connection> connThreadLocal = new ThreadLocal<Connection>();

    public static Connection getConnection() {
        // ②如果connThreadLocal没有本线程对应的Connection创建一个新的Connection，
        // 并将其保存到线程本地变量中。
        if (connThreadLocal.get() == null) {
            Connection conn = getConnection();
            connThreadLocal.set(conn);
            return conn;
        } else {
            return connThreadLocal.get();// ③直接返回线程本地变量
        }
    }

    public void addTopic() throws SQLException {
        // ④从ThreadLocal中获取线程对应的Connection
        Statement stat = getConnection().createStatement();
    }
}

　　不同的线程在使用 TopicDao 时，先判断 connThreadLocal.get() 是否是 null，如果是 null，则说明当前线程还没有对应的 Connection 对象，这时创建一个 Connection 对象并添加到本地线程变量中；如果不为 null，则说明当前的线程已经拥有了 Connection 对象，直接使用就可以了。这样，就保证了不同的线程使用线程相关的 Connection，而不会使用其它线程的 Connection。因此，这个 TopicDao 就可以做到 singleton 共享了。
　　当然，这个例子本身很粗糙，将 Connection 的 ThreadLocal 直接放在 DAO 只能做到本 DAO 的多个方法共享 Connection 时不发生线程安全问题，但无法和其它 DAO 共用同一个 Connection，要做到同一事务多 DAO 共享同一 Connection，必须在一个共同的外部类使用 ThreadLocal 保存 Connection。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

package com.test;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class ConnectionManager {

    private static ThreadLocal<Connection> connectionHolder = new ThreadLocal<Connection>() {
        @Override
        protected Connection initialValue() {
            Connection conn = null;
            try {
                conn = DriverManager.getConnection(
                        "jdbc:mysql://localhost:3306/test", "username",
                        "password");
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return conn;
        }
    };

    public static Connection getConnection() {
        return connectionHolder.get();
    }

    public static void setConnection(Connection conn) {
        connectionHolder.set(conn);
    }
}

java.lang.ThreadLocal 的具体实现

　　那么到底 ThreadLocal 类是如何实现这种 “为每个线程提供不同的变量拷贝” 的呢？先来看一下 ThreadLocal 的 set () 方法的源码是如何实现的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

/**
    * Sets the current thread's copy of this thread-local variable
    * to the specified value.  Most subclasses will have no need to
    * override this method, relying solely on the {@link #initialValue}
    * method to set the values of thread-locals.
    *
    * @param value the value to be stored in the current thread's copy of
    *        this thread-local.
    */
   public void set(T value) {
       Thread t = Thread.currentThread();
       ThreadLocalMap map = getMap(t);
       if (map != null)
           map.set(this, value);
       else
           createMap(t, value);
   }

　　在这个方法内部我们看到，首先通过 getMap (Thread t) 方法获取一个和当前线程相关的 ThreadLocalMap，然后将变量的值设置到这个 ThreadLocalMap 对象中，当然如果获取到的 ThreadLocalMap 对象为空，就通过 createMap 方法创建。 　　
　　线程隔离的秘密，就在于 ThreadLocalMap 这个类。ThreadLocalMap 是 ThreadLocal 类的一个静态内部类，它实现了键值对的设置和获取（对比 Map 对象来理解），每个线程中都有一个独立的 ThreadLocalMap 副本，它所存储的值，只能被当前线程读取和修改
　　ThreadLocal 类通过操作每一个线程特有的 ThreadLocalMap 副本，从而实现了变量访问在不同线程中的隔离。因为每个线程的变量都是自己特有的，完全不会有并发错误。还有一点就是，ThreadLocalMap 存储的键值对中的键是 this 对象指向的 ThreadLocal 对象，而值就是你所设置的对象了。
　　为了加深理解，我们接着看上面代码中出现的 getMap 和 createMap 方法的实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

/**
 * Get the map associated with a ThreadLocal. Overridden in
 * InheritableThreadLocal.
 *
 * @param  t the current thread
 * @return the map
 */
ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}
    
/**
 * Create the map associated with a ThreadLocal. Overridden in
 * InheritableThreadLocal.
 *
 * @param t the current thread
 * @param firstValue value for the initial entry of the map
 * @param map the map to store.
 */
void createMap(Thread t, T firstValue) {
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

接下来再看一下 ThreadLocal 类中的 get () 方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

/**
 * Returns the value in the current thread's copy of this
 * thread-local variable.  If the variable has no value for the
 * current thread, it is first initialized to the value returned
 * by an invocation of the {@link #initialValue} method.
 *
 * @return the current thread's value of this thread-local
 */
public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null)
            return (T)e.value;
    }
    return setInitialValue();
}

再来看 setInitialValue () 方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

 /**
 * Variant of set() to establish initialValue. Used instead
 * of set() in case user has overridden the set() method.
 *
 * @return the initial value
 */
private T setInitialValue() {
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
    return value;
}

　　获取和当前线程绑定的值时，ThreadLocalMap 对象是以 this 指向的 ThreadLocal 对象为键进行查找的，这当然和前面 set () 方法的代码是相呼应的。 　　
　　进一步地，我们可以创建不同的 ThreadLocal 实例来实现多个变量在不同线程间的访问隔离，为什么可以这么做？因为不同的 ThreadLocal 对象作为不同键，当然也可以在线程的 ThreadLocalMap 对象中设置不同的值了。通过 ThreadLocal 对象，在多线程中共享一个值和多个值的区别，就像你在一个 HashMap 对象中存储一个键值对和多个键值对一样，仅此而已。

小结

　　ThreadLocal 是解决线程安全问题一个很好的思路，它通过为每个线程提供一个独立的变量副本解决了变量并发访问的冲突问题。在很多情况下，ThreadLocal 比直接使用 synchronized 同步机制解决线程安全问题更简单，更方便，且结果程序拥有更高的并发性。 ConnectionManager.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

package com.test;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class ConnectionManager {

    private static ThreadLocal<Connection> connectionHolder = new ThreadLocal<Connection>() {
        @Override
        protected Connection initialValue() {
            Connection conn = null;
            try {
                conn = DriverManager.getConnection(
                        "jdbc:mysql://localhost:3306/test", "username",
                        "password");
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return conn;
        }
    };

    public static Connection getConnection() {
        return connectionHolder.get();
    }

    public static void setConnection(Connection conn) {
        connectionHolder.set(conn);
    }
}

后记

　　看到网友评论的很激烈，甚至关于 ThreadLocalMap 不是 ThreadLocal 里面的，而是 Thread 里面的这种评论都出现了，于是有了这个后记，下面先把 jdk 源码贴上，源码最有说服力了。

1
2
3
4
5
6
7
8
9
10
11

/**
     * ThreadLocalMap is a customized hash map suitable only for
     * maintaining thread local values. No operations are exported
     * outside of the ThreadLocal class. The class is package private to
     * allow declaration of fields in class Thread.  To help deal with
     * very large and long-lived usages, the hash table entries use
     * WeakReferences for keys. However, since reference queues are not
     * used, stale entries are guaranteed to be removed only when
     * the table starts running out of space.
     */
    static class ThreadLocalMap {...}

源码就是以上，这源码自然是在 ThreadLocal 里面的，有截图为证。 　　 　　

本文是自己在学习 ThreadLocal 的时候，一时兴起，深入看了源码，思考了此类的作用、使用范围，进而联想到对传统的 synchronize 共享变量线程安全的问题进行比较，而总结的博文，总结一句话就是一个是锁机制进行时间换空间，一个是存储拷贝进行空间换时间。 (全文完)

转载自 http://blog.csdn.net/lufeng20

• Java NIO: Channels and Buffers（通道和缓冲区）：标准的 IO 基于字节流和字符流进行操作的，而 NIO 是基于通道（Channel）和缓冲区（Buffer）进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。
• Java NIO: Non-blocking IO（非阻塞 IO）：Java NIO 可以让你非阻塞的使用 IO，例如：当线程从通道读取数据到缓冲区时，线程还是可以进行其他事情。当数据被写入到缓冲区时，线程可以继续处理它。从缓冲区写入通道也类似。
• Java NIO: Selectors（选择器）：Java NIO 引入了选择器的概念，选择器用于监听多个通道的事件（比如：连接打开，数据到达）。因此，单个的线程可以监听多个数据通道。

一、Java NIO 概述

Java NIO 由以下几个核心部分组成：

• Channels
• Buffers
• Selectors

虽然 Java NIO 中除此之外还有很多类和组件，但在我看来，Channel，Buffer 和 Selector 构成了核心的 API。其它组件，如 Pipe 和 FileLock，只不过是与三个核心组件共同使用的工具类。因此，在概述中我将集中在这三个组件上。其它组件会在单独的章节中讲到。

Channel 和 Buffer

基本上，所有的 IO 在 NIO 中都从一个 Channel 开始。Channel 有点象流。 数据可以从 Channel 读到 Buffer 中，也可以从 Buffer 写到 Channel 中。这里有个图示：

Channel 和 Buffer 有好几种类型。下面是 JAVA NIO 中的一些主要 Channel 的实现：

• FileChannel
• DatagramChannel
• SocketChannel
• ServerSocketChannel

正如你所看到的，这些通道涵盖了 UDP 和 TCP 网络 IO，以及文件 IO。 与这些类一起的有一些有趣的接口，但为简单起见，我尽量在概述中不提到它们。本教程其它章节与它们相关的地方我会进行解释。 以下是 Java NIO 里关键的 Buffer 实现：

• ByteBuffer
• CharBuffer
• DoubleBuffer
• FloatBuffer
• IntBuffer
• LongBuffer
• ShortBuffer

这些 Buffer 覆盖了你能通过 IO 发送的基本数据类型：byte, short, int, long, float, double 和 char。 Java NIO 还有个 MappedByteBuffer，用于表示内存映射文件， 我也不打算在概述中说明。

Selector

Selector 允许单线程处理多个 Channel。如果你的应用打开了多个连接（通道），但每个连接的流量都很低，使用 Selector 就会很方便。例如，在一个聊天服务器中。 这是在一个单线程中使用一个 Selector 处理 3 个 Channel 的图示：

要使用 Selector，得向 Selector 注册 Channel，然后调用它的select()方法。这个方法会一直阻塞到某个注册的通道有事件就绪。一旦这个方法返回，线程就可以处理这些事件，事件的例子有如新连接进来，数据接收等。

二、Channal

Java NIO 的通道类似流，但又有些不同：

• 既可以从通道中读取数据，又可以写数据到通道。但流的读写通常是单向的。
• 通道可以异步地读写。
• 通道中的数据总是要先读到一个 Buffer，或者总是要从一个 Buffer 中写入。

正如上面所说，从通道读取数据到缓冲区，从缓冲区写入数据到通道。如下图所示：

Channel 的实现

这些是 Java NIO 中最重要的通道的实现：

• FileChannel
• DatagramChannel
• SocketChannel
• ServerSocketChannel

FileChannel 从文件中读写数据。 DatagramChannel 能通过 UDP 读写网络中的数据。 SocketChannel 能通过 TCP 读写网络中的数据。 ServerSocketChannel 可以监听新进来的 TCP 连接，像 Web 服务器那样。对每一个新进来的连接都会创建一个 SocketChannel。

基本的 Channel 示例

下面是一个使用 FileChannel 读取数据到 Buffer 中的示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

RandomAccessFile aFile = new RandomAccessFile("data/nio-data.txt", "rw");
FileChannel inChannel = aFile.getChannel();
ByteBuffer buf = ByteBuffer.allocate(48);
int bytesRead = inChannel.read(buf);
while (bytesRead != -1) {
  System.out.println("Read " + bytesRead);
  buf.flip();
  while(buf.hasRemaining()){
      System.out.print((char) buf.get());
  }
  buf.clear();
  bytesRead = inChannel.read(buf);
}
aFile.close();

注意 buf.flip() 的调用，首先读取数据到 Buffer，然后反转 Buffer, 接着再从 Buffer 中读取数据。下一节会深入讲解 Buffer 的更多细节。

三、Buffer

Java NIO 中的 Buffer 用于和 NIO 通道进行交互。如你所知，数据是从通道读入缓冲区，从缓冲区写入到通道中的。 缓冲区本质上是一块可以写入数据，然后可以从中读取数据的内存。这块内存被包装成 NIO Buffer 对象，并提供了一组方法，用来方便的访问该块内存。

Buffer 的基本用法

使用 Buffer 读写数据一般遵循以下四个步骤：

1. 写入数据到 Buffer
2. 调用flip()方法
3. 从 Buffer 中读取数据
4. 调用clear()方法或者compact()方法

当向 buffer 写入数据时，buffer 会记录下写了多少数据。一旦要读取数据，需要通过flip()方法将 Buffer 从写模式切换到读模式。在读模式下，可以读取之前写入到 buffer 的所有数据。 一旦读完了所有的数据，就需要清空缓冲区，让它可以再次被写入。有两种方式能清空缓冲区：调用clear()或compact()方法。

• clear()方法会清空整个缓冲区。
• compact()方法只会清除已经读过的数据。任何未读的数据都被移到缓冲区的起始处，新写入的数据将放到缓冲区未读数据的后面。

下面是一个使用 Buffer 的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

RandomAccessFile aFile = new RandomAccessFile("data/nio-data.txt", "rw");
FileChannel inChannel = aFile.getChannel();
//create buffer with capacity of 48 bytes
ByteBuffer buf = ByteBuffer.allocate(48);
int bytesRead = inChannel.read(buf); //read into buffer.
while (bytesRead != -1) {
  buf.flip(); //make buffer ready for read
  while(buf.hasRemaining()){
      System.out.print((char) buf.get()); // read 1 byte at a time
  }
  buf.clear(); //make buffer ready for writing
  bytesRead = inChannel.read(buf);
}
aFile.close();

Buffer 的 capacity,position 和 limit

缓冲区本质上是一块可以写入数据，然后可以从中读取数据的内存。这块内存被包装成 NIO Buffer 对象，并提供了一组方法，用来方便的访问该块内存。 为了理解 Buffer 的工作原理，需要熟悉它的三个属性：

• capacity
• position
• limit

position 和 limit 的含义取决于 Buffer 处在读模式还是写模式。不管 Buffer 处在什么模式，capacity 的含义总是一样的。 这里有一个关于 capacity，position 和 limit 在读写模式中的说明，详细的解释在插图后面。

• capacity：作为一个内存块，Buffer 有一个固定的大小值，也叫 “capacity”.你只能往里写 capacity 个 byte、long，char 等类型。一旦 Buffer 满了，需要将其清空（通过读数据或者清除数据）才能继续写数据往里写数据。
• position：当你写数据到 Buffer 中时，position 表示当前的位置。初始的 position 值为 0. 当一个 byte、long 等数据写到 Buffer 后， position 会向前移动到下一个可插入数据的 Buffer 单元。position 最大可为 capacity – 1。 当读取数据时，也是从某个特定位置读。当将 Buffer 从写模式切换到读模式，position 会被重置为 0. 当从 Buffer 的 position 处读取数据时，position 向前移动到下一个可读的位置。
• limit：在写模式下，Buffer 的 limit 表示你最多能往 Buffer 里写多少数据。 写模式下，limit 等于 Buffer 的 capacity。当切换 Buffer 到读模式时， limit 表示你最多能读到多少数据。因此，当切换 Buffer 到读模式时，limit 会被设置成写模式下的 position 值。换句话说，你能读到之前写入的所有数据（limit 被设置成已写数据的数量，这个值在写模式下就是 position）。

Buffer 的类型

Java NIO 有以下 Buffer 类型

• ByteBuffer
• MappedByteBuffer
• CharBuffer
• DoubleBuffer
• FloatBuffer
• IntBuffer
• LongBuffer
• ShortBuffer

如你所见，这些 Buffer 类型代表了不同的数据类型。换句话说，就是可以通过 char，short，int，long，float 或 double 类型来操作缓冲区中的字节。 MappedByteBuffer 有些特别，在涉及它的专门章节中再讲。

Buffer 的分配

要想获得一个 Buffer 对象首先要进行分配。 每一个 Buffer 类都有一个allocate()方法。下面是一个分配 48 字节 capacity 的 ByteBuffer 的例子。

1

ByteBuffer buf = ByteBuffer.allocate(48);

这是分配一个可存储 1024 个字符的 CharBuffer：

1

CharBuffer buf = CharBuffer.allocate(1024);

向 Buffer 中写数据

写数据到 Buffer 有两种方式：

• 从 Channel 写到 Buffer。
• 通过 Buffer 的put()方法写到 Buffer 里。

从 Channel 写到 Buffer 的例子

1

int bytesRead = inChannel.read(buf); //read into buffer.

通过put()方法写 Buffer 的例子：

1

buf.put(127);

put()方法有很多版本，允许你以不同的方式把数据写入到 Buffer 中。例如， 写到一个指定的位置，或者把一个字节数组写入到 Buffer。 更多 Buffer 实现的细节参考 JavaDoc。

flip () 方法

flip()方法将 Buffer 从写模式切换到读模式。调用flip()方法会将 position 设回 0，并将 limit 设置成之前 position 的值。 换句话说，position 现在用于标记读的位置，limit 表示之前写进了多少个 byte、char 等 —— 现在能读取多少个 byte、char 等。

从 Buffer 中读取数据

从 Buffer 中读取数据有两种方式：

• 从 Buffer 读取数据到 Channel。
• 使用get()方法从 Buffer 中读取数据。

从 Buffer 读取数据到 Channel 的例子：

1
2

//read from buffer into channel.
int bytesWritten = inChannel.write(buf);

使用get()方法从 Buffer 中读取数据的例子

1

byte aByte = buf.get();

get()方法有很多版本，允许你以不同的方式从 Buffer 中读取数据。例如，从指定 position 读取，或者从 Buffer 中读取数据到字节数组。更多 Buffer 实现的细节参考 JavaDoc。

rewind () 方法

Buffer.rewind()将 position 设回 0，所以你可以重读 Buffer 中的所有数据。limit 保持不变，仍然表示能从 Buffer 中读取多少个元素（byte、char 等）。

clear () 与 compact () 方法

一旦读完 Buffer 中的数据，需要让 Buffer 准备好再次被写入。可以通过clear()或compact()方法来完成。

• 如果调用的是clear()方法，position 将被设回 0，limit 被设置成 capacity 的值。换句话说，Buffer 被清空了。Buffer 中的数据并未清除，只是这些标记告诉我们可以从哪里开始往 Buffer 里写数据。如果 Buffer 中有一些未读的数据，调用clear()方法，数据将 “被遗忘”，意味着不再有任何标记会告诉你哪些数据被读过，哪些还没有。

• 如果 Buffer 中仍有未读的数据，且后续还需要这些数据，但是此时想要先先写些数据，那么使用compact()方法。compact()方法将所有未读的数据拷贝到 Buffer 起始处。然后将 position 设到最后一个未读元素正后面。limit 属性依然像clear()方法一样，设置成 capacity。现在 Buffer 准备好写数据了，但是不会覆盖未读的数据。

mark () 与 reset () 方法

通过调用Buffer.mark()方法，可以标记 Buffer 中的一个特定 position。之后可以通过调用Buffer.reset()方法恢复到这个 position。例如：

1
2
3

buffer.mark();
//call buffer.get() a couple of times, e.g. during parsing.
buffer.reset(); //set position back to mark.

equals () 与 compareTo () 方法

可以使用equals()和compareTo()方法两个 Buffer。 ####equals () 当满足下列条件时，表示两个 Buffer 相等：

1. 有相同的类型（byte、char、int 等）。
2. Buffer 中剩余的 byte、char 等的个数相等。
3. Buffer 中所有剩余的 byte、char 等都相同。

如你所见，equals 只是比较 Buffer 的一部分，不是每一个在它里面的元素都比较。实际上，它只比较 Buffer 中的剩余元素。 ####compareTo () 方法 compareTo()方法比较两个 Buffer 的剩余元素 (byte、char 等)， 如果满足下列条件，则认为一个 Buffer “小于” 另一个 Buffer：

1. 第一个不相等的元素小于另一个 Buffer 中对应的元素 。
2. 所有元素都相等，但第一个 Buffer 比另一个先耗尽 (第一个 Buffer 的元素个数比另一个少。

（译注：剩余元素是从 position 到 limit 之间的元素）

四、Scatter/Gather

Java NIO 开始支持 scatter/gather，scatter/gather 用于描述从 Channel（译者注：Channel 在中文经常翻译为通道）中读取或者写入到 Channel 的操作。

• 分散（scatter）：从 Channel 中读取是指在读操作时将读取的数据写入多个 buffer 中。因此，Channel 将从 Channel 中读取的数据 “分散（scatter）” 到多个 Buffer 中。
• 聚集（gather）：写入 Channel 是指在写操作时将多个 buffer 的数据写入同一个 Channel，因此，Channel 将多个 Buffer 中的数据 “聚集（gather）” 后发送到 Channel。

scatter / gather 经常用于需要将传输的数据分开处理的场合，例如传输一个由消息头和消息体组成的消息，你可能会将消息体和消息头分散到不同的 buffer 中，这样你可以方便的处理消息头和消息体。 ###Scattering Reads Scattering Reads 是指数据从一个 channel 读取到多个 buffer 中。如下图描述：

代码示例如下：

1
2
3
4

ByteBuffer header = ByteBuffer.allocate(128);
ByteBuffer body = ByteBuffer.allocate(1024);
ByteBuffer[] bufferArray = { header, body };
channel.read(bufferArray);

注意 buffer 首先被插入到数组，然后再将数组作为channel.read() 的输入参数。read()方法按照 buffer 在数组中的顺序将从 channel 中读取的数据写入到 buffer，当一个 buffer 被写满后，channel 紧接着向另一个 buffer 中写。 Scattering Reads 在移动下一个 buffer 前，必须填满当前的 buffer，这也意味着它不适用于动态消息 (译者注：消息大小不固定)。换句话说，如果存在消息头和消息体，消息头必须完成填充（例如 128byte），Scattering Reads 才能正常工作。

Gathering Writes

Gathering Writes 是指数据从多个 buffer 写入到同一个 channel。如下图描述：

代码示例如下：

1
2
3
4
5

ByteBuffer header = ByteBuffer.allocate(128);
ByteBuffer body = ByteBuffer.allocate(1024);
//write data into buffers
ByteBuffer[] bufferArray = { header, body };
channel.write(bufferArray);

buffers 数组是write()方法的入参，write () 方法会按照 buffer 在数组中的顺序，将数据写入到 channel，注意只有 position 和 limit 之间的数据才会被写入。因此，如果一个 buffer 的容量为 128byte，但是仅仅包含 58byte 的数据，那么这 58byte 的数据将被写入到 channel 中。因此与 Scattering Reads 相反，Gathering Writes 能较好的处理动态消息。

五、通道之间的数据传输

在 Java NIO 中，如果两个通道中有一个是 FileChannel，那你可以直接将数据从一个 channel（译者注：channel 中文常译作通道）传输到另外一个 channel。

transferFrom()

FileChannel 的transferFrom()方法可以将数据从源通道传输到 FileChannel 中（译者注：这个方法在 JDK 文档中的解释为将字节从给定的可读取字节通道传输到此通道的文件中）。下面是一个简单的例子：

1
2
3
4
5
6
7

javaRandomAccessFile fromFile = new RandomAccessFile("fromFile.txt", "rw");
FileChannel fromChannel = fromFile.getChannel();
RandomAccessFile toFile = new RandomAccessFile("toFile.txt", "rw");
FileChannel toChannel = toFile.getChannel();
long position = 0;
long count = fromChannel.size();
toChannel.transferFrom(fromChannel, position, count);

方法的输入参数 position 表示从 position 处开始向目标文件写入数据，count 表示最多传输的字节数。如果源通道的剩余空间小于 count 个字节，则所传输的字节数要小于请求的字节数。 此外要注意，在 SoketChannel 的实现中，SocketChannel 只会传输此刻准备好的数据（可能不足 count 字节）。因此，SocketChannel 可能不会将请求的所有数据 (count 个字节) 全部传输到 FileChannel 中。

transferTo()

transferTo()方法将数据从 FileChannel 传输到其他的 channel 中。下面是一个简单的例子：

1
2
3
4
5
6
7