gachi

在简悦中使用ChatGPT助手

2023-05-21T00:38:00.000Z

[!info]
SimpReader（简悦）这款浏览器插件我从大学时期用到现在（虽然也没几年），一开始只是当做一款 " 阅读模式 " 插件在使用，因为实在是受不了那些繁杂的弹窗获取侧边栏。

最近闲着没事的时候看了看 Kenshin 的消息推送，发现简悦已经有了许多实用的插件，尤其阅读助手这个插件，深得我心。具体的使用教程作者说的非常详细，下面是相关的地址

最近关于newbing的使用

2023-05-21T00:38:00.000Z

前一段时间 New Bing 宣布全面开放，我顺便也去白嫖了一番。
总的来说 new bing 相对于 GPT3.5 来说还是是更胜一筹的，但是对于 GPT4 还是有着差距。在我的使用感受上来说
易用性 Claude>new bing>GPT4>GPT3.5,效果 GPT4>new bing>Claude>GPT3.5。毕竟 new bing 和 Claude 都是免费的嘛

通过DG自定义组件添加评论组件

2023-05-21T00:38:00.000Z

[!info]
通过 Digital Garden自定义组件添加评论组件
我使用的是 Valine 一款快速、简洁且高效的无后端评论系统。作为我的评论组件

前置条件

根据快速开始 | Valine 一款快速、简洁且高效的无后端评论系统。获取 id 和 key，我使用的是华东节点，可以根据自己的情况选择节点
没了

添加组件至仓库

路径

\src\site\_includes\components\user\notes\afterContent

文件名

01-comment.njk

代码块

<script src='//cdn.jsdelivr.net/npm/valine/dist/Valine.min.js'></script>

<div id="vcomments"></div>

<script>

    new Valine({

        el: '#vcomments',

        appId: '',

        appKey: ''

    })

</script>

效果展示

通过DG自定义组件添加网站统计组件

2023-05-21T00:38:00.000Z

我们可以通过 Digital Garden自定义组件向网站中添加网站统计组件，由于我使用的是 vercel 来托管我的博客，这里就演示使用 vercel 统计组件的方法。

添加自定义代码段

在 src/site/_includes/components/user/common/footer/analytics.njk 路径下添加统计组件的代码段。

<script defer src="/_vercel/insights/script.js"></script>

开启 Vercel 统计功能

然后将之前的代码段提交至仓库即可。

添加Waline到DG生成的网页

2023-05-21T00:38:00.000Z

[!warning]
之前在通过DG自定义组件添加评论组件中使用的 Valine 后来了解到它其实已经闭源了，并且存在着安全问题。在浏览过部分大佬的文章后决定将评论组件换为 Waline

准备

添加模块到笔记

文件结构：

添加 css 到 head： src\site\_includes\components\user\notes\head\walinecss.njk

<link

    rel="stylesheet"

    href="https://unpkg.com/@waline/client@v2/dist/waline.css"

  />

添加模块到文章下： src\site\_includes\components\user\notes\afterContent\01-walinediv.njk

  <div id="waline"></div>

  <script type="module">

    import { init } from 'https://unpkg.com/@waline/client@v2/dist/waline.mjs';

  

    init({

      el: '#waline',

      serverURL: 'https://waline.gachi.cn',

    });

  </script>

发布方案

2023-05-24T23:36:00.000Z

Obsidian 的发布方案

我选择的是最省事的 Digital Garden 插件配合 github 和 vercel 将文章发布到公网。
这是我的首页供大家参考：Welcom
其他关于发布的拓展与问题解决可以看：obsidian

为什么选择 Digital Garden 作为我的发布方案

Digital Garden 插件发布文章十分简单，通杀 Digital Garden 还适配 Obsidian 主题作为网站主题，支持双链、等等许多优点。配合 vercel 的自动构建和 CDN 基本上能烦恼我的就只有文章该怎么写这种世纪难题了。

搭建和部署

所用到的工具和网站

Digital Garden： GitHub - oleeskild/obsidian-digital-garden
插件文档地址： Digital Garden Overview
Vercel：Vercel: Develop. Preview. Ship. For the best frontend teams

部署步骤

参考： 01 Getting started

在 Obsidian 中下载 Digital Garden 插件
根据文档提示在 GitHub - oleeskild/digitalgarden 这个仓库中点击 Deploy 即可自动构建仓库和 Vercel 项目
等待项目构建完成后进入这个链接会自动为你创建条件合适的 token，如果不想过几个月就更新一下 token 可以选择将过期时间改为永久，默认是三十天，当然如果当心安全问题，也可以自己为单独的仓库设置 token 但是过期时间无法设置为永久，过程比较简单我就不一步一步去详述了
将刚刚获取到的 token 和你的 github 账号名和仓库名称填入插件中
配置到这就结束了，肥肠的简单

插件的设置

一定要关闭slugify note url这个选项

根据这篇issue，不关闭这个选项会在项目构建中对文件名进行路径处理，而如果路径中含有非英文字符则会构建失败导致无法访问这篇文章

下面是我的设置，有需要的同学可以参考

如何发布文章

dg-publish: true
dg-home: true

dg-home 是告诉插件这篇文章应该是你的主页。(它只需要添加到一个笔记，而不是你要发布的每个笔记)。
dg-publish 设置告诉插件这个注释所在的文章需要发布。没有此设置的注释将无法发布。(换句话说: 你发布的每个笔记都需要这个设置。)
通过在 Windows/Linux（Mac 上的 CMD+P）上按 CTRL+P 打开您的命令板，然后找到“Digital Garden: Publish Single Note”命令。按 Enter。就能发布当前笔记了

完成

现在已经完成了网站的构建和发布，是不是非常的简单。最后需要注意的一点 Digital Garden 构建的网站不支持网站内中文搜索，但是我们能借助搜索引擎来弥补这一缺点。当然还有其他的解决方案，比如 lunr.js 修改为 jp 则可以同时兼容英文和中文（当然效果一般），又或者接入 jieba 分词等等，但是都需要修改源码很麻烦。当然也可以用 Digital Garden自定义组件去添加自定义的搜索组件，但是难度相对较大，我又很懒。

[!check]
Digital Garden已经支持中文搜索了

[!warning]-
在 dataview 和 dataviewjs 上使用警告块会造成渲染错误

[!bug]
路径渲染错误 bug
经过测试，需要在文章上传好后再更新带有 dateview 的页面，如果在文章上传之前更新 welcome，则会因为构建仓库没有这篇文章而路径渲染错误。严格来说这不是 BUG

关于大陆访问无法加载局部关系图的问题：Digital Garden国内访问大框问题

为DG生成的网页加上meta标签

2023-05-22T14:24:00.000Z

[!info]
为了提高搜索引擎的 seo 权重，我们通常需要添加 keywords 和 description 帮助搜索引擎爬虫去理解我们的网页内容，来提高搜索权重。

添加自定义组件

根据 Digital Garden自定义组件，我们可以添加一个根据文章元数据自动生成页面 meta 元数据标签的组件。

Njk 文件代码：



    

        <meta name="description" content="为DG生成的网页加上meta标签">

    

        <meta name="keywords" content="科技,seo,obsidian,博客,自建站">

Md 文件元数据：

metatags:
  description: 为DG生成的网页加上meta标签
  keywords:
    - 科技
    - seo

Others

[!error]
Njk 文件代码块在构建成网页后渲染出错，更改为图片

[!warning] 注意

Yml 格式对文本格式缩进要求非常严格元数据一定要用上面提供的格式进行编写，最好是 Copy，否则可能会出现无法获取值的问题

obsidian同步方案

2023-05-21T00:38:00.000Z

方案一 Git

[!check]
使用 obsidian-git 插件，各个客户端都能使用，是目前最靠谱和成熟的同步与备份方案

方案二

使用 GitHub - vrtmrz/obsidian-livesync 插件
参考：

Obsidian 最优雅的多端同步插件LiveSync - 经验分享 - Obsidian 中文论坛
 obsidian-livesync/README_cn.md at main · vrtmrz/obsidian-livesync · GitHub

CouchDb 部署

参考：

obsidian-livesync/setup_own_server_cn.md at main · vrtmrz/obsidian-livesync · GitHub
GitHub - vrtmrz/self-hosted-livesync-server

建议使用 Docker-compose candy 和 CouchDb 方案，candy 作为反向代理部署 ssh 服务

插件设置

这一部分是开启实时同步，使用回收站方案删除文件，同步隐藏文件

这一部分是插件同步

obsidian

2023-05-22T14:18:00.000Z

Obsidian Overview

![[obsidian-canvas.canvas]]

本文件夹中总共有18 个文件

标签 3个

已发布笔记

File	tags	别名
Digital Garden已经支持中文搜索了	obsidian	-
Digital Garden构建页面链接错误解决方法	obsidian	-
Digital Garden发布方案Vercel构建次数限制解决办法	-	-
Digital Garden国内访问大框问题	obsidian	-
Obsidain-Commander 取代Cmenu和customizable-menu	-	-
添加Waline到DG生成的网页	Obsidian	-
通过DG自定义组件添加评论组件	-	-
Weread Plugin 更漂亮的模板	obsidian	-
为DG生成的网页加上meta标签	obsidian	-
通过DG自定义组件添加网站统计组件	-	-
Digital Garden自定义组件	-	-
obsidian	index	-
发布方案	obsidian	-
Templater插件	obsidian	-
obsidian同步方案	obsidian	-

Weread Plugin 更漂亮的模板

2023-05-21T00:38:00.000Z

[!info]
Weread 插件的原生导入模板说实话颜值上有点不敢恭维，这么方便好用的插件怎么能没有一个漂亮的面孔呢？于是我准备用警告块对插件的生成结果进行一下修饰。

模板修改

首先将 Weread 插件的原生模板 Copy 下来并备份，以免出什么意外，避免重新配置的尴尬
对 Copy 的模板副本参照作者给出的 wiki 进行随心所欲的修改，我就只是给高亮划线和评论进行了修改
将修改后的模板填入插件配置，并修改随便一本未被引用的书籍笔记（最好是一本新加入书架的崭新书籍，避免出现问题导致原来的笔记受到污染）

效果对比

原生模板：

修改后的模板：

模板文件

由于这个模板比较特殊，会导致渲染错误等等问题所以把模板放在了码世纪公众号里
Weread Plugin 模板

[!warning]
如果需要将笔记发布至需要渲染的地方（比如静态博客），这个模板大概是不能用的，会有点神奇的小问题

Templater插件

2023-05-21T00:38:00.000Z

Templater 第三方插件比核心插件功能更加强大，可以为文件夹分配不同不同模板，自动在文件创建时使用模板

Obsidain-Commander 取代Cmenu和customizable-menu

2023-05-21T00:38:00.000Z

[!info]
这一款插件是在阅读 customizable-menu 的 issue 看看为什么不更新时看到作者推荐的，因为 kzhovn 的精力放在了 statusbar-pomo-obsidian 的开发上，而 Cmenu 也两年没更新了。Commander 不仅包含了 customizable 的所有功能，还能根据平台对菜单进行隔离，是 Cmenu 与 customizable 的完美替代。

这款插件使用几乎没有门槛，就连 UI 也是中文的也就没必要写教程了

插件地址：

GitHub - phibr0/obsidian-commander: Commander - Obsidian Plugin | Add Commands to every part of Obsidian's user interface

Digital Garden自定义组件

2023-05-22T14:30:00.000Z

[!info]
在发布方案中我使用的是 Digital Garden 作为发布方案，当然 DG 的默认组件还是做不到开箱即用的，而作者也考虑到了这一点为我们自定义网站提供了充足的空间，我们可以自定义 css 和添加标签至页面中。这篇文章提供了部分 Slot 的翻译，当然没翻译的部分其实也和这部分差不了多少（才不是因为懒得写那么多），以及我会开源一部分我使用的组件（现在还没想好是放网盘还是放 github）

添加自定义组件

[!info] 作者原文
Release 1.39.0 of the template introduced a new way to add custom components to your site. Previously, any customization done in the template would be overwritten whenever you updated the template, making it hard to maintain if you wanted the latest update.

The template now has the concept of slots, where you can add any content you want. Be it Javascript, HTML or CSS.

模板引入插槽（插件）的概念，现在可以向网站中引入任何你想要添加的组件！无论是 JS 还是 HTML 还是 CSS，即使模板更新了也不会被覆盖。

具体的使用方法和介绍作者写的十分详细可以在 Adding custom components 查看具体的使用方法

添加自定义组件的模板语法

这是一段路径，包含了自定组件的作用域等待内容。

src/site/_includes/components/user/<namespace>/<slot>/<filename>.njk

Namespace

支持使用自定义组件的命名空间：

common
同时在主页和笔记上添加
index
只添加到主页
notes
添加到笔记

Slot

以下是支持的插槽：

head
- 将被放置在 html<head> 标记内
header
- 将被放置在 <header> 中, 在 tag 和标题后
beforeContent
- 将被放置在页面内容之前
afterContent
- 将被放置在页面内容的后面
footer
- 将被放置在页面的页脚

参考连接：

Digital Garden构建页面链接错误解决方法

2023-05-22T14:02:00.000Z

使用发布方案中介绍的 Digital Garden 作为发布方案，当我从仓库中 clone 笔记库到本地后，发现已发布的笔记需要全部修改。起初我认为是插件的问题，但是重新发布后，全站居然出现 404 错误。这还不是终点，这时候我并没有意识到真正的问题所在，认为是 Vercel 的构建次数限制导致的问题，于是有了 Digital Garden发布方案Vercel构建次数限制解决办法这篇文章，当然这也不是无用功，我们依然可以用这个方法去对构建失败或者其他问题进行预防。

问题产生的原因

[!warning]
目前我认为 markdown 元数据的原因，当然有可能是之前使用的格式化插件的原因（但是为什么之前没问题呢，总不能是玄学吧），也有可能是 DG 插件的原因，具体原因我还没有找到（因为我不会前端），但是目前发现确实是因为 md 元数据导致插件在处理文件时的构建仓库的文件元数据渲染错误。

错误的构建文件元数据：（指的是通过插件已经 push 到构建仓库的文件，而不是 Obsidian 库中的笔记）：

正确的构建文件元数据：

[!note]
未被成功转义的元数据在 Vercel 或者 netlify 进行 Buiding 时会出现页面路径渲染错误的情况，比如在原有路径上添加一个 note 字段（这应该是插件的某个功能性特性导致并不是 bug）

解决方法

使用 GitHub - platers/obsidian-linter 插件格式化需要发布的笔记重新发布即可

Digital Garden已经支持中文搜索了

2023-05-24T23:22:00.000Z

[!info] 作者原文
The search should now be significantly faster, and support other languages aside from just english. It should also be much better at finding relevant pages.
Technical explanation:
Lunr.js has been replaced by FlexSearch. Additionally the search is no longer done serverside using serverless functions, but instead done locally on the user's browser using a generated search index formatted as json. The search index is only downloaded once, then cached in the user's localstorage. It will be re-downloaded as soon as a new build is triggered (i.e. a page has been published).
Additionally the 404 page redirection is handled in the build step. It is no longer dependent on vendor specific rewrite rules. This means the garden can very easily be deployed to any static site host provider.

[!note] 翻译
现在的搜索速度应该会快得多，并且不仅支持英语，还支持其他语言。它也应该更擅长查找相关页面。

技术解释：Lunr.js 已被 FlexSearch 替换。此外，搜索不再使用无服务器函数在服务器端进行，而是在用户的浏览器上使用生成的格式化为 json 的搜索索引进行本地搜索。搜索索引仅下载一次，然后缓存在用户的本地存储中。只要触发新的构建（即发布页面），它就会重新下载。此外，404 页面重定向是在构建步骤中处理的，不再依赖于供应商特定的重写规则。这意味着可以非常轻松地将该平台部署到任何静态站点主机提供商。

Digital Garden 已经支持中文搜索了，在 1.53.0 版本使用 FlexSearch 代替了 Lunr.js，意味着由 DG 发布的网站已经支持包括中文在内的多种语言进行站内搜索。
Release Release 1.53.0 · oleeskild/digitalgarden · GitHub

如何更新

在 Digital Garden 面板插件中点击 Manage site template 按钮
点击 creat pr 按钮等待一小会
进入仓库合并 PR 即可

Digital Garden国内访问大框问题

2023-05-24T22:17:00.000Z

[!check]
作者已经接受了我的 PR，这个问题应该不会出现了 2023 年 5 月 24 日 22:17:40

无法加载文件关系图

因为 cdn.jsdelivr.net 在国内已经无法使用，而 Digital Garden 在 vercel 的构建仓库中默认使用的确实 cdn.jsdelivr.net。导致在国内访问的时候无法加载对应 js，则会出现下图的问题。

这个问题一开始也困扰了我一段时间，毕竟如果关闭局部关系图的展示那还叫数字花园吗？而且我自己访问其实并不会出现这个问题，直到我在看到了 cdn.jsdelivr.net 后。。。

替换 Cdn 解决问题

首先将托管仓库拉到本地（不会拉就百度，教程都挺详细的）

需要替换的文件目录：

src\site\_includes\components\pageheader.njk
src\site\_includes\components\timestamps.njk

将 cdn.jsdelivr.net 使用 ctrl+h 替换为 fastly.jsdelivr.net,下图是我替换后的结果

commit 这次修改，然后 push 到远程仓库。等待 vercel 构建完成后访问，应该就没问题了

[!info]
我已经向作者提交了 pr，在作者采纳之前可以作为临时补救方法 2023 年 5 月 2 日 22:36:07

Digital Garden发布方案Vercel构建次数限制解决办法

2023-05-22T14:06:00.000Z

今天将 Obsidian 的笔记仓库重新从社区拉取了下来，结果发布插件 digital-garden 判断我所有已经发布的文章已经修改（已找到原因，请看 Digital Garden构建页面链接错误解决方法），然后就导致了全站 404。这个方法主要是用来预防可能会出现的构建失败的状况，避免生产环境受到影响。

[!warning]
digital-garden 不会将所有已修改的文章打包一次性提交，而是一个一个遍历提交。这样就带来了几个问题：

提交速度慢

Vercel 有构建次数限制，免费账户每天限量 100 次构建（就是因为这个导致我的博客暴毙）

解决办法

[!note]
核心就是让 vercel 的构建由我们自己控制，因 dg 插件目前无法更换提交的分支所以我的解决方案就是更换 vercel 的默认构建分支，由 main 替换为其他分支。

操作步骤

首先从 main 分支拉取一个新的分支作为发布分支，如图我新建了一个名叫 publisher 的分支

在 vercel 的 setting 中更改 git 构建分支为之前我们新建的 publisher 即可

在以上条件都准备好后以后我们每次需要更新文章都需要手动合并 main 与 publisher 分支，以避免出现 vercel 构建次数超额的情况。

01-利用滴答清单与Notion形成高效的工作流

2023-06-09T20:20:00.000Z

01-Notion 联动滴答清单

本文将介绍如何使用 Notion、滴答清单和腾讯轻联三个工具实现任务管理与自动同步。Notion 作为数据库整合信息,滴答清单专注于任务管理,而腾讯轻联将二者连接,实现双向同步。这套工作流程可以高效地管理你的日常任务。

碎碎念（没什么用可以跳过）

这一篇文章主要是聊聊关于个人任务管理的问题，我一直使用的是滴答清单来管理我的个人任务，大到吃饭小到工作我几乎都会在前一天的晚上八点花一点时间进行计划，因为这样能让我对第二天的安排和对我个人的办事效率等有个清晰的认知。于是我就开始思考，如果我每天写的日志或者随手记就这么摆在滴答清单中而不进行一个梳理和总结是不是就没有任何意义了？也正是这一个想法驱动我开始去了解 Notion，在接触 Notion 之前我对 All in one 的概念其实是抱有偏见的，我认为 All in one 所带来的臃肿会成为学习路上的一大阻碍。而在真正接触 Notion 后我的观点开始慢慢地改变，Notion 在整理数据上的能力为我的工作流提供了强大的支持，同时也更新了我对 All in one 的理解，或许 All in one 指的并不是将读、写、存、整理等等功能集中于一身。对于 Notion 的 All in one 我的策略是 Notion 是一个数据库，它负责存储于整理这也是它功能最为强大的地方。

我将我的日常任务全都存入了 Notion，但是我依然使用滴答清单来管理我的任务，相比于 Notion 滴答清单显然在任务管理上更为专业，但是在数据的筛选与整理上 Notion 又更胜一筹，如果我将 Notion 配置成了一个功能类似于滴答清单的数据库那我又该花多少精力在这上面呢？专业的事情让专业的来做，我只负责将它们整合在一起，于是便有了这一篇文章。

在开始写这一篇文章的时候是我接触 Notion 的第三天，这一次需要使用到三个工具：滴答清单、Notion、腾讯轻联。参考模板也放到了文章末尾。

使用 Notion 的数据库功能来管理每日待办

我选择 Notion 的原因是其作为一体化工作空间,具有强大的数据库和视图功能。我 built 了一个数据库来存储各项任务,并分类为不同的视图,如日期、优先级、状态视图等。这样可以方便地管理和过滤任务。

如下图我在 Notion 中管理这我的每一个任务和随手记下来的灵感（类似于 Flomo），利用视图功能对任务进行过滤与整合，利用优先级的单选表单完成“四象限“等等。以及我还看到过利用时间戳随机回顾的想法，但我接触 Notion 的时间并不是很长（到写这篇文章为止才三天…）具体的实现我还需要在熟悉了 Notion 后才能去实现。

倚重滴答清单完成每日任务

滴答清单可以说是目前最强大的任务管理软件之一，它最吸引我的地方是配合输入浮窗，我可以随时随地无干扰地记录我的想法，比如在看视频时只需要通过悬浮球呼出输入窗口即可记录当前的想法，既不会打断思绪，也不会因为突然的页面跳转导致灵感消失等等。

使用腾讯轻联作为粘合剂

最重要的来了，我使用腾讯轻联作为 Notion 与滴答清单互通的桥梁，比如在 Notion 中新建任务自动同步到滴答清单、在滴答清单中完成任务或者有新的笔记自动写入到 Notion 中。

为什么选择腾讯轻联？

主要原因是它位于搜索引擎第一的位置实在是忍不住想点进去看看是怎么个回事，其次它的免费额度是我找到的平台中最多的，对于一个刚刚接触的新手而言可供测试的免费资源是学习这一个工具的强大驱动力（实在是因为这一类工具太贵了，如果达到了要付费的程度，其实还不如自己写脚本来的划算）。

正式开始教程

复制我的模板或者自己新建数据库

我创建三个模块:Notion 新建任务添加到滴答清单、滴答清单完成任务后更新至 Notion 和滴答清单新建任务同步至 Notion。这三个模块通过监听 Notion 数据库和滴答清单变化实现自动同步。
我的模板会放在文章的末尾，现在主要说说模板中的字段和功能。

字段	类型	功能	备注
Name	Title	这一列的名字
tags	Select	主要用于保存从滴答清单来的 tag	因为腾讯轻联目前不支持 multi-Select，多个标签可能会出现问题（我还没尝试过）
所属清单	Select	用于标明任务所属的清单，Notion 和滴答清单双向使用	滴答清单选择清单需要使用清单 id，而回执的确实清单名，所以需要在任务中进行转换
描述	text	可以书写任务的具体内容	与腾讯轻联对应的是“内容字段”
优先级	Select	用于标明任务优先级，可以实现四象限待办，Notion 和滴答清单双向使用	通所属清单一样，需要自行转换
Date	Date	时间	在传入 Notion 时要注意时区
Satus	Status	状态，比如完成，执行中，未开始等	这里是我在制作数据库时敲错了，看着不舒服的请自行修改
Created time	Created time	创建时间
Dida_id	text	用于保存滴答清单中的任务 id，实现滴答清单完成任务后修改 Notion 为 Done，以及避免重复创建任务	最重要的字段
URL	URL	用于保存对应的滴答清单任务链接

这就是目前我的模板所拥有的功能和字段，给大家提供一个参考。

Notion 新建任务添加到滴答清单

主要步骤：获取数据库后进行判断是否已经存在 Dida_id 避免重复添加任务 (毕竟一般也不会对 Dida_id 进行编辑)->对所属清单和优先级进行转换 ->滴答清单创建任务 ->回写 Dida_id 到 Notion 中。

滴答清单完成任务后更新到 Notion 中

既可以更新 Notion 的状态，也可以将滴答清单中存在的而 Notion 中不存在的任务写入 Notion（如果额度有限的话可以只使用这一个模块）

滴答清单完成任务 ->根据 Dida_id 查询 notion 中的任务 ->将时间转换成 Notion 可用的 ISO 8601 时间格式 ->写入 Notion

滴答清单新建任务同步到 Notion

主要是作为辅助模块，将重要的任务和随手记及时写入 Notion。

滴答清单新建任务 ->在 Notion 中根据 DIda_id 查询是否存在这个任务，不存在则继续操作 ->转换时间 ->添加到 Notion 中。

最后关于清单 Id 和优先级的转换

因为在写入清单时传入的值需要是对应清单的 id，而在查询滴答清单任务时回传的却是清单的名称，所以这一步需要我们自己添加关于清单名称与 ID 的映射，而优先级也同理。
我使用的是 Js 对参数进行转换，将名称与 id 使用 Switch-case 的方式进行转换，下面是我提供的参考代码非常的简单（因为复制代码需要先将流程下线，这里只是提供了截图，可以直接去我分享的模块中查看代码）。注意清单 ID 需要修改为你自己的，获取方法很简单：只需要在网页上打开相关清单的页面 https://dida365.com/webapp/#p/5f2c4fa8c500eac9dae6e79d/kanban 这中间的 5f2c4fa8c500eac9dae6e79d 就是清单 id。

写在最后

因为免费额度是有限的，对于同步的策略可以使用优先级、清单、tag 来细粒度地控制同步方案，比如只同步中优先级以上的任务，又或者只同步某一个 tag 下的任务等等。毕竟日常琐事其实也没必要同步，甚至还会污染我们的数据库。

模板链接

Notion – The all-in-one workspace for your notes, tasks, wikis, and databases.
滴答清单新建到 Notion：腾讯轻联
Notion 新建任务添加到滴答清单：腾讯轻联
滴答清单更新数据后同步更新 Notion 任务状态：腾讯轻联

读书笔记

2023-05-02T19:33:00.000Z

读书笔记 Overview

[!info]
这里是我的读书笔记，全部由插件自动生成，分类上可能有些错误。

本文件夹中总共有54 个文件

标签 1个

已发布笔记

File	作者	分类	笔记数量	划线数量	最后一次阅读时间
富爸爸穷爸爸（20周年修订版）	罗伯特·清崎	经济理财-理财	28	55	June 29, 2023
影响力（全新升级版）	罗伯特·西奥迪尼	心理-社会心理学	33	180	June 28, 2023
与罗摩相会	阿瑟·克拉克	精品小说-科幻经典	2	16	June 11, 2023
Java从入门到精通（第6版）	明日科技	计算机-编程设计	1	10	June 09, 2023
认知驱动：做成一件对他人很有用的事	周岭	心理-认知与行为	3	53	June 08, 2023
掌控聊天：人际沟通中的关键策略	张超	个人成长-沟通表达	11	26	June 03, 2023
Java并发编程之美	翟陆续薛宾田	计算机-编程设计	17	80	June 02, 2023
认知觉醒：开启自我改变的原动力	周岭	心理-认知与行为	35	175	June 01, 2023
看天下（2023年第13期）	看天下	期刊杂志-其他	0	1	May 26, 2023
让成熟的大脑自由	约翰·梅迪纳	心理-心理学应用	0	5	May 22, 2023
阿米巴经营	陈伟编著	经济理财-商业	0	1	May 18, 2023
学点法律，避点坑：有趣有料的法律科普	隋兵	社会文化-法律	1	70	May 14, 2023
性格修正：如何突破你的原生性格	本杰明·哈迪	心理-积极心理学	0	1	May 13, 2023
Ferryman	Claire McFall	-	4	0	May 13, 2023
高性能MySQL（第4版）	Silvia Botros, Jeremy Tinley	社会文化-社科	3	35	May 13, 2023
投资中最简单的事（更新版）	邱国鹭	经济理财-财经	0	4	May 13, 2023
公司法学（上）	朱锦清	社会文化-法律	0	4	May 09, 2023
Redis设计与实现	黄健宏	计算机-编程设计	0	9	May 09, 2023
看天下（2023年第11期）	看天下	期刊杂志-其他	2	0	May 05, 2023
余华作品全集（《活着》等 13 册）	余华	文学-经典作品	1	24	May 03, 2023
茶馆（无删节经典完整版）	老舍	文学-经典作品	3	35	May 02, 2023
毛泽东选集（全四卷）		政治军事-政治	0	3	May 02, 2023
Netty进阶之路：跟着案例学Netty	李林锋	计算机-编程设计	0	1	May 01, 2023
Spring Boot进阶：原理、实战与面试题分析	郑天民	计算机-编程设计	8	132	May 01, 2023
大地（三部曲）	赛珍珠	文学-经典作品	0	2	April 30, 2023
资本论（超值白金版）	马克思	哲学宗教-马克思哲学	0	6	April 30, 2023
四世同堂	老舍	文学-经典作品	0	1	April 28, 2023
海外文摘（2023年第3期）	海外文摘	期刊杂志-文学	0	7	April 27, 2023
微积分的力量	史蒂夫·斯托加茨	科学技术-自然科学	0	1	April 27, 2023
冰心精选集（冰心经典小说全新结集）	冰心	文学-散文杂著	0	2	April 26, 2023
希腊三部曲I：追逐阳光之岛（英剧《德雷尔一家》原著）	杰拉尔德·达雷尔	文学-散文杂著	0	1	April 26, 2023
骆驼祥子	老舍	文学-经典作品	0	2	April 26, 2023
腾讯技术工程	公众号	-	0	11	April 24, 2023
尘埃落定	阿来	文学-经典作品	1	1	April 23, 2023
羊脂球（读客三个圈经典文库）	莫泊桑	文学-外国文学	0	1	April 23, 2023
Java 8函数式编程	Richard Warburton	计算机-编程设计	1	18	April 23, 2023
Netty、Redis、Zookeeper高并发实战	尼恩	计算机-编程设计	20	157	April 23, 2023
解构领域驱动设计	张逸	计算机-编程设计	0	2	April 23, 2023
技术自由圈	公众号	-	0	2	April 22, 2023
阿里云云原生	公众号	-	0	8	April 22, 2023
哪吒编程	公众号	-	0	5	April 22, 2023
深入理解Java虚拟机：JVM高级特性与最佳实践（第2版）	周志明	计算机-编程设计	0	11	April 22, 2023
2018年4月1日	刘慈欣	精品小说-科幻经典	0	1	April 21, 2023
深入浅出通信原理	陈爱军	计算机-计算机综合	0	1	April 19, 2023
剑指Offer（专项突破版）：数据结构与算法名企面试题精讲	何海涛	计算机-编程设计	0	2	April 17, 2023
大话设计模式【Java溢彩加强版】	程杰	计算机-编程设计	6	147	April 16, 2023
尘埃落定 (共和国作家文库)	阿来	-	1	4	April 15, 2023
密码学原理与Java实现	朱文伟李建英	计算机-编程设计	0	3	April 02, 2023
Go语言精进之路：从新手到高手的编程思想、方法和技巧1	白明	计算机-编程设计	1	23	March 23, 2023
MySQL 8从入门到精通（视频教学版）	王英英	计算机-编程设计	0	1	March 23, 2023
零基础入门学习Python（第2版）	小甲鱼	计算机-编程设计	0	1	March 22, 2023
大话数据结构-CB_CPNCH7CGBH2F6e76cn15r314	程杰	-	5	4	January 25, 2023
大话数据结构-3300013357	程杰	计算机-编程设计	0	1	January 24, 2023
读书笔记	Ten	-	-	-	-

零基础入门学习Python（第2版）

2023-07-02T03:21:50Z

元数据

[!abstract] 零基础入门学习Python（第2版）

书名：零基础入门学习Python（第2版）

作者：小甲鱼

简介：本书提倡理解为主，应用为王。因此，只要有可能，小甲鱼（注：作者）都会通过生动的实例来让大家理解概念。虽然这是一本入门书籍，但本书的“野心”并不止于“初级水平”的教学。本书前半部分首先讲解基础的Python 3语法知识，包括列表、元组、字符串、字典以及各种语句；之后循序渐进地介绍一些相对高级的主题，包括抽象、异常、魔法方法以及属性迭代器。后半部分则围绕着Python 3在爬虫、界面开发和游戏开发上的应用，通过实例引导读者进行深入学习和探究，既富有乐趣，又锻炼了读者的动手能力。本书适合学习Python 3的入门读者，也适合对编程一无所知，但渴望用编程改变世界的朋友们。

出版时间 2019-06-01 00:00:00

ISBN： 9787302514084

分类：计算机-编程设计

出版社：清华大学出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

3.3 原始字符串

📌 原始字符串的使用非常简单，只需要在字符串前边加一个英文字母r即可：
- ⏱ 2023-03-22 11:35:28

读书笔记

本书评论

解构领域驱动设计

2023-07-02T03:21:50Z

元数据

[!abstract] 解构领域驱动设计

书名：解构领域驱动设计

作者：张逸

简介：本书全面阐释了领域驱动设计（domain-driven design，DDD）的知识体系，内容覆盖领域驱动设计的主要模式与主流方法，并在此基础上提出“领域驱动设计统一过程”（domain-driven design unified process，DDDUP），将整个软件构建过程划分为全局分析、架构映射和领域建模3个阶段。除给出诸多案例来阐释领域驱动设计统一过程中的方法与模式之外，本书还通过一个真实而完整的案例全面展现了如何进行领域驱动设计统一过程的实施和落地。为了更好地运用领域驱动设计统一过程，本书还开创性地引入了业务服务、菱形对称架构、领域驱动架构、服务驱动设计等方法与模式，总结了领域驱动设计能力评估模型与参考过程模型。本书提出的一整套方法体系已在多个项目中推广和落地。本书适合希望领会软件架构本质、提高软件架构能力的软件架构师，希望提高领域建模能力、打磨软件设计能力的开发人员，希望掌握业务分析与建模方法的业务分析人员，希望学习领域驱动设计并将其运用到项目中的软件行业从业人员阅读参考。

出版时间 2021-09-01 00:00:00

ISBN： 9787115566232

分类：计算机-编程设计

出版社：人民邮电出版社有限公司

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

第一篇开篇

📌 领域驱动设计统一过程分为3个阶段：·全局分析阶段；·架构映射阶段；·领域建模阶段。
- ⏱ 2023-04-23 00:01:21

第1章软件复杂度剖析

📌 由大量相互作用的部分组成的系统。与整个系统比起来，这些组成部分相对简单，没有中央控制，组成部分之间也没有全局性的通信，并且组成部分的相互作用导致了复杂行为。
- ⏱ 2023-04-23 21:54:58

读书笔记

本书评论

深入理解Java虚拟机：JVM高级特性与最佳实践（第2版）

2023-07-02T03:21:50Z

元数据

[!abstract] 深入理解Java虚拟机：JVM高级特性与最佳实践（第2版）

书名：深入理解Java虚拟机：JVM高级特性与最佳实践（第2版）

作者：周志明

简介：全书共分为五大部分，围绕内存管理、执行子系统、程序编译与优化、高效并发等核心主题对JVM进行了全面而深入的分析，深刻揭示了JVM的工作原理。第一部分从宏观的角度介绍了整个Java技术体系、Java和JVM的发展历程、模块化，以及JDK的编译，这对理解本书后面内容有重要帮助。第二部分讲解了JVM的自动内存管理，包括虚拟机内存区域的划分原理以及各种内存溢出异常产生的原因；常见的垃圾收集算法以及垃圾收集器的特点和工作原理；常见虚拟机监控与故障处理工具的原理和使用方法。第三部分分析了虚拟机的执行子系统，包括类文件结构、虚拟机类加载机制、虚拟机字节码执行引擎。第四部分讲解了程序的编译与代码的优化，阐述了泛型、自动装箱拆箱、条件编译等语法糖的原理；讲解了虚拟机的热点探测方法、HotSpot的即时编译器、编译触发条件，以及如何从虚拟机外部观察和分析JIT编译的数据和结果；第五部分探讨了Java实现高效并发的原理，包括JVM内存模型的结构和操作；原子性、可见性和有序性在Java内存模型中的体现；先行发生原则的规则和使用；线程在Java语言中的实现原理；虚拟机实现高效并发所做的一系列锁优化措施。

出版时间 2013-06-01 00:00:00

ISBN： 9787111421900

分类：计算机-编程设计

出版社：机械工业出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

第二部分自动内存管理机制

📌 Java与C++之间有一堵由内存动态分配和垃圾收集技术所围成的“高墙”，墙外面的人想进去，墙里面的人却想出来。
- ⏱ 2023-04-22 00:21:52
📌 Java虚拟机在执行Java程序的过程中会把它所管理的内存划分为若干个不同的数据区域。
- ⏱ 2023-04-22 00:25:19
📌 程序计数器（Program Counter Register）是一块较小的内存空间，它可以看作是当前线程所执行的字节码的行号指示器
- ⏱ 2023-04-22 00:27:51
📌 在虚拟机的概念模型里（仅是概念模型，各种虚拟机可能会通过一些更高效的方式去实现），字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令，分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成。
- ⏱ 2023-04-22 00:28:21
📌 每条线程都需要有一个独立的程序计数器，各条线程之间计数器互不影响，独立存储，我们称这类内存区域为“线程私有”的内存。
- ⏱ 2023-04-22 00:30:18
📌 如果线程正在执行的是一个Java方法，这个计数器记录的是正在执行的虚拟机字节码指令的地址；如果正在执行的是Native方法，这个计数器值则为空（Undefined）
- ⏱ 2023-04-22 00:30:54
📌 此内存区域是唯一一个在Java虚拟机规范中没有规定任何OutOfMemoryError情况的区域。
- ⏱ 2023-04-22 00:31:05
📌 Java虚拟机栈（Java Virtual Machine Stacks）也是线程私有的，它的生命周期与线程相同。
- ⏱ 2023-04-22 00:32:05
📌 虚拟机栈描述的是Java方法执行的内存模型：每个方法在执行的同时都会创建一个栈帧（Stack Frame)[插图]用于存储局部变量表、操作数栈、动态链接、方法出口等信息。每一个方法从调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中入栈到出栈的过程。
- ⏱ 2023-04-22 00:33:26
📌 局部变量表存放了编译期可知的各种基本数据类型（boolean、byte、char、short、int、float、long、double）、对象引用（reference类型，它不等同于对象本身，可能是一个指向对象起始地址的引用指针，也可能是指向一个代表对象的句柄或其他与此对象相关的位置）和returnAddress类型（指向了一条字节码指令的地址）。
- ⏱ 2023-04-22 00:34:40
📌 64位长度的long和double类型的数据会占用2个局部变量空间（Slot），其余的数据类型只占用1个。
- ⏱ 2023-04-22 00:34:28

读书笔记

本书评论

深入浅出通信原理

2023-07-02T03:21:50Z

元数据

[!abstract] 深入浅出通信原理

书名：深入浅出通信原理

作者：陈爱军

简介：本书的主要内容源于作者在通信人家园上的“深入浅出通信原理”系列连载，汇编成为继承了连载图文并茂、深入浅出、理论联系实际的特点，并在连载内容的基础上进行了补充和完善。从信号和频谱讲起，以通信模型为主线，对信道、信源编码、信道编码和交织、脉冲成形、调制、天线技术、复用和多址技术等做了系统讲解。本书针对真正希望搞清楚通信原理的读者编写，适用于高等院校通信专业本科生和研究生、在职的电信行业工程师，也适用于对通信原理具有浓厚兴趣的非通信专业人士。

出版时间 2018-02-01 00:00:00

ISBN： 9787302483861

分类：计算机-计算机综合

出版社：清华大学出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

第1章通信原理概述

📌 广义的通信：无论采用什么方法、使用什么传输媒介，只要将信息从一地传送到另一地，均可称为通信
- ⏱ 2023-04-19 13:27:24

读书笔记

本书评论

密码学原理与Java实现

2023-07-02T03:21:50Z

元数据

[!abstract] 密码学原理与Java实现

书名：密码学原理与Java实现

作者：朱文伟李建英

简介：现在，Java开发可谓如日中天，并且Java安全开发是Java开发领域中的一个重要内容，每个Java开发人员都必须掌握。市面中的绝大多数密码学书籍都是针对C或C++的，本书重点介绍Java自带加解密函数的相关技术，以及密码学领域重要的开源库OpenSSL在Java开发中的应用。本书共8章，主要内容包括密码学和Java概述、搭建Java密码开发环境、对称密码算法原理、利用JCA\JCE对称加解密、杂凑函数和HMAC、密码学中常见的编码格式、非对称算法RSA的加解密、数字签名技术等。本书内容非常详细，学习坡度非常平滑，循序渐进，就算没有密码学基础，也能从零开始到全面掌握。本书面向的读者是Java开发人员、企业内转行计算机信息安全的工作人员、已有信息安全基础并想了解Java加解密新特性的人员。本书也可作为高等院校和培训机构计算机及相关专业师生的教学参考书。

出版时间 2021-06-01 00:00:00

ISBN： 9787302580270

分类：计算机-编程设计

出版社：清华大学出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

第1章加解密和Java概述

📌 对称密钥加密技术的特点在于效率高、算法简单、易于实现、计算开销小，适合于对大量数据进行加密
- ⏱ 2023-04-02 22:39:38
📌 。在实际应用中，常用的对称密钥加密技术有DES算法、AES算法等。·DES算法：数据加密标准(Data Encryption Standard)，是由IBM公司研制的一种加密算法。DES是一个分组加密算法，以64位为分组对数据加密。加密和解密使用的是同一个密钥。它的密钥长度是56位。64位的明文从算法的一端输入，经过左右部分的迭代和密钥的异或、置换等一系列操作，从另一端输出。·AES算法：高级加密标准(Advanced Encryption Standard)，是由美国国家标准技术协会(NIST)在2001年发布的。AES也是一种分组密码，用以取代DES。AES作为新一代的安全加密标准，集合了强安全性、高性能、高效率、易用和灵活等优点，其分组长度为128位，密钥长度为128位、192位或256位。
- ⏱ 2023-04-02 22:40:12
📌 公开密钥加密技术又称为非对称密钥加密技术，与对称密钥加密技术不同，它使用一对密钥分别进行加密和解密操作，其中一个是公开密钥(Public-Key)，另一个是由用户自己保存（不能公开）的私有密钥(Private-Key)，发送方用公钥或私钥进行加密，接收方使用私钥或公钥进行解密。
- ⏱ 2023-04-02 22:40:55

读书笔记

本书评论

大话设计模式【Java溢彩加强版】

2023-07-02T03:21:50Z

元数据

[!abstract] 大话设计模式【Java溢彩加强版】

书名：大话设计模式【Java溢彩加强版】

作者：程杰

简介：《大话设计模式Java溢彩加强版》是百万销量的经典畅销书《大话设计模式》的全新升级版，描述语言由上一版C#变为Java。《大话设计模式Java溢彩加强版》在形式上开创了IT技术图书的先河。通篇以情景对话形式，用多个小故事和编程示例来组织解读GoF（设计模式经典名著—DesignPatternsElementsofReusableObject-OrientedSoftware）的23个设计模式。《大话设计模式Java溢彩加强版》共分为一个楔子+29章正文。其中，楔子主要通过一个编程实例的演变为初学者介绍了面向对象的基本概念，用来奠定面向对象基础以及树立正确的、有高度的开发思维；第0、1、3、4、5章着重讲解了面向对象的意义、好处以及几个重要的设计规则；第2章，以及第6～28章详细讲解了23种设计模式；第29章对设计模式进行了全面总结。《大话设计模式Java溢彩加强版》的特色是通过小菜与大鸟的趣味问答，在讲解程序的不断重构和演讲过程中，极大地降低设计模式的学习门槛，让初学者可以更加容易地理解为什么这样设计才是好的？是怎样想到这样设计的？以达到不但授之以“鱼”，还授之以“渔”的目的，引导读者体会设计演变过程中蕴藏的大智慧。

出版时间 2022-10-01 00:00:00

ISBN： 9787302615538

分类：计算机-编程设计

出版社：清华大学出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

2.4 策略模式

📌 策略模式(Strategy)：它定义了算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。
- ⏱ 2023-03-31 00:58:01

2.7 策略模式解析

📌 策略模式是一种定义一系列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合［DPE］。
- ⏱ 2023-03-31 01:01:55
📌 策略模式就是用来封装算法的，但在实践中，我们发现可以用它来封装几乎任何类型的规则，只要在分析过程中听到需要在不同时间应用不同的业务规则，就可以考虑使用策略模式处理这种变化的可能性
- ⏱ 2023-04-02 17:48:26

3.4 单一职责原则

📌 就一个类而言，应该仅有一个引起它变化的原因
- ⏱ 2023-04-02 18:03:25

3.5 方块游戏的设计

📌 如果一个类承担的职责过多，就等于把这些职责耦合在一起，一个职责的变化可能会削弱或者抑制这个类完成其他职责的能力。这种耦合会导致脆弱的设计，当变化发生时，设计会遭受到意想不到的破坏［ASD］。事实上，你完全可以找出
- ⏱ 2023-04-02 18:11:17
📌 软件设计真正要做的许多内容，就是发现职责并把那些职责相互分离
- ⏱ 2023-04-02 18:20:41
📌 如果你能够想到多于一个的动机去改变一个类，那么这个类就具有多于一个的职责［ASD］，就应该考虑类的职责分离。"
- ⏱ 2023-04-02 18:21:30

4.2 开放-封闭原则

📌 开放-封闭原则，是说软件实体（类、模块、函数等）应该可以扩展，但是不可修改。［ASD］
- ⏱ 2023-04-02 18:26:03

4.3 何时应对变化

📌 无论模块是多么的'封闭'，都会存在一些无法对之封闭的变化。既然不可能完全封闭，设计人员必须对于他设计的模块应该对哪种变化封闭做出选择。他必须先猜测出最有可能发生的变化种类，然后构造抽象来隔离那些变化
- ⏱ 2023-04-02 21:23:12
📌 面对需求，对程序的改动是通过增加新代码进行的，而不是更改现有的代码
- ⏱ 2023-04-02 21:25:45

5.3 依赖倒转原则

📌 抽象不应该依赖细节，细节应该依赖于抽象
- ⏱ 2023-04-02 19:39:02
📌 针对接口编程，不要对实现编程
- ⏱ 2023-04-02 19:39:09
📌 依赖倒转原则(1)高层模块不应该依赖低层模块。两个都应该依赖抽象。(2)抽象不应该依赖细节。细节应该依赖抽象。［
- ⏱ 2023-04-02 19:42:46

5.4 里氏代换原则

📌 一个软件实体如果使用的是一个父类的话，那么一定适用于其子类，而且它察觉不出父类对象和子类对象的区别。也就是说，在软件里面，把父类都替换成它的子类，程序的行为没有变化
- ⏱ 2023-04-02 19:48:46
📌 里氏代换原则(LSP)：子类型必须能够替换掉它们的父类型。
- ⏱ 2023-04-02 20:40:25
📌 能，只有当子类可以替换掉父类，软件单位的功能不受到影响时，父类才能真正被复用，而子类也能够在父类的基础上增加新的行为。
- ⏱ 2023-04-02 20:41:38

5.5 修收音机

📌 依赖倒转其实可以说是面向对象设计的标志，用哪种语言来编写程序不重要，如果编写时考虑的都是如何针对抽象编程而不是针对细节编程，即程序中所有的依赖关系都是终止于抽象类或者接口，那就是面向对象的设计，反之那就是过程化的设计了
- ⏱ 2023-04-02 20:44:51

6.4 装饰模式

📌 装饰模式(Decorator)，动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更为灵活。［DP］
- ⏱ 2023-04-03 21:15:18
📌 Component是定义一个对象接口，可以给这些对象动态地添加职责。ConcreteComponent是定义了一个具体的对象，也可以给这个对象添加一些职责。Decorator，装饰抽象类，继承了Component，从外类来扩展Component类的功能，但对于Component来说，是无须知道Decorator的存在的。至于ConcreteDecorator就是具体的装饰对象，起到给Component添加职责的功能［DPE］。
- ⏱ 2023-04-04 11:21:46
📌 装饰模式是利用SetComponent来对对象进行包装
- ⏱ 2023-04-04 11:22:01
📌 每个装饰对象的实现就和如何使用这个对象分离开了，每个装饰对象只关心自己的功能，不需要关心如何被添加到对象链当中［DPE］
- ⏱ 2023-04-04 11:22:07
📌 如果只有一个ConcreteComponent类而没有抽象的Component类，那么Decorator类可以是ConcreteComponent的一个子类。同样道理，如果只有一个ConcreteDecorator类，那么就没有必要建立一个单独的Decorator类，而可以把Decorator和ConcreteDecorator的责任合并成一个类。
- ⏱ 2023-04-04 11:23:47

6.8 装饰模式总结

📌 装饰模式是为已有功能动态地添加更多功能的一种方式
- ⏱ 2023-04-15 02:04:20
📌 有效地把类的核心职责和装饰功能区分开了。而且可以去除相关类中重复的装饰逻辑。
- ⏱ 2023-04-15 02:05:39

7.6 代理模式应用

📌 远程代理，也就是为一个对象在不同的地址空间提供局部代表。这样可以隐藏一个对象存在于不同地址空间的事实
- ⏱ 2023-04-15 02:12:32
📌 虚拟代理，是根据需要创建开销很大的对象。通过它来存放实例化需要很长时间的真实对象
- ⏱ 2023-04-15 02:13:00
📌 浏览器当中是用代理模式来优化下载的。"
- ⏱ 2023-04-15 02:13:25
📌 安全代理，用来控制真实对象访问时的权限［
- ⏱ 2023-04-15 02:13:34
📌 代理模式其实就是在访问对象时引入一定程度的间接性，因为这种间接性，可以附加多种用途
- ⏱ 2023-04-15 02:14:23

8.4 简单工厂vs.工厂方法

📌 工厂类中包含必要的逻辑判断
- ⏱ 2023-04-15 02:18:20
📌 工厂方法模式(Factory Method)，定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。
- ⏱ 2023-04-15 02:21:39
📌 当只有一个工厂时，就是简单工作模式，当有多个工厂时，就是工厂方法模式。类似由一维进化成了二维，更强大了
- ⏱ 2023-04-15 02:22:37

8.6 简单工厂+策略+装饰+工厂方法

📌 工厂方法的好处有这么几条：第一，对于复杂的参数的构造对象，可以很好地对外层屏蔽代码的复杂性
- ⏱ 2023-04-15 02:26:00
📌 第二，很好的解耦能力
- ⏱ 2023-04-15 02:26:21

9.3 原型模式

📌 原型模式(Prototype)，用原型实例指定创建对象的种类，并且通过复制这些原型创建新的对象
- ⏱ 2023-04-15 02:30:30

9.4 简历的原型实现

📌 一般在初始化的信息不发生变化的情况下，克隆是最好的办法。这既隐藏了对象创建的细节，又对性能是大大的提高
- ⏱ 2023-04-15 02:33:56
📌 不用重新初始化对象，而是动态地获得对象运行时的状态。
- ⏱ 2023-04-15 02:34:22

9.5 浅复制与深复制

📌 浅复制'，被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用都仍然指向原来的对象
- ⏱ 2023-04-15 02:36:06
📌 深复制把引用对象的变量指向复制过的新对象，而不是原有的被引用的对象。
- ⏱ 2023-04-15 02:36:17

10.3 提炼代码

📌 当我们要完成在某一细节层次一致的一个过程或一系列步骤，但其个别步骤在更详细的层次上的实现可能不同时，我们通常考虑用模板方法模式来处理。
- ⏱ 2023-04-15 02:43:50

10.5 模板方法模式的特点

📌 模板方法模式是通过把不变行为搬移到超类，去除子类中的重复代码来体现它的优势。"
- ⏱ 2023-04-15 02:45:43
📌 当不变的和可变的行为在方法的子类实现中混合在一起的时候，不变的行为就会在子类中重复出现。我们通过模板方法模式把这些行为搬移到单一的地方，这样就帮助子类摆脱重复的不变行为的纠缠。
- ⏱ 2023-04-15 02:46:04

11.3 迪米特法则

📌 米特法则(LoD)'也叫最少知识原则
- ⏱ 2023-04-15 02:51:32
📌 迪米特法则(LoD)：如果两个类不必彼此直接通信，那么这两个类就不应当发生直接的相互作用。如果其中一个类需要调用另一个类的某一个方法的话，可以通过第三者转发这个调用。
- ⏱ 2023-04-15 02:51:47
📌 是在类的结构设计上，每一个类都应当尽量降低成员的访问权限
- ⏱ 2023-04-15 02:52:09
📌 类之间的耦合越弱，越有利于复用，一个处在弱耦合的类被修改，不会对有关系的类造成波及
- ⏱ 2023-04-15 02:53:01

12.4 外观模式

📌 外观模式(Facade)，为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得这一子系统更加容易使用
- ⏱ 2023-04-15 02:56:09

12.5 何时使用外观模式

📌 在设计初期阶段，应该要有意识地将不同的两个层分离
- ⏱ 2023-04-15 02:57:08
📌 在开发阶段，子系统往往因为不断的重构演化而变得越来越复杂
- ⏱ 2023-04-15 02:57:19

13.4 建造者模式

📌 建造者模式(Builder)，将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
- ⏱ 2023-04-15 03:10:28

13.6 建造者模式基本代码

📌 建造者模式是在当创建复杂对象的算法应该独立于该对象的组成部分
- ⏱ 2023-04-15 08:28:07

14.5 观察者模式

📌 观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己
- ⏱ 2023-04-15 08:34:31

14.6 观察者模式的特点

📌 将一个系统分割成一系列相互协作的类有一个很不好的副作用，那就是需要维护相关对象间的一致性。我们不希望为了维持一致性而使各类紧密耦合，这样会给维护、扩展和重用都带来不便
- ⏱ 2023-04-15 08:48:05
📌 观察者模式所做的工作其实就是在解除耦合。让耦合的双方都依赖于抽象，而不是依赖于具体。从而使得各自的变化都不会影响另一边的变化
- ⏱ 2023-04-15 08:50:38

15.5 抽象工厂模式

📌 抽象工厂模式(Abstract Factory)，提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。
- ⏱ 2023-04-15 09:05:36

15.9 用反射+配置文件实现数据访问程序

📌 所有在用简单工厂的地方，都可以考虑用反射技术来去除switch或if，解除分支判断带来的耦合。
- ⏱ 2023-04-15 10:48:11

16.5 状态模式

📌 状态模式(State)，当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类。
- ⏱ 2023-04-15 10:56:08
📌 状态模式主要解决的是当控制一个对象状态转换的条件表达式过于复杂时的情况。把状态的判断逻辑转移到表示不同状态的一系列类当中，可以把复杂的判断逻辑简化
- ⏱ 2023-04-15 10:56:40

16.6 状态模式的好处与用处

📌 状态模式的好处是将与特定状态相关的行为局部化，并且将不同状态的行为分割开来
- ⏱ 2023-04-15 10:58:59
📌 将特定的状态相关的行为都放入一个对象中，由于所有与状态相关的代码都存在于某个ConcreteState中，所以通过定义新的子类可以很容易地增加新的状态和转换
- ⏱ 2023-04-15 11:00:32
📌 消除庞大的条件分支语句
- ⏱ 2023-04-15 11:00:50
📌 状态模式通过把各种状态转移逻辑分布到State的子类之间，来减少相互间的依赖
- ⏱ 2023-04-15 11:03:52
📌 当一个对象的行为取决于它的状态，并且它必须在运行时刻根据状态改变它的行为时，就可以考虑使用状态模式了
- ⏱ 2023-04-15 11:28:32

17.2 适配器模式

📌 系统的数据和行为都正确，但接口不符时，我们应该考虑用适配器，目的是使控制范围之外的一个原有对象与某个接口匹配。适配器模式主要应用于希望复用一些现存的类，但是接口又与复用环境要求不一致的情况
- ⏱ 2023-04-15 11:12:01
📌 类适配器模式和对象适配器模式
- ⏱ 2023-04-15 11:12:20

18.3 备忘录模式

📌 备忘录(Memento)：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态
- ⏱ 2023-04-15 11:21:11

18.4 备忘录模式基本代码

📌 Memento模式比较适用于功能比较复杂的，但需要维护或记录属性历史的类，或者需要保存的属性只是众多属性中的一小部分时，Originator可以根据保存的Memento信息还原到前一状态。
- ⏱ 2023-04-15 11:24:18
📌 如果在某个系统中使用命令模式时，需要实现命令的撤销功能，那么命令模式可以使用备忘录模式来存储可撤销操作的状态
- ⏱ 2023-04-15 11:24:05

19.2 组合模式

📌 组合模式(Composite)，将对象组合成树形结构以表示'部分-整体'的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性
- ⏱ 2023-04-16 10:36:57

19.3 透明方式与安全方式

📌 透明方式，也就是说，在Component中声明所有用来管理子对象的方法，其中包括add、remove等。这样实现Component接口的所有子类都具备了add和remove。这样做的好处就是叶节点和枝节点对于外界没有区别，它们具备完全一致的行为接口。但问题也很明显，因为Leaf类本身不具备add()、remove()方法的功能，所以实现它是没有意义的。
- ⏱ 2023-04-16 10:58:46
📌 安全方式，也就是在Component接口中不去声明add和remove方法，那么子类的Leaf也就不需要去实现它，而是在Composite中声明所有用来管理子类对象的方法，这样做就不会出现刚才提到的问题，不过由于不够透明，所以树叶和树枝类将不具有相同的接口，客户端的调用需要做相应的判断，带来了不便。
- ⏱ 2023-04-16 10:59:15

19.4 何时使用组合模式

📌 当你发现需求中是体现部分与整体层次的结构时，以及你希望用户可以忽略组合对象与单个对象的不同，统一地使用组合结构中的所有对象时，就应该考虑用组合模式了
- ⏱ 2023-04-16 13:51:32

19.6 组合模式好处

📌 用户是不用关心到底是处理一个叶节点还是处理一个组合组件，也就用不着为定义组合而写一些选择判断语句了
- ⏱ 2023-04-16 14:53:42
📌 组合模式让客户可以一致地使用组合结构和单个对象。"
- ⏱ 2023-04-16 14:53:55

20.2 迭代器模式

📌 迭代器模式(Iterator)，提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露该对象的内部表示。
- ⏱ 2023-04-16 14:57:11
📌 当你需要访问一个聚集对象，而且不管这些对象是什么都需要遍历的时候，你就应该考虑用迭代器模式
- ⏱ 2023-04-16 14:58:03
📌 你需要对聚集有多种方式遍历时，可以考虑用迭代器模式
- ⏱ 2023-04-16 14:58:15

20.4 Java的迭代器实现

📌 迭代器(Iterator)模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可以让外部代码透明地访问集合内部的数据
- ⏱ 2023-04-16 15:03:16

21.3 生还是不生是自己的责任

📌 所有类都有构造方法，不编码则系统默认生成空的构造方法，若有显式定义的构造方法，默认的构造方法就会失效
- ⏱ 2023-04-16 15:08:11
📌 对于外部代码，不能用new来实例化它，但是我们完全可以再写一个public方法，叫作getInstance()，这个方法的目的就是返回一个类实例，而此方法中，去做是否有实例化的判断。如果没有实例化过，由调用private的构造方法new出这个实例，之所以它可以调用，是因为它们在同一个类中，private方法可以被调用的
- ⏱ 2023-04-16 15:08:54

21.4 单例模式

📌 单例模式(Singleton)，保证一个类仅有一个实例，并提供一个访问它的全局访问点。
- ⏱ 2023-04-16 15:10:21
📌 通常我们可以让一个全局变量使得一个对象被访问，但它不能防止你实例化多个对象。一个最好的办法就是，让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可以被创建，并且它可以提供一个访问该实例的方法
- ⏱ 2023-04-16 15:10:59
📌 单例模式因为Singleton类封装它的唯一实例，这样它可以严格地控制客户怎样访问它以及何时访问它。简单地说就是对唯一实例的受控访问。
- ⏱ 2023-04-16 15:12:26

21.5 多线程时的单例

📌 多线程的程序中，多个线程同时，注意是同时访问Singleton类，调用getInstance()方法，会有可能造成创建多个实例
- ⏱ 2023-04-16 15:13:15

21.6 双重锁定

📌 我们不用让线程每次都加锁，而只是在实例未被创建的时候再加锁处理。同时也能保证多线程的安全。这种做法被称为Double-Check Locking（双重锁定
- ⏱ 2023-04-16 15:22:01

21.7 静态初始化

📌 静态初始化的方式是在自己被加载时就将自己实例化，所以被形象地称之为饿汉式单例类
- ⏱ 2023-04-16 15:24:06
📌 在第一次被引用时，才会将自己实例化，所以就被称为懒汉式单例类
- ⏱ 2023-04-16 15:24:25
📌 饿汉式，即静态初始化的方式，它是类一加载就实例化的对象，所以要提前占用系统资源。然而懒汉式，又会面临着多线程访问的安全性问题，需要做双重锁定这样的处理才可以保证安全
- ⏱ 2023-04-16 15:24:54

22.2 紧耦合的程序演化

📌 对象的继承关系是在编译时就定义好了，所以无法在运行时改变从父类继承的实现。子类的实现与它的父类有非常紧密的依赖关系，以至于父类实现中的任何变化必然会导致子类发生变化。当你需要复用子类时，如果继承下来的实现不适合解决新的问题，则父类必须重写或被其他更适合的类替换。这种依赖关系限制了灵活性并最终限制了复用性
- ⏱ 2023-04-16 15:29:36
📌 在面向对象设计中，我们还有一个很重要的设计原则，那就是合成／聚合复用原则。即优先使用对象合成／聚合，而不是类继承
- ⏱ 2023-04-16 15:29:56

22.3 合成／聚合复用原则

📌 合成／聚合复用原则(CARP)，尽量使用合成／聚合，尽量不要使用类继承。
- ⏱ 2023-04-16 15:30:02
📌 聚合表示一种弱的'拥有'关系，体现的是A对象可以包含B对象，但B对象不是A对象的一部分；合成则是一种强的'拥有'关系，体现了严格的部分和整体的关系，部分和整体的生命周期一样
- ⏱ 2023-04-16 15:30:37
📌 优先使用对象的合成／聚合将有助于你保持每个类被封装，并被集中在单个任务上。这样类和类继承层次会保持较小规模，并且不太可能增长为不可控制的庞然大物
- ⏱ 2023-04-16 15:32:10

22.5 桥接模式

📌 桥接模式(Bridge)，将抽象部分与它的实现部分分离，使它们都可以独立地变化。
- ⏱ 2023-04-16 15:35:25
📌 "这里需要理解一下，什么叫抽象与它的实现分离，这并不是说，让抽象类与其派生类分离，因为这没有任何意义。实现指的是抽象类和它的派生类用来实现自己的对象
- ⏱ 2023-04-16 15:35:59

22.6 桥接模式基本代码

📌 实现系统可能有多角度分类，每一种分类都有可能变化，那么就把这种多角度分离出来让它们独立变化，减少它们之间的耦合
- ⏱ 2023-04-16 15:37:59
📌 只要真正深入地理解了设计原则，很多设计模式其实就是原则的应用而已，或许在不知不觉中就在使用设计模式了。
- ⏱ 2023-04-16 15:38:18

23.4 命令模式

📌 命令模式(Command)，将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作
- ⏱ 2023-04-16 15:43:34

23.7 命令模式的作用

📌 第一，它能较容易地设计一个命令队列；第二，在需要的情况下，可以较容易地将命令记入日志；第三，允许接收请求的一方决定是否要否决请求。
- ⏱ 2023-04-16 15:54:49
📌 第四，可以容易地实现对请求的撤销和重做；第五，由于加进新的具体命令类不影响其他的类，因此增加新的具体命令类很容易。其实还有最关键的优点就是命令模式把请求一个操作的对象与知道怎么执行一个操作的对象分割开
- ⏱ 2023-04-16 15:54:54
📌 敏捷开发原则告诉我们，不要为代码添加基于猜测的、实际不需要的功能。如果不清楚一个系统是否需要命令模式，一般就不要着急去实现它，事实上，在需要的时候通过重构实现这个模式并不困难，只有在真正需要如撤销／恢复操作等功能时，把原来的代码重构为命令模式才有意义。
- ⏱ 2023-04-16 15:55:43

24.3 职责链模式

📌 职责链模式(Chain of Responsibility)：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。
- ⏱ 2023-04-16 16:00:38

24.4 职责链的好处

📌 当客户提交一个请求时，请求是沿链传递直至有一个ConcreteHandler对象负责处理它。
- ⏱ 2023-04-16 16:03:11
📌 接收者和发送者都没有对方的明确信息，且链中的对象自己也并不知道链的结构。结果是职责链可简化对象的相互连接，它们仅需保持一个指向其后继者的引用，而不需保持它所有的候选接受者的引用
- ⏱ 2023-04-16 16:04:14
📌 随时地增加或修改处理一个请求的结构。增强了给对象指派职责的灵活性
- ⏱ 2023-04-16 16:04:30
📌 一个请求极有可能到了链的末端都得不到处理，或者因为没有正确配置而得不到处理
- ⏱ 2023-04-16 16:04:39

第25章世界需要和平——中介者模式

📌 尽管将一个系统分割成许多对象通常可以增加其可复用性，但是对象间相互连接的激增又会降低其可复用性了
- ⏱ 2023-04-16 16:09:19

25.2 中介者模式

📌 中介者模式(Mediator)，用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
- ⏱ 2023-04-16 16:10:48

25.4 中介者模式的优缺点

📌 中介者模式很容易在系统中应用，也很容易在系统中误用。当系统出现了'多对多'交互复杂的对象群时，不要急于使用中介者模式，而要先反思你的系统在设计上是不是合理
- ⏱ 2023-04-16 16:13:29
📌 减少了各个Colleague的耦合，使得可以独立地改变和复用各个Colleague类和Mediator
- ⏱ 2023-04-16 16:20:14
📌 把对象如何协作进行了抽象，将中介作为一个独立的概念并将其封装在一个对象中，这样关注的对象就从对象各自本身的行为转移到它们之间的交互上来，也就是站在一个更宏观的角度去看待系统
- ⏱ 2023-04-16 16:20:19
📌 由于ConcreteMediator控制了集中化，于是就把交互复杂性变为中介者的复杂性，这就使得中介者会变得比任何一个ConcreteColleague都复杂
- ⏱ 2023-04-16 16:20:08
📌 中介者模式一般应用于一组对象以定义良好但是复杂的方式进行通信的场合
- ⏱ 2023-04-16 16:20:47
📌 以及想定制一个分布在多个类中的行为，而又不想生成太多的子类的场合
- ⏱ 2023-04-16 16:20:52

26.4 内部状态与外部状态

📌 享元模式可以避免大量非常相似类的开销。在程序设计中，有时需要生成大量细粒度的类实例来表示数据。如果能发现这些实例除了几个参数外基本上都是相同的，有时就能够大幅度地减少需要实例化的类的数量。如果能把那些参数移到类实例的外面，在方法调用时将它们传递进来，就可以通过共享大幅度地减少单个实例的数目。
- ⏱ 2023-04-16 16:27:05

26.5 享元模式应用

📌 如果一个应用程序使用了大量的对象，而大量的这些对象造成了很大的存储开销时就应该考虑使用；还有就是对象的大多数状态可以是外部状态，如果删除对象的外部状态，那么可以用相对较少的共享对象取代很多组对象，此时可以考虑使用享元模式
- ⏱ 2023-04-16 16:29:49
📌 在Java中，字符串String就是运用了Flyweight模式。举个例子吧。'=='可以用来确定titleA与titleB是否是相同的实例，返回值为boolean值。当用new String()方法时，两个对象titleA和titleB的引用地址是不相同的，但当titleC和titleD都使用赋值的方式时，两个字符串的引用地址竟然是相同的。
- ⏱ 2023-04-16 16:30:35
📌 用享元模式需要维护一个记录了系统已有的所有享元的列表，而这本身需要耗费资源，另外享元模式使得系统更加复杂。为了使对象可以共享，需要将一些状态外部化，这使得程序的逻辑复杂化。因此，应当在有足够多的对象实例可供共享时才值得使用享元模式。"
- ⏱ 2023-04-16 16:33:27

27.2 解释器模式

📌 解释器模式(interpreter)，给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。［
- ⏱ 2023-04-16 16:35:11
📌 如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语言中的句子。这样就可以构建一个解释器，该解释器通过解释这些句子来解决该问题
- ⏱ 2023-04-16 16:35:30

27.3 解释器模式的好处

📌 当有一个语言需要解释执行，并且你可将该语言中的句子表示为一个抽象语法树时，可使用解释器模式
- ⏱ 2023-04-16 16:39:23
📌 容易地改变和扩展文法，因为该模式使用类来表示文法规则，你可使用继承来改变或扩展该文法。也比较容易实现文法，因为定义抽象语法树中各个节点的类的实现大体类似，这些类都易于直接编写［
- ⏱ 2023-04-16 16:39:53
📌 解释器模式也有不足的，解释器模式为文法中的每一条规则至少定义了一个类，因此包含许多规则的文法可能难以管理和维护。建议当文法非常复杂时，使用其他的技术如语法分析程序或编译器生成器来处理
- ⏱ 2023-04-16 16:40:35

28.5 访问者模式

📌 访问者模式(Visitor)，表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。
- ⏱ 2023-04-16 18:52:56
📌 访问者模式适用于数据结构相对稳定的系统
- ⏱ 2023-04-16 18:55:29
📌 它把数据结构和作用于结构上的操作之间的耦合解脱开，使得操作集合可以相对自由地演化。
- ⏱ 2023-04-16 18:55:33
📌 访问者模式的目的是要把处理从数据结构分离出来。
- ⏱ 2023-04-16 18:56:00
📌 访问者模式的优点就是增加新的操作很容易，因为增加新的操作就意味着增加一个新的访问者。访问者模式将有关的行为集中到一个访问者对象中。
- ⏱ 2023-04-16 18:56:31
📌 那访问者的缺点其实也就是使增加新的数据结构变得困难了
- ⏱ 2023-04-16 18:57:47

29.4 创建型模式比赛

📌 创建型模式在创建了什么、谁创建它、它是怎么被创建的，以及何时创建这些方面提供了很大的灵活性
- ⏱ 2023-04-16 19:10:16
📌 建立相应数目的原型并克隆它们通常比每次用合适的状态手工实例化该类更方便一些
- ⏱ 2023-04-16 19:11:01
📌 内聚性描述的是一个例程内部组成部分之间相互联系的紧密程度。而耦合性描述的是一个例程与其他例程之间联系的紧密程度。软件开发的目标应该是创建这样的例程：内部完整，也就是高内聚，而与其他例程之间的联系则是小巧、直接、可见、灵活的，这就是松耦合
- ⏱ 2023-04-16 22:51:18
📌 创建型模式抽象了实例化的过程。它们帮助一个系统独立于如何创建、组合和表示它的那些对象。创建型模式都会将关于该系统使用哪些具体的类的信息封装起来。允许客户用结构和功能差别很大的'产品'对象配置一个系统。配置可以是静态的，即在编译时指定，也可以是动态的，就是运行时再指定。
- ⏱ 2023-04-16 22:54:30
📌 通常设计应该是从我，也就是工厂方法开始，当设计者发现需要更大的灵活性时，设计便会向其他创建型模式演化。当设计者在设计标准之间进行权衡的时候，了解多个创建型模式可以给设计者更多的选择余地
- ⏱ 2023-04-16 22:55:02

29.5 结构型模式比赛

📌 适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作
- ⏱ 2023-04-16 23:00:29
📌 将对象组合成树形结构以表示'部分-整体'的层次结构，组合模式使得用户对单个对象和组合对象的使用具有一致性
- ⏱ 2023-04-16 23:01:23
📌 动态地给一个对象添加一些额外的职责。就增加功能来说，装饰模式相比生成子类更加灵活
- ⏱ 2023-04-16 23:03:48
📌 外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。
- ⏱ 2023-04-16 23:05:27
📌 如果两个类不必彼此直接通信，那么就不要让这两个类发生直接的相互作用
- ⏱ 2023-04-16 23:15:45
📌 对象使得内存占用过多，而且如果都是大量重复的对象，那就是资源的极大浪费
- ⏱ 2023-04-16 23:17:19
📌 代理与外观的主要区别在于，代理对象代表一个单一对象而外观对象代表一个子系统；代理的客户对象无法直接访问目标对象，由代理提供对单独的目标对象的访问控制，而外观的客户对象可以直接访问子系统中的各个对象，但通常由外观对象提供对子系统各元件功能的简化的共同层次的调用接口
- ⏱ 2023-04-16 23:18:45
📌 代理是一种原来对象的代表，其他需要与这个对象打交道的操作都是和这个代表交涉。而适配器则不需要虚构出一个代表者，只需要为应付特定使用目的，将原来的类进行一些组合。
- ⏱ 2023-04-16 23:21:15

29.6 行为型模式一组比赛

📌 MVC是包括三类对象，Model是应用对象，View是它在屏幕上的表示，Controller定义用户界面对用户输入的响应方式。如果不使用MVC，则用户界面设计往往将这些对象混在一起，而MVC则将它们分离以提高灵活性和复用性
- ⏱ 2023-04-16 23:32:57
📌 MVC是多种模式的综合应用，应该算是一种架构模式
- ⏱ 2023-04-16 23:33:32

29.8 决赛

📌 类是对对象的抽象，抽象类呢，其实就是对类的抽象，那接口呢，说白了就是对行为的抽象
- ⏱ 2023-04-16 23:46:41

读书笔记

15.9 用反射+配置文件实现数据访问程序

章节评论 No.1

spring配置文件使用的抽象工厂模式配合反射和配置文件
- ⏱ 2023-04-15 10:49:19

19.6 组合模式好处

划线评论

📌 基本对象可以被组合成更复杂的组合对象，而这个组合对象又可以被组合，这样不断地递归下去，客户代码中，任何用到基本对象的地方都可以使用组合对象了。
- 💭 组合模式的好处
- ⏱ 2023-04-16 14:53:26

29.5 结构型模式比赛

划线评论

📌 因为外观定义的是一个新的接口，而适配器则是复用一个原有的接口，适配器是使两个已有的接口协同工作，而外观则是为现存系统提供一个更为方便的访问接口
- 💭 适配器模式与外观模式的区别
- ⏱ 2023-04-16 23:23:52

29.6 行为型模式一组比赛

划线评论

📌 MVC是多种模式的综合应用，应该算是一种架构模式
- 💭 观察者，组合，策略
- ⏱ 2023-04-16 23:34:29

划线评论

📌 定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新
- 💭 观察者模式
- ⏱ 2023-04-16 23:26:18

本书评论

书评 No.1

⏱ 2023-04-16 23:48:03

大话数据结构-3300013357

2023-07-02T03:21:50Z

元数据

[!abstract] 大话数据结构

书名：大话数据结构

作者：程杰

简介：大话数据结构》为超级畅销书《大话设计模式》作者程杰潜心三年推出的扛鼎之作！以一个计算机教师教学为场景，讲解数据结构和相关算法的知识。通篇以一种趣味方式来叙述，大量引用了各种各样的生活知识来类比，并充分运用图形语言来体现抽象内容，对数据结构所涉及到的一些经典算法做到逐行分析、多算法比较。与市场上的同类数据结构图书相比，本书内容趣味易读，算法讲解细致深刻，是一本非常适合自学的读物。

出版时间 2011-06-01 00:00:00

ISBN： 9787302255659

分类：计算机-编程设计

出版社：清华大学出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

1.4 基本概念和术语

📌 ，数据项是数据的最小单位
- ⏱ 2023-01-24 17:05:43

读书笔记

本书评论

剑指Offer（专项突破版）：数据结构与算法名企面试题精讲

2023-07-02T03:21:50Z

元数据

[!abstract] 剑指Offer（专项突破版）：数据结构与算法名企面试题精讲

书名：剑指Offer（专项突破版）：数据结构与算法名企面试题精讲

作者：何海涛

简介：本书全面、系统地总结了在准备程序员面试过程中必备的数据结构与算法。本书首先详细讨论整数、数组、链表、字符串、哈希表、栈、队列、二叉树、堆和前缀树等常用的数据结构，然后深入讨论二分查找、排序、回溯法、动态规划和图搜索等算法。除了介绍相应的基础知识，每章还通过大量的高频面试题系统地总结了各种数据结构与算法的应用场景及解题技巧。本书适合所有正在准备面试的程序员阅读。无论是计算机相关专业的应届毕业生还是初入职场的程序员，本书总结的数据结构和算法的基础知识及解题经验都不仅可以帮助他们提高准备面试的效率，还可以增加他们通过面试的成功率。

出版时间 2021-07-01 00:00:00

ISBN： 9787121415203

分类：计算机-编程设计

出版社：电子工业出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

第1章整数

📌 Java中有4种不同的整数类型，分别为8位的byte（-27～27-1）、16位的short（-215～215-1）、32位的int（-231～231-1）和64位的long（-263～263-1）
- ⏱ 2023-04-17 00:11:49
📌 Java中的整数类型都是有符号整数，即如果整数的二进制表示的最高位为0则表示其为正数，如果整数的二进制表示的最高位为1则表示其为负数。
- ⏱ 2023-04-17 00:10:47

读书笔记

本书评论

Spring Boot进阶：原理、实战与面试题分析

2023-07-02T03:21:50Z

元数据

[!abstract] Spring Boot进阶：原理、实战与面试题分析

书名： Spring Boot进阶：原理、实战与面试题分析

作者：郑天民

简介：这是一本能带领读者全方位掌握Spring Boot技术体系的功能、原理和Z佳实践的著作，能帮助读者在Spring Boot领域快速实现从入门到进阶。
　　　　全书涵盖Spring Boot的6大核心主题：核心容器、Web服务、缓存、数据访问、并发执行、监控与扩展，内容具有以下4大特性：
　　　　针对性：系统梳理了6个主题所包含技术的功能特性、工作原理、实践方案，读者能快速掌握其核心技术、底层设计理念和生态扩展；
　　　　创新性：与同类书不同，本书搜集并分析了每个主题下的高频面试题，旨在帮助读者在面试和晋升时事半功倍；
　　　　实战性：注重实用性，基于作者近15年的经验，通过丰富的场景案例提供了大量应用方案和Z佳实践；
　　　　前瞻性：不仅系统讲解了常用的核心技术，而且还讲解了时下流行的云原生、RSocket等前沿技术及其应用方案。

出版时间 2022-05-01 00:00:00

ISBN： 9787111706748

分类：计算机-编程设计

出版社：机械工业出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

1.2 开发Spring Boot应用程序

📌 度量监控。基于Spring Boot提供的Actuator组件，可以通过RESTful接口获取JVM性能指标、线程工作状态等运行时信息
- ⏱ 2023-04-17 09:10:34
📌 @RestController注解是传统Spring MVC中所提供的@Controller注解的升级版，相当于@Controller和@ResponseEntity注解的结合体，会自动使用JSON实现序列化/反序列化操作。
- ⏱ 2023-04-17 09:23:58
📌 配置文件可以是空的，开发人员如果不需要特别指定服务器端口的信息
- ⏱ 2023-04-17 09:24:59
📌 如果我们不希望在全局配置文件中指定所需要激活的Profile，而是想把这个过程延迟到运行这个服务时，那么可以直接在java -jar命令中添加--spring.profiles.active参数，
- ⏱ 2023-04-17 09:32:17

1.3 Spring Boot实战内容和案例

📌 Spring的依赖注入机制在解决循环依赖问题时采用了三级缓存机制
- ⏱ 2023-04-17 10:49:29
📌 相较Spring WebMVC，Spring WebFlux能够为我们实现异步、非阻塞的远程交互过程
- ⏱ 2023-04-17 10:58:48
📌 Spring内置的响应式编程框架是Project Reactor
- ⏱ 2023-04-17 11:01:48
📌 Spring的缓存机制非常灵活，提供了一组包括@Cacheable、@CachePut和@CacheEvict在内的注解来简化系统缓存的使用过程，可以通过这些注解对容器中的任意Bean或者Bean的方法添加缓存功能
- ⏱ 2023-04-17 11:03:07
📌 Spring Boot Actuator组件是承载系统监控功能的组件，通过一系列HTTP端点提供系统监控功能。
- ⏱ 2023-04-17 11:17:10
📌 Spring也提供了专门针对云原生架构的Spring Native框架。Spring Native基于GraalVM虚拟机技术，为开发人员提供了更快的启动时间以及更少的内存占用
- ⏱ 2023-04-17 11:18:52

2.1 Spring依赖注入类型

📌 构造器注入能够保证注入的组件不可变，并且确保需要的依赖不为空
- ⏱ 2023-04-17 11:33:47

2.2 Spring依赖注入原理分析

📌 在刚开始阅读Spring源码时，我建议你直接从AnnotationConfigApplicationContext的启动流程切入，这一流程位于它的构造函数中
- ⏱ 2023-04-17 15:21:08
📌 ListableBeanFactory是Spring中常用的一个BeanFactory，通过这个接口，我们可以一次获取多个Bean。
- ⏱ 2023-04-17 11:47:13

2.3 Spring循环依赖案例分析

📌 所谓的三级缓存，在Spring中表现为三个Map对象
- ⏱ 2023-04-17 12:03:42
📌 singletonObjects变量就是第一级缓存，用来持有完整的Bean实例。而earlySingletonObjects中存放的是那些提前暴露的对象，也就是已经创建但还没有完成属性注入的对象，属于第二级缓存。最后的singletonFactories存放用来创建earlySingleton-Objects的工厂对象，属于第三级缓存。
- ⏱ 2023-04-17 12:05:32
📌 Spring解决循环依赖的诀窍就在于singletonFactories这个第三级缓存
- ⏱ 2023-04-17 15:33:08
📌 相信你也理解了为什么构造器注入无法解决循环依赖问题。这是因为构造器注入过程是发生在Bean初始化的第一个步骤createBeanInstance()中，而这个步骤还没有调用addSingletonFactory()方法完成第三级缓存的构建，自然也就无法从该缓存中获取目标对象
- ⏱ 2023-04-18 11:02:12
📌 消除循环依赖的基本思路也是这样，就是通过在两个相互循环依赖的组件之间添加中间层，变循环依赖为间接依赖。有三种方法可以做到这一点，分别是提取中介者、转移业务逻辑和引入回调
- ⏱ 2023-04-18 11:07:23
📌 提取中介者的核心思想是把两个相互依赖的组件中的交互部分抽象出来形成一个新的组件，而新组件同时包含着对原有两个组件的引用，这样就把循环依赖关系剥离出来并提取到一个专门的中介者组件中
- ⏱ 2023-04-18 11:09:59

2.4 Spring依赖注入实战经验

📌 在Spring IoC容器中，Bean的默认作用域是单例，也就是说不管有多少个对Bean的引用，容器只会创建一个实例。而原型作用域则不同，每次请求Bean时，Spring IoC容器都会创建一个新的对象实例。
- ⏱ 2023-04-18 11:12:38
📌 从两种作用域的效果而言，我们总结出一条开发上的经验，即对于有状态的Bean，我们应该使用原型作用域，反之则应该使用单例作用域。
- ⏱ 2023-04-18 11:12:48
📌 在Spring中，我们可以通过设置组件扫描范围来简化Bean的注入配置。因为任何类都位于某一个包结构之下，所以Spring提供了一个@ComponentScan注解，该注解在需要大规模对象注入的场景下非常有用
- ⏱ 2023-04-18 11:18:03
📌 添加了@Lazy注解的效果是只有在使用到这个Bean时它才会去初始化，而不是在Spring IoC容器启动时直接初始化，这样就可以节省容器资源
- ⏱ 2023-04-18 11:22:06

3.2 动态代理机制与Spring AOP

📌 。和Proxy只能代理接口不同，Enhancer既能够代理接口，也能够代理普通类，但不能拦截final类和方法。
- ⏱ 2023-04-18 18:55:07

3.3 AOP代理机制对性能的影响案例分析

📌 @Scope注解还可以用来指定代理模式ScopedProxyMode
- ⏱ 2023-04-18 22:07:40

3.4 AOP实战经验

📌 代码清单3-22　execution()基本语法execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern)throws-pattern?)这个语法看似复杂，但是我们逐个分解所有的模式，它们其实就是描述了一个方法的特征。■modifiers-pattern：表示方法的修饰符。■ret-type-pattern：表示方法的返回值。■declaring-type-pattern：表示方法所在的类的路径。■name-pattern：表示方法名。■param-pattern：表示方法的参数。■throws-pattern：表示方法抛出的异常。
- ⏱ 2023-04-18 22:14:56
📌 这是因为Spring AOP是通过代理实现的，而无论是JDK代理还是CGLIB代理，其运行机制是对某一个外部的接口或实现类进行代理，像上述代码中直接调用ServiceImpl类内的方法是不会应用代理的。
- ⏱ 2023-04-18 22:22:34
📌 不要在已经受Spring管理的Bean类上使用@Configurable注解，否则它将执行双重初始化，一次是通过Spring容器，一次是通过AOP切面。
- ⏱ 2023-04-18 22:26:44
📌 @Configurable这个注解的作用就是告诉Spring在构造函数运行之前将依赖关系注入对象中
- ⏱ 2023-04-18 22:27:10
📌 Spring的推荐做法是尽可能使用JDK动态代理而不是CGLIB代理
- ⏱ 2023-04-18 22:27:45

3.5 Spring AOP面试题分析

📌 常见的动态代理实现技术包括JDK自带的代理类、第三方的CGLIB和javassist。
- ⏱ 2023-04-18 22:29:55

4.1 Spring WebMVC

📌 Spring Boot提供了一系列便捷有用的注解来简化对请求输入的控制过程，常用的包括上述UserController中所展示的@PathVariable和@RequestBody
- ⏱ 2023-04-19 11:27:50
📌 @PathVariable注解用于获取路径参数，即从类似url/{id}这种形式的路径中获取{id}参数的值
- ⏱ 2023-04-19 11:27:57
📌 在HTTP中，content-type属性用来指定所传输的内容类型。而我们可以通过@Request-Mapping注解中的produces属性来对其进行设置，通常会将其设置为application/json
- ⏱ 2023-04-19 11:29:43
📌 InterceptingHttpAccessor应该包含两部分处理功能，一部分是设置和管理请求拦截器ClientHttpRequestInterceptor，另一部分则是获取用于创建客户端HTTP请求的工厂类ClientHttpRequestFactory
- ⏱ 2023-04-20 13:27:59
📌 通过RestTemplate的类层结构，我们可以理解它的设计思想。整个类层结构可以清晰地分成两条线，左边部分用于完成与HTTP请求相关的实现机制，而右边部分则提供了RESTful风格的操作入口，并使用了面向对象的接口和抽象类完成了对这两部分功能的聚合。
- ⏱ 2023-04-22 00:07:31

4.2 Spring HATEOAS

📌 我们已经知道什么是多媒体（Multimedia），以及什么是超文本（Hypertext）。其中超文本特有的优势是拥有超链接（Hyperlink）。如果我们把超链接引入到多媒体中，那就得到了超媒体（Hypermedia），因此这里的关键角色还是超链接。从HATEOAS的字面上进行理解，使用超媒体作为应用状态的引擎，指的就是应用的状态变更将由客户端访问不同的超媒体资源来驱动。
- ⏱ 2023-04-22 16:14:44
📌 HATEOAS的重要性在于打破了客户端和服务器之间严格的契约，使得客户端可以更加智能和自适应，而RESTful服务本身的演化和更新也变得更加容易。
- ⏱ 2023-04-22 16:15:11
📌 HATEOAS更多是一种概念，而HAL（Hypertext Application Language，超文本应用语言）是HATEOAS的一种实现方式。与普通的RESTful风格不同，对每个资源，HAL又将其细分成状态（State）、链接（Links）和子资源（Embedded Resource）三个标准部分
- ⏱ 2023-04-22 16:15:41
📌 HAL的出现主要弥补了普通JSON格式在API交互中的不足，让JSON更具有自描述性和导航性。
- ⏱ 2023-04-22 16:18:58

4.3 Spring GraphQL

📌 RESTful API的第一个典型问题就是前端无法预判响应的数据格式
- ⏱ 2023-04-22 16:22:54
📌 一旦服务端对数据结构做了任何改变，前端都只能被动接收，而无法在发起请求之前感知到这种改变。
- ⏱ 2023-04-22 16:23:04
📌 RESTful API的第二个典型问题是无法根据请求控制对应的返回结果。
- ⏱ 2023-04-22 16:23:10
📌 前端请求可能只想获取User对象中的name和age字段，而不需要address字段。
- ⏱ 2023-04-22 16:23:27
📌 RESTful API的第四个典型问题，即请求地址过多的问题。如果针对各个具体场景我们都需要一一暴露专门的HTTP端点，那么在一个系统中HTTP端点数量会非常庞大，难以维护和管理
- ⏱ 2023-04-22 16:26:09
📌 相比于REST，GraphQL可以说是一个比较新的技术，它于2012年诞生在Facebook内部，并于2015年正式开源。顾名思义，GraphQL是一种基于图（Graph）的查询语言（Query Language，QL），从根本上改变了前后端交互API的定义和实现方式。
- ⏱ 2023-04-22 16:26:35
📌 针对RESTful API存在的多次请求问题，GraphQL可以把多次请求合并成一次。
- ⏱ 2023-04-22 16:30:50
📌 Schema首先，我们需要引入一个核心组件，即Schema。所谓Schema，简单讲就是一种前后端交互的协议和规范，或者可以把它类比成RESTful API中的接口定义文档。
- ⏱ 2023-04-22 16:32:27
📌 在Schema中，开发人员需要指定两部分内容。一方面，我们需要明确定义前后端交互的数据结构，包括具体的字段名称、类型、是否为空等属性。另一方面，GraphQL规定每一个Schema中可以存在一个根Query和根Mutation，分别用于执行查询和更新操作。
- ⏱ 2023-04-22 16:32:53
📌 DataFetcher组件的作用就是在执行查询时获取字段对应的数据。
- ⏱ 2023-04-22 16:39:11
📌 开发人员可以从DataFetchingEnvironment中获取传入的参数，并根据该参数来执行具体的数据查询操作
- ⏱ 2023-04-22 16:39:28
📌 通过Runtime Wiring机制，我们可以把DataFetcher整合在GraphQL的运行环境中
- ⏱ 2023-04-22 16:40:23
📌 开发人员本身并不需要了解这个GraphQlSource对象的构建过程，因为它的职责是在框架内部完成GraphQL执行引擎的初始化，这是Spring GraphQL框架自动会为我们做的事情。开发人员唯一要做的就是通过GraphQlSource获取一个GraphQL对象
- ⏱ 2023-04-22 16:44:15
📌 GraphQL引擎所需要执行的数据查询操作与业务相关，这部分功能需要开发人员根据具体业务场景进行设计并实现，这时候就会使用到graphql-spring-boot-starter中的RuntimeWiringBuilderCustomizer接口。RuntimeWiringBuilderCustomizer接口简化了Runtime-Wiring的实现过程，开发人员通过实现这个接口就可以设置一系列的DataFetcher
- ⏱ 2023-04-22 16:45:23
📌 首先，如果你在公开的Maven仓库中搜索graphql-spring-boot-starter这个artifactId，会发现存在多个对应的groupId，这是因为老版本的GraphQL Java Spring框架已经实现了同名的artifactId。而我们在这里指定groupId为org.springframework.experimental，这是Spring GraphQL框架目前所属的groupId，可以看到它还属于试验（experimental）阶段，并没有发布到公开的Maven仓库中。所以，为了引入这个依赖包，我们需要指定Spring官方的Maven仓库地址
- ⏱ 2023-04-22 16:48:09

4.4 轻量级Web实战经验

📌 并不推荐你在任何场景下都使用GraphQL
- ⏱ 2023-04-22 16:56:05
📌 对于那些API定义与资源概念匹配度较高，也不需要实现类似在用户信息内部嵌套家庭成员信息的复杂查询场景，传统的RESTful API仍然是首选，各个HTTP端点之间相互独立，职责非常明确
- ⏱ 2023-04-22 16:56:13
📌 对于业务复杂度较高的场景，推荐使用GraphQL
- ⏱ 2023-04-22 16:56:21
📌 对于那些单一的RESTful服务，可以把GraphQL直接嫁接到已有的RESTful服务上
- ⏱ 2023-04-22 16:58:01
📌 RESTful服务中已经实现的业务逻辑层、数据访问层组件都可以得到复用，我们要做的只是开放一个新的GraphQL访问入口而已
- ⏱ 2023-04-22 16:58:15

5.1 响应式编程和Spring Boot

📌 对于响应式编程而言，首先要明确的概念是数据流（Data Stream）
- ⏱ 2023-04-22 17:00:46
📌 所谓的流就是由生产者生产并由一个或多个消费者消费的元素序列。
- ⏱ 2023-04-22 17:00:54
📌 Java API版本的响应式流只包含四个接口，即Publisher、Subscriber、Subscription和Processor<T,R>。
- ⏱ 2023-04-22 17:01:08
📌 发布者（Publisher）是潜在的包含无限数量的有序元素的生产者，它根据收到的请求向当前订阅者发送元素。
- ⏱ 2023-04-22 17:01:29
📌 订阅者（Subscriber）从发布者那里订阅并接收元素。发布者向订阅者发送订阅令牌（Subscription Token）。
- ⏱ 2023-04-22 17:02:09
📌 处理器（Processor）充当订阅者和发布者之间的转换器（Transformer）。
- ⏱ 2023-04-22 17:12:10
📌 1）当发布者使用subscribe()方法实现对该发布者的订阅时，首先会创建一个具有相应逻辑的Subscription对象，这个Subscription对象定义了如何处理请求，以及如何发出数据。2）然后发布者将这个Subscription通过订阅者的onSubscribe()方法传给订阅者。3）在订阅者的onSubscribe()方法中，需要通过Subscription的request ()方法发起第一次请求。4）Subscription收到请求，就可以通过回调订阅者的onNext()方法发出元素，有多少发多少，但不能超过请求的个数。5）订阅者在onNext()方法中通常定义对元素的处理逻辑，处理完成之后，可以继续发起请求。6）发布者根据需要继续满足订阅者的请求。7）如果发布者的元素序列正常结束，就通过订阅者的onComplete()方法予以告知。如果序列发送过程中有错误，则通过订阅者的onError()方法予以告知并传递错误提示。这两种情况都会导致序列终止，订阅过程结束。
- ⏱ 2023-04-22 17:13:24
📌 Spring Cloud Gateway基于最新的Spring 5和Spring Boot 2以及用于响应式编程的Project Reactor框架，提供响应式、非阻塞式I/O模型。和其他API网关系统类似，Spring Cloud Gateway中的核心组件也是过滤器。
- ⏱ 2023-04-22 17:21:18
📌 过滤器用于在响应HTTP请求之前或之后修改请求本身及对应的响应结果。Spring Cloud Gateway提供了一个全局过滤器（GlobalFilter）的概念，对所有路由都生效。
- ⏱ 2023-04-22 17:21:34
📌 Spring WebFlux提供了完整的支持响应式开发的服务端技术栈。和Spring WebMVC相比，Spring WebFlux既支持基于@Controller、@RequestMapping等注解的传统开发模式，又支持基于Router Functions的函数式开发模式。
- ⏱ 2023-04-22 17:24:16
📌 Spring WebFlux则是构建在响应式流以及它的实现框架Reactor基础之上的一个开发框架，因此可以基于HTTP实现异步非阻塞的Web服务。
- ⏱ 2023-04-22 17:24:49

5.2 Spring WebFlux

📌 在Spring WebMVC中，对Web请求的处理机制也基于管道-过滤器（Pipe-Filter）架构模式。Spring WebMVC使用了Servlet中的过滤器链（FilterChain）来对请求进行拦截
- ⏱ 2023-04-22 17:25:41
📌 当HTTP请求通过Servlet容器时就会被转换为一个ServletRequest对象，而处理的结果将以Servlet-Response对象的形式返回。当ServletRequest通过过滤器链中的一系列过滤器之后，最终就会到达作为前端控制器的DispatcherServlet。
- ⏱ 2023-04-22 17:26:36
📌 就整体架构而言，Spring WebFlux和Spring WebMVC本质上并没有什么区别。
- ⏱ 2023-04-22 17:30:39
📌 在WebFlux中，和DispatcherServlet相对应的组件是DispatcherHandler
- ⏱ 2023-04-22 17:32:19
📌 WebFlux同样实现了响应式版本的RequestMappingHandlerMapping和RequestMapping-HandlerAdapter，因此我们仍然可以采用注解的方法来构建Controller
- ⏱ 2023-04-22 17:33:23
📌 WebFlux还提供了RouterFunctionMapping和HandlerFunctionAdapter组合，专门用来提供基于函数式编程的开发模式。
- ⏱ 2023-04-22 17:33:33
📌 使用函数式编程模型创建响应式Web API时，我们需要引入一组全新的编程对象，即ServerRequest、ServerResponse、HandlerFunction和RouterFunction。
- ⏱ 2023-04-22 19:47:17
📌 相比retrieve()方法，exchange()方法对响应结果拥有更多的控制权
- ⏱ 2023-04-22 20:01:17

5.3 Spring RSocket

📌 RSocket协议诞生于2015年，是一个与语言无关的二进制网络协议，用来解决单一的请求-响应模式以及现有网络传输协议所存在的问题
- ⏱ 2023-04-22 21:34:36
📌 RSocket以异步消息的方式提供了四种交互模式，除了请求-响应（request/response）模式之外，还包括请求-响应流（request/stream）、即发-即忘（fire-and-forget）和通道（channel）这三种新的交互模式
- ⏱ 2023-04-22 21:35:28
📌 请求-响应模式：这是最典型也最常见的交互模式。发送方在发送消息给接收方之后，等待与之对应的响应消息。
- ⏱ 2023-04-22 21:36:07
📌 请求-响应流模式：发送方的每个请求消息，都对应于接收方的一个消息流作为响应。
- ⏱ 2023-04-22 21:36:11
📌 即发-即忘模式：发送方的请求消息没有与之对应的响应。
- ⏱ 2023-04-22 21:36:15
📌 通道模式：在发送方和接收方之间建立一个双向传输的通道。
- ⏱ 2023-04-22 21:36:19
📌 @MessageMapping是Spring提供的，用来指定WebSocket、RSocket等协议中消息处理的目的地。
- ⏱ 2023-04-22 22:07:44

5.4 响应式Web实战经验

📌 R2DBC是Reactive Relational DataBase Connectivity的简称，即响应式关系数据库连接。该规范允许驱动程序提供与数据库的完全响应式和非阻塞集成
- ⏱ 2023-04-22 22:53:47

6.1 缓存注解

📌 @Cacheable注解可以标记在一个方法上，也可以标记在一个类上。当标记在一个类上时，该类所有的方法都是支持缓存的。
- ⏱ 2023-04-23 09:50:30
📌 @CachePut注解也可以声明在一个方法中来启用缓存功能。与@Cacheable注解不同的是，添加了@CachePut注解的方法在执行前不会去检查缓存中是否存在之前执行过的结果，而是每次都会执行该方法，并将执行结果存入指定的缓存中。显然，从命名上看，@CachePut适合于执行更新操作的方法。
- ⏱ 2023-04-23 19:21:55
📌 @CacheEvict可以指定的属性也包括value、key和condition。但因为清除缓存的操作可能涉及多个元素，所以@CacheEvict注解额外提供了一个allEntries属性来指定是否清除缓存中的所有元素。这个属性的默认值是false。而当指定了allEntries属性为true时，Spring将忽略指定的key，并清除缓存中的所有元素。
- ⏱ 2023-04-23 19:23:09

6.2 缓存键管理

📌 在Spring缓存中，缓存键的生成有两种策略，一种是默认策略，另一种是自定义策略。
- ⏱ 2023-04-23 19:28:17
📌 。除了上述将方法参数作为key之外，Spring还为我们提供了一个Root对象来生成key。通过该Root对象，开发人员可以获取到本地方法调用所涉及的一组元数据
- ⏱ 2023-04-23 19:31:49
📌 如果没有指定key属性，那么Spring会帮我们自动生成键。默认的键生成策略是通过KeyGenerator生成的
- ⏱ 2023-04-23 19:33:29
📌 默认键生成策略的具体运作方式是这样的：如果方法没有参数，则使用0作为key；如果只有一个参数，则使用该参数作为key；如果参数多于一个的话则使用所有参数的HashCode作为key。
- ⏱ 2023-04-23 19:36:31

6.3 缓存配置

📌 在注解模式下想要启用Spring内置的缓存功能，需要在配置类上添加@EnableCaching
- ⏱ 2023-04-23 19:41:46
📌 除了基于Java API的ConcurrentMapCacheManager之外，EhCache、Redis、Caffeine、Guava等第三方缓存工具都已经被整合进了Spring框架
- ⏱ 2023-04-23 19:43:09

6.5 缓存实现原理

📌 对于缓存而言，其核心思想是在调用一个缓存方法时把该方法的参数和返回结果作为一个键值对存放在缓存中，等到下次基于同样的参数来调用该方法时将不再执行该方法，而是直接从缓存中获取结果并进行返回。
- ⏱ 2023-04-23 20:38:15
📌 在对缓存机制的整体设计上，Spring采用了典型的两层架构，即内核层和扩展层。所谓内核层，相当于对缓存本身的一种抽象，抽取了与缓存相关的最核心的操作方法；
- ⏱ 2023-04-23 20:46:05
📌 扩展层，则是基于内核层的抽象，分别集成业界主流的缓存工具，从而对缓存的核心操作方法提供实现方案。
- ⏱ 2023-04-23 21:06:46

6.7 系统缓存面试题分析

📌 答案：Spring为开发人员提供的缓存注解数量并不多，比较容易让人理解和记忆。日常开发过程中比较常用的缓存注解包括@Cacheable注解、@CachePut注解和@CacheEvict注解，这三个注解分别对应查询、更新和删除操作
- ⏱ 2023-04-23 21:42:49

7.1 Spring Security安全框架

📌 Spring Security中所采用的最基本的架构就是管道-过滤器架构模式。
- ⏱ 2023-04-23 21:54:17

7.3 Spring Security认证缓存案例分析

📌 在Web应用程序开发过程中，客户端访问RESTful服务端的过程应该是无状态的。如果不配置为无状态，则服务端会堆积海量的Session ID，导致出现性能问题
- ⏱ 2023-04-24 01:03:08

7.4 认证缓存原理分析

📌 Spring Security中的认证过程由一组核心对象组成，这些对象可以分成两大类，一类是用户对象，另一类是认证对象。
- ⏱ 2023-04-24 01:05:37

8.3 JdbcTemplate实现原理

📌 JdbcTemplate正是基于模板方法模式和回调机制解决了原生JDBC面临的复杂性问题。
- ⏱ 2023-04-24 22:47:44

8.4 Spring JDBC实战经验

📌 Fetch Size可以用来指定一次从数据库中检索的行数，而大多数JDBC驱动程序的默认值是10
- ⏱ 2023-04-28 00:01:43
📌 Fetch Size不应该采用硬编码，而需要确保它的可配置性，因为它影响到JVM堆内存大小，不同的环境会有所不同。
- ⏱ 2023-04-28 00:02:36
📌 在大多数标准JDBC API中，默认的提交模式是自动提交（Auto Commit）
- ⏱ 2023-04-28 00:07:56

9.1 Spring Data架构与应用

📌 Spring Data基于Repository架构模式抽象出一套实现该模式的统一数据访问方式。
- ⏱ 2023-04-28 00:10:45
📌 JPA全称是Java Persistence API，即Java持久化API，是一个Java应用程序接口规范，充当面向对象的领域模型和关系数据库系统之间的桥梁，所以属于一种ORM技术。
- ⏱ 2023-04-28 00:14:46

9.3 Spring ORM实战经验

📌 所谓延迟加载（Lazy Load，有时也称为懒加载）是指在进行表的关联查询时，按照设置的延迟规则推迟对关联对象的查询
- ⏱ 2023-04-28 09:17:14
📌 二级缓存是与命名空间（namespace）强关联的，即如果在不同的命名空间下存在相同的查询SQL，这两者之间也是不共享缓存数据的
- ⏱ 2023-04-28 09:30:07

9.4 Spring ORM面试题分析

📌 在Spring Data JPA中，解决N+1问题的方式也很明确，就是使用JOIN FETCH机制。JOIN FETCH机制会强制Spring Data JPA在处理关联对象时使用INNER JOIN语句来执行关联查询，从而使用一条SQL语句完成对所有对象的查询。
- ⏱ 2023-04-28 09:34:17

10.2 Spring @Async实现原理

📌 方法的实际执行过程将提交给Spring的任务执行器TaskExecutor进行执行。
- ⏱ 2023-04-28 14:19:24
📌 一方面，@Async注解的运行过程依赖于Spring中对Bean生命周期的处理；另一方面，我们也需要充分利用基于代理的拦截器机制来实现异步操作
- ⏱ 2023-04-28 14:39:07
📌 在Spring中，BeanPostProcessor的作用是在完成Bean实例化和依赖注入之后，在显式调用初始化方法的前后添加我们自己的逻辑，可以认为这里是添加代理机制的绝佳位置
- ⏱ 2023-04-28 14:52:22

10.3 Spring Web异步处理

📌 相较于@Async注解，WebAsyncTask为开发人员提供了更灵活的异步任务处理机制，并内置了异步回调、超时处理和异常处理等功能特性。
- ⏱ 2023-04-29 16:51:39

10.5 Spring Async面试题分析

📌 在日常Web开发过程中，常见的异步处理需求来自三方面的场景，包括常规的异步请求处理过程、不需要返回值的即发-即忘处理过程，以及耗时较长的大数据量请求处理。
- ⏱ 2023-04-29 16:57:28

11.1 Java执行器模型

📌 所谓的Executor，本质上是在所有内部任务线程上提供了一个抽象层，从而管理线程的整个并发执行流。
- ⏱ 2023-04-29 17:02:02
📌 Java并发API支持固定线程池（Fixed-Thread Pool）、缓存线程池（Cached-Thread Pool）、单线程池（Single-Thread Pool）和Fork/Join线程池等多种线程池类型。
- ⏱ 2023-04-29 17:04:03

11.2 Spring任务执行器

📌 限流器的作用是在线程执行的并发度达到阈值时让后续的线程处于阻塞等待。
- ⏱ 2023-04-29 17:56:33

12.1 Spring Boot Actuator组件

📌 pring Cloud中的Spring Cloud Config框架，该框架的客户端自动更新机制就依赖于Actuator的/actuator/bus-refresh端点
- ⏱ 2023-05-01 16:00:11
📌 Spring Cloud Bus是Spring Cloud中用于实现消息总线的专用组件，集成了RabbitMQ、Kafka等主流消息中间件
- ⏱ 2023-05-01 16:02:33
📌 Spring Cloud Config集成Spring Cloud Bus的目的就是想借助它的消息通信能力。
- ⏱ 2023-05-01 16:02:46

12.2 Admin Server组件

📌 Spring Boot Admin组件并不是Spring家族官方提供的组件，而是来自一个叫作codecentric AG的团队。想要把普通的Spring Boot应用程序转变为Spring Boot Admin Server，只需要在Bootstrap类上添加一个注解即可，这个注解就是@EnableAdminServer。
- ⏱ 2023-05-01 16:09:07

13.1 Spring Boot Starter原理与应用

📌 @SpringBootApplication注解实际上由三个注解组合而成，分别是@SpringBootConfiguration、@EnableAutoConfiguration和@ComponentScan。
- ⏱ 2023-05-01 16:16:06
📌 根据所引入类的不同类型，Spring容器对@Import注解有以下四种处理方式。■如果该类实现了ImportSelector接口，Spring容器就会实例化该类，并且调用其selectImports()方法完成类的导入。■如果该类实现了DeferredImportSelector接口，则Spring容器也会实例化该类并调用其selectImports()方法。DeferredImportSelector继承了ImportSelector，区别在于DeferredImportSelector实例的selectImports()方法的调用时机晚于ImportSelector实例，要等到@Configuration注解中相关的业务全部都处理完了才会调用。■如果该类实现了ImportBeanDefinitionRegistrar接口，Spring容器就会实例化该类，并且调用其registerBeanDefinitions()方法。■如果该类没有实现上述三种接口中的任何一个，Spring容器就会直接实例化该类。
- ⏱ 2023-05-01 16:19:28
📌 JDK提供了一个工具类java.util.ServiceLoader来实现SPI机制，该类用于实现服务查找和加载。当服务提供者提供了服务接口的一种实现之后，我们可以在JAR包的META-INF/services/目录下创建一个以该服务接口命名的文件，并在这个文件中配置一组Key-Value，用于指定服务接口与其具体实现类的映射关系。当外部程序装配这个JAR包时，它就能通过该JAR包META-INF/services/目录中的配置文件找到具体的实现类名，并装载实例化，从而完成目标服务的注入。
- ⏱ 2023-05-01 16:26:22

13.3 Spring Boot与云原生

📌 Spring Native原生镜像的启动速度非常快，通常不会超过100ms，相比于传统模式下的启动时间可以说是瞬时的启动。同时，Spring Native原生镜像在运行时也具备更低的资源消耗。
- ⏱ 2023-05-01 16:57:27

读书笔记

2.1 Spring依赖注入类型

划线评论

📌 该方法可以实现按需注入，帮助我们只在需要时注入依赖关系。
- 💭 setter注入可以实现按需注入
- ⏱ 2023-04-17 11:37:51

划线评论

📌 一旦采用构造器注入，在Spring项目启动的时候，就会抛出一个循环依赖异常，从而提醒你避免使用循环依赖。
- 💭 因为构造器注入能够保证依赖不为空，所以在启动时能够提醒避免使用循环依赖
- ⏱ 2023-04-17 11:35:45

3.3 AOP代理机制对性能的影响案例分析

章节评论 No.1

性能上JDK动态代理比Cglib略有优势，但是不用太过于关注，因为差别不大
- ⏱ 2023-04-18 22:12:23

3.4 AOP实战经验

划线评论

📌 @Transactional
- 💭 失效场景加一，在类内直接调用方法因为无法获得代理对象会导致事务失效
- ⏱ 2023-04-18 22:24:17

划线评论

📌 这里我们直接从AopContext中获取代理对象。
- 💭 在类中调用类内部的方法无法获得代理对象，需要通过AOpContext上下文获取代理对象
- ⏱ 2023-04-18 22:21:50

4.3 Spring GraphQL

划线评论

📌 RESTful API的第三个典型问题就是多次请求。
- 💭 RESTful在需要获取不同接口的所组成的一组数据时需要多次访问服务器
- ⏱ 2023-04-22 16:25:51

6.7 系统缓存面试题分析

划线评论

📌 Spring缓存组件的核心优势在于设计并实现了一个抽象层，从而为开发人员提供了统一的缓存使用API
- 💭 隔离了开发人员与细节的解除
- ⏱ 2023-04-23 21:11:54

本书评论

书评 No.1

⏱ 2023-05-01 17:01:29

Redis设计与实现

2023-07-02T03:21:50Z

元数据

[!abstract] Redis设计与实现

书名： Redis设计与实现

作者：黄健宏

简介：《Redis设计与实现》对Redis的大多数单机功能以及所有多机功能的实现原理进行了介绍，展示了这些功能的核心数据结构以及关键的算法思想。通过阅读本书，读者可以快速、有效地了解Redis的内部构造以及运作机制，这些知识可以帮助读者更好、更高效地使用Redis。本书主要分为四大部分。第一部分“数据结构与对象”介绍了Redis中的各种对象及其数据结构，并说明这些数据结构如何影响对象的功能和性能。第二部分“单机数据库的实现”对Redis实现单机数据库的方法进行了介绍，包括数据库、RDB持久化、AOF持久化、事件等。第三部分“多机数据库的实现”对Redis的Sentinel、复制（replication）、集群（cluster）三个多机功能进行了介绍。第四部分“独立功能的实现”对Redis中各个相对独立的功能模块进行了介绍，涉及发布与订阅、事务、Lua脚本、排序、二进制位数组、慢查询日志、监视器等。

出版时间 2015-01-01 00:00:00

ISBN： 9787111464747

分类：计算机-编程设计

出版社：机械工业出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

2.1 SDS的定义

📌 每个sds.h/sdshdr结构表示一个SDS值：[插图]图2-1展示了一个SDS示例：[插图]图2-1 SDS示例❑free属性的值为0，表示这个SDS没有分配任何未使用空间。❑len属性的值为5，表示这个SDS保存了一个五字节长的字符串。❑buf属性是一个char类型的数组，数组的前五个字节分别保存了'R'、'e'、'd'、'i'、's'五个字符，而最后一个字节则保存了空字符'\0'。
- ⏱ 2023-03-22 11:20:15

2.2 SDS与C字符串的区别

📌 与C字符串不同，SDS的空间分配策略完全杜绝了发生缓冲区溢出的可能性：当SDS API需要对SDS进行修改时，API会先检查SDS的空间是否满足修改所需的要求，如果不满足的话，API会自动将SDS的空间扩展至执行修改所需的大小，然后才执行实际的修改操作，所以使用SDS既不需要手动修改SDS的空间大小，也不会出现前面所说的缓冲区溢出问题。
- ⏱ 2023-05-09 10:19:22
📌 正如前两个小节所说，因为C字符串并不记录自身的长度，所以对于一个包含了N个字符的C字符串来说，这个C字符串的底层实现总是一个N+1个字符长的数组（额外的一个字符空间用于保存空字符）。因为C字符串的长度和底层数组的长度之间存在着这种关联性，所以每次增长或者缩短一个C字符串，程序都总要对保存这个C字符串的数组进行一次内存重分配操作：❑如果程序执行的是增长字符串的操作，比如拼接操作（append），那么在执行这个操作之前，程序需要先通过内存重分配来扩展底层数组的空间大小——如果忘了这一步就会产生缓冲区溢出。❑如果程序执行的是缩短字符串的操作，比如截断操作（trim），那么在执行这个操作之后，程序需要通过内存重分配来释放字符串不再使用的那部分空间——如果忘了这一步就会产生内存泄漏。
- ⏱ 2023-05-09 10:28:33
📌 为了避免C字符串的这种缺陷，SDS通过未使用空间解除了字符串长度和底层数组长度之间的关联：在SDS中，buf数组的长度不一定就是字符数量加一，数组里面可以包含未使用的字节，而这些字节的数量就由SDS的free属性记录。
- ⏱ 2023-05-09 10:29:56
📌 通过未使用空间，SDS实现了空间预分配和惰性空间释放两种优化策略。
- ⏱ 2023-05-09 10:30:03
📌 空间预分配用于优化SDS的字符串增长操作：当SDS的API对一个SDS进行修改，并且需要对SDS进行空间扩展的时候，程序不仅会为SDS分配修改所必须要的空间，还会为SDS分配额外的未使用空间。
- ⏱ 2023-05-09 10:32:03
📌 其中，额外分配的未使用空间数量由以下公式决定：❑如果对SDS进行修改之后，SDS的长度（也即是len属性的值）将小于1MB，那么程序分配和len属性同样大小的未使用空间，这时SDS len属性的值将和free属性的值相同。举个例子，如果进行修改之后，SDS的len将变成13字节，那么程序也会分配13字节的未使用空间，SDS的buf数组的实际长度将变成13+13+1=27字节（额外的一字节用于保存空字符）。❑如果对SDS进行修改之后，SDS的长度将大于等于1MB，那么程序会分配1MB的未使用空间。举个例子，如果进行修改之后，SDS的len将变成30MB，那么程序会分配1MB的未使用空间，SDS的buf数组的实际长度将为30MB+1MB+1byte。
- ⏱ 2023-05-09 10:33:36
📌 通过空间预分配策略，Redis可以减少连续执行字符串增长操作所需的内存重分配次数。
- ⏱ 2023-05-09 10:33:49
📌 惰性空间释放用于优化SDS的字符串缩短操作：当SDS的API需要缩短SDS保存的字符串时，程序并不立即使用内存重分配来回收缩短后多出来的字节，而是使用free属性将这些字节的数量记录起来，并等待将来使用。
- ⏱ 2023-05-09 11:12:09

读书笔记

本书评论

Netty进阶之路：跟着案例学Netty

2023-07-02T03:21:50Z

元数据

[!abstract] Netty进阶之路：跟着案例学Netty

书名： Netty进阶之路：跟着案例学Netty

作者：李林锋

简介： Netty将JavaNIO接口封装，提供了全异步编程方式，是各大Java项目的网络应用开发必备神器。本书作者是国内Netty技术的先行者和布道者，本书是他继《Netty权威指南》之后的又一力作。在本书中，作者将在过去几年实践中遇到的问题，以及Netty学习者咨询的相关问题，进行了归纳和总结，以问题案例做牵引，通过对案例进行剖析，讲解问题背后的原理，并结合Netty源码分析，让读者能够真正掌握Netty，在实际工作中少犯错。本书中的案例涵盖了Netty的启动和停止、内存、并发多线程、性能、可靠性、安全等方面，囊括了Netty绝大多数常用的功能及容易让人犯错的地方。在案例的分析过程中，还穿插讲解了Netty的问题定位思路、方法、技巧，以及解决问题使用的相关工具，对读者在实际工作中用好Netty具有很大的帮助和启发作用。

出版时间 2018-11-01 00:00:00

ISBN： 9787121352621

分类：计算机-编程设计

出版社：电子工业出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

1.1 Netty服务端意外退出问题

📌 Daemon线程在Java里面的定义是，如果虚拟机中只有Daemon线程运行，则虚拟机退出
- ⏱ 2023-05-01 23:03:17

读书笔记

本书评论

Netty、Redis、Zookeeper高并发实战

2023-07-02T03:21:50Z

元数据

[!abstract] Netty、Redis、Zookeeper高并发实战

书名： Netty、Redis、Zookeeper高并发实战

作者：尼恩

简介：本书从操作系统底层的IO原理入手，同时提供高性能开发的实战案例，是一本高并发Java编程应用基础图书。本书共分为12章。第1~5章为高并发基础，浅显易懂地剖析高并发IO的底层原理，细致地讲解Reactor高性能模式，图文并茂地介绍Java异步回调模式。这些原理方面的基础知识非常重要，会为读者打下坚实的基础，也是日常开发Java后台应用时解决实际问题的金钥匙。第6~9章为Netty原理和实战，是本书的重中之重，主要介绍高性能通信框架Netty、Netty的重要组件、单体IM的实战设计和模块实现。第10~12章对ZooKeeper、Curator API、Redis、Jedis API的使用进行详尽的说明，以提升读者设计和开发高并发、可扩展系统的能力。本书兼具基础知识和实战案例，既可作为对Java NIO、高性能IO、高并发编程感兴趣的大专院校学生和初、中级Java工程师的学习参考书，也可作为在生产项目中需要用到Netty、Redis、ZooKeeper三大框架的架构师或项目人员的使用参考书。

出版时间 2019-08-01 00:00:00

ISBN： 9787111632900

分类：计算机-编程设计

出版社：机械工业出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

1.1 Netty为何这么火

📌 Netty是JBOSS提供的一个Java开源框架，是基于NIO的客户端/服务器编程框架，它既能快速开发高并发、高可用、高可靠性的网络服务器程序，也能开发高可用、高可靠的客户端程序。
- ⏱ 2023-03-23 00:11:32
📌 NOI是指非阻塞输入输出（Non-Blocking IO），也称非阻塞IO。
- ⏱ 2023-03-23 00:12:04

1.2 高并发利器Redis

📌 支持管道Redis管道是指客户端可以将多个命令一次性发送到服务器，然后由服务器一次性返回所有结果。管道技术的优点是：在批量执行命令的应用场景中，可以大大减少网络传输的开销，提高性能。
- ⏱ 2023-03-23 12:46:33

1.3 分布式利器ZooKeeper

📌 ZooKeeper的核心优势是，实现了分布式环境的数据一致性，简单地说：每时每刻我们访问ZooKeeper的树结构时，不同的节点返回的数据都是一致的。也就是说，对ZooKeeper进行数据访问时，无论是什么时间，都不会引起脏读、重复读。注：脏读是指在数据库存取中无效数据的读出。
- ⏱ 2023-03-23 12:48:46

2.1 IO读写的基础原理

📌 用户程序进行IO的读写，依赖于底层的IO读写，基本上会用到底层的read&write两大系统调用。
- ⏱ 2023-03-23 14:34:53
📌 调用操作系统的read，是把数据从内核缓冲区复制到进程缓冲区；而write系统调用，是把数据从进程缓冲区复制到内核缓冲区。
- ⏱ 2023-03-23 14:35:55
📌 read&write两大系统调用，都不负责数据在内核缓冲区和物理设备（如磁盘）之间的交换，这项底层的读写交换，是由操作系统内核（Kernel）来完成的
- ⏱ 2023-03-23 14:37:38
📌 缓冲区的目的，是为了减少频繁地与设备之间的物理交换
- ⏱ 2023-03-23 14:41:15
📌 发生系统中断时，需要保存之前的进程数据和状态等信息，而结束中断之后，还需要恢复之前的进程数据和状态等信息。为了减少这种底层系统的时间损耗、性能损耗，于是出现了内存缓冲区。
- ⏱ 2023-03-23 14:43:40
📌 底层操作会对内核缓冲区进行监控，等待缓冲区达到一定数量的时候，再进行IO设备的中断处理
- ⏱ 2023-03-23 14:44:57
📌 至于什么时候中断（读中断、写中断），由操作系统的内核来决定，用户程序则不需要关心。
- ⏱ 2023-03-23 14:45:06
📌 的IO读写程序，在大多数情况下，并没有进行实际的IO操作，而是在进程缓冲区和内核缓冲区之间直接进行数据的交换。
- ⏱ 2023-03-23 14:47:53
📌 等待数据从网络中到达网卡。当所等待的分组到达时，它被复制到内核中的某个缓冲区。这个工作由操作系统自动完成，用户程序无感知。
- ⏱ 2023-03-23 14:51:23

2.2 四种主要的IO模型

📌 阻塞IO，指的是需要内核IO操作彻底完成后，才返回到用户空间执行用户的操作。阻塞指的是用户空间程序的执行状态。传统的IO模型都是同步阻塞IO。在Java中，默认创建的socket都是阻塞的。
- ⏱ 2023-03-23 15:03:01
📌 同步IO，是一种用户空间与内核空间的IO发起方式。同步IO是指用户空间的线程是主动发起IO请求的一方，内核空间是被动接受方。异步IO则反过来，是指系统内核是主动发起IO请求的一方，用户空间的线程是被动接受方。
- ⏱ 2023-03-23 15:04:34
📌 非阻塞IO，指的是用户空间的程序不需要等待内核IO操作彻底完成，可以立即返回用户空间执行用户的操作，即处于非阻塞的状态，与此同时内核会立即返回给用户一个状态值
- ⏱ 2023-03-23 15:06:44
📌 阻塞是指用户空间（调用线程）一直在等待，而不能干别的事情；非阻塞是指用户空间（调用线程）拿到内核返回的状态值就返回自己的空间，IO操作可以干就干，不可以干，就去干别的事情。
- ⏱ 2023-03-23 15:08:00
📌 用户空间的线程向内核空间注册了各种IO事件的回调函数，由内核去主动调用。
- ⏱ 2023-03-23 15:15:16
📌 在阻塞式IO模型中，Java应用程序从IO系统调用开始，直到系统调用返回，在这段时间内，Java进程是阻塞的。返回成功后，应用进程开始处理用户空间的缓存区数据。
- ⏱ 2023-03-23 15:15:58
📌 [插图]
- ⏱ 2023-03-23 15:16:13
📌 高并发的应用场景下，需要大量的线程来维护大量的网络连接，内存、线程切换开销会非常巨大。因此，基本上阻塞IO模型在高并发应用场景下是不可用的。
- ⏱ 2023-03-23 15:19:08
📌 [插图]
- ⏱ 2023-03-23 15:21:57
📌 同步非阻塞IO的特点：应用程序的线程需要不断地进行IO系统调用，轮询数据是否已经准备好，如果没有准备好，就继续轮询，直到完成IO系统调用为止。
- ⏱ 2023-03-23 15:24:31
📌 每次发起的IO系统调用，在内核等待数据过程中可以立即返回
- ⏱ 2023-03-23 15:25:11
📌 同步非阻塞IO的缺点：不断地轮询内核，这将占用大量的CPU时间，效率低下
- ⏱ 2023-03-23 15:26:53
📌 通过该系统调用，一个进程可以监视多个文件描述符，一旦某个描述符就绪（一般是内核缓冲区可读/可写），内核能够将就绪的状态返回给应用程序。随后，应用程序根据就绪的状态，进行相应的IO系统调用。
- ⏱ 2023-03-23 15:34:11
📌 用户线程获得了就绪状态的列表后，根据其中的socket连接，发起read系统调用，用户线程阻塞。内核开始复制数据，将数据从内核缓冲区复制到用户缓冲区。
- ⏱ 2023-03-23 15:42:19
📌 [插图]图2-4 IO多路复用模型的流程
- ⏱ 2023-03-23 15:43:32
📌 和NIO模型相似，多路复用IO也需要轮询。负责select/epoll状态查询调用的线程，需要不断地进行select/epoll轮询，查找出达到IO操作就绪的socket连接。
- ⏱ 2023-03-23 16:01:37
📌 IO多路复用模型与同步非阻塞IO模型是有密切关系的。对于注册在选择器上的每一个可以查询的socket连接，一般都设置成为同步非阻塞模型。仅是这一点，对于用户程序而言是无感知的。
- ⏱ 2023-03-23 16:00:49
📌 IO多路复用模型的缺点：本质上，select/epoll系统调用是阻塞式的，属于同步IO。都需要在读写事件就绪后，由系统调用本身负责进行读写，也就是说这个读写过程是阻塞的。
- ⏱ 2023-03-23 16:07:48
📌 AIO的基本流程是：用户线程通过系统调用，向内核注册某个IO操作。内核在整个IO操作（包括数据准备、数据复制）完成后，通知用户程序，用户执行后续的业务操作。
- ⏱ 2023-03-23 16:08:54
📌 异步IO模型的特点：在内核等待数据和复制数据的两个阶段，用户线程都不是阻塞的。用户线程需要接收内核的IO操作完成的事件，或者用户线程需要注册一个IO操作完成的回调函数。正因为如此，异步IO有的时候也被称为信号驱动IO。
- ⏱ 2023-03-23 16:14:51

2.3 通过合理配置来支持百万级并发连接

📌 文件句柄，也叫文件描述符。在Linux系统中，文件可分为：普通文件、目录文件、链接文件和设备文件。文件描述符（File Descriptor）是内核为了高效管理已被打开的文件所创建的索引，它是一个非负整数（通常是小整数），用于指代被打开的文件。所有的IO系统调用，包括socket的读写调用，都是通过文件描述符完成的。
- ⏱ 2023-03-23 16:18:34
📌 在服务器运行Netty时，也需要去解除文件句柄数量的限制，修改/etc/security/limits.conf文件即可。
- ⏱ 2023-03-23 16:22:06

3.1 Java NIO简介

📌 Java NIO由以下三个核心组件组成：· Channel（通道）· Buffer（缓冲区）· Selector（选择器）
- ⏱ 2023-03-23 23:19:28
📌 在NIO中，同一个网络连接使用一个通道表示，所有的NIO的IO操作都是从通道开始的。一个通道类似于OIO中的两个流的结合体，既可以从通道读取，也可以向通道写入。
- ⏱ 2023-03-23 23:33:13
📌 通道的读取，就是将数据从通道读取到缓冲区中；通道的写入，就是将数据从缓冲区中写入到通道中。
- ⏱ 2023-03-23 23:38:13

3.2 详解NIO Buffer类及其属性

📌 3.2 详解NIO Buffer类及其属性NIO的Buffer（缓冲区）本质上是一个内存块，既可以写入数据，也可以从中读取数据。NIO的Buffer类，是一个抽象类，位于java.nio包中，其内部是一个内存块（数组）。NIO的Buffer与普通的内存块（Java数组）不同的是：NIO Buffer对象，提供了一组更加有效的方法，用来进行写入和读取的交替访问。需要强调的是：Buffer类是一个非线程安全类。3.2.1 Buffer类
- ⏱ 2023-03-24 02:06:27
📌 MappedByteBuffer是专门用于内存映射的一种ByteBuffer类型
- ⏱ 2023-03-25 01:32:40
📌 Buffer类在其内部，有一个byte[]数组内存块，作为内存缓冲区。为了记录读写的状态和位置，Buffer类提供了一些重要的属性。其中，有三个重要的成员属性：capacity（容量）、position（读写位置）、limit（读写的限制）。
- ⏱ 2023-03-24 21:55:14
📌 标记属性：mark（标记），可以将当前的position临时存入mark中；需要的时候，可以再从mark标记恢复到position位置。
- ⏱ 2023-03-24 21:54:56
📌 Buffer类的capacity属性，表示内部容量的大小。一旦写入的对象数量超过了capacity容量，缓冲区就满了，不能再写入了。Buffer类的capacity属性一旦初始化，就不能再改变。原因是什么呢？Buffer类的对象在初始化时，会按照capacity分配内部的内存。在内存分配好之后，它的大小当然就不能改变了。再强调一下，capacity容量不是指内存块byte[]数组的字节的数量。capacity容量指的是写入的数据对象的数量。前面讲到，Buffer类是一个抽象类，Java不能直接用来新建对象。
- ⏱ 2023-03-25 01:13:26
📌 Buffer类的capacity属性一旦初始化，就不能再改变。
- ⏱ 2023-03-24 21:55:33
📌 Buffer类的对象在初始化时，会按照capacity分配内部的内存。在内存分配好之后，它的大小当然就不能改变了。
- ⏱ 2023-03-24 21:55:43
📌 capacity容量不是指内存块byte[]数组的字节的数量。capacity容量指的是写入的数据对象的数量。
- ⏱ 2023-03-24 21:56:35
📌 Buffer类的position属性，表示当前的位置。position属性与缓冲区的读写模式有关。在不同的模式下，position属性的值是不同的。当缓冲区进行读写的模式改变时，position会进行调整。
- ⏱ 2023-03-24 21:59:51
📌 在写入模式下，position的值变化规则如下：（1）在刚进入到写模式时，position值为0，表示当前的写入位置为从头开始。（2）每当一个数据写到缓冲区之后，position会向后移动到下一个可写的位置。（3）初始的position值为0，最大可写值position为limit-1。当position值达到limit时，缓冲区就已经无空间可写了。
- ⏱ 2023-03-24 22:00:15
📌 在读模式下，position的值变化规则如下：（1）当缓冲区刚开始进入到读模式时，position会被重置为0。（2）当从缓冲区读取时，也是从position位置开始读。读取数据后，position向前移动到下一个可读的位置。（3）position最大的值为最大可读上限limit，当position达到limit时，表明缓冲区已经无数据可读。
- ⏱ 2023-03-24 22:00:21
📌 模式的切换，可以使用（即调用）flip翻转方法，将缓冲区变成读取模式。
- ⏱ 2023-03-24 22:00:50
📌 在这个flip翻转过程中，position会进行非常巨大的调整，具体的规则是：position由原来的写入位置，变成新的可读位置，也就是0，表示可以从头开始读。
- ⏱ 2023-03-24 22:01:05
📌 Buffer类的limit属性，表示读写的最大上限。limit属性，也与缓冲区的读写模式有关。在不同的模式下，limit的值的含义是不同的。
- ⏱ 2023-03-25 11:59:53
📌 在写模式下，limit属性值的含义为可以写入的数据最大上限。
- ⏱ 2023-03-25 12:00:24
📌 在读模式下，limit的值含义为最多能从缓冲区中读取到多少数据。
- ⏱ 2023-03-25 12:00:42
📌 一般来说，是先写入再读取。当缓冲区写入完成后，就可以开始从Buffer读取数据，可以使用flip翻转方法，这时，limit的值也会进行非常大的调整。
- ⏱ 2023-03-25 12:00:50
📌 将写模式下的position值，设置成读模式下的limit值，也就是说，将之前写入的最大数量，作为可以读取的上限值。
- ⏱ 2023-03-25 12:01:13

3.3 详解NIO Buffer类的重要方法

📌 flip()翻转方法是Buffer类提供的一个模式转变的重要方法，它的作用就是将写入模式翻转成读取模式
- ⏱ 2023-03-24 08:48:03
📌 新的问题来了，在读取完成后，如何再一次将缓冲区切换成写入模式呢？可以调用Buffer.clear()清空或者Buffer.compact()压缩方法，它们可以将缓冲区转换为写模式。
- ⏱ 2023-03-24 09:00:37
📌 在读完之后，是否可以立即进行写入模式呢？不能。现在还处于读取模式，我们必须调用Buffer.clear()或Buffer.compact()，即清空或者压缩缓冲区，才能变成写入模式，让其重新可写。
- ⏱ 2023-03-24 09:07:39
📌 缓冲区是不是可以重复读呢？答案是可以的。
- ⏱ 2023-03-24 09:12:07
📌 已经读完的数据，如果需要再读一遍，可以调用rewind()方法。rewind()也叫倒带，就像播放磁带一样倒回去，再重新播放。
- ⏱ 2023-03-24 09:12:38
📌 Buffer.mark()方法的作用是将当前position的值保存起来，放在mark属性中，让mark属性记住这个临时位置；之后，可以调用Buffer.reset()方法将mark的值恢复到position中。
- ⏱ 2023-03-24 09:18:41
📌 Buffer.mark()和Buffer.reset()方法是配套使用的
- ⏱ 2023-03-24 09:19:21
📌 在读取模式下，调用clear()方法将缓冲区切换为写入模式。此方法会将position清零，limit设置为capacity最大容量值，可以一直写入，直到缓冲区写满。
- ⏱ 2023-03-24 09:21:35
📌 总体来说，使用Java NIO Buffer类的基本步骤如下：（1）使用创建子类实例对象的allocate()方法，创建一个Buffer类的实例对象。（2）调用put方法，将数据写入到缓冲区中。（3）写入完成后，在开始读取数据前，调用Buffer.flip()方法，将缓冲区转换为读模式。（4）调用get方法，从缓冲区中读取数据。（5）读取完成后，调用Buffer.clear() 或Buffer.compact()方法，将缓冲区转换为写入模式。
- ⏱ 2023-03-24 09:26:08

3.4 详解NIO Channel（通道）类

📌 一个通道可以表示一个底层的文件描述符，例如硬件设备、文件、网络连接等
- ⏱ 2023-03-24 09:28:29
📌 （1）FileChannel文件通道，用于文件的数据读写。（2）SocketChannel套接字通道，用于Socket套接字TCP连接的数据读写。（3）ServerSocketChannel服务器嵌套字通道（或服务器监听通道），允许我们监听TCP连接请求，为每个监听到的请求，创建一个SocketChannel套接字通道。（4）DatagramChannel数据报通道，用于UDP协议的数据读写。
- ⏱ 2023-03-24 09:30:04
📌 FileChannel为阻塞模式，不能设置为非阻塞模式。
- ⏱ 2023-03-24 09:31:14
📌 在大部分应用场景，从通道读取数据都会调用通道的int read（ByteBufferbuf）方法，它从通道读取到数据写入到ByteBuffer缓冲区，并且返回读取到的数据量
- ⏱ 2023-03-26 16:23:24
📌 虽然对于通道来说是读取数据，但是对于ByteBuffer缓冲区来说是写入数据，这时，ByteBuffer缓冲区处于写入模式。
- ⏱ 2023-03-24 10:38:04
📌 在将缓冲区写入通道时，出于性能原因，操作系统不可能每次都实时将数据写入磁盘。如果需要保证写入通道的缓冲数据，最终都真正地写入磁盘，可以调用FileChannel的force()方法。[插图]
- ⏱ 2023-03-24 10:46:57
📌 更高效的文件复制，可以调用文件通道的transferFrom方法
- ⏱ 2023-03-26 23:26:32
📌 ServerSocketChannel应用于服务器端，而SocketChannel同时处于服务器端和客户端。换句话说，对应于一个连接，两端都有一个负责传输的SocketChannel传输通道。
- ⏱ 2023-03-24 11:51:47
📌 无论是ServerSocketChannel，还是SocketChannel，都支持阻塞和非阻塞两种模式
- ⏱ 2023-03-24 11:53:06
📌 （1）socketChannel.configureBlocking（false）设置为非阻塞模式。（2）socketChannel.configureBlocking（true）设置为阻塞模式。
- ⏱ 2023-03-24 11:52:22
📌 在非阻塞模式下，通道的操作是异步、高效率的，这也是相对于传统的OIO的优势所在
- ⏱ 2023-03-26 23:32:42
📌 在客户端，先通过SocketChannel静态方法open()获得一个套接字传输通道；然后，将socket套接字设置为非阻塞模式；最后，通过connect()实例方法，对服务器的IP和端口发起连接。
- ⏱ 2023-03-24 12:03:03
📌 并且通过调用服务器端ServerSocketChannel监听套接字的accept()方法，来获取新连接的套接字通道
- ⏱ 2023-03-24 13:23:26
📌 在非阻塞模式下，如何知道通道何时是可读的呢？这就需要用到NIO的新组件——Selector通道选择器
- ⏱ 2023-03-24 13:24:41
📌 在关闭SocketChannel传输通道前，如果传输通道用来写入数据，则建议调用一次shutdownOutput()终止输出方法，向对方发送一个输出的结束标志（-1）。然后调用socketChannel.close()方法，关闭套接字连接。
- ⏱ 2023-03-24 13:33:09
📌 和Socket套接字的TCP传输协议不同，UDP协议不是面向连接的协议。使用UDP协议时，只要知道服务器的IP和端口，就可以直接向对方发送数据。
- ⏱ 2023-03-24 13:35:53
📌 和前面的SocketChannel的读取方式不同，不是调用read方法，而是调用receive（ByteBufferbuf）方法将数据从DatagramChannel读入，再写入到ByteBuffer缓冲区中
- ⏱ 2023-03-27 03:57:59
📌 向DatagramChannel发送数据，和向SocketChannel通道发送数据的方法也是不同的。这里不是调用write方法，而是调用send方法
- ⏱ 2023-03-27 03:59:31
📌 由于UDP是面向非连接的协议，因此，在调用send方法发送数据的时候，需要指定接收方的地址（IP和端口）。
- ⏱ 2023-03-27 04:00:05
📌 当数据到来后，调用了receive方法，从datagramChannel数据包通道接收数据，再写入到ByteBuffer缓冲区中
- ⏱ 2023-03-27 04:03:06

3.5 详解NIO Selector选择器

📌 Java NIO的三大核心组件：Channel（通道）、Buffer（缓冲区）、Selector（选择器）。其中通道和缓冲区，二者的联系也比较密切：数据总是从通道读到缓冲区内，或者从缓冲区写入到通道中。
- ⏱ 2023-03-24 20:55:31
📌 选择器的使命是完成IO的多路复用。一个通道代表一条连接通路，通过选择器可以同时监控多个通道的IO（输入输出）状况。选择器和通道的关系，是监控和被监控的关系。
- ⏱ 2023-03-25 10:42:47
📌 调用通道的Channel.register（Selector sel, int ops）方法，可以将通道实例注册到一个选择器中。
- ⏱ 2023-03-25 10:44:34
📌 可供选择器监控的通道IO事件类型，包括以下四种：（1）可读：SelectionKey.OP_READ（2）可写：SelectionKey.OP_WRITE（3）连接：SelectionKey.OP_CONNECT（4）接收：SelectionKey.OP_ACCEPT
- ⏱ 2023-03-24 20:56:35
📌 判断一个通道能否被选择器监控或选择，有一个前提：判断它是否继承了抽象类SelectableChannel（可选择通道）。如果继承了SelectableChannel，则可以被选择，否则不能。
- ⏱ 2023-03-25 10:48:42
📌 而FileChannel文件通道，并没有继承SelectableChannel，因此不是可选择通道。
- ⏱ 2023-03-25 10:50:19
📌 一旦在通道中发生了某些IO事件（就绪状态达成），并且是在选择器中注册过的IO事件，就会被选择器选中，并放入SelectionKey选择键的集合中。
- ⏱ 2023-03-27 04:08:03
📌 SelectionKey选择键就是那些被选择器选中的IO事件
- ⏱ 2023-03-27 04:08:36
📌 一个IO事件发生（就绪状态达成）后，如果之前在选择器中注册过，就会被选择器选中，并放入SelectionKey选择键集合中；如果之前没有注册过，即使发生了IO事件，也不会被选择器选中。SelectionKey选择键和IO的关系，可以简单地理解为：选择键，就是被选中了的IO事件。
- ⏱ 2023-03-27 04:09:10
📌 （1）获取选择器实例；（2）将通道注册到选择器中；（3）轮询感兴趣的IO就绪事件（选择键集合）。
- ⏱ 2023-03-27 04:09:42
📌 Java通过SPI的方式，提供选择器的默认实现版本
- ⏱ 2023-03-27 04:10:35
📌 注册到选择器的通道，必须处于非阻塞模式下，否则将抛出IllegalBlockingModeException异常。
- ⏱ 2023-03-27 04:13:14
📌 通过Selector选择器的select()方法，选出已经注册的、已经就绪的IO事件，保存到SelectionKey选择键集合中
- ⏱ 2023-03-27 04:14:27
📌 select()方法返回的数量，指的是通道数，而不是IO事件数，准确地说，是指发生了选择器感兴趣的IO事件的通道数。
- ⏱ 2023-03-27 04:18:02

第4章鼎鼎大名的Reactor反应器模式

📌 Reactor反应器模式是高性能网络编程在设计和架构层面的基础模式
- ⏱ 2023-03-27 04:25:13

4.1 Reactor反应器模式为何如此重要

📌 反应器模式由Reactor反应器线程、Handlers处理器两大角色组成：（1）Reactor反应器线程的职责：负责响应IO事件，并且分发到Handlers处理器。（2）Handlers处理器的职责：非阻塞的执行业务处理逻辑。
- ⏱ 2023-03-27 04:26:39

4.2 单线程Reactor反应器模式

📌 反应器模式中的反应器角色，类似于事件驱动模式中的dispatcher事件分发器角色
- ⏱ 2023-03-27 04:32:01
📌 Reactor反应器：负责查询IO事件，当检测到一个IO事件，将其发送给相应的Handler处理器去处理。这里的IO事件，就是NIO中选择器监控的通道IO事件。
- ⏱ 2023-03-27 04:32:26
📌 Handler处理器：与IO事件（或者选择键）绑定，负责IO事件的处理。完成真正的连接建立、通道的读取、处理业务逻辑、负责将结果写出到通道等。
- ⏱ 2023-03-27 04:32:46
📌 什么是单线程版本的Reactor反应器模式呢？简单地说，Reactor反应器和Handers处理器处于一个线程中执行。
- ⏱ 2023-03-27 11:13:00
📌 作为附件添加到SelectionKey实例。
- ⏱ 2023-03-27 11:14:46
📌 在选择键注册完成之后，调用attach方法，将Handler处理器绑定到选择键；当事件发生时，调用attachment方法，可以从选择键取出Handler处理器，将事件分发到Handler处理器中，完成业务处理。
- ⏱ 2023-03-27 11:15:54
📌 AcceptorHandler处理器的两大职责：一是接受新连接，二是在为新连接创建一个输入输出的Handler处理器，称之为IOHandler。
- ⏱ 2023-03-27 16:13:27
📌 IOHandler的构造器中，有两点比较重要：（1）将新的SocketChannel传输通道，注册到了反应器Reactor类的同一个选择器中。这样保证了Reactor类和Handler类在同一个线程中执行。（2）Channel传输通道注册完成后，将IOHandler自身作为附件，attach到了选择键中。这样，在Reactor类分发事件（选择键）时，能执行到IOHandler的run方法。
- ⏱ 2023-03-27 16:16:13
📌 在单线程反应器模式中，Reactor反应器和Handler处理器，都执行在同一条线程上。这样，带来了一个问题：当其中某个Handler阻塞时，会导致其他所有的Handler都得不到执行
- ⏱ 2023-03-28 11:58:09
📌 一旦AcceptorHandler处理器阻塞，会导致整个服务不能接收新的连接，使得服务器变得不可用。因为这个缺陷，因此单线程反应器模型用得比较少。
- ⏱ 2023-03-28 11:58:40

4.3 多线程的Reactor反应器模式

📌 将负责输入输出处理的IOHandler处理器的执行，放入独立的线程池中。这样，业务处理线程与负责服务监听和IO事件查询的反应器线程相隔离，避免服务器的连接监听受到阻塞。
- ⏱ 2023-03-28 15:28:00
📌 如果服务器为多核的CPU，可以将反应器线程拆分为多个子反应器（SubReactor）线程；同时，引入多个选择器，每一个SubReactor子线程负责一个选择器。这样，充分释放了系统资源的能力；也提高了反应器管理大量连接，提升选择大量通道的能力。
- ⏱ 2023-03-28 15:28:55
📌 建议SubReactor的数量和选择器的数量一致。避免多个线程负责一个选择器，导致需要进行线程同步，引起的效率降低
- ⏱ 2023-03-28 15:34:06
📌 int state = RECIEVING;
//引入线程池
static ExecutorService pool = Executors.newFixedThreadPool(4);
MultiThreadEchoHandler(Selector selector, SocketChannel c) throws
IOException {
channel = c;
c.configureBlocking(false);
//取得选择键，、再设置感兴趣的IO事件
sk = channel.register(selector, 0);
//将本Handler作为sk选择键的附件，方便事件分发（dispatch）
sk.attach(this);
//向sk选择键注册Read就绪事件
sk.interestOps(SelectionKey.OP_READ);
selector.wakeup();
- ⏱ 2023-03-28 16:38:36

4.4 Reactor反应器模式小结

📌 1．反应器模式和生产者消费者模式对比相似之处：在一定程度上，反应器模式有点类似生产者消费者模式。在生产者消费者模式中，一个或多个生产者将事件加入到一个队列中，一个或多个消费者主动地从这个队列中提取（Pull）事件来处理。不同之处在于：反应器模式是基于查询的，没有专门的队列去缓冲存储IO事件，查询到IO事件之后，反应器会根据不同IO选择键（事件）将其分发给对应的Handler处理器来处理。
- ⏱ 2023-03-30 17:06:00

5.2 join异步阻塞

📌 join操作的原理是：阻塞当前的线程，直到准备合并的目标线程的执行完成。
- ⏱ 2023-03-30 17:46:30
📌 假设线程A调用了线程B的B.join方法，合并B线程。那么，线程A进入阻塞状态，直到B线程执行完成。
- ⏱ 2023-03-30 17:47:18

5.3 FutureTask异步回调之重武器

📌 Runnable有一个重要的问题，它的run方法是没有返回值的。正因为如此，Runnable不能用于需要有返回值的应用场景。
- ⏱ 2023-04-22 14:14:58
📌 Callable接口是一个泛型接口，也声明为了“函数式接口”。其唯一的抽象方法call有返回值，返回值的类型为泛型形参的实际类型。call抽象方法还有一个Exception的异常声明，容许方法内部的异常不经过捕获。
- ⏱ 2023-04-22 14:15:30
📌 如果Callable实例需要异步执行，就要想办法赋值给Thread的target成员，一个Runnable类型的成员。为此，Java提供了在Callable实例和Thread的target成员之间一个搭桥的类——FutureTask类。
- ⏱ 2023-04-22 15:15:30

6.1 第一个Netty的实践案例DiscardServer

📌 也就是说，如果要实现自己的入站处理器Handler，只要继承ChannelInboundHandlerAdapter入站处理器，再写入自己的入站处理的业务逻辑。
- ⏱ 2023-03-31 17:34:14

6.2 解密Netty中的Reactor反应器模式

📌 对于每一种通信连接协议，Netty都实现了自己的通道
- ⏱ 2023-04-02 22:23:50
📌 Netty中的每一种协议的通道，都有NIO（异步IO）和OIO（阻塞式IO）两个版本
- ⏱ 2023-04-02 22:24:03
📌 对应于不同的协议，Netty中常见的通道类型如下：· NioSocketChannel：异步非阻塞TCP Socket传输通道。· NioServerSocketChannel：异步非阻塞TCP Socket服务器端监听通道。· NioDatagramChannel：异步非阻塞的UDP传输通道。· NioSctpChannel：异步非阻塞Sctp传输通道。· NioSctpServerChannel：异步非阻塞Sctp服务器端监听通道。· OioSocketChannel：同步阻塞式TCP Socket传输通道。· OioServerSocketChannel：同步阻塞式TCP Socket服务器端监听通道。· OioDatagramChannel：同步阻塞式UDP传输通道。· OioSctpChannel：同步阻塞式Sctp传输通道。· OioSctpServerChannel：同步阻塞式Sctp服务器端监听通道。
- ⏱ 2023-04-02 22:24:53
📌 一个EventLoopNetty反应器和NettyChannel通道是一对多的关系：一个反应器可以注册成千上万的通道。
- ⏱ 2023-04-02 22:30:21
📌 ChannelPipeline（通道流水线），它像一条管道，将绑定到一个通道的多个Handler处理器实例，串在一起，形成一条流水线
- ⏱ 2023-04-03 11:39:58
📌 每一个来自通道的IO事件，都会进入一次ChannelPipeline通道流水线。
- ⏱ 2023-04-03 11:38:56
📌 Netty是这样规定的：入站处理器Handler的执行次序，是从前到后；出站处理器Handler的执行次序，是从后到前
- ⏱ 2023-04-03 11:40:48
📌 入站的IO操作只会且只能从Inbound入站处理器类型的Handler流过；出站的IO操作只会且只能从Outbound出站处理器类型的Handler流过。
- ⏱ 2023-04-03 11:43:06

6.3 详解Bootstrap启动器类

📌 Bootstrap类是Netty提供的一个便利的工厂类，可以通过它来完成Netty的客户端或服务器端的Netty组件的组装，以及Netty程序的初始化。
- ⏱ 2023-04-03 11:43:53
📌 操作系统底层的socket描述符分为两类：· 连接监听类型。连接监听类型的socket描述符，放在服务器端，它负责接收客户端的套接字连接；在服务器端，一个“连接监听类型”的socket描述符可以接受（Accept）成千上万的传输类的socket描述符。· 传输数据类型。数据传输类的socket描述符负责传输数据。同一条TCP的Socket传输链路，在服务器和客户端，都分别会有一个与之相对应的数据传输类型的socket描述符。
- ⏱ 2023-04-03 12:02:52
📌 在Netty中，将有接收关系的NioServerSocketChannel和NioSocketChannel，叫作父子通道。其中，NioServerSocketChannel负责服务器连接监听和接收，也叫父通道（Parent Channel）。对应于每一个接收到的NioSocketChannel传输类通道，也叫子通道（Child Channel）。
- ⏱ 2023-04-03 12:03:35
📌 Netty的EventLoopGroup线程组就是一个多线程版本的反应器。而其中的单个EventLoop线程对应于一个子反应器（SubReactor）。
- ⏱ 2023-04-03 12:09:48
📌 默认的EventLoopGroup内部线程数为最大可用的CPU处理器数量的2倍。
- ⏱ 2023-04-03 12:21:12
📌 对应到Netty服务器程序中，则是设置两个EventLoopGroup线程组，一个EventLoopGroup负责新连接的监听和接受，一个EventLoopGroup负责IO事件处理。
- ⏱ 2023-04-03 12:25:19

6.4 详解Channel通道

📌 在Netty中，通道是其中的核心概念之一，代表着网络连接
- ⏱ 2023-04-23 15:42:29
📌 AbstractChannel内部有一个pipeline属性，表示处理器的流水线。Netty在对通道进行初始化的时候，将pipeline属性初始化为DefaultChannelPipeline的实例。这段代码也表明，每个通道拥有一条ChannelPipeline处理器流水线。
- ⏱ 2023-04-23 21:14:58
📌 方法1. ChannelFuture connect(SocketAddress address)此方法的作用为：连接远程服务器。方法的参数为远程服务器的地址，调用后会立即返回，返回值为负责连接操作的异步任务ChannelFuture。此方法在客户端的传输通道使用。
- ⏱ 2023-04-23 21:43:22
📌 方法2. ChannelFuture bind（SocketAddress address）此方法的作用为：绑定监听地址，开始监听新的客户端连接。此方法在服务器的新连接监听和接收通道使用。
- ⏱ 2023-04-23 21:52:00

10.1 ZooKeeper伪集群安装和配置

📌 ZooKeeper集群节点数必须是奇数。
- ⏱ 2023-04-16 13:50:38
📌 在ZooKeeper集群中，需要一个主节点，也称为Leader节点。主节点是集群通过选举的规则从所有节点中选举出来的。在选举的规则中很重要的一条是：要求可用节点数量>总节点数量/2。如果是偶数个节点，则可能会出现不满足这个规则的情况。
- ⏱ 2023-04-16 13:50:48

12.1 如何支撑亿级流量的高并发IM架构的理论基础

📌 Protobuf是最高效的二进制序列化协议，用于长连接
- ⏱ 2023-04-22 10:10:30

读书笔记

1.2 高并发利器Redis

划线评论

📌 丰富的数据结构除了string之外，还有list、hash、set、sortedset，一共五种类型。
- 💭 常用有这五种类型，现在一共有九种类型
  我们都知道 Redis 提供了丰富的数据类型，常见的有五种：String（字符串），Hash（哈希），List（列表），Set（集合）、Zset（有序集合）。
  随着 Redis 版本的更新，后面又支持了四种数据类型： BitMap（2.2 版新增）、HyperLogLog（2.8 版新增）、GEO（3.2 版新增）、Stream（5.0 版新增）。

作者：wefashe
链接：https://juejin.cn/post/7108920755592626207
来源：稀土掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
- ⏱ 2023-03-23 12:45:03

2.1 IO读写的基础原理

划线评论

📌 如果是在Java服务器端，完成一次socket请求和响应，完整的流程
- 💭 简单来说就是系统先通过网卡从客户端获取数据刷入系统内核缓冲区->Java程序通过read调用操作将数据刷入应用缓冲区->Java处理数据->通过write操作将数据从应用缓冲区刷入内核缓冲区
- ⏱ 2023-03-23 15:45:34

2.2 四种主要的IO模型

划线评论

📌 IO多路复用模型的优点：与一个线程维护一个连接的阻塞IO模式相比，使用select/epoll的最大优势在于，一个选择器查询线程可以同时处理成千上万个连接（Connection）。系统不必创建大量的线程，也不必维护这些线程，从而大大减小了系统的开销。
- 💭 IO多路复用模型的优点：不需要创建和维护大量的线程去查询和处理连接状态，只需要去维护Select查询线程就可以同时处理成千上万的连接，减小了系统开销
- ⏱ 2023-03-23 16:06:53

划线评论

📌 当用户进程调用了select查询方法，那么整个线程会被阻塞掉。
- 💭 是用户调用select查询方法后已经就绪的socket数据从内核缓冲区刷入用户缓冲区导致线程阻塞吗？
- ⏱ 2023-03-23 15:41:41

划线评论

📌 在IO多路复用模型中通过select/epoll系统调用，单个应用程序的线程，可以不断地轮询成百上千的socket连接，当某个或者某些socket网络连接有IO就绪的状态，就返回对应的可以执行的读写操作。
- 💭 有误，epoll应该为poll
- ⏱ 2023-03-23 15:36:40

划线评论

📌 总体来说，在高并发应用场景下，同步非阻塞IO也是不可用的。
- 💭 同步非阻塞IO在内核缓冲区准备阶段实现了异步，在这个阶段用户发起的请求都会立刻获得反馈，但是在内核缓冲区到应用缓冲区的过程中还是阻塞，同时应用还需要不断轮询获取状态，占用大量cpu时间。在高并发场景下这种模式并不可用
- ⏱ 2023-03-23 15:30:55

划线评论

📌 3．IO多路复用（IO Multiplexing）
即经典的Reactor反应器设计模式，有时也称为异步阻塞IO, Java中的Selector选择器和Linux中的epoll都是这种模型。
- 💭 存疑，需要查证准确性
- ⏱ 2023-03-23 15:14:14

2.3 通过合理配置来支持百万级并发连接

划线评论

📌 Linux的系统默认值为1024，也就是说，一个进程最多可以接受1024个socket连接
- 💭 在生产环境中1024个句柄是远远不够的，需要解除句柄数的限制
- ⏱ 2023-03-23 16:17:22

3.1 Java NIO简介

划线评论

📌 应用程序与通道（Channel）主要的交互操作，就是进行数据的read读取和write写入。
- 💭 应用程序与channel的主要操作就是进行数据的read&write。Nio使用buffer缓冲区进行数据交互，channel的读取就是将channel的数据读到buffer中，而channel的写入则是将数据从buffer中读到channel中
- ⏱ 2023-03-23 23:42:30

划线评论

📌 Selector选择器
- 💭 基于操作系统的select等实现
- ⏱ 2023-03-23 23:36:25

划线评论

📌 NIO和OIO的对比
- 💭 nio与oio的区别
  1.oio是面向流的，严格要求顺序读取；nio是面向通道和缓存区的，可以乱序读取后组合成完整数据
  2.oio是阻塞的，而nio采用多路复用模型极大的降低了阻塞的影响
  3.nio中有selector调查器
- ⏱ 2023-03-23 23:31:07

划线评论

📌 NIO如何做到非阻塞的呢？
- 💭 nio也是阻塞的，但是nio使用了多路复用模型，极大的降低了阻塞带来的影响
- ⏱ 2023-03-23 23:26:47

划线评论

📌 NIO中引入了Channel（通道）和Buffer（缓冲区）的概念。读取和写入，只需要从通道中读取数据到缓冲区中，或将数据从缓冲区中写入到通道中。NIO不像OIO那样是顺序操作，可以随意地读取Buffer中任意位置的数据。
- 💭 从流中读取数据需要严格要求顺序，而从channel和buffer中可以使用数据分块，乱序传输再组装成完整的数据
- ⏱ 2023-03-23 23:23:48

3.3 详解NIO Buffer类的重要方法

划线评论

📌 读取操作会改变可读位置position的值，而limit值不会改变
- 💭 如果position=limit则代表所有元素已经读完了，此时position所指向的位置已经没有值了，如果再读就会报错
- ⏱ 2023-03-24 09:11:20

划线评论

📌 如何将缓冲区切换成读取模式
- 💭 缓冲区有两种模式，分别为读模式和写模式，只有缓冲区处于对应模式下才能读或者写，而flip方法则是用来反转模式的。为什么需要反转模式呢？因为在读模式和写模式下缓冲区下同一个元素的状态和值是不太一样的，需要反转才能不使数据混乱。这是目前的理解还需要验证
- ⏱ 2023-03-24 08:58:38

划线评论

📌 最后，清除之前的mark标记，因为mark保存的是写模式下的临时位置。在读模式下，如果继续使用旧的mark标记，会造成位置混乱。
- 💭 这个mark标记是指的写入元素的位置吗
- ⏱ 2023-03-24 08:51:41

3.4 详解NIO Channel（通道）类

划线评论

📌 在读取时，因为是异步的，因此我们必须检查read的返回值，以便判断当前是否读取到了数据。read()方法的返回值，是读取的字节数。如果返回-1，那么表示读取到对方的输出结束标志，对方已经输出结束，准备关闭连接。
- 💭 这个读取时是异步的，应该为主线程循环查询调用read的线程状态
- ⏱ 2023-03-24 13:26:09

划线评论

📌 此时的ByteBuffer缓冲区要求是可读的，处于读模式下。
- 💭 写入Channel需要buffer处于可读模式，读取Channel需要buffer处于可写模式。因为Channel的写入是从buffer中读取，而读取相反
- ⏱ 2023-03-24 10:44:16

划线评论

📌 FileChannel、SocketChannel、ServerSocketChannel、DatagramChannel。
- 💭 其中常用的channel
- ⏱ 2023-03-24 09:29:20

本书评论

书评 No.1 对于io部分讲的不错，但是其他的内容就像是博客文章拼凑在一起，总得来说前小部分推荐阅读

⏱ 2023-03-30 22:29:52

MySQL 8从入门到精通（视频教学版）

2023-07-02T03:21:50Z

元数据

[!abstract] MySQL 8从入门到精通（视频教学版）

书名： MySQL 8从入门到精通（视频教学版）

作者：王英英

简介：本书主要内容包括MySQL的安装与配置、数据库的创建、数据表的创建、数据类型和运算符、MySQL函数、查询数据、数据表的操作（插入、更新与删除数据）、索引、存储过程和函数、视图、触发器、用户管理、数据备份与还原、MySQL日志、性能优化、MySQL Replication、MySQL Workbench、MySQL Utilities、MySQL Proxy、PHP操作MySQL数据库和PDO数据库抽象类库等。最后通过3个综合案例的数据库设计，进一步讲述MySQL在实际工作中的应用。本书共有480个实例和16个综合案例，还有大量的经典习题。随书赠送了近20小时培训班形式的视频教学录像，详细讲解了书中每一个知识点和每一个数据库操作的方法和技巧，同时还提供了本书所有例子的源代码，读者可以直接查看和调用。本书注重实战操作，帮助读者循序渐进地掌握MySQL中的各项技术，非常适合MySQL数据库初学者、MySQL数据库开发人员和MySQL数据库管理员阅读，同时也能作为高等院校和培训学校相关专业师生的教学用书。

出版时间 2019-08-01 00:00:00

ISBN： 9787302531272

分类：计算机-编程设计

出版社：清华大学出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

1.1 数据库基础

📌 行被称为记录，是组织数据的单位；列被称为字段，每一列表示记录的一个属性，有相应的描述信息，如数据类型、数据宽度等。
- ⏱ 2023-03-23 00:01:22

读书笔记

本书评论

Java并发编程之美

2023-07-02T03:21:50Z

元数据

[!abstract] Java并发编程之美

书名： Java并发编程之美

作者：翟陆续薛宾田

简介： Java并发编程无处不在，涉及的知识点多，要掌握并用好它并非易事。作者加多拥有在大型互联网公司阿里巴巴的丰富工作经验，遇到并解决了业务场景中很多实际的并发问题。本书是他对自己实践经验的总结与升华。为帮助读者解决学习中的各类痛点，作者将全书明确地分为基础篇、高级篇和实践篇，脉络清晰；全书以代码说话，辅以图表，让初学者能一步一步地深入堂奥，掌握并发编程的精髓。

出版时间 2018-10-01 00:00:00

ISBN： 9787121349478

分类：计算机-编程设计

出版社：电子工业出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

第1章并发编程线程基础

📌 进程是代码在数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，线程则是进程的一个执行路径，一个进程中至少有一个线程，进程中的多个线程共享进程的资源。
- ⏱ 2023-05-02 16:23:54
📌 操作系统在分配资源时是把资源分配给进程的，但是CPU资源比较特殊，它是被分配到线程的，因为真正要占用CPU运行的是线程，所以也说线程是CPU分配的基本单位。
- ⏱ 2023-05-02 16:26:43
📌 一个进程中有多个线程，多个线程共享进程的堆和方法区资源，但是每个线程有自己的程序计数器和栈区域
- ⏱ 2023-05-02 16:42:38
📌 程序计数器是一块内存区域，用来记录线程当前要执行的指令地址。
- ⏱ 2023-05-02 16:42:49
📌 如果执行的是native方法，那么pc计数器记录的是undefined地址，只有执行的是Java代码时pc计数器记录的才是下一条指令的地址。
- ⏱ 2023-05-02 16:43:38
📌 堆是一个进程中最大的一块内存，堆是被进程中的所有线程共享的，是进程创建时分配的，堆里面主要存放使用new操作创建的对象实例。
- ⏱ 2023-05-02 16:44:17
📌 方法区则用来存放JVM加载的类、常量及静态变量等信息，也是线程共享的
- ⏱ 2023-05-02 16:44:26

1.2 线程创建与运行

📌 Java中有三种线程创建方式，分别为实现Runnable接口的run方法，继承Thread类并重写run的方法，使用FutureTask方式。
- ⏱ 2023-05-02 16:44:36
📌 当创建完thread对象后该线程并没有被启动执行，直到调用了start方法后才真正启动了线程。
- ⏱ 2023-05-02 16:46:58
📌 使用继承方式的好处是，在run（）方法内获取当前线程直接使用this就可以了，无须使用Thread.currentThread（）方法；不好的地方是Java不支持多继承，如果继承了Thread类，那么就不能再继承其他类。
- ⏱ 2023-06-01 09:46:42
📌 使用继承方式的好处是方便传参，你可以在子类里面添加成员变量，通过set方法设置参数或者通过构造函数进行传递，而如果使用Runnable方式，则只能使用主线程里面被声明为final的变量。不好的地方是Java不支持多继承，如果继承了Thread类，那么子类不能再继承其他类，而Runable则没有这个限制。前两种方式都没办法拿到任务的返回结果，但是Futuretask方式可以。
- ⏱ 2023-05-02 20:13:17

1.3 线程通知与等待

📌 当一个线程调用一个共享变量的wait（）方法时，该调用线程会被阻塞挂起，直到发生下面几件事情之一才返回：（1）其他线程调用了该共享对象的notify（）或者notifyAll（）方法；（2）其他线程调用了该线程的interrupt（）方法，该线程抛出InterruptedException异常返回。
- ⏱ 2023-05-06 15:35:59
📌 notify() 函数一个线程调用共享对象的notify（）方法后，会唤醒一个在该共享变量上调用wait系列方法后被挂起的线程。一个共享变量上可能会有多个线程在等待，具体唤醒哪个等待的线程是随机的。此外，被唤醒的线程不能马上从wait方法返回并继续执行，它必须在获取了共享对象的监视器锁后才可以返回，也就是唤醒它的线程释放了共享变量上的监视器锁后，被唤醒的线程也不一定会获取到共享对象的监视器锁，这是因为该线程还需要和其他线程一起竞争该锁，只有该线程竞争到了共享变量的监视器锁后才可以继续执行。类似wait系列方法，只有当前线程获取到了共享变量的监视器锁后，才可以调用共享变量的notify（）方法，否则会抛出IllegalMonitorStateException异常。
- ⏱ 2023-06-01 10:23:38
📌 notifyAll() 函数不同于在共享变量上调用notify（）函数会唤醒被阻塞到该共享变量上的一个线程，notifyAll（）方法则会唤醒所有在该共享变量上由于调用wait系列方法而被挂起的线程。
- ⏱ 2023-06-01 10:23:46

1.11 ThreadLocal

📌 ThreadLocal是JDK包提供的，它提供了线程本地变量，也就是如果你创建了一个ThreadLocal变量，那么访问这个变量的每个线程都会有这个变量的一个本地副本。当多个线程操作这个变量时，实际操作的是自己本地内存里面的变量，从而避免了线程安全问题。创建一个ThreadLocal变量后，每个线程都会复制一个变量到自己的本地内存
- ⏱ 2023-06-02 11:05:50
📌 Thread类中有一个threadLocals和一个inheritableThreadLocals，它们都是ThreadLocalMap类型的变量，而ThreadLocalMap是一个定制化的Hashmap。在默认情况下，每个线程中的这两个变量都为null，只有当前线程第一次调用ThreadLocal的set或者get方法时才会创建它们
- ⏱ 2023-06-02 11:16:54
📌 每个线程的本地变量不是存放在ThreadLocal实例里面，而是存放在调用线程的threadLocals变量里面。也就是说，ThreadLocal类型的本地变量存放在具体的线程内存空间中。
- ⏱ 2023-06-02 11:16:29
📌 如果调用线程一直不终止，那么这个本地变量会一直存放在调用线程的threadLocals变量里面，所以当不需要使用本地变量时可以通过调用ThreadLocal变量的remove方法，从当前线程的threadLocals里面删除该本地变量。
- ⏱ 2023-06-02 11:17:36
📌 同一个ThreadLocal变量在父线程中被设置值后，在子线程中是获取不到的。
- ⏱ 2023-06-02 11:29:02

2.5 Java中的synchronized关键字

📌 synchronized块是Java提供的一种原子性内置锁，Java中的每个对象都可以把它当作一个同步锁来使用，这些Java内置的使用者看不到的锁被称为内部锁，也叫作监视器锁。线程的执行代码在进入synchronized代码块前会自动获取内部锁，这时候其他线程访问该同步代码块时会被阻塞挂起。拿到内部锁的线程会在正常退出同步代码块或者抛出异常后或者在同步块内调用了该内置锁资源的wait系列方法时释放该内置锁。内置锁是排它锁，也就是当一个线程获取这个锁后，其他线程必须等待该线程释放锁后才能获取该锁。
- ⏱ 2023-05-27 10:12:35
📌 由于Java中的线程是与操作系统的原生线程一一对应的，所以当阻塞一个线程时，需要从用户态切换到内核态执行阻塞操作，这是很耗时的操作，而synchronized的使用就会导致上下文切换
- ⏱ 2023-05-27 10:32:24
📌 其实这也是加锁和释放锁的语义，当获取锁后会清空锁块内本地内存中将会被用到的共享变量，在使用这些共享变量时从主内存进行加载，在释放锁时将本地内存中修改的共享变量刷新到主内存。
- ⏱ 2023-05-27 10:37:42

2.6 Java中的volatile关键字

2.7 Java中的原子性操作

📌 简单的++value由2、5、6、7四步组成，其中第2步是获取当前value的值并放入栈顶，第5步把常量1放入栈顶，第6步把当前栈顶中两个值相加并把结果放入栈顶，第7步则把栈顶的结果赋给value变量。因此，Java中简单的一句++value被转换为汇编后就不具有原子性了。
- ⏱ 2023-05-27 11:08:07

2.8 Java中的CAS操作

📌 CAS有四个操作数，分别为：对象内存位置、对象中的变量的偏移量、变量预期值和新的值
- ⏱ 2023-05-27 15:24:00
📌 如果对象obj中内存偏移量为valueOffset的变量值为expect，则使用新的值update替换旧的值expect。这是处理器提供的一个原子性指令。
- ⏱ 2023-05-27 15:26:58
📌 JDK中的AtomicStampedReference类给每个变量的状态值都配备了一个时间戳，从而避免了ABA问题的产生。
- ⏱ 2023-05-28 15:45:48

2.9 Unsafe类

📌 JDK的rt.jar包中的Unsafe类提供了硬件级别的原子性操作，Unsafe类中的方法都是native方法，它们使用JNI的方式访问本地C++ 实现库。
- ⏱ 2023-05-28 15:48:33

2.10 Java指令重排序

📌 重排序在多线程下会导致非预期的程序执行结果，而使用volatile修饰ready就可以避免重排序和内存可见性问题。
- ⏱ 2023-05-28 16:07:21
📌 写volatile变量时，可以确保volatile写之前的操作不会被编译器重排序到volatile写之后。读volatile变量时，可以确保volatile读之后的操作不会被编译器重排序到volatile读之前。
- ⏱ 2023-05-28 16:07:30

2.11 伪共享

📌 在Cache内部是按行存储的，其中每一行称为一个Cache行
- ⏱ 2023-05-21 19:07:18
📌 Cache行（如图2-7所示）是Cache与主内存进行数据交换的单位，Cache行的大小一般为2的幂次数字节。
- ⏱ 2023-05-21 19:07:32
📌 当CPU访问某个变量时，首先会去看CPU Cache内是否有该变量，如果有则直接从中获取，否则就去主内存里面获取该变量，然后把该变量所在内存区域的一个Cache行大小的内存复制到Cache中
- ⏱ 2023-05-21 19:09:09
📌 由于存放到Cache行的是内存块而不是单个变量，所以可能会把多个变量存放到一个Cache行中
- ⏱ 2023-05-21 19:09:50
📌 当多个线程同时修改一个缓存行里面的多个变量时，由于同时只能有一个线程操作缓存行，所以相比将每个变量放到一个缓存行，性能会有所下降，这就是伪共享
- ⏱ 2023-05-21 19:10:22
📌 如果CPU只有一级缓存，则会导致频繁地访问主内存。
- ⏱ 2023-05-21 19:19:34
📌 伪共享的产生是因为多个变量被放入了一个缓存行中，并且多个线程同时去写入缓存行中不同的变量。
- ⏱ 2023-05-21 19:21:54
📌 地址连续的多个变量才有可能会被放到一个缓存行中。
- ⏱ 2023-05-21 19:22:43
📌 所以在单个线程下顺序修改一个缓存行中的多个变量，会充分利用程序运行的局部性原则，从而加速了程序的运行。而在多线程下并发修改一个缓存行中的多个变量时就会竞争缓存行，从而降低程序运行性能。
- ⏱ 2023-05-21 21:46:18
📌 JDK 8提供了一个sun.misc.Contended注解，用来解决伪共享问题。
- ⏱ 2023-05-21 21:47:32
📌 在默认情况下，@Contended注解只用于Java核心类，比如rt包下的类。如果用户类路径下的类需要使用这个注解，则需要添加JVM参数：-XX:-RestrictContended。填充的宽度默认为128，要自定义宽度则可以设置-XX:ContendedPaddingWidth参数。
- ⏱ 2023-05-21 21:48:27

2.12 锁的概述

📌 悲观锁指对数据被外界修改持保守态度，认为数据很容易就会被其他线程修改，所以在数据被处理前先对数据进行加锁，并在整个数据处理过程中，使数据处于锁定状态
- ⏱ 2023-05-28 16:08:35
📌 乐观锁是相对悲观锁来说的，它认为数据在一般情况下不会造成冲突，所以在访问记录前不会加排它锁，而是在进行数据提交更新时，才会正式对数据冲突与否进行检测。
- ⏱ 2023-05-28 16:11:41
📌 根据线程获取锁的抢占机制，锁可以分为公平锁和非公平锁，公平锁表示线程获取锁的顺序是按照线程请求锁的时间早晚来决定的，也就是最早请求锁的线程将最早获取到锁。而非公平锁则在运行时闯入，也就是先来不一定先得。
- ⏱ 2023-05-28 16:20:34
📌 ReentrantLock提供了公平和非公平锁的实现。● 公平锁：ReentrantLock pairLock = new ReentrantLock（true）。● 非公平锁：ReentrantLock pairLock = new ReentrantLock（false）。如果构造函数不传递参数，则默认是非公平锁。
- ⏱ 2023-05-28 16:20:47
📌 在没有公平性需求的前提下尽量使用非公平锁，因为公平锁会带来性能开销。
- ⏱ 2023-05-28 16:21:43
📌 根据锁只能被单个线程持有还是能被多个线程共同持有，锁可以分为独占锁和共享锁。
- ⏱ 2023-05-28 16:22:06
📌 独占锁保证任何时候都只有一个线程能得到锁，ReentrantLock就是以独占方式实现的。共享锁则可以同时由多个线程持有，例如ReadWriteLock读写锁，它允许一个资源可以被多线程同时进行读操作。
- ⏱ 2023-05-28 16:22:23
📌 独占锁是一种悲观锁，由于每次访问资源都先加上互斥锁，这限制了并发性，因为读操作并不会影响数据的一致性，而独占锁只允许在同一时间由一个线程读取数据，其他线程必须等待当前线程释放锁才能进行读取。共享锁则是一种乐观锁，它放宽了加锁的条件，允许多个线程同时进行读操作。
- ⏱ 2023-05-28 16:22:36
📌 当一个线程要获取一个被其他线程持有的独占锁时，该线程会被阻塞，那么当一个线程再次获取它自己已经获取的锁时是否会被阻塞呢？如果不被阻塞，那么我们说该锁是可重入的，也就是只要该线程获取了该锁，那么可以无限次数（在高级篇中我们将知道，严格来说是有限次数）地进入被该锁锁住的代码。
- ⏱ 2023-05-28 16:23:11
📌 synchronized内部锁是可重入锁
- ⏱ 2023-05-28 16:24:32
📌 可重入锁的原理是在锁内部维护一个线程标示，用来标示该锁目前被哪个线程占用，然后关联一个计数器。一开始计数器值为0，说明该锁没有被任何线程占用。当一个线程获取了该锁时，计数器的值会变成1，这时其他线程再来获取该锁时会发现锁的所有者不是自己而被阻塞挂起。
- ⏱ 2023-05-28 16:25:48
📌 但是当获取了该锁的线程再次获取锁时发现锁拥有者是自己，就会把计数器值加+1，当释放锁后计数器值-1。当计数器值为0时，锁里面的线程标示被重置为null，这时候被阻塞的线程会被唤醒来竞争获取该锁。
- ⏱ 2023-05-28 16:26:18
📌 自旋锁则是，当前线程在获取锁时，如果发现锁已经被其他线程占有，它不马上阻塞自己，在不放弃CPU使用权的情况下，多次尝试获取（默认次数是10，可以使用-XX:PreBlockSpinsh参数设置该值），很有可能在后面几次尝试中其他线程已经释放了锁。如果尝试指定的次数后仍没有获取到锁则当前线程才会被阻塞挂起。由此看来自旋锁是使用CPU时间换取线程阻塞与调度的开销，但是很有可能这些CPU时间白白浪费了。
- ⏱ 2023-05-28 16:32:32

3.1 Random类及其局限性

📌 每个Random实例里面都有一个原子性的种子变量用来记录当前的种子值，当要生成新的随机数时需要根据当前种子计算新的种子并更新回原子变量。在多线程下使用单个Random实例生成随机数时，当多个线程同时计算随机数来计算新的种子时，多个线程会竞争同一个原子变量的更新操作，由于原子变量的更新是CAS操作，同时只有一个线程会成功，所以会造成大量线程进行自旋重试，这会降低并发性能，所以ThreadLocalRandom应运而生。
- ⏱ 2023-05-28 16:37:35

3.2 ThreadLocalRandom

📌 ThreadLocal通过让每一个线程复制一份变量，使得在每个线程对变量进行操作时实际是操作自己本地内存里面的副本，从而避免了对共享变量进行同步。实际上ThreadLocalRandom的实现也是这个原理，Random的缺点是多个线程会使用同一个原子性种子变量，从而导致对原子变量更新的竞争
- ⏱ 2023-05-28 16:39:28

3.3 源码分析

📌 ThreadLocalRandom类继承了Random类并重写了nextInt方法，在ThreadLocalRandom类中并没有使用继承自Random类的原子性种子变量。在ThreadLocalRandom中并没有存放具体的种子，具体的种子存放在具体的调用线程的threadLocalRandomSeed变量里面。ThreadLocalRandom类似于ThreadLocal类，就是个工具类。当线程调用ThreadLocalRandom的current方法时，ThreadLocalRandom负责初始化调用线程的threadLocalRandomSeed变量，也就是初始化种子。
- ⏱ 2023-05-28 16:45:01
📌 当调用ThreadLocalRandom的nextInt方法时，实际上是获取当前线程的threadLocalRandomSeed变量作为当前种子来计算新的种子，然后更新新的种子到当前线程的threadLocalRandomSeed变量，而后再根据新种子并使用具体算法计算随机数。这里需要注意的是，threadLocalRandomSeed变量就是Thread类里面的一个普通long变量，它并不是原子性变量。其实道理很简单，因为这个变量是线程级别的，所以根本不需要使用原子性变量
- ⏱ 2023-05-28 16:45:55
📌 seeder和probeGenerator是两个原子性变量，在初始化调用线程的种子和探针变量时会用到它们，每个线程只会使用一次。
- ⏱ 2023-05-28 16:48:02
📌 变量instance是ThreadLocalRandom的一个实例，该变量是static的。当多线程通过ThreadLocalRandom的current方法获取ThreadLocalRandom的实例时，其实获取的是同一个实例。但是由于具体的种子是存放在线程里面的，所以在ThreadLocalRandom的实例里面只包含与线程无关的通用算法，所以它是线程安全的
- ⏱ 2023-05-28 16:47:38

4.1 原子变量操作类

📌 这些原子操作类都使用CAS非阻塞算法，性能更好。但是在高并发情况下AtomicLong还会存在性能问题。JDK 8提供了一个在高并发下性能更好的LongAdder类
- ⏱ 2023-05-28 17:09:24

4.2 JDK 8新增的原子操作类LongAdder

📌 使用AtomicLong时，在高并发下大量线程会同时去竞争更新同一个原子变量，但是由于同时只有一个线程的CAS操作会成功，这就造成了大量线程竞争失败后，会通过无限循环不断进行自旋尝试CAS的操作，而这会白白浪费CPU资源。
- ⏱ 2023-05-28 17:09:51
📌 使用LongAdder时，则是在内部维护多个Cell变量，每个Cell里面有一个初始值为0的long型变量，这样，在同等并发量的情况下，争夺单个变量更新操作的线程量会减少，这变相地减少了争夺共享资源的并发量。另外，多个线程在争夺同一个Cell原子变量时如果失败了，它并不是在当前Cell变量上一直自旋CAS重试，而是尝试在其他Cell的变量上进行CAS尝试，这个改变增加了当前线程重试CAS成功的可能性。最后，在获取LongAdder当前值时，是把所有Cell变量的value值累加后再加上base返回的。
- ⏱ 2023-05-28 17:14:45
📌 LongAdder维护了一个延迟初始化的原子性更新数组（默认情况下Cell数组是null）和一个基值变量base。由于Cells占用的内存是相对比较大的，所以一开始并不创建它，而是在需要时创建，也就是惰性加载。
- ⏱ 2023-05-28 17:15:36
📌 当一开始判断Cell数组是null并且并发线程较少时，所有的累加操作都是对base变量进行的。保持Cell数组的大小为2的N次方，在初始化时Cell数组中的Cell元素个数为2，数组里面的变量实体是Cell类型。Cell类型是AtomicLong的一个改进，用来减少缓存的争用，也就是解决伪共享问题。
- ⏱ 2023-05-28 17:16:55
📌 对于大多数孤立的多个原子操作进行字节填充是浪费的，因为原子性操作都是无规律地分散在内存中的（也就是说多个原子性变量的内存地址是不连续的），多个原子变量被放入同一个缓存行的可能性很小。但是原子性数组元素的内存地址是连续的，所以数组内的多个元素能经常共享缓存行，因此这里使用@sun.misc.Contended注解对Cell类进行字节填充，这防止了数组中多个元素共享一个缓存行，在性能上是一个提升。
- ⏱ 2023-05-28 17:17:53
📌 LongAdder类继承自Striped64类，在Striped64内部维护着三个变量。LongAdder的真实值其实是base的值与Cell数组里面所有Cell元素中的value值的累加，base是个基础值，默认为0。cellsBusy用来实现自旋锁，状态值只有0和1，当创建Cell元素，扩容Cell数组或者初始化Cell数组时，使用CAS操作该变量来保证同时只有一个线程可以进行其中之一的操作
- ⏱ 2023-05-28 17:19:41

读书笔记

第1章并发编程线程基础

划线评论

📌 每个线程都有自己的栈资源，用于存储该线程的局部变量，这些局部变量是该线程私有的，其他线程是访问不了的，除此之外栈还用来存放线程的调用栈帧。
- 💭 线程中的栈资源就好像是工作中的git分支,一个任务一个分支,最后完成时再将处理好的结果刷回主分支,当然这个比喻不是很恰当.
- ⏱ 2023-06-01 09:42:43

划线评论

📌 其实程序计数器就是为了记录该线程让出CPU时的执行地址的，待再次分配到时间片时线程就可以从自己私有的计数器指定地址继续执行。
- 💭 就好比阅读时在要结束的时候添加一个书签在当前位置,这样下次再看这本书的时候就不用花时间去回想上次的进度了,只需要从书签的位置开始继续阅读
- ⏱ 2023-06-01 09:39:34

1.2 线程创建与运行

划线评论

📌 其实调用start方法后线程并没有马上执行而是处于就绪状态，这个就绪状态是指该线程已经获取了除CPU资源外的其他资源，等待获取CPU资源后才会真正处于运行状态。一旦run方法执行完毕，该线程就处于终止状态
- 💭 类比手头正在做的工作,已经把材料都准备好了,就等着自己将其他事情做完或者放下来处理这一件事情
- ⏱ 2023-06-01 09:45:49

1.3 线程通知与等待

划线评论

📌 在如上代码中假如生产者线程A首先通过synchronized获取到了queue上的锁，那么后续所有企图生产元素的线程和消费线程将会在获取该监视器锁的地方被阻塞挂起。线程A获取锁后发现当前队列已满会调用queue.wait（）方法阻塞自己，然后释放获取的queue上的锁，这里考虑下为何要释放该锁？如果不释放，由于其他生产者线程和所有消费者线程都已经被阻塞挂起，而线程A也被挂起，这就处于了死锁状态。这里线程A挂起自己后释放共享变量上的锁，就是为了打破死锁必要条件之一的持有并等待原则。关于死锁后面的章节会讲。线程A释放锁后，其他生产者线程和所有消费者线程中会有一个线程获取queue上的锁进而进入同步块，这就打破了死锁状态。
- 💭 简单来说就是生产者线程在获取到监视器锁后如果发现当前的人消费队列已满就会阻塞挂起并释放监视器锁,避免进入死锁状态
- ⏱ 2023-06-01 10:08:30

划线评论

📌 如果调用wait（）方法的线程没有事先获取该对象的监视器锁，则调用wait（）方法时调用线程会抛出IllegalMonitorStateException异常。
- 💭 这是为了避免最后执行结果与预期不符
- ⏱ 2023-06-01 09:51:58

1.11 ThreadLocal

划线评论

📌 Thread类中有一个threadLocals和一个inheritableThreadLocals
- 💭 其中threadLocals中存放的的是由ThreadLocal通过set方法放入的value,因为它是ThreadLocalMap类型,是一个定制化的HashMap,它可一个关联多个ThreadLocal变量
- ⏱ 2023-06-02 11:16:03

2.5 Java中的synchronized关键字

划线评论

📌 进入synchronized块的内存语义是把在synchronized块内使用到的变量从线程的工作内存中清除，这样在synchronized块内使用到该变量时就不会从线程的工作内存中获取，而是直接从主内存中获取。退出synchronized块的内存语义是把在synchronized块内对共享变量的修改刷新到主内存。
- 💭 进入synchronize块时会将使用的的变量从工作线程中清除，使得获取变量需要从主内存获取。退出时将块内的共享变量的修改刷新的主内存中
- ⏱ 2023-05-27 10:37:14

2.6 Java中的volatile关键字

划线评论

📌 那么一般在什么时候才使用volatile关键字呢？● 写入变量值不依赖变量的当前值时。因为如果依赖当前值，将是获取—计算—写入三步操作，这三步操作不是原子性的，而volatile不保证原子性。● 读写变量值时没有加锁。因为加锁本身已经保证了内存可见性，这时候不需要把变量声明为volatile的。
- 💭 在单例模式下使用volatile关键字保证变量的可见性
- ⏱ 2023-05-27 11:02:42

划线评论

📌 那么一般在什么时候才使用volatile关键字呢？● 写入变量值不依赖变量的当前值时。因为如果依赖当前值，将是获取—计算—写入三步操作，这三步操作不是原子性的，而volatile不保证原子性。● 读写变量值时没有加锁。因为加锁本身已经保证了内存可见性，这时候不需要把变量声明为volatile的。
- 💭 例如可以使用volatile关键字修饰用来表示状态的共享值，由需要使用这一变量的线程监控这个值，当值修改时线程根据逻辑进行相应的变化如退出等等。
- ⏱ 2023-05-27 11:00:12

划线评论

📌 当线程写入了volatile变量值时就等价于线程退出synchronized同步块（把写入工作内存的变量值同步到主内存），读取volatile变量值时就相当于进入同步块（先清空本地内存变量值，再从主内存获取最新值）。
- 💭 但是synchronize是独占锁同时只有一个线程能够读取或者写入修饰的共享变量，同时其他的调用线程会被阻塞，同时也存在着线程上下文切换和线程重新调度的开销。而volatile关键字是非阻塞的，不会造成线程上下文切换的开销，但是volatile关键字不保证操作的原子性。
- ⏱ 2023-05-27 10:52:38

划线评论

📌 当一个变量被声明为volatile时，线程在写入变量时不会把值缓存在寄存器或者其他地方，而是会把值刷新回主内存。当其他线程读取该共享变量时，会从主内存重新获取最新值，而不是使用当前线程的工作内存中的值。
- 💭 由volatile关键字修饰的变量在线程写入时会直接将值刷入主内存中，而当其他线程读取这个共享变量时会直接从主内存中获取最新值，而不是当前线程工作内存中的值
- ⏱ 2023-05-27 10:46:49

2.7 Java中的原子性操作

划线评论

📌 所谓原子性操作，是指执行一系列操作时，这些操作要么全部执行，要么全部不执行，不存在只执行其中一部分的情况。
- 💭 除不可控制因素外
- ⏱ 2023-05-27 11:05:51

2.8 Java中的CAS操作

划线评论

📌 CAS即Compare and Swap，其是JDK提供的非阻塞原子性操作，它通过硬件保证了比较—更新操作的原子性
- 💭 CAS是通过CPU提供的原子性操作指令实现的，当一个线程执行CAS操作时它会先读取内存中的值，然后将需要修改的值与内存中的值进行比较。如果两个值相等就会将新值写入内存并返回操作成功，否则失败不进行任何修改。当多个线程同时执行CAS操作时只有一个会成功，而其他的均失败且不会改变目标的值。因此CAS通过不可中断的原子性CPU指令和等待策略保证了非阻塞原子性操作
- ⏱ 2023-05-28 15:44:46

2.10 Java指令重排序

划线评论

📌 Java内存模型允许编译器和处理器对指令重排序以提高运行性能，并且只会对不存在数据依赖性的指令重排序。
- 💭 指令重排可以保证单线程下最终执行结果与预想结果一致，但是无法保证多线程最终结果与执行结果一致
- ⏱ 2023-05-28 16:02:49

2.12 锁的概述

划线评论

📌 乐观锁并不会使用数据库提供的锁机制，一般在表中添加version字段或者使用业务状态来实现。乐观锁直到提交时才锁定，所以不会产生任何死锁。
- 💭 乐观锁通过添加version字段来保证并发状态下只有一个线程能够成功执行，在线程修改数据库内容前会先查询相应数据并获取到version字段，在提交修改时通过检查version字段是否正确来判断数据是否已被修改，如果被修改则执行失败或者重试
- ⏱ 2023-05-28 16:19:52

3.2 ThreadLocalRandom

划线评论

📌 如果每个线程都维护一个种子变量，则每个线程生成随机数时都根据自己老的种子计算新的种子，并使用新种子更新老的种子，再根据新种子计算随机数，就不会存在竞争问题了，这会大大提高并发性能
- 💭 ThreadLocalRandom通过每个线程都维护一个种子的方式解决了Random因为原子性种子变量导致的竞争问题，大大提高了并发性能
- ⏱ 2023-05-28 16:44:00

4.2 JDK 8新增的原子操作类LongAdder

划线评论

📌 JDK 8新增了一个原子性递增或者递减类LongAdder用来克服在高并发下使用AtomicLong的缺点
- 💭 LongAdder通过将变量分解为多个变量,让多个线程去竞争多个资源解决性能问题
- ⏱ 2023-05-28 17:14:01

本书评论

Java从入门到精通（第6版）

2023-07-02T03:21:50Z

元数据

[!abstract] Java从入门到精通（第6版）

书名： Java从入门到精通（第6版）

作者：明日科技

简介：《Java从入门到精通（第6版）》从初学者角度出发，通过通俗易懂的语言、丰富多彩的实例，详细讲解了使用Java语言进行程序开发需要掌握的知识。全书分为23章，内容包括初识Java，熟悉Eclipse开发工具，Java语言基础，流程控制，数组，类和对象，继承、多态、抽象类与接口，包和内部类，异常处理，字符串，常用类库，集合类，枚举类型与泛型，lambda表达式与流处理，I/O（输入/输出），反射与注释，数据库操作，Swing程序设计，Java绘图，多线程，网络通信，奔跑吧小恐龙，MR人脸识别打卡系统。书中所有知识都结合具体实例进行讲解，涉及的程序代码都给出了详细的注释，可以使读者轻松领会Java程序开发的精髓，快速提高开发技能。

出版时间 2021-07-01 00:00:00

ISBN： 9787302581260

分类：计算机-编程设计

出版社：清华大学出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

第9章异常处理

📌 Java语言的异常捕获结构由try、catch和finally 3部分组成。其中，try语句块存放的是可能发生异常的Java语句；catch语句块在try语句块之后，用来激发被捕获的异常；finally语句块是异常处理结构的最后执行部分，无论try语句块中的代码如何退出，都将执行finally语句块。
- ⏱ 2023-06-09 08:36:38
📌 Java异常强制用户去考虑程序的强健性和安全性。异常处理不应用来控制程序的正常流程，其主要作用是捕获程序在运行时发生的异常并进行相应的处理。
- ⏱ 2023-06-09 09:08:12

第14章 lambda表达式与流处理

📌 因为lambda抽象（lambda abstraction）表示一个匿名的函数，于是开发语言也将lambda表达式用来表示匿名函数，也就是没有函数名字的函数
- ⏱ 2023-04-02 21:54:31
📌 函数式接口指的是仅包含一个抽象方法的接口
- ⏱ 2023-04-02 21:56:07
📌 lambda表达式无法更改局部变量的值
- ⏱ 2023-04-02 21:58:44
📌 lambda表达式只能调用局部变量，却不能改变其值。
- ⏱ 2023-04-02 21:59:23
📌 lambda表达式只是描述了抽象方法是如何实现的，在抽象方法没有被调用前，lambda表达式中的代码并没有被执行，所以运行抽象方法之前类成员变量的值不会发生变化。
- ⏱ 2023-04-02 22:01:38
📌 但是lambda表达式中并没有抛出异常的语法，这是因为lambda表达式会默认抛出抽象方法原有的异常，当此方法被调用时则需要进行异常处理。
- ⏱ 2023-04-02 22:02:00
📌 Optional类像是一个容器，可以保存任何对象，并且针对NullPointerException空指针异常做了优化，保证Optional类保存的值不会是null
- ⏱ 2023-04-02 22:20:17

读书笔记

第14章 lambda表达式与流处理

划线评论

📌 局部变量在lambda表达式中默认被定义为final（静态）的
- 💭 被final修饰的变量无法改变值或者地址指向
- ⏱ 2023-04-02 22:00:21

本书评论

Java 8函数式编程

2023-07-02T03:21:50Z

元数据

[!abstract] Java 8函数式编程

书名： Java 8函数式编程

作者： Richard Warburton

简介：多年以来，函数式编程被认为是少数人的游戏，不适合推广给普罗大众。写作此书的目的就是为了挑战这种思想。本书将探讨如何编写出简单、干净、易读的代码；如何简单地使用并行计算提高性能；如何准确地为问题建模，并且开发出更好的领域特定语言；如何写出不易出错，并且更简单的并发代码；如何测试和调试Lambda表达式。如果你已经掌握Java SE，想尽快了解Java 8新特性，写出简单干净的代码，那么本书不容错过。

出版时间 2015-03-30 00:00:00

ISBN： 9787115384881

分类：计算机-编程设计

出版社：人民邮电出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

1.1 为什么需要再次修改Java

📌 面向对象编程是对数据进行抽象，而函数式编程是对行为进行抽象。
- ⏱ 2023-03-30 23:45:29

1.2 什么是函数式编程

📌 在思考问题时，使用不可变值和函数，函数对一个值进行处理，映射成另一个值
- ⏱ 2023-03-30 23:46:15

2.1 第一个Lambda表达式

📌 在Lambda表达式中无需指定类型，程序依然可以编译。这是因为javac根据程序的上下文（addActionListener方法的签名）在后台推断出了参数event的类型
- ⏱ 2023-03-31 10:39:48
📌 参数类型不言而明，则无需显式指定
- ⏱ 2023-03-30 23:53:23

2.2 如何辨别Lambda表达式

📌 Lambda表达式的主体不仅可以是一个表达式，而且也可以是一段代码块，使用大括号（{}）将代码块括起来
- ⏱ 2023-03-30 23:56:03
📌 变量add的类型是BinaryOperator，它不是两个数字的和，而是将两个数字相加的那行代码。
- ⏱ 2023-03-30 23:58:32
📌 目标类型是指Lambda表达式所在上下文环境的类型
- ⏱ 2023-03-31 00:00:52
📌 Lambda表达式的类型依赖于上下文环境，是由编译器推断出来的
- ⏱ 2023-03-31 00:00:58

2.3 引用值，而不是变量

📌 如果你曾使用过匿名内部类，也许遇到过这样的情况：需要引用它所在方法里的变量。这时，需要将变量声明为final
- ⏱ 2023-03-31 00:01:35

2.4 函数接口

📌 使用只有一个方法的接口来表示某特定方法并反复使用
- ⏱ 2023-03-31 00:13:56
📌 接口中单一方法的命名并不重要，只要方法签名和Lambda表达式的类型匹配即可
- ⏱ 2023-03-31 00:15:48

2.5 类型推断

📌 如果将构造函数直接传递给一个方法，也可根据方法签名来推断类型
- ⏱ 2023-03-31 00:19:39
📌 Predicate——用来判断真假的函数接口。
- ⏱ 2023-03-31 00:24:00

3.2 实现机制

📌 判断一个操作是惰性求值还是及早求值很简单：只需看它的返回值。如果返回值是Stream，那么是惰性求值；如果返回值是另一个值或为空，那么就是及早求值。
- ⏱ 2023-04-23 09:02:17

3.3 常用的流操作

📌 collect(toList())方法由Stream里的值生成一个列表，是一个及早求值操作。
- ⏱ 2023-04-23 21:21:38
📌 如果有一个函数可以将一种类型的值转换成另外一种类型，map操作就可以使用该函数，将一个流中的值转换成一个新的流。
- ⏱ 2023-04-23 21:43:04
📌 遍历数据并检查其中的元素时，可尝试使用Stream中提供的新方法filter
- ⏱ 2023-04-23 21:53:29

读书笔记

2.3 引用值，而不是变量

划线评论

📌 换句话说，Lambda表达式引用的是值，而不是变量。
- 💭 lambda表达式引用的不是变量，而是在编译中就知道内容的值
- ⏱ 2023-03-31 00:08:16

本书评论

Go语言精进之路：从新手到高手的编程思想、方法和技巧1

2023-07-02T03:21:50Z

元数据

[!abstract] Go语言精进之路：从新手到高手的编程思想、方法和技巧1

书名： Go语言精进之路：从新手到高手的编程思想、方法和技巧1

作者：白明

简介： Go入门容易，精进难，如何才能像Go开发团队那样写出符合Go思维和语言惯例的高质量代码呢？本书将从编程思维和实践技巧2个维度给出答案，帮助你在Go进阶的路上事半功倍。编程思维层面：只有真正领悟了一门语言的设计哲学和编程思维，并能将之用于实践，才算精通了这门语言。本书从Go语言设计者的视角对Go背后的设计哲学和编程思想进行了梳理和分析，指引读者体会那些看似随意实则经过深思熟虑的设计背后的秘密。实践技巧层面：实践技巧源于对Go开发团队和Go社区开发的高质量代码的阅读、挖掘和归纳，从项目结构、代码风格、语法及其实现、接口、并发、同步、错误与异常处理、测试与调试、性能优化、标准库、第三方库、工具链、最佳实践、工程实践等多个方面给出了改善Go代码质量、写出符合Go思维和惯例的代码的有效实践。学完这本书，你将拥有和Go专家一样的编程思维，写出符合Go惯例和风格的高质量代码，从众多Go初学者中脱颖而出，快速实现从Go新手到专家的转变！

出版时间 2022-01-01 00:00:00

ISBN： 9787111698210

分类：计算机-编程设计

出版社：机械工业出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

3.2 偏好组合，正交解耦

📌 C++、Java等主流面向对象（以下简称OO）语言通过庞大的自上而下的类型体系、继承、显式接口实现等机制将程序的各个部分耦合起来，但在Go语言中我们找不到经典OO的语法元素、类型体系和继承机制，或者说Go语言本质上就不属于经典OO语言范畴。
- ⏱ 2023-03-22 12:22:33
📌 Go语言遵从的设计哲学也是组合。
- ⏱ 2023-03-22 16:16:30
📌 Go采用了组合的方式，也是唯一的方式。
- ⏱ 2023-03-22 16:17:24
📌 Go语言提供的最为直观的组合的语法元素是类型嵌入（type embedding）。通过类型嵌入，我们可以将已经实现的功能嵌入新类型中，以快速满足新类型的功能需求。
- ⏱ 2023-03-22 16:18:22
📌 在通过新类型实例调用方法时，方法的匹配取决于方法名字，而不是类型
- ⏱ 2023-03-22 16:24:19
📌 // $GOROOT/src/sync/pool.gotype poolLocal struct { private interface{} shared []interface{} Mutex pad [128]byte}我们在poolLocal这个结构体类型中嵌入了类型Mutex，被嵌入的Mutex类型的方法集合会被提升到外面的类型（poolLocal）中。比如，这里的poolLocal将拥有Mutex类型的Lock和Unlock方法。但在实际调用时，方法调用会被传给poolLocal中的Mutex实例。
- ⏱ 2023-03-22 16:26:40
📌 通过在interface的定义中嵌入interface类型来实现接口行为的聚合，组成大接口，这种方式在标准库中尤为常用，并且已经成为Go语言的一种惯用法。
- ⏱ 2023-03-22 16:27:53
📌 隐式的interface实现会不经意间满足依赖抽象、里氏替换、接口隔离等设计原则
- ⏱ 2023-03-22 16:28:28
📌 组合原则的应用塑造了Go程序的骨架结构。类型嵌入为类型提供垂直扩展能力，interface是水平组合的关键，
- ⏱ 2023-03-22 16:34:04

3.3 原生并发，轻量高效

📌 并发是有关结构的，而并行是有关执行的。
- ⏱ 2023-03-22 16:34:48
📌 用户层轻量级线程或者说是类协程（coroutine）
- ⏱ 2023-03-22 16:39:15
📌 Go运行时默认为每个goroutine分配的栈空间仅2KB。goroutine调度的切换也不用陷入（trap）操作系统内核层完成，代价很低
- ⏱ 2023-03-22 16:39:37
📌 所有的Go代码都在goroutine中执行，哪怕是Go的运行时代码也不例外。
- ⏱ 2023-03-22 16:40:21
📌 而将这些goroutine按照一定算法放到CPU上执行的程序就称为goroutine调度器（goroutine scheduler）
- ⏱ 2023-03-22 16:41:04
📌 并发goroutine的通信：通过语言内置的channel传递消息或实现同步，并通过select实现多路channel的并发控制。
- ⏱ 2023-03-22 16:46:04
📌 并发程序的结构设计不要局限于在单核情况下处理能力的高低，而要以在多核情况下充分提升多核利用率、获得性能的自然提升为最终目的。
- ⏱ 2023-03-22 16:53:43
📌 goroutine各自执行特定的工作，通过channel+select将goroutine组合连接起来
- ⏱ 2023-03-22 16:54:01

3.4 面向工程，“自带电池”

📌 首字母大小写定义标识符可见性，这是Go的一个创新
- ⏱ 2023-03-22 17:12:54

4.3 Go语言原生编程思维

📌 我们学习和使用一门编程语言，目标是用这门语言的原生思维方式编写高质量代码。
- ⏱ 2023-03-23 11:46:45

5.1 Go项目的项目结构

📌 1）代码构建的脚本源文件放在src下面的顶层目录下。2）src下的二级目录cmd下面存放着Go工具链相关的可执行文件（比如go、gofmt等）的主目录以及它们的main包源文件。
- ⏱ 2023-03-23 11:50:16
📌 3）src下的二级目录pkg下面存放着上面cmd下各工具链程序依赖的包、Go运行时以及Go标准库的源文件。
- ⏱ 2023-03-23 11:51:27

5.2 Go语言典型项目结构

📌 在Go典型项目中，项目构建工具的脚本一般放在项目顶层目录下，比如这里的Makefile；对于构建脚本较多的项目，也可以建立build目录，并将构建脚本的规则属性文件、子构建脚本放入其中。
- ⏱ 2023-03-23 11:59:41

读书笔记

3.3 原生并发，轻量高效

划线评论

📌 并发是有关结构的，它是一种将一个程序分解成多个小片段并且每个小片段都可以独立执行的程序设计方法；并发程序的小片段之间一般存在通信联系并且通过通信相互协作。
并行是有关执行的，它表示同时进行一些计算任务。
- 💭 并发是结构性的，它是将一个大服务拆分成多个小服务，这些小服务互相协作去完成一个复杂的逻辑实现。类似于工厂流水线，原料生产后将原料储存在原料仓库，部件生产流水线将材料从原料仓库取出生产部件，部件生产完成后放入部件仓库。组装流水线将部件材料从部件仓库中取出，将部件组装完成。这些步骤都可以同时进行，由此形成一个完整的业务逻辑
- ⏱ 2023-03-22 17:01:25

本书评论

阿米巴经营

2023-07-02T03:21:50Z

元数据

[!abstract] 阿米巴经营

书名：阿米巴经营

作者：陈伟编著

简介：《阿米巴经营》是通过一个个小集体的独立核算来实现全员参与经营、凝聚全体员工力量和智慧的经营管理系统。阿米巴经营模式的诞生历程颇有戏剧性。阿米巴经营模式经过数十年发展，早已走出日本，走向世界。国内外许多企业都借鉴阿米巴经营哲学来推动组织变革，并适应互联网时代的市场环境。本书系统地讲述了阿米巴经营模式的经营哲学、组织划分、配套措施、内部交易制度、会计核算制度、阿米巴长选拔制度、团队目标管理、多元化激励制度、经营误区等相关知识，旨在让有志于从事企业经营管理工作的朋友了解阿米巴经营的各方面知识。

出版时间 2019-05-01 00:00:00

ISBN： 9787513924405

分类：经济理财-商业

出版社：民主与建设出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

克服大企业病，人人参与经营

📌 机构臃肿既增加了管理成本，又降低了工作效率，且积重难返
- ⏱ 2023-05-18 23:37:18

读书笔记

本书评论

投资中最简单的事（更新版）

2023-07-02T03:21:50Z

元数据

[!abstract] 投资中最简单的事（更新版）

书名：投资中最简单的事（更新版）

作者：邱国鹭

简介：投资本身是一件很复杂的事，我们是否可以化繁为简、直接追问什么才是投资的本质？有没有一些简单可行的法则和工具能够让我们直接触及投资的本质？《投资中最简单的事》（更新版）为读者呈现的正是符合投资的内核和本质的、与时俱进的普适性规律，这些规律不会因为时间的流逝而有所淡化，相反，自本书第一版面世5年来，这些规律经过了时间的检验和市场的充分验证，更新版不仅在第一版的基础上新增了作者当下的思考，还对于那些反复被证明有效的规律进行了拓展和完善。高毅资产董事长邱国鹭从多年投资的自身经验出发，剖析了“便宜才是硬道理”“定价权是核心竞争力”“人弃我取，逆向投资”“投资应该数月亮，胜而后求战”等简单易行的投资原则，阐明了“对于大多数人而言，只有价值投资才是真正可学、可用、可掌握的”这一观点，分享了易于普通投资者学习、操作的投资方法。在对“投资中最简单的事”娓娓道来的过程中，作者用生动晓畅的语言分享了自己投资生涯中的丰富投资实例，使本书兼具了易读性与实操性。

出版时间 2020-03-31 00:00:00

ISBN： 9787513660389

分类：经济理财-财经

出版社：中国经济出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

第一部分投资理念

📌 股价的短期起伏，反映的只是看客们的情绪波动，与企业价值无关
- ⏱ 2023-05-13 01:08:25
📌 做生意的最终目的是赚取现金流。
- ⏱ 2023-05-13 10:55:55
📌 互联网的本质是“人生人”，优势在于能以极低成本服务无数客户，规模效应体现在“人多”，“二八”现象不明显，是典型的散户经济，得散户者得天下。
- ⏱ 2023-05-13 11:03:23
📌 投资制造业时更应关注工程机械、核心汽配、白色家电这样的寡头行业。
- ⏱ 2023-05-13 11:12:48

读书笔记

本书评论

富爸爸穷爸爸（20周年修订版）

2023-07-02T03:21:50Z

元数据

[!abstract] 富爸爸穷爸爸（20周年修订版）

书名：富爸爸穷爸爸（20周年修订版）

作者：罗伯特·清崎

简介：清崎有两个爸爸：“穷爸爸”是他的亲生父亲，一个高学历的教育官员；“富爸爸”是他好朋友的父亲，一个高中没毕业却善于投资理财的企业家。清崎遵从“穷爸爸”为他设计的人生道路：上大学，服兵役，参加越战，走过了平凡的人生初期。直到1977年，清崎亲眼目睹一生辛劳的“穷爸爸”失了业，“富爸爸”则成了夏威夷的有钱人。清崎毅然追寻“富爸爸”的脚步，踏入商界，从此登上了致富快车。
清崎以亲身经历的财富故事展示了“穷爸爸”和“富爸爸”截然不同的金钱观和财富观：穷人为钱工作，富人让钱为自己工作！
本次20周年修订版还在内容上做了以下几项升级：
1.内附作者罗伯特·清崎的来信
2.“20年后的今天”贯穿全书，以今天的经济形势来印证富爸爸当初的理念
3.核心思想提炼，方便回味经典、巩固记忆
4.融入新型学习模式，让你对本书的理解更高效
本书两大特点：
真实：书中的很多理念和方法都是作者和许多富爸爸读者亲身实践和印证过的。
易懂：无论您的财务状况属于什么水平，都能从这本书中得到一些有益的启迪。

通过本书您将了解以下四个问题的答案：

为什么富人从不为钱工作
什么是资产
为什么致富很简单却很少人富有
普通人也可以通过投资和创业致富吗

出版时间 2017-09-01 00:00:00

ISBN： 9787220102912

分类：经济理财-理财

出版社：四川人民出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

后见之明 20年后的今天

📌 实际上，富人们只是在拯救自己，并没有将穷人和中产阶级拉上被拯救的列车。
- ⏱ 2023-06-28 23:08:15
📌 “你的房子并非资产”。
- ⏱ 2023-06-28 23:08:51

序言

📌 那就是一个人的观念对他的一生影响巨大。
- ⏱ 2023-06-28 23:18:00
📌 贫穷和破产的区别是：破产是暂时的，而贫穷是永久的。
- ⏱ 2023-06-28 23:22:12

第一课富人不为钱工作

📌 如果你不能下定决心，就永远也学不会如何赚钱。机会总是转瞬即逝。知道什么时候要迅速做出决定是一项非常重要的技能
- ⏱ 2023-06-28 23:35:35
📌 大多数时候，生活不会和你说什么，它只是推着你转，每一次推，它都像是在说：‘喂，醒一醒，我要让你学点东西。’”
- ⏱ 2023-06-28 23:40:49
📌 假如你学会了生活这门课程，做任何事情你都会游刃有余。如果你学不会，生活照样会推着你转。人们通常会做两件事，一些人在生活推着他转的同时，抓住生活赐予的每个机会；而另一些人则非常生气，去与生活抗争。他们与老板抗争，与工作抗争，甚至与自己的配偶抗争，他们不知道生活同时也给了他们机会。”
- ⏱ 2023-06-28 23:41:51
📌 而书籍学习在现实世界中越来越没价值，大学教育不再能保证一份工作。
- ⏱ 2023-06-28 23:47:11
📌 只有你知道，在你内心深处，你始终认为你不可能赢，所以你选择了稳定
- ⏱ 2023-06-28 23:47:54
📌 有些人会这么做。但他们所做的也只是等待，等待加薪，因为他们认为更多的钱能解决问题。大部分人接受这样的工资，还有一些人会再找一份工作，仍旧干得很努力，但仍只能得到很少的报酬。
- ⏱ 2023-06-28 23:50:33
📌 购买或创造提供现金流的资产能使你的钱为你工作。高薪工作只意味着两件事：你在为钱工作，你所支付的税收可能会增加。我已经学会了让钱为我工作，让税收优惠产生收入，而不是薪水。
- ⏱ 2023-06-28 23:52:57
📌 大多数人都希望稳稳妥妥地挣钱，这样他们才感到安全。关于钱，他们没有激情，有的只是恐惧。
- ⏱ 2023-06-28 23:53:47
📌 对大多数人而言，给他们的钱越多，他们欠的债也就越多。
- ⏱ 2023-06-28 23:54:06
📌 人们的生活永远被这两种感觉所控制：恐惧和贪婪。
- ⏱ 2023-06-29 00:00:54
📌 恐惧使他们落入工作的陷阱，挣钱——工作——挣钱，希望恐惧就此烟消云散
- ⏱ 2023-06-29 00:03:11
📌 正是因为有感情，我们才成为人。感情是我们行动的动力。忠实于你的感情，以你喜欢的方式运用你的头脑和感情，不要让它们控制你
- ⏱ 2023-06-29 00:18:38
📌 好好观察你的感情，别急于行动。大多数人并不知道是他们的感情代替了他们进行思考，感情只是感情，你还必须学会抛开感情来思考
- ⏱ 2023-06-29 00:19:02
📌 从现在开始，对你们来说最重要的是，运用感情作长远打算，别让感情控制了思想
- ⏱ 2023-06-29 00:22:05
📌 他说一个人一旦停止了解有关自己的知识和信息，就会变得无知
- ⏱ 2023-06-29 00:23:19
📌 永远不要忘记，恐惧和欲望，如果你让它们来控制你的思想，你就会落入一生中最大的陷阱。一直生活在恐惧中，从不追求自己的梦想，这是残酷的。为钱拼命工作，以为钱能买来快乐，这也是残酷的。
- ⏱ 2023-06-29 00:24:19
📌 精于计算是重要的，我希望更多的人能够懂得它，但这并不是全部。”
- ⏱ 2023-06-29 00:26:38
📌 我失去了什么
- ⏱ 2023-06-29 00:29:27
📌 富人知道钱是虚幻的东西，就像挂在驴子面前的胡萝卜一样。正是恐惧和贪婪使无数人紧抓着这个幻觉不放，还以为它是真实的。它不是。钱的确是造出来的，正是由于对这种幻觉的信任以及人们的无知才使人们做出许多经不起推敲的计划。
- ⏱ 2023-06-29 00:30:43

第二课为什么要教授财务知识

📌 只有知识才能解决问题并创造财富，那些不是靠财务知识挣来的钱也不会长久。
- ⏱ 2023-06-29 01:08:54
📌 重要的不是你挣了多少钱，而是你能留下多少钱，以及能够留住多久。
- ⏱ 2023-06-29 01:10:00
📌 你必须明白资产和负债的区别，并且购买资产。
- ⏱ 2023-06-29 01:12:15
📌 资产是能把钱放进我口袋里的东西。负债是把钱从我口袋里取走的东西。
- ⏱ 2023-06-29 01:14:44
📌 关键不是数字，而是数字要告诉你的东西。它的作用就像词语一样，虽然它不是词语，但它能告诉你词语不能告诉你的东西。
- ⏱ 2023-06-29 01:15:24
📌 其他事也一样能借助“镜子”来看清，如运动、社会关系、职业和金钱等。
- ⏱ 2023-06-29 01:29:05
📌 大多数人的财务困境是由于随大流、盲目地跟从其他人所造成的。
- ⏱ 2023-06-29 01:29:32
📌 钱能使决策变得情绪化。
- ⏱ 2023-06-29 01:32:49
📌 最大的损失是致富机会的损失。如果你所有的钱都投在了房子上，你就不得不努力工作，因为你的现金正不断地从支出项流出，而不是流入资产项，这是典型的中产阶级现金流模式
- ⏱ 2023-06-29 01:34:22
📌 没有财务报表，你就不会知道你在财务游戏中的位置
- ⏱ 2023-06-29 01:35:36
📌 财富就是支撑一个人生存多长时间的能力，或者说，如果我今天停止工作，我还能活多久？
- ⏱ 2023-06-29 01:43:31
📌 如果我想增加支出，就必须先增加资产项产生的现金来维持我的财富水平
- ⏱ 2023-06-29 01:45:31

第三课关注自己的事业

📌 只有你把额外的收入用来购买可产生收入的资产，你才能获得真正的财务安全。
- ⏱ 2023-06-29 02:11:08
📌 对成年人而言，把支出保持在低水平、减少借款并勤劳地工作会帮你打下一个稳固的资产基础。对于还未经济独立的年轻人来说，父母应该教他们搞清楚资产和负债的区别，让他们在离家、结婚、买房子、生孩子、陷入财务危机、完全依赖工作和贷款之前建立起坚实的资产基础，这是非常重要的。
- ⏱ 2023-06-29 02:14:14
📌 如果我必须在那儿工作，那它就不是我的事业而是我的职业了。
- ⏱ 2023-06-29 02:15:03

第四课税收的历史和公司的力量

📌 他总在提醒我知识就是力量，而且钱越多，就越需要知识管理它，使它继续增加。
- ⏱ 2023-06-29 15:55:16
📌 公司可以做许多个人无法做的事，例如：用税前收入支付开支
- ⏱ 2023-06-29 16:10:34

第五课富人的投资

📌 我意识到过分的害怕和自我怀疑是毁掉我们才能的最大因素。
- ⏱ 2023-06-29 16:19:11
📌 。那些失去了工作或房子的人总在抱怨技术进步，抱怨经济状况不佳以及他们的老板。
- ⏱ 2023-06-29 16:21:34
📌 如果你清楚自己在做什么，就不是在赌博；如果你把钱投进一笔交易然后只是祈祷，才是在赌博
- ⏱ 2023-06-29 17:01:30
📌 寻找其他人都忽视的机会
- ⏱ 2023-06-29 17:15:09
📌 增加资金。
- ⏱ 2023-06-29 17:15:48
📌 把精明的人组织起来。
- ⏱ 2023-06-29 17:17:31

第六课学会不为钱工作

📌 经营一家公司最困难的就是对人员进行管理。
- ⏱ 2023-06-29 17:30:42
📌 还有另外一种可怕的管理理论是这样说的：“工人付出最大努力以免于被解雇，而雇主提供最低工资以防止工人辞职。
- ⏱ 2023-06-29 17:33:16
📌 我劝告年轻人在找工作时要看能从中学到什么，而不是只看能挣多少钱。
- ⏱ 2023-06-29 17:37:47
📌 “如果婴儿潮一代发现，在年老的时候并没有足够的钱来维生，他们会陷入绝望。”
- ⏱ 2023-06-29 17:39:44

读书笔记

序言

划线评论

📌 我的一个爸爸总是习惯说“我可付不起”，而另一个爸爸则禁止我们说这样的话，他坚持让我这样说：“我怎样才能付得起？”这两句话，一句是陈述句，另一句是疑问句。一句让你放弃，而另一句则促使你去想办法。
- 💭 在认知驱动中引用了这一部分
- ⏱ 2023-06-28 23:18:51

第一课富人不为钱工作

划线评论

📌 大多数人都希望有一份工资收入，因为他们都有恐惧和贪婪之心。一开始，没钱的恐惧会促使他们努力工作，得到报酬后，贪婪或欲望又让他们想拥有所有用钱能买到的好东西。于是就形成了一种模式。
- 💭 三点一线的工作生活
- ⏱ 2023-06-29 00:01:32

划线评论

📌 我没对我爸爸说我没工钱了，他是不会理解的，而且我也不想向他解释连我自己也没完全明白的事
- 💭 我也还没想明白
- ⏱ 2023-06-28 23:58:46

划线评论

📌 生活中的很多事情是我们无法控制的。我学会了专注于我所能控制的：我自己。如果事情必须改变，首先要改变的就是我自己。
- 💭 从做成功一件事开始
- ⏱ 2023-06-28 23:49:24

划线评论

📌 “生活推着我们所有的人，有些人放弃了，有些人在抗争。少数人学会了这门课程，取得了进步，他们欢迎生活来推动他们，对他们来说，这种推动意味着他们需要并愿意去学习一些东西。他们学习，然后取得进步。但大多数人放弃了，还有一部分人像你一样在抗争。”
- 💭 摆烂。现在在我们这一代流行的开摆就是一种对生活的放弃，大部分的同代人只会怨天尤人
- ⏱ 2023-06-28 23:46:05

划线评论

📌 我爸爸要我去争取应有的待遇。每小时至少应该得到25美分。爸爸说如果我得不到加薪，就应该立即辞职。
- 💭 这里表现穷爸爸只是将目光放在了工作时所得的金钱上，而忽略了这份工作的教育意义
- ⏱ 2023-06-28 23:39:04

讨论学习环节

划线评论

📌 你是否觉得大多数人都意识到了他们已深陷“老鼠赛跑”的陷阱中？为什么？
- 💭 我不这么认为，至少我目前处于的时代中依然是大部分人想着如何找一个稳定的好工作然后摆烂
- ⏱ 2023-06-29 01:04:01

划线评论

📌 富人或穷人，哪个更容易受到恐惧和贪婪的影响呢？为什么会这样想？
- 💭 到这里我的笔记方式也向着不对自己定性为穷人了，而是我目前是，但我会想办法去改变的
- ⏱ 2023-06-29 01:02:43

划线评论

📌 富人或穷人，哪个更容易受到恐惧和贪婪的影响呢？为什么会这样想？
- 💭 以目前的想法来说我认为是穷人。因为我自己目前是其中的一员，我害怕生活因为得不到工资而得不到保障，同时我也想要更高的工资而去学习。
- ⏱ 2023-06-29 01:01:30

划线评论

📌 你的生活中有没有追随情感做出反应的例子？什么时候你才能观察自己的情感，选择自己的想法？
- 💭 我曾经因为前公司迟迟不发工资而辞职，我会因为不满的情感去抗争，但是不会去思考。很多人包括领导都劝我不要这么做因为经济不景气，但是我依然辞职了。现在理性地想一想确实是被情感支配了，大部分时候我可能只能事后去观察自己的情感，这是我需要改正的地方。
- ⏱ 2023-06-29 00:58:56

划线评论

📌 你是否强烈地感觉更多的钱可以平复恐惧？为什么人们会有这样常见的反应？
- 💭 是的，更多的钱给我们心理上提供了安全保障，我会想我至少还有这么多钱对自己兜底
- ⏱ 2023-06-29 00:53:36

划线评论

📌 是恐惧驱使大部分人工作吗？还有没有其他的因素？
- 💭 不只是恐惧，还有对于丰富生活的欲望
- ⏱ 2023-06-29 00:52:06

划线评论

📌 如果支付你10美分每小时——然后一分钱也不给——你会跟罗伯特有一样的反应吗？
- 💭 会的，对于求知的欲望会让我顺从
- ⏱ 2023-06-29 00:51:03

划线评论

📌 罗伯特的富爸爸说真正的学习需要精力、激情和热切的愿望。你的人生之中有什么例子可以证明吗？让你最难忘的一课是什么？为什么？
- 💭 前一段时间对认知觉醒的阅读让我重拾了对学习的热情，但是我依然目标不是很明确
- ⏱ 2023-06-29 00:50:06

划线评论

📌 罗伯特的穷爸爸对钱的处理方法是不是很普遍？
- 💭 可以说我的的圈子里几乎都是这么处理的
- ⏱ 2023-06-29 00:48:01

划线评论

📌 罗伯特的穷爸爸对钱的处理方法是不是很普遍？
- 💭 是的
- ⏱ 2023-06-29 00:47:26

划线评论

📌 讨论学习环节

本章小结

- 💭 利用观察与想象力去创造金钱
- ⏱ 2023-06-29 00:36:14

讨论学习环节

划线评论

📌 如果你今天停止工作你还能生存多少天？这个数字是否让你感到惊讶或恐慌？
- 💭 停止工作没有父母的救济我活不过一天
- ⏱ 2023-06-29 02:00:31

划线评论

📌 你的生活中是否有某个时刻看起来是取得了一个小成就，比如晋升或者加薪，然而又没有带来资产负债表上你想要的结果？
- 💭 意外得到了一些金钱，但是我花光了他们
- ⏱ 2023-06-29 01:59:57

划线评论

📌 富爸爸告诉孩子们，在会计上，关键不是数字，而是数字要告诉你的东西。你生活中的数字又告诉了你什么？
- 💭 我生活中的数字告诉我我正在陷入困境中，我需要想办法摆脱这个困境
- ⏱ 2023-06-29 01:59:08

划线评论

📌 你是否同意这个观点：“大多数人的教育中缺少的不是如何挣钱，而是如何处理这些钱。”为什么？
- 💭 同意的，在我们的教育中都是以就职为目的的
- ⏱ 2023-06-29 01:58:14

划线评论

📌 除了你的房子，还有什么东西是你开始认为是资产后来证明是负债的？
- 💭 还有车子
- ⏱ 2023-06-29 01:57:13

划线评论

📌 哪种现金流情况更贴近你的生活？
- 💭 现在我处于失业状态，但以未失业时的现金流来看，我属于支出与工资收益对等的中产现金流
- ⏱ 2023-06-29 01:56:05

划线评论

📌 当罗伯特说到房子不是资产的时候你又是什么反应？你是否曾把自己的房子视为资产？当他进行充分论证后，你是否改变了想法？
- 💭 或许是现在房子太贵了，又或者是我的房子都是我父母送给我的，我对罗伯特的思想并没有排斥，反而是接受。我从来没有把房子视为升值的筹码，但是它的确是我资产的一部分，因为我只需要付出微不足道的钱来使用它
- ⏱ 2023-06-29 01:54:22

划线评论

📌 当你第一次读到罗伯特对于资产和负债的定义时是什么反应？
- 💭 与我预想资产和负债的定义相差不大
- ⏱ 2023-06-29 01:51:38

划线评论

📌 你的财务教育是从什么时候开始的？是从这本书开始的，还是其他的地方？
- 💭 我的财务教育是从这一本书开始的
- ⏱ 2023-06-29 01:50:52

第五课富人的投资

划线评论

📌 大部分人从来赢不了是因为他们太害怕失去，这也是我发现的学校教育的一大误区
- 💭 在影响力一书中提到过，人往往更害怕失去，大部分即便是需要付出代价，也不愿意失去，即便这个代价可能能够获得更多的利益
- ⏱ 2023-06-29 17:13:42

第六课学会不为钱工作

划线评论

📌 我一定会去学习一些有关广告文案和销售方面的课程。然后，
- 💭 我也可以试着去学习这方面的内容，为我的新书打好底子
- ⏱ 2023-06-29 17:25:23

本书评论

与罗摩相会

2023-07-02T03:21:50Z

元数据

[!abstract] 与罗摩相会

书名：与罗摩相会

作者：阿瑟·克拉克

简介：科幻历史上真正的神作。《与罗摩相会》是科幻三巨头阿瑟·克拉克代表作，横扫雨果奖、星云奖、轨迹奖、木星奖、英国科幻协会奖、约翰·坎贝尔纪念奖6项科幻至高大奖。阿瑟·克拉克与阿西莫夫、海因莱因一起并称为“20世纪科幻三巨头”，被誉为科幻小说之王。其一生创作100多部作品，被翻译成40多种语言，作品总销量破1亿册。阿瑟·克拉克被誉为20世纪伟大的太空预言家，他针对太空技术作出的许多预测都成为现实，地球静止卫星的轨道正是因为他而被命名为“克拉克轨道”。

出版时间 2018-06-01 00:00:00

ISBN： 9787559416551

分类：精品小说-科幻经典

出版社：江苏凤凰文艺出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

第一章太空卫士

📌 一百年前，世界远不及今日富裕，资源也更加匮乏，可人类却浪费了大量财富，用于拦截对准自己脑袋发射的、自相残杀的武器。
- ⏱ 2023-04-26 10:22:04

第三章罗摩和悉多

📌 即使是在二十二世纪，人们还是无力避免老朽又守旧的科学家占据关键的行政职位。
- ⏱ 2023-04-26 23:22:54

第五章首次出舱

📌 不过，也没道理认定罗摩上的时针和螺丝起子的转动方向跟地球上一样吧……
- ⏱ 2023-04-27 13:27:56

第六章委员会

📌 就算非得建在这里，那大概也该建到月球背面，地球上永远也看不到的一面……
- ⏱ 2023-04-27 13:28:30
📌 地球火星双重星籍
- ⏱ 2023-04-27 13:37:30
📌 而且两个文明的技术水平相差甚远，就好比皮萨罗[插图]之于印加古国，佩里[插图]之于幕府日本，欧洲之于非洲。
- ⏱ 2023-04-27 13:41:03
📌 这些接触，几乎无一例外都导致了灾难性的后果——有的只是一方的灾难，有的是两方都遭了殃。
- ⏱ 2023-04-27 13:41:24

第七章两个妻子

📌 这些家伙似乎做什么都要来个好事成三。
- ⏱ 2023-04-27 13:45:28

第八章穿过中轴区

📌 在这个位置，任何方向都是“下”，而不是上
- ⏱ 2023-04-27 15:37:30

第十章深入黑暗

📌 那空气中毫无养分，哪怕是在珠穆朗玛峰上住惯了的高原居民，在这里也会很快死去。
- ⏱ 2023-04-30 00:52:48

第十一章男人、女人和猴子

📌 任何暧昧的关系都有可能影响士气，因为这样一来几乎不可避免地会引起偏袒。
- ⏱ 2023-04-30 01:05:18

第十五章海边

📌 有一回，厄恩斯特觉得自己脸颊上似乎感受到了一丝微风。
- ⏱ 2023-04-30 10:50:59

第十六章凯阿拉凯夸湾

📌 “你曾经见过我的医务官劳拉·厄恩斯特——”他犹豫着停了下来，劳拉见过他的一位妻子，可是是哪一位？还是别说这个了——
- ⏱ 2023-04-30 10:54:55

第十七章春天

📌 自然条件下不会一丝声音都没有，人类的所有感官都需要接收到信息。如果失去了这些感知，人的意识就会自行制造出替代品。
- ⏱ 2023-05-02 00:55:13

第二十九章第一次接触

📌 在罗摩内部行走最怪异的事情之一就是，你可以一直看见你的目的地。
- ⏱ 2023-06-11 17:43:03

读书笔记

第四章会合

划线评论

📌 诺顿船长
- 💭 想起了诺顿皇帝
- ⏱ 2023-04-27 09:58:58

第十一章男人、女人和猴子

划线评论

📌 因为笨笨十分乐意每天工作十五个小时，而且不会因为工作重复琐碎而感到厌烦
- 💭 在解放一部分人的生产力时会由另一部分人或者非人承接这一部分生产力
- ⏱ 2023-04-30 01:09:17

本书评论

2018年4月1日

2023-07-02T03:21:50Z

元数据

[!abstract] 2018年4月1日

书名： 2018年4月1日

作者：刘慈欣

简介：著名科幻小说家，雨果奖获得者，刘慈欣老师的短篇科幻作品。

出版时间 1998-01-01 00:00:00

ISBN：

分类：精品小说-科幻经典

出版社：科幻世界杂志社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

📌 自我的概念本来就很可疑，构成自我的身体、记忆和意识都是在不断的变化中，与简简分别之前的我，以犯罪的方式付款之前的我，与主任交谈之前的我，甚至在打出这个“甚至”之前的我，都已经不是同一个人了，想到这里我很释然。
- ⏱ 2023-04-21 12:40:20

读书笔记

本书评论

微积分的力量

2023-07-02T03:21:50Z

元数据

[!abstract] 微积分的力量

书名：微积分的力量

作者：史蒂夫·斯托加茨

简介：微积分是人类历史上的伟大思想成就之一，也是数学领域不可或缺的一个重要分支。除此之外，我们更应该关注的事实是：如果没有微积分，人类就不可能发明电视、微波炉、移动电话、GPS、激光视力矫正手术、孕妇超声检查，也不可能发现冥王星、破解人类基因组、治疗艾滋病，以及弄明白如何把5000首歌曲装进口袋里。在《微积分的力量》书中，应用数学家兼“导游”斯托加茨将用一种“讲故事”和“看展览”的方式为你一一揭晓答案。“我们不必为了理解微积分的重要性而学习如何做运算，就像我们不必为了享用美食而学习如何做佳肴一样。我将借助图片、隐喻和趣闻逸事等，尝试解释你们需要了解的关于微积分的知识。我也会给你们介绍有史以来颇为精致的一些方程和证明，就像我们在参观画展的时候不会错过其中的代表作一样。”在高中和大学时期，尽管我们中的许多人都对这门课程退避三舍，但斯托加茨用一种新颖独特和接地气儿的方式给我们讲述了微积分的历史。

出版时间 2021-01-01 00:00:00

ISBN： 9787521723298

分类：科学技术-自然科学

出版社：中信出版集团

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

引言

📌 艾萨克·牛顿是最早瞥见这一宇宙奥秘的人。他发现行星的轨道、潮汐的韵律和炮弹的弹道都可以用一组微分方程来描述、解释和预测
- ⏱ 2023-04-27 09:53:18

读书笔记

本书评论

高性能MySQL（第4版）

2023-07-02T03:21:50Z

元数据

[!abstract] 高性能MySQL（第4版）

书名：高性能MySQL（第4版）

作者： Silvia Botros, Jeremy Tinley

简介：《高性能 MySQL》一直是 MySQL 领域的经典之作，影响了一代又一代的 DBA 和技术人员，从第3 版出版到第 4 版出版过去了近十年，MySQL 也从 5.5 版本更新到了 8.0 版本。第 4 版中增加了大量对 MySQL 5.7 和 8.0 版本新特性的介绍，删除了一些在新版本中已经废弃或者不再常用的功能，还增加了对云数据库的介绍，减少了在官方文档中已有的基础使用和配置相关的内容。这些年，MySQL 经过在大量大规模互联网场景中的应用验证，使得本书在继续关注高性能之外，还用了较多的篇幅来介绍如何实现 MySQL 的大规模可扩展应用和合规性问题，这是相比第 3 版最大的不同，也是本书封面上所写的“经过大规模运维验证的策略”的体现。本书适合数据库管理员（DBA）阅读，也适合系统运维和开发人员参考学习。不管你是数据库新手还是专家，相信都能从本书中有所收获。

出版时间 2022-09-01 00:00:00

ISBN： 9787121442575

分类：社会文化-社科

出版社：电子工业出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

第1章 MySQL架构

📌 MySQL解析查询以创建内部数据结构（解析树），然后对其进行各种优化，包括重写查询、决定表的读取顺序，以及选择合适的索引等。
- ⏱ 2023-05-01 22:19:16
📌 一个写锁既会阻塞读锁也会阻塞其他的写锁
- ⏱ 2023-04-03 11:04:25
📌 一种提高共享资源并发性的方式就是让锁定对象更有选择性。尽量只锁定包含需要修改的部分数据，而不是所有的资源。更理想的方式是，只对需要修改的数据片段进行精确的锁定。任何时候，让锁定的数据量最小化，理论上就能保证在给定资源上同时进行更改操作，只要被修改的数据彼此不冲突即可。问题是加锁也需要消耗资源。锁的各种操作，包括获取锁、检查锁是否空闲、释放锁等，都会增加系统的开销。如果系统花费大量的时间来管理锁，而不是存取数据，那么系统的性能可能会受影响。
- ⏱ 2023-05-01 22:31:13
📌 锁定策略是锁开销和数据安全性之间的平衡，这种平衡会影响性能
- ⏱ 2023-04-21 09:54:30
📌 。锁是数据库实现一致性保证的方法
- ⏱ 2023-04-21 09:54:49
📌 表锁(table lock)是MySQL中最基本也是开销最小的锁策略
- ⏱ 2023-04-21 09:55:12
📌 当客户端想对表进行写操作（插入、删除、更新等）时，需要先获得一个写锁，这会阻塞其他客户端对该表的所有读写操作。只有没有人执行写操作时，其他读取的客户端才能获得读锁，读锁之间不会相互阻塞。
- ⏱ 2023-04-21 09:55:32
📌 写锁队列和读锁队列是分开的，但写锁队列的优先级绝对高于读队列
- ⏱ 2023-04-21 09:56:41
📌 使用行级锁(row lock)可以最大程度地支持并发处理（也带来了最大的锁开销）
- ⏱ 2023-04-21 09:57:07
📌 行级锁是在存储引擎而不是服务器中实现的
- ⏱ 2023-04-21 09:57:37
📌 。事务就是一组SQL语句，作为一个工作单元以原子方式进行处理
- ⏱ 2023-04-21 09:58:58
📌 死锁是指两个或多个事务相互持有和请求相同资源上的锁，产生了循环依赖
- ⏱ 2023-04-21 10:05:54
📌 InnoDB目前处理死锁的方式是将持有最少行级排他锁的事务回滚（这是一种最容易回滚的近似算法）。
- ⏱ 2023-04-21 10:06:38
📌 死锁的产生有双重原因：有些是因为真正的数据冲突，这种情况通常很难避免，但有些则完全是由于存储引擎的实现方式导致的
- ⏱ 2023-04-21 10:07:00
📌 事务日志有助于提高事务的效率
- ⏱ 2023-04-21 10:08:47
📌 存储引擎只需要更改内存中的数据副本，而不用每次修改磁盘中的表，这会非常快。然后再把更改的记录写入事务日志中，事务日志会被持久化保存在硬盘上。因为事务日志采用的是追加写操作，是在硬盘中一小块区域内的顺序I/O，而不是需要写多个地方的随机I/O，所以写入事务日志是一种相对较快的操作。最后会有一个后台进程在某个时间去更新硬盘中的表。因此，大多数使用这种技术（write-ahead logging，预写式日志）的存储引擎修改数据最终需要写入磁盘两次。如果修改操作已经写入事务日志，那么即使系统在数据本身写入硬盘之前发生崩溃，存储引擎仍可在重新启动时恢复更改。具体的恢复方法则因存储引擎而异。
- ⏱ 2023-04-21 10:09:14
📌 默认情况下，单个INSERT、UPDATE或DELETE语句会被隐式包装在一个事务中并在执行成功后立即提交，这称为自动提交(AUTOCOMMIT)模式。通过禁用此模式，可以在事务中执行一系列语句，并在结束时执行COMMIT提交事务或ROLLBACK回滚事务。
- ⏱ 2023-04-21 10:11:38
📌 在当前连接中，可以使用SET命令设置AUTOCOMMIT变量来启用或禁用自动提交模式
- ⏱ 2023-04-21 10:11:24
📌 当启用AUTOCOMMIT时，也可以使用关键字BEGIN或者START TRANSACTION来开始一个多语句的事务
- ⏱ 2023-04-21 10:12:15
📌 MySQL不在服务器层管理事务，事务是由下层的存储引擎实现的
- ⏱ 2023-04-21 10:15:39
📌 InnoDB使用两阶段锁定协议(two-phase locking protocol)。在事务执行期间，随时都可以获取锁，但锁只有在提交或回滚后才会释放，并且所有的锁会同时释放。
- ⏱ 2023-04-21 10:28:39
📌 MySQL的大多数事务型存储引擎使用的都不是简单的行级锁机制。它们会将行级锁和可以提高并发性能的多版本并发控制(MVCC)技术结合使用。
- ⏱ 2023-05-01 22:05:09
📌 MVCC的工作原理是使用数据在某个时间点的快照来实现的。
- ⏱ 2023-04-24 08:54:48
📌 这意味着，无论事务运行多长时间，都可以看到数据的一致视图，也意味着不同的事务可以在同一时间看到同一张表中的不同数据！
- ⏱ 2023-04-24 08:55:15
📌 InnoDB通过为每个事务在启动时分配一个事务ID来实现MVCC。该ID在事务首次读取任何数据时分配。在该事务中修改记录时，将向Undo日志写入一条说明如何恢复该更改的Undo记录，并且事务的回滚指针指向该Undo日志记录。这就是事务如何在需要时执行回滚的方法。
- ⏱ 2023-04-21 12:37:47

第7章创建高性能的索引

📌 索引，在MySQL中也叫作键(key)，是存储引擎用于快速找到记录的一种数据结构。
- ⏱ 2023-05-13 17:38:33
📌 索引可以包含一列或多列的值。如果索引包含多列，那么列的顺序也十分重要，因为MySQL只能有效地使用索引的最左前缀列。
- ⏱ 2023-05-02 10:06:01
📌 在MySQL中，索引是在存储引擎层而不是服务器层实现的。
- ⏱ 2023-05-13 17:42:49
📌 NDB集群存储引擎虽然依然使用了BTREE标识，但在其内部实际上使用了T-tree结构存储这种索引，InnoDB则使用的是B+tree。
- ⏱ 2023-05-13 17:43:54
📌 B-tree索引能够加快数据访问的速度，这是因为有了索引，在查询某些条件的数据时，存储引擎不再需要进行全表扫描。而是从索引的根节点（图中并未画出）开始进行搜索，根节点的槽中存放了指向子节点的指针，存储引擎根据这些指针向下层查找。通过比较节点页的值和要查找的值可以找到合适的指针进入下层子节点，这些指针实际上定义了子节点页中值的上限和下限。最终存储引擎要么找到对应的值，要么该记录不存在。
- ⏱ 2023-05-13 17:48:15
📌 B-tree是按照索引列中的数据大小顺序存储的，所以很适合按照范围来查询。
- ⏱ 2023-05-02 10:11:12
📌 InnoDB存储引擎有一个被称为自适应哈希索引的特性。当InnoDB发现某些索引值被非常频繁地被访问时，它会在原有的B-tree索引之上，在内存中再构建一个哈希索引。
- ⏱ 2023-05-13 18:02:36
📌 B-tree索引适用于全键值、键值范围或键前缀查找。其中键前缀查找只适用于根据最左前缀的查找
- ⏱ 2023-05-13 18:11:38

读书笔记

第1章 MySQL架构

划线评论

📌 服务器维护了一个缓存区，用于存放已就绪的线程，因此不需要为每个新的连接创建或者销毁线程。
- 💭 线程池
- ⏱ 2023-05-01 22:17:42

划线评论

📌 所以在同一个事务中，混合使用多种存储引擎是不可靠的
- 💭 会使得数据库中的数据处于不一致的状态，事务变得没有意义了
- ⏱ 2023-04-21 10:27:27

划线评论

📌 所以在同一个事务中，混合使用多种存储引擎是不可靠的
- 💭 在事务中混用存储引擎会造成非事务表不可回滚
- ⏱ 2023-04-21 10:25:57

本书评论

学点法律，避点坑：有趣有料的法律科普

2023-07-02T03:21:50Z

元数据

[!abstract] 学点法律，避点坑：有趣有料的法律科普

书名：学点法律，避点坑：有趣有料的法律科普

作者：隋兵

简介：本书是一本“不一样”的法律科普读物，不同于其他传统的普法读物，本书用平实的语言和鲜活的例子把晦涩的法律条文“翻译”出来，幽默的行文是本书的“增味剂”，力求让你在轻松愉悦中学会法律知识，本书还汇集了许多大家生活中经常碰到但又束手无策的法律难题，比如怎么让渣男净身出户？遭遇职场性骚扰怎么处理？碰到老赖不还钱该怎么办？针对每一个问题，书中都给出详细的“法律操作指南”，手把手地教你维权。除此之外，本书还选择了多个大家非常关心，但又不明就里的法律“漏洞”，比如精神病、幼童杀人为何不处罚？人贩子为什么不一律死刑？这些令人不解的疑问后，都有着深层次的原因，书中将一一揭示这些法律秘密。

出版时间 2018-09-01 00:00:00

ISBN： 9787302508595

分类：社会文化-法律

出版社：清华大学出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

人贩子为何不一律判死刑？

📌 实际上，我国法律规定拐卖儿童罪的最高刑已经达到了死刑
- ⏱ 2023-05-04 14:28:06
📌 《中华人民共和国刑法》第二百四十条规定：“拐卖妇女、儿童的，处五年以上十年以下有期徒刑，并处罚金；有下列情形之一的，处十年以上有期徒刑或者无期徒刑，并处罚金或者没收财产；情节特别严重的，处死刑，并处没收财产。”
- ⏱ 2023-05-04 14:34:02
📌 重刑主义不但无法解决拐卖人口问题，而且还会带来一系列副作用。
- ⏱ 2023-05-04 14:36:15
📌 贝卡利亚曾说“刑罚的威慑力不在于刑罚的严酷，而在于其不可避免”。
- ⏱ 2023-05-04 14:37:47

“疑罪从无”是让坏人逍遥法外吗？

📌 与“疑罪从无”相对的，古代法律里也有一个所谓的漏洞，就是“刑讯逼供
- ⏱ 2023-05-04 14:40:34
📌 法律是统治阶级意志的体现
- ⏱ 2023-05-04 14:42:27
📌 冤枉一个人的社会损失造成的影响远大于放纵十个罪犯。
- ⏱ 2023-05-04 14:43:10

知识产权制度是让少数人合法地“垄断”知识吗？

📌 知识产权的“公开性”不但没有让少数人垄断知识，反而是强迫他们向社会共享知识。
- ⏱ 2023-05-04 14:45:18
📌 我国的《著作权法》规定，为个人学习、研究或者欣赏、使用他人已经发表的作品的，可以不向著作权人支付费用；
- ⏱ 2023-05-04 14:45:41
📌 我国的《专利权法》也规定，专为科学研究和实验而使用有关专利的，也属法律允许的范畴。
- ⏱ 2023-05-04 14:46:30
📌 如果利用他人的知识产权牟利，则必须获得知识产权人的同意，大多数情况下还要支付报酬。
- ⏱ 2023-05-04 14:52:39

幼童、精神病患者杀人为什么不处罚？

📌 我国法律规定，只有具备刑事责任能力的人犯罪，刑法才会进行处罚。
- ⏱ 2023-05-04 22:45:06
📌 刑事责任能力是指行为人辨认和控制自己行为的能力。
- ⏱ 2023-05-04 22:45:17
📌 《周礼》云：“司刺掌三赦之法，一赦曰幼弱，再赦曰老耄，三赦曰蠢愚。”
- ⏱ 2023-05-04 22:47:02
📌 在摆脱了“同态复仇”的现代法制中，刑罚的目的早已不再是报复和打击，而是教育、指引、强制和威慑。
- ⏱ 2023-05-04 22:47:59

自己的身体自己不能做主？法律为什么要限制你“自残”？

📌 法律家长主义其实也是同样的设定，即法律为了公民个体的利益，限制公民的某些自由
- ⏱ 2023-05-04 23:14:24
📌 法律这种霸道而又温情的关怀，在现代社会中无处不在，以至于法学家给法律家长主义起了一个生动的昵称——“法律父爱主义”。
- ⏱ 2023-05-05 00:27:18
📌 如果是智力正常、身体健康的成年人，大多数人都可以轻易地判断哪些是对自己有利的，哪些是不利的，从而选择自己的行为模式
- ⏱ 2023-05-04 23:20:26
📌 一个人吸毒、自残不可怕，可怕的是大家都默许、认可甚至加入这种行为群体
- ⏱ 2023-05-04 23:21:18

法律对财产的保护真的是平等的吗？

📌 《中华人民共和国宪法》第十二条规定：“社会主义的公共财产神圣不可侵犯。”
- ⏱ 2023-05-04 23:35:58
📌 第十三条规定：“公民的合法的私有财产不受侵犯。”
- ⏱ 2023-05-04 23:36:22

第二章财产保险箱：学点法律避点坑，懂点法律止点损

📌 根据洛卡德物质交换原理，任何一个人在进入特定的现场环境后总会或多或少地和现场的物质发生接触和交换
- ⏱ 2023-05-05 00:00:29

律师借钱为什么从来不给现金？

📌 正确的借款方式应该这样操作：（1）双方达成意向后，参照本书的介绍，签订完备的借款合同；（2）支付钱款应当避免现金支付，要通过银行转账或者微信、支付宝等可以留下痕迹的方式支付。银行转账支付时要保留银行打款凭证；（3）在付款时要同时在付款内容中备注钱款的性质为“借款”；（4）特别注意要审查收款方的账户，最好是借款人本人的账户。如果借款合同有约定的，则应是约定的收款账户。
- ⏱ 2023-05-05 00:15:23

碰到“教科书式的耍赖”怎么办？

📌 2016年11月国家公布了《关于民事执行中变更、追加当事人若干问题的规定》，如果发现欠款的公司、企业存在特定的恶意行为，可以追加包括瑕疵出资有限合伙人、承担连带责任的公司发起人、出让瑕疵股权的股东、违规注销企业的清算责任人这些人的责任，直接处理这些人的个人财产，让躲在皮包公司背后的老赖无处遁形。
- ⏱ 2023-05-05 00:19:37
📌 《刑法》第三百一十三条拒不执行判决、裁定罪规定：“对人民法院的判决、裁定有能力执行而拒不执行，情节严重的，处三年以下有期徒刑、拘役或者罚金。”
- ⏱ 2023-05-05 00:21:34

民法上“限制行为能力”是什么？“熊孩子”乱花钱能追回吗？

📌 《民法总则》规定，8岁到18岁之间的未成年人（特殊情况除外）属于限制民事行为能力人。限制民事行为能力人做出的民事行为如果跟他的智力、年龄状况不相适应，那么这样的行为是效力待定的，只有当家长追认后，才能发生效力。
- ⏱ 2023-05-05 18:14:33
📌 如果提供的证据能够显示某个事实存在的可能性较大，即便不能排除事实不存在的情况，法官也会认定这个事实。
- ⏱ 2023-05-05 18:38:53

官司还没打完钱就拿到了？哪些情况可以申请“先予执行”？

📌 但在很多情况下，迟到的正义却是一种非正义。
- ⏱ 2023-05-05 18:47:03
📌 先予执行就是在法院受理案件后，不需要对案件作出最终的判决，就可以根据一方的申请，让对方支付一定财物（或者做出行为）的程序。简单说就是先执行后判决。
- ⏱ 2023-05-05 18:47:44
📌 《中华人民共和国民事诉讼法》第一百零六条规定：人民法院对下列案件，根据当事人的申请，可以裁定先予执行：（一）追索赡养费、扶养费、抚育费、抚恤金、医疗费用的；（二）追索劳动报酬的；（三）因情况紧急需要先予执行的。
- ⏱ 2023-05-05 18:48:51

花式抄袭有多可恶？被抄袭了怎么让对方赔钱？

📌 《著作权法》对作品的保护有一个原则，就是“只保护表达，不保护思想”。
- ⏱ 2023-05-05 22:21:40

有“免费请律师”的好事吗？哪些情况下别人帮你出律师费？

📌 律师费在性质上应属于财产利益，原则上可以作为损失
- ⏱ 2023-05-06 13:22:17

给人做担保只是签个字那么简单吗？因为担保变得一贫如洗真的只是传说吗？

📌 担保不是简单签个字就完事了，而是要对债务的履行负责到底。
- ⏱ 2023-05-06 17:17:50

如何有效处理网络暴力？

📌 如果网站、手机APP的管理者怠于履行删除义务，那么你就可以直接根据《侵权责任法》第三十六条要求网站一起承担赔偿责任。
- ⏱ 2023-05-06 18:16:39

怎样稳妥地向警察叔叔表示“我的律师马上就到”？

📌 我国的《刑事诉讼法》明确规定，当嫌疑人接受第一次讯问时就可以要求律师介入。
- ⏱ 2023-05-06 18:21:36

“能动手尽量别吵吵”这句话对不对？打人的成本到底有多高？

📌 （1）轻微伤直接成本=5天至15天拘留+500～1000元罚款+至少1000元医药费；（2）轻伤直接成本=3年以下有期徒刑、拘役或管制+经济赔偿+开除公职+社会及家庭影响；（3）重伤直接成本=3年以上10年以下有期徒刑、无期徒刑或死刑+社会及家庭严重影响；（4）打架附加成本=心情沮丧、低落、郁闷+名誉、形象受损+家人朋友担心+生意、工作可能蒙受更大损失；（5）民事责任费用=诉讼费+律师费+医药费+误工费。
- ⏱ 2023-05-06 18:27:36

什么样的伤害可以主张精神损失赔偿？

📌 《中华人民共和国侵权责任法》第二十二条规定：“行为人侵害他人人身权益，造成他人严重精神损害的，被侵权人可以请求精神损害赔偿。”
- ⏱ 2023-05-06 23:01:14
📌 《最高人民法院关于确定民事侵权精神损害赔偿责任若干问题的解释》的规定则更为具体，其中规定：“第一条　自然人因下列人格权利遭受非法侵害，向人民法院起诉请求赔偿精神损害的，人民法院应当依法予以受理：（一）生命权、健康权、身体权；（二）姓名权、肖像权、名誉权、荣誉权；（三）人格尊严权、人身自由权。违反社会公共利益、社会公德侵害他人隐私或者其他人格利益，受害人以侵权为由向人民法院起诉请求赔偿精神损害的，人民法院应当依法予以受理。第四条　具有人格象征意义的特定纪念物品，因侵权行为而永久性灭失或者毁损，物品所有人以侵权为由，向人民法院起诉请求赔偿精神损害的，人民法院应当依法予以受理。”
- ⏱ 2023-05-06 23:02:20
📌 人身权利和人身权利相关的利益是否受到损害才是法院是否支持精神损失赔偿的主要考虑因素
- ⏱ 2023-05-06 23:03:23

讨债有理，绑人合法吗？

📌 一般在司法实践中，只要非法拘禁他人的时间超过24小时，就可以认定构成犯罪，或者虽然时间未达24小时，但在拘禁过程中有捆绑、殴打他人的行为也属于犯罪。
- ⏱ 2023-05-06 23:08:44

女友结婚了，新郎不是你，送她的钻石项链还能要回来吗？

📌 《最高人民法院关于适用〈中华人民共和国婚姻法〉若干问题的解释（二）》第十条规定：“当事人请求返还按照习俗给付的彩礼的，如果查明属于以下情形，人民法院应当予以支持：（一）双方未办理结婚登记手续的；（二）双方办理结婚登记手续但确未共同生活的；（三）婚前给付并导致给付人生活困难的。适用前款第（二）、（三）项的规定，应当以双方离婚为条件。”
- ⏱ 2023-05-06 23:18:27
📌 没领证、领证了没过日子或者给“彩礼”导致生活困难时，当事人都可以提起诉讼，要求对方返还“彩礼”
- ⏱ 2023-05-06 23:18:52

怎么合法地让渣男、渣女“净身出户”？

📌 “婚姻法所规定的夫妻应当互相忠实、互相尊重的义务。从立法本意上，是一种道德义务，而不是法律义务，夫妻一方以此道德义务作为对价(1)与另一方进行交换而订立的协议，不能理解为确定具体民事权利义务的协议，故该协议无效”。
- ⏱ 2023-05-06 23:48:32

当军属有荣耀也有风险，军婚为什么不好离？

📌 现役军人的配偶要求离婚，须得军人同意，但军人一方有重大过错的除外
- ⏱ 2023-05-06 23:56:22

法律也有道德标准？婚姻第三者继承、包养协议都合法吗？

📌 《民法总则》第十条规定：“处理民事纠纷，应当依照法律；法律没有规定的，可以适用习惯，但是不得违背公序良俗
- ⏱ 2023-05-07 12:48:35

“父债子还”合理吗？哪些情况下可以“父债子还”？

📌 《中华人民共和国继承法》第三十三条规定：继承遗产应当清偿被继承人依法应当缴纳的税款和债务，缴纳税款和清偿债务以他的遗产实际价值为限。超过遗产实际价值部分，继承人自愿偿还的不在此限。继承人放弃继承的，对被继承人依法应当缴纳的税款和债务可以不负偿还责任
- ⏱ 2023-05-09 23:57:21
📌 《中华人民共和国民法总则》第五十六条规定：个体工商户的债务，个人经营的，以个人财产承担；家庭经营的，以家庭财产承担；无法区分的，以家庭财产承担。
- ⏱ 2023-05-09 23:59:46
📌 《中华人民共和国婚姻法》第二十一条规定：父母对子女有抚养教育的义务；子女对父母有赡养扶助的义务。子女不履行赡养义务时，无劳动能力的或生活困难的父母，有要求子女付给赡养费的权利。
- ⏱ 2023-05-09 23:59:56

同居真的没成本吗？为什么有人同居后摊上了巨额债务？

📌 《最高人民法院关于人民法院审理未办结婚登记而以夫妻名义同居生活案件的若干意见》第十一条规定：解除非法同居关系时，同居期间为共同生产、生活而形成的债权、债务，可按共同债权、债务处理。
- ⏱ 2023-05-10 00:06:15

认定强奸真的只看女性怎么说吗？被人诬陷强奸怎么办？

📌 办理刑事案件的时候证据都是要检察院、公安去搞定的，它们要是搞不定或者弄来的证据存在疑点，那么嫌疑人就不能定罪。
- ⏱ 2023-05-10 00:14:41

什么情况下被开除了还能“发笔小财”？

📌 根据《中华人民共和国劳动合同法》规定，一旦单位被认定为违法辞退，就应该按员工在单位工作的年限支付赔偿金，每满一年支付二个月工资。六个月以上不满一年的，按一年计算，支付两个月的工资；不满六个月的，支付一个月的工资。
- ⏱ 2023-05-10 00:30:31

老板跑路了怎么办？合法讨薪怎么做最有效？

📌 《劳动合同法》第三十条规定：在用人单位拖欠或者未足额支付劳动报酬的，员工依法向当地人民法院申请支付令，人民法院应当依法发出支付令
- ⏱ 2023-05-10 00:33:11

上班族也有“丹书铁券”？哪些人无法被开除？

📌 《妇女权益保障法》第二十七条规定：任何单位不得因结婚、怀孕、产假、哺乳等情形，降低女职工的工资，辞退女职工，单方解除劳动（聘用）合同或者服务协议。
- ⏱ 2023-05-10 00:34:38
📌 《劳动合同法》第四十二条规定：在本单位患职业病或者因工负伤并被确认丧失或者部分丧失劳动能力的，用人单位不得依照本法第四十条、第四十一条的规定解除劳动合同。
- ⏱ 2023-05-10 00:35:04
📌 疑似职业病诊断或者医学观察期间的员工也不得随意辞退。
- ⏱ 2023-05-10 00:35:25
📌 根据《企业职工患病或非因工负伤医疗期规定》，医疗期是指企业职工因患病或非因工负伤停止工作治病休息不得解除劳动合同的时限。医疗期一般为3个月到24个月，以劳动者本人实际参加工作年限和在本单位工作年限为标准计算具体的医疗期。
- ⏱ 2023-05-10 00:36:05
📌 《劳动合同法》第四十二条规定：在本单位连续工作满十五年，且距法定退休年龄不足五年的，用人单位不得根据劳动合同法第四十条、第四十一条的规定单方解除劳动合同。
- ⏱ 2023-05-10 00:36:17
📌 出现下面的情形时，企业可以立即辞退员工（包括上面的几类人）：（1）自身能力太差，在试用期内被发现不符合录用条件；（2）员工去其他单位兼职，还不听劝，给单位造成了影响；（3）严重违反公司规章制度。过度放飞自我，例如长期不上班、迟到，等等；（4）劳动者通过欺骗、胁迫手段签了合同，如简历造假；（5）严重失职、营私舞弊给单位造成损害；（6）被追究刑事责任。
- ⏱ 2023-05-10 00:37:06

试用期员工就低人一等？试用期能随意解聘吗？

📌 《中华人民共和国劳动合同法》第三十九条规定：劳动者有下列情形之一的，用人单位可以解除劳动合同：（一）在试用期间被证明不符合录用条件的；（二）严重违反用人单位的规章制度的；（三）严重失职，营私舞弊，给用人单位造成重大损害的；（四）劳动者同时与其他用人单位建立劳动关系，对完成本单位的工作任务造成严重影响，或者经用人单位提出，拒不改正的；（五）因本法第二十六条第一款第（一）项规定的情形致使劳动合同无效的；（六）被依法追究刑事责任的
- ⏱ 2023-05-10 00:40:05

公司里也有铁饭碗？无固定期限劳动合同怎么签？

📌 劳动者在该用人单位连续工作满十年的，应签订无固定期限劳动合同。
- ⏱ 2023-05-10 13:23:43

社保是员工福利吗？单位不缴纳社保该怎么维权？

📌 然而根据《社会保险费申报缴纳管理规定》，单位为员工缴纳“五险”是一项强制性规定，员工不能放弃，企业也不能拒缴。
- ⏱ 2023-05-10 13:30:42

骑电动车也算酒驾？什么样的电动车享受“机动车”待遇？

📌 最高时速过快或者净重过大的电动车都有可能属于“摩托车”。
- ⏱ 2023-05-14 12:56:21

“限时不取，快递退回”合法吗？收件人应该怎么应对？

📌 根据《最高人民法院关于以法院快递方式邮寄送达民事诉讼文书的若干规定》第十一条：因受送达人本人或者受送达人制定的代收人拒绝签收，导致诉讼文书未能被受送达人实际接收的，文书被退回之日视为送达之日。
- ⏱ 2023-05-14 13:00:56

起诉黑心商家怕路远？打官司能不能挑个法院？

📌 《中华人民共和国民事诉讼法》规定：因合同纠纷提起的诉讼，由被告住所地或者合同履行地人民法院管辖。《最高人民法院关于适用〈中华人民共和国民事诉讼法〉的解释》规定：以信息网络方式订立的买卖合同，通过信息网络交付标的的，以买受人住所地为合同履行地；通过其他方式交付标的的，收货地为合同履行地。
- ⏱ 2023-05-14 13:06:46
📌 如果消费者购买的商品和服务造成了消费者身体健康权、财产权的损失，那么这类案件就属于侵权案件。
- ⏱ 2023-05-14 13:10:07
📌 《中华人民共和国民事诉讼法》规定：因侵权行为提起的诉讼，由侵权行为地或者被告住所地人民法院管辖。
- ⏱ 2023-05-14 13:10:11

房东换了，房子还能不能继续住？

📌 《中华人民共和国合同法》第二百二十九条规定：租赁物在租赁期间发生所有权变动的，不影响租赁合同的效力。
- ⏱ 2023-05-14 13:20:07
📌 《中华人民共和国合同法》第二百三十条规定：出租人出卖租赁房屋的，应当在出卖之前的合理期限内通知承租人，承租人享有以同等条件优先购买的权利。
- ⏱ 2023-05-14 13:26:53

房价上涨了，房东不卖了，可以让他赔多少？

📌 《中华人民共和国合同法》规定：给付定金的一方不履行约定的债务的，无权要求返还定金；收受定金的一方不履行约定的债务的，应该双倍返还定金
- ⏱ 2023-05-14 15:40:52

小产权房为何那么便宜？买小产权房的最大风险是什么？

📌 小产权房”虽然名字里有“产权”二字，实际上却是一种没有土地使用权的房屋。市面上比较常见的小产权房主要是指占用集体土地建起的住宅，比如乡产房、村产房等。而普通的商品住房则都是建设在国有土地上并以出让的方式获得土地使用权的房屋。
- ⏱ 2023-05-14 15:46:53

读书笔记

本书评论

书评 No.1 举了很多贴近生活的例子，大部分内容现实生活中都用的上。是一本普法方面相对较好的书籍

⏱ 2023-05-14 19:26:29

公司法学（上）

2023-07-02T03:21:50Z

元数据

[!abstract] 公司法学（上）

书名：公司法学（上）

作者：朱锦清

简介：中国法学的落后集中反映在教材上。内容空洞无物、语言枯燥乏味的法学教材耽误了一代又一代的莘莘学子，浪费了他们的时间和精力，扼杀了他们的兴趣和热情。本来，教材的编写要以现有的科研成果为基础，从中系统地吸收养料。可是学风浮夸，制度低效，法学界尤甚。发表出来的所谓成果和论文大都是无用的垃圾。教材的编写者们即使是巧妇也难为无米之炊。教材上不去，年轻一代的基础打不扎实，科研就没有后劲，反过来又制约教材质量的提高。要突破这个恶性循环的局面，写出与国际接轨的教材来，必须跳出学术界，向两个方面寻求素材：第一是实践部门，主要是我国法院的判例以及工商、税务等部门的实务；第二是国外的判例、规则和学术讨论。除此之外别无他路。本书正是在这两个方向上努力的。

出版时间 2017-09-01 00:00:00

ISBN： 9787302478768

分类：社会文化-法律

出版社：清华大学出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

第一节什么是公司

📌 传统的分类大致将企业分为个人独资、合伙、公司三大类。
- ⏱ 2023-05-09 23:42:57
📌 公司就是由股东组成的，只有股东才是公司的成员，雇员（包括高级管理人员）不是公司的成员。
- ⏱ 2023-05-09 23:43:31
📌 股票是证明股东身份和持股数量的实物凭证
- ⏱ 2023-05-09 23:50:47
📌 写了股东姓名的股票叫作记名股票；不写股东姓名的股票叫作无记名股票。
- ⏱ 2023-05-09 23:51:28

读书笔记

本书评论

尘埃落定 (共和国作家文库)

2023-07-02T03:21:50Z

元数据

[!abstract] 尘埃落定 (共和国作家文库)

书名：尘埃落定 (共和国作家文库)

作者：阿来

简介：

出版时间

ISBN：

分类：

出版社：作家出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

第三章

📌 是不少，但也不是太多。我给你同样多的银子，不过你要答应用一半的一半从我手里买新式武器把你的人武装起来。
- ⏱ 2023-04-15 15:47:46
📌 不要告诉我明天是什么样子，现在天还没有亮，我却看到自己比天黑前过得坏了。
- ⏱ 2023-04-15 15:48:35

第四章

第八章

📌 鞋匠穿着一双快掉底的靴子，啪哒啪哒地跑过来。
- ⏱ 2023-04-15 23:27:31

读书笔记

第四章

划线评论

📌 门巴不是喇嘛，但他却是法力高强的神巫。他不过就喜欢喇嘛这样一个称呼罢了。
- 💭 第二次出现这段话
- ⏱ 2023-04-15 21:06:08

本书评论

大话数据结构-CB_CPNCH7CGBH2F6e76cn15r314

2023-07-02T03:21:50Z

元数据

[!abstract] 大话数据结构

书名：大话数据结构

作者：程杰

简介：

出版时间

ISBN：

分类：

出版社：

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

2.9 算法时间复杂度

📌 循环的时间复杂度等于循环体的复杂度乘以该循环运行的次数。
- ⏱ 2023-01-25 14:05:37

3.4 线性表的顺序存储结构

📌 数组的长度是存放线性表的存储空间的长度，存储分配后这个量一般是不变的
- ⏱ 2023-01-25 15:45:52
📌 线性表的长度是线性表中数据元素的个数，随着线性表插入和删除操作的进行，这个量是变化的。
- ⏱ 2023-01-25 15:46:48
📌 在任意时刻，线性表的长度应该小于等于数组的长度。
- ⏱ 2023-01-25 15:46:57

读书笔记

2.9 算法时间复杂度

划线评论

📌 1．用常数1取代运行时间中的所有加法常数。
2．在修改后的运行次数函数中，只保留最高阶项。
3．如果最高阶项存在且不是1，则去除与这个项相乘的常数。
- 💭 计算时间复杂度
- ⏱ 2023-01-25 14:07:55

划线评论

📌 事实上无论n为多少，上面的两段代码就是3次和12次执行的差异。这种与问题的大小无关（n的多少），执行时间恒定的算法，我们称之为具有O(1)的时间复杂度，又叫常数阶
- 💭 常数阶
- ⏱ 2023-01-25 14:01:16

划线评论

📌 显然，由此算法时间复杂度的定义可知，我们的三个求和算法的时间复杂度分别为O(n)，O(1)，O(n2)。我们分别给它们取了非官方的名称，O(1)叫常数阶、O(n)叫线性阶、O(n2)叫平方阶，当然，还有其他的一些阶，我们之后会介绍
- 💭 算法的时间复杂度
- ⏱ 2023-01-25 13:57:05

2.11 最坏情况与平均情况

划线评论

📌 对算法的分析，一种方法是计算所有情况的平均值，这种时间复杂度的计算方法称为平均时间复杂度。另一种方法是计算最坏情况下的时间复杂度，这种方法称为最坏时间复杂度。一般在没有特殊说明的情况下，都是指最坏时间复杂度。
- 💭 算法的分析
- ⏱ 2023-01-25 14:22:01

2.12 算法空间复杂度

划线评论

📌 算法的空间复杂度通过计算算法所需的存储空间实现，算法空间复杂度的计算公式记作：S(n)=O(f(n))，其中，n为问题的规模，f(n)为语句关于n所占存储空间的函数。
- 💭 算法空间复杂度计算公式
- ⏱ 2023-01-25 14:31:59

本书评论

Ferryman

2023-07-02T03:21:50Z

元数据

[!abstract] Ferryman

书名： Ferryman

作者： Claire McFall

简介：

出版时间

ISBN：

分类：

出版社： Templar Publishing

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

读书笔记

Chapter One

划线评论

📌 circulation
- 💭 循环
- ⏱ 2023-05-13 10:35:27

划线评论

📌 numb
- 💭 麻木
- ⏱ 2023-05-13 10:34:36

划线评论

📌 warm
- 💭 暖和温暖
- ⏱ 2023-05-13 10:32:00

划线评论

📌 disjointed
- 💭 脱下
- ⏱ 2023-05-13 10:29:48

本书评论

看天下（2023年第13期）

2023-07-02T03:21:50Z

元数据

[!abstract] 看天下（2023年第13期）

书名：看天下（2023年第13期）

作者：看天下

简介：《看天下》是一本综合类新闻杂志，创刊于2005年，也是经全球华文媒体BPA认证国内发行量最大的新闻期刊。内容丰富多元，包含时政、财经、科技、文化、娱乐、教育、心理等多个领域。立志于为读者展现更广阔的世界和人生的更多可能。

出版时间 2023-05-18 00:00:00

ISBN：

分类：期刊杂志-其他

出版社：

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

当枪战发生在我身边

📌 所谓身怀利器，杀心自起，拥枪本身就会促使一部分自制力弱的人主动使用它。
- ⏱ 2023-05-26 01:23:51

读书笔记

本书评论

看天下（2023年第11期）

2023-07-02T03:21:50Z

元数据

[!abstract] 看天下（2023年第11期）

书名：看天下（2023年第11期）

作者：看天下

简介：《看天下》是一本综合类新闻杂志，创刊于2005年，也是经全球华文媒体BPA认证国内发行量最大的新闻期刊。内容丰富多元，包含时政、财经、科技、文化、娱乐、教育、心理等多个领域。立志于为读者展现更广阔的世界和人生的更多可能。

出版时间 2023-04-28 00:00:00

ISBN：

分类：期刊杂志-其他

出版社：

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

读书笔记

VOICES OF YOUTH｜青年说

章节评论 No.1

作者并不是相关从业人员，在阐述角度上带着对所谓人工智能的固有偏见且表现出了狭窄的信息获取渠道，这种偏见不知道是所谓指导老师强加的还是基于自己的思考。程序的价值在于帮助人们去除简单枯燥的重复工作，提高生产效率，而GPT这类大模型的发展正好符合这一特点。当然这类工具的出现必然会伴随着工作结构的改变，而这种改变必定会导致部分人员失去一份赖以生存的工作而转向他们不熟悉的领域。
- ⏱ 2023-05-05 01:34:09

本书评论

书评 No.1

⏱ 2023-05-05 11:40:58

海外文摘（2023年第3期）

2023-07-02T03:21:50Z

元数据

[!abstract] 海外文摘（2023年第3期）

书名：海外文摘（2023年第3期）

作者：海外文摘

简介：《海外文摘》是一本贴近生活、透视海外的综合性中文月刊。它专门介绍国外以及台湾、香港、澳门的社会万象和风土人情，以传播知识、开阔眼界、陶冶情操为宗旨。

出版时间 2023-03-01 00:00:00

ISBN：

分类：期刊杂志-文学

出版社：《海外文摘》杂志社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

封面文章｜Cover Story

📌 2022年，人们的笑容变少了
- ⏱ 2023-04-27 15:08:36
📌 鲍尔为此获得的报酬是45美元，他没有给这个图案注册商标。
- ⏱ 2023-04-27 15:10:33
📌 我一次只能吃一块牛排、开一辆车。
- ⏱ 2023-04-27 15:16:11
📌 重要的不是谁把它设计出来，而是谁决定将它发展成一个企业，进行宣传推广，为它增添价值。
- ⏱ 2023-04-27 15:17:34
📌 然而，在这个无限复制的年代，图像和标志在网络上可以瞬间被分享和改造，笑脸图案有可能迸发出自己的生命力，从而违背笑脸公司的价值观。
- ⏱ 2023-04-27 15:21:07
📌 网络漫画形象“佩佩蛙”本来单纯无害，却被极右团体利用，现在成为了仇恨标志。
- ⏱ 2023-04-27 15:21:27

印度的婚姻大事

📌 如果数据可靠，婚庆业俨然已是印度第四大产业，仅次于能源、银行和保险业，比汽车、钢铁制造和科技产业的排名都要靠前。
- ⏱ 2023-04-27 15:30:33

读书笔记

本书评论

骆驼祥子

2023-07-02T03:21:50Z

元数据

[!abstract] 骆驼祥子

书名：骆驼祥子

作者：老舍

简介：一部年轻人的个人奋斗史，一卷老北京的人物世情图。现代文学的经典之作。翻译成17种语言，数十个版本，畅销70多年。本书包括《骆驼祥子》《正红旗下》两部京味长篇经典，老舍研究会审定。依据老舍1936年手稿还原的一字不删的“足本”。国内通行各版本因为时代等影响，部分内容都有不同程度的删节或改动。本书以近年偶然发现的老舍手稿为底本，恢复删改部分，还原本书的真实面貌。《正红旗下》是老舍偷偷写作的一部具有自传性质的长篇小说，大清末年，旧梦将醒未醒，大厦将倾未倾。一个小孩的诞生，带来浓浓的黑色幽默……这部生前没有发表，没有完成的作品，被公认为是老舍的代表作和当代真正伟大的文学巨著。

出版时间 2017-03-01 00:00:00

ISBN： 9787550295285

分类：文学-经典作品

出版社：北京联合出版公司

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

一

📌 这些人，生命最鲜壮的时期已经卖掉，现在再把窝窝头变成的血汗滴在马路上
- ⏱ 2023-04-26 10:08:54
📌 头不很大，圆眼，肉鼻子，两条眉很短很粗，头上永远剃得发亮。
- ⏱ 2023-04-26 10:15:07

读书笔记

本书评论

茶馆（无删节经典完整版）

2023-07-02T03:21:50Z

元数据

[!abstract] 茶馆（无删节经典完整版）

书名：茶馆（无删节经典完整版）

作者：老舍

简介：本书收录老舍著名话剧《茶馆》《龙须沟》和十几篇经典散文。《茶馆》结构上分三幕，以老北京一家叫裕泰的大茶馆的兴衰变迁为背景，展示了从清末到北洋军阀时期再到抗战胜利以后的近50年间，北京的社会风貌和各阶层的不同人物的生活变迁。每一幕写一个时代，北京各阶层的三教九流人物，出人于这家大茶馆，全剧展示出来的是一幅幅气势庞大的历史画卷，形象地说明了旧中国的必然灭亡和新中国诞生的必然性。

出版时间 2017-07-03 00:00:00

ISBN： 9787505739628

分类：文学-经典作品

出版社：中国友谊出版公司

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

话剧卷

📌 这里还可以听到某京戏演员新近创造了什么腔儿，和煎熬鸦片烟的最好的方法
- ⏱ 2023-04-24 00:21:03
📌 今天又有一起打群架的，据说是为了争一只家鸽，惹起非用武力解决不可的纠纷。
- ⏱ 2023-04-24 00:22:47
📌 用不着相面，咱们既在江湖内，都是苦命人
- ⏱ 2023-04-24 00:24:44
📌 二爷文绉绉的，提着小黄鸟笼；常四爷雄赳赳的，提着大而高的画眉笼。
- ⏱ 2023-04-24 00:25:56
📌 二德子怎么着？我碰不了洋人，还碰不了你吗？
- ⏱ 2023-04-24 00:29:04
📌 刘麻子咱们大清国有的是金山银山，永远花不完！您坐着，我办点小事！（领康六找了个座儿）
- ⏱ 2023-04-24 00:31:49
📌 刘麻子谁知道！要不怎么说，就是条狗也得托生在北京城里嘛！
- ⏱ 2023-04-24 00:33:51
📌 老人（喝了茶）多谢！八十二了，没人管！这年月呀，人还不如一只鸽子呢！唉！（慢慢走出去）
- ⏱ 2023-04-24 00:36:17
📌 在街面上混饭吃，人缘儿顶要紧。
- ⏱ 2023-04-24 00:36:56
📌 秦仲义（对王利发）轰出去！
- ⏱ 2023-04-24 00:39:17
📌 大英帝国的烟，日本的“白面儿”，两个强国侍侯着我一个人，这点福气还小吗？
- ⏱ 2023-04-24 23:06:34
📌 常四爷我卖菜呢！自食其力，不含糊！今儿个城外头乱乱哄哄，买不到菜；东抓西抓，抓到这么两只鸡，几斤老腌萝卜。听说你明天开张，也许用的着，特意给你送来了！
- ⏱ 2023-04-24 23:08:50
📌 松二爷怎么样？我想大哭一场！看见我这身衣裳没有？我还像个人吗？
- ⏱ 2023-04-24 23:09:51
📌 我饿着，也不能叫鸟儿饿着！（有了点精神）你看看，看看，（打开罩子）多么体面！一看见它呀，我就舍不得死啦！
- ⏱ 2023-04-24 23:10:39
📌 “莫谈国事”的纸条更多，字也更大了。在这些条子旁边还贴着“茶钱先付”的新纸条。
- ⏱ 2023-04-24 23:27:11
📌 去吧，小花，在路上留神吉普车！
- ⏱ 2023-04-24 23:29:04
📌 那有什么办法呢，现而今就是狱里人多呀！满汉全席？我连家伙都卖喽！
- ⏱ 2023-04-24 23:42:37
📌 常四爷提着小筐进来，筐里有些纸钱和花生米。他虽年过七十，可是腰板还不太弯。
- ⏱ 2023-04-24 23:59:46

龙须沟（三幕话剧）

📌 沟的两岸，密密层层的住满了卖力气的、耍手艺的，各色穷苦劳动人民
- ⏱ 2023-04-28 16:42:58
📌 他们终日终年乃至终生，都挣扎在那肮脏腥臭的空气里
- ⏱ 2023-04-28 16:43:08
📌 有一天，沟不臭，水又清，国泰民安享太平。
- ⏱ 2023-05-01 23:09:18
📌 我里边，没小褂，光着脊梁不像话！
- ⏱ 2023-05-01 23:12:24
📌 城里头，大官儿在哪儿住，哪儿就修柏油大马路；谁作了官，谁就盖高楼大瓦房。咱们穷人哪，没人管！
- ⏱ 2023-05-01 23:19:42
📌 晌午六万一斤的大饼，晚上就十二万啦！
- ⏱ 2023-05-01 23:23:47
📌 我们穷，我们脏，我们可不偷！
- ⏱ 2023-05-01 23:30:20
📌 我是好人，二姑娘，好人要是没力气啊，就成了受气包儿！
- ⏱ 2023-05-01 23:36:09
📌 黎明之前，满院子还是昏黑的，只隐约的看得见各家门窗的影子。
- ⏱ 2023-05-01 23:37:21

取钱

📌 一进银行的门，就是柜台，柜台上没有亮亮的黄铜栏杆，也没有大小的铜牌
- ⏱ 2023-05-02 00:29:25
📌 大热的天，说什么时候开门就什么时候开门，真叫不容易
- ⏱ 2023-05-02 00:30:07
📌 人家已经都各按部位坐得稳稳当当，吸着烟卷，按着铃要茶水，太好了，活像一群皇上，太够派儿了
- ⏱ 2023-05-02 00:30:26
📌 有一位看了我一眼，我很高兴；大热的天，看我一眼，不容易。
- ⏱ 2023-05-02 00:30:50
📌 等取钱的已有了六七位，我们彼此对看，眼中都带出对不起人的神气。
- ⏱ 2023-05-02 00:32:55
📌 我真不愿过去，这个人使我失望！才等了四点钟就放钱，派儿不到家！
- ⏱ 2023-05-02 00:33:53

读书笔记

话剧卷

划线评论

📌 秦仲义我不喝！也不坐着！
- 💭 有事来的
- ⏱ 2023-04-24 00:37:16

划线评论

📌 他们自带茶叶
- 💭 生活充裕的旗人身份
- ⏱ 2023-04-24 00:27:25

划线评论

📌 今年是光绪二十四年，戊戌
- 💭 正是戊戌变法
- ⏱ 2023-04-24 00:24:09

本书评论

羊脂球（读客三个圈经典文库）

2023-07-02T03:21:50Z

元数据

[!abstract] 羊脂球（读客三个圈经典文库）

书名：羊脂球（读客三个圈经典文库）

作者：莫泊桑

简介：世界短篇小说巨匠莫泊桑的扛鼎之作！世界短篇小说巨匠莫泊桑，把现实主义文学提高到了一个亘古未有的水平，为短篇小说创作开辟了广阔的道路。纪德盛赞他卓尔不群，屠格涅夫将他誉为法国文坛的天才。收录29篇莫泊桑的代表作品，包括《项链》《我的叔叔于勒》等经典篇目。法语翻译界大家柳鸣九经典译本。新课标、教育部推荐读物。随书附赠解读手册：莫泊桑的文学人生本书收录29篇莫泊桑的短篇小说代表作。

出版时间 2018-07-01 00:00:00

ISBN： 9787549624522

分类：文学-外国文学

出版社：文汇出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

羊脂球

📌 车夫不断甩响他的大鞭，四面飞舞，颇像一条长蛇，时而蜷缩，时而伸展，突然一下，长鞭抽在一个滚圆的马屁股上，那马的臀部便往上一拱，用力拉车。
- ⏱ 2023-04-23 23:55:47

读书笔记

本书评论

希腊三部曲I：追逐阳光之岛（英剧《德雷尔一家》原著）

2023-07-02T03:21:50Z

元数据

[!abstract] 希腊三部曲I：追逐阳光之岛（英剧《德雷尔一家》原著）

书名：希腊三部曲I：追逐阳光之岛（英剧《德雷尔一家》原著）

作者：杰拉尔德·达雷尔

简介：《追逐阳光之岛》是达雷尔“希腊三部曲”中的第一部，展现了在动植物种类浩繁的小岛上，年仅10岁的达雷尔以纯真的心、童稚的眼睛观察到的科孚岛上优美的自然风景、各式各样动植物、热情温暖的当地居民，以及行径古怪的一家人的故事。

出版时间 2012-11-01 00:00:00

ISBN： 9787213049460

分类：文学-散文杂著

出版社：浙江人民出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

01 移栖

📌 “我们大家都需要的，”拉里又开始唱他那一调，“是阳光……是一个可以让我们茁壮成长的国家。
- ⏱ 2023-04-26 22:54:58

读书笔记

本书评论

尘埃落定

2023-07-02T03:21:50Z

元数据

[!abstract] 尘埃落定

书名：尘埃落定

作者：阿来

简介：《尘埃落定》是近年来诺贝尔文学奖呼声极高的重量级作家阿来的长篇代表作，荣获第五届茅盾文学奖，也是当代中国文坛畅销不衰的经典之作。在小说中，一个声势显赫的藏族老麦其土司，在酒后和汉族太太生了一个傻瓜儿子。这个人人都认定的傻子与现实生活格格不入，却有着超越时代的预感能力和举止。在其他土司遍种罂粟时，傻子少爷突然建议改种麦子，结果鸦片供过于求，无人问津，大批饥民投奔麦其麾下，麦其家族的领地和人口达到空前的规模，傻子少爷也因此而娶到了美貌的妻子塔娜，并开辟了康巴地区第一个边贸集市。然而当傻子少爷回到麦其土司官寨后，一场家族内部关于继承权的腥风血雨却悄然拉开了帷幕……

出版时间 2020-09-30 00:00:00

ISBN： 9787533960919

分类：文学-经典作品

出版社：浙江文艺出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

第一章

📌 所以，我就只好心甘情愿当一个傻子了。
- ⏱ 2023-04-23 23:52:49

读书笔记

本书评论

书评 No.1

⏱ 2023-04-18 23:30:57

大地（三部曲）

2023-07-02T03:21:50Z

元数据

[!abstract] 大地（三部曲）

书名：大地（三部曲）

作者：赛珍珠

简介：安徽出生的贫苦农夫王龙，娶了村里地主黄家的丫鬟阿兰。阿兰虽不美丽，且个性木讷，但吃苦耐劳，还生下两个儿子。结发夫妻一起耕耘，迎来了土地丰收，连年的好收成甚至让王龙有积蓄买下家业日败的黄家肥沃的土地。偏偏在富裕临门前，天灾降临，王龙不得不带着一家老小逃亡南城，靠着乞讨与拉车，苟延残喘地在城墙边过日子。正当生活陷入泥淖的时候，战乱发生了。王龙意外地从被盗贼劫掠的大户人家中抢得银两，启程回家，用那些意外之财买了牛、种子、犁田的器具，重振家园。年年丰收的王龙，持续买进更多土地，逐渐成了村里最大的富豪。生活富足起来的王龙开始上酒楼，大肆挥霍，还在阿兰眼下娶了位酒女荷花作姨太太。直到天灾再临……

出版时间 2019-09-01 00:00:00

ISBN： 9787559633002

分类：文学-经典作品

出版社：北京联合出版有限公司

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

第一章

📌 他匆匆走到堂屋，边走边把他蓝色的外裤穿好，蓝色的布腰带系紧在腰间。
- ⏱ 2023-04-30 00:22:35
📌 现在父亲和儿子都可以歇下来了。有个女人就要进门了。
- ⏱ 2023-04-30 00:29:21

读书笔记

本书评论

四世同堂

2023-07-02T03:21:50Z

元数据

[!abstract] 四世同堂

书名：四世同堂

作者：老舍

简介：《四世同堂》是老舍20世纪40年代主要的长篇小说，反映了北平抗战时沦陷区普通民众与生活与抗战历程。该书以北平小羊圈胡同为背景，通过复杂的矛盾纠葛，以胡同内的祁家为主，钱家、冠家以及其他居民为辅，刻画了当时社会各阶层众多普通人的形象；反抗与顺从的选择，国家与个人的选择种种艰难的选择纷繁地交织在一起，深刻地展示了普通人在大时代历史进程中所走过的艰难曲折的道路。

出版时间 2018-01-01 00:00:00

ISBN： 9787513917872

分类：文学-经典作品

出版社：民主与建设出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

第一部惶惑

📌 出嫁以后，才由她的丈夫像赠送博士学位似的送给她一个名字——韵梅。
- ⏱ 2023-04-28 10:06:56

读书笔记

本书评论

冰心精选集（冰心经典小说全新结集）

2023-07-02T03:21:50Z

元数据

[!abstract] 冰心精选集（冰心经典小说全新结集）

书名：冰心精选集（冰心经典小说全新结集）

作者：冰心

简介：本套书《冰心精选集》一套六本，全面囊括了冰心的小说、诗歌、散文和儿童文学代表作。

出版时间 2018-05-01 00:00:00

ISBN：

分类：文学-散文杂著

出版社：长江文艺出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

春水

📌 青年人！你不能像风般飞扬，便应当像山般静止。
- ⏱ 2023-04-26 23:03:34
📌 山头独立，宇宙只一人占有了么？
- ⏱ 2023-04-26 23:07:38

读书笔记

本书评论

余华作品全集（《活着》等 13 册）

2023-07-02T03:21:50Z

元数据

[!abstract] 余华作品全集（《活着》等 13 册）

书名：余华作品全集（《活着》等 13 册）

作者：余华

简介：本套装收入了余华《活着》、《许三观卖血记》、《兄弟》等13部经典代表作品。

出版时间 2011-07-01 00:00:00

ISBN：

分类：文学-经典作品

出版社：作家出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

活着

📌 ：千万不要忘记阶级斗争
- ⏱ 2023-04-15 01:18:36

第一章

📌 那女人与李血头的交情，是一个被窝里的交情，她要是去卖血，谁都得站一边先等着，谁要是把她给得罪了，身上的血哪怕是神仙血，李血头也不会要了。
- ⏱ 2023-04-21 23:26:37
📌 他们把木桶扔进了井里，木桶打在水上“啪”的一声，就像是一巴掌打在人的脸上
- ⏱ 2023-04-21 23:27:35
📌 医院的李血头坐在供血室的桌子后面，两只脚架在一只拉出来的抽屉上，裤裆那地方敞开着，上面的纽扣都掉光了，里面的内裤看上去花花绿绿
- ⏱ 2023-04-21 23:28:24
📌 你听着，按规矩是要抽一管血，先得检验你有没有病，今天我是看在阿方和根龙的面子上，就不抽你这一管血……再说我们今天算是认识了，这就算是我送给你的见面礼…
- ⏱ 2023-04-21 23:31:55
📌 你把力气卖掉了，所以你觉得没有力气了。我们卖掉的是力气，你知道吗？你们城里人叫血，我们乡下人叫力气。力气有两种，一种是从血里使出来的，还有一种是从肉里使出来的，血里的力气比肉里的力气值钱多了。
- ⏱ 2023-04-21 23:30:48

第二章

📌 从土里长出来的只要能吃，就都有营养
- ⏱ 2023-04-21 23:34:20
📌 四叔，我想找个女人去结婚了。四叔，这两天我一直在想这卖血挣来的三十五块钱怎么花？我想给爷爷几块钱，可是爷爷太老了，爷爷都老得不会花钱了。我还想给你几块钱，我爹的几个兄弟里，你对我最好。四叔，可我又舍不得给你，这是我卖血挣来的钱，不是我卖力气挣来的钱，我舍不得给。四叔，我刚才站起来的时候突然想到娶女人了。四叔，我卖血挣来的钱总算是花对地方了……四叔，我吃了一肚子的瓜，怎么像是喝了一斤酒似的，四叔，我的脸，我的脖子，我的脚底，我的手掌，都在一阵阵地发烧。
- ⏱ 2023-04-21 23:35:51

第三章

📌 许玉兰觉得许三观其实不比何小勇差，论模样比何小勇还英俊几分，口袋里的钱也比何小勇多，而且看上去力气也比何小勇大。
- ⏱ 2023-04-22 23:12:31

第九章

📌 她把领口尽量翻得大一点，胸前多露出一些那件精纺线衣
- ⏱ 2023-04-22 23:34:12
📌 她的邻居四散而去，像是戏院已经散场
- ⏱ 2023-04-22 23:39:47

第十一章

📌 我只有你们两个儿子，你们要记住了，是谁把我们害成这样的
- ⏱ 2023-04-22 23:44:57

第十五章

📌 许三观从林芬芳家里出来，仿佛是从澡堂里出来似的身上没有了力气
- ⏱ 2023-05-03 01:13:43
📌 这十来年里只见过他们两次，两次都是他回到村里去奔丧，第一次是他爷爷死了，第二次是他四叔死了
- ⏱ 2023-05-03 01:14:47

第十六章

📌 戴眼镜的男人背着十斤肉骨头，五斤黄豆，两斤绿豆，还有一斤菊花回家去了。
- ⏱ 2023-05-03 01:20:41

第十七章

📌 许玉兰从许三观手里缴获的三十元钱，有二十一元五角花在做衣服上
- ⏱ 2023-05-03 01:22:48

第十八章

📌 我们明天去丝厂食堂吧，我知道你们想去戏院食堂，可是戏院食堂已经关掉了，听说天宁寺食堂这两天也要关门了，就是我们丝厂食堂还没有关门，不过我们要去得早，去晚了就什么都吃不上了……”
- ⏱ 2023-05-03 12:02:30

第十九章

📌 她每天都让许三观少吃两口饭，有了一乐、二乐、三乐以后，也让他们每天少吃两口饭，至于她自己，每天少吃的就不止是两口饭了。
- ⏱ 2023-05-03 12:03:11
📌 从今天起，二乐、三乐，还有你，一乐，喝完粥以后都给我上床去躺着，不要动，一动就会饿，你们都给我静静地躺着，我和你们妈也上床躺着……我不能再说话了，我饿得一点力气都没有了，我刚才喝下去的稀粥一点都没有了。
- ⏱ 2023-05-03 12:07:33

第二十章

📌 现在我也是没有办法了，遇上这灾荒年，我要是再不收点吃的，不收点喝的，这城里有名的李血头就饿死啦。等日子好过起来，我还是会不拿群众一针一线的。
- ⏱ 2023-05-03 12:25:40

第二十一章

📌 最后，他对许三观的鼾声说：我不是你的亲生儿子，你也不是我亲爹。
- ⏱ 2023-05-03 12:39:02

第二十五章

📌 “我把菜藏在米饭下面，现在没有人，你快吃口菜。”
- ⏱ 2023-05-03 13:13:17

第二十七章

📌 许三观离开方铁匠那里，一个上午走了十一户人家，有八户借给了他钱。
- ⏱ 2023-05-03 13:31:27

第二十八章

📌 “十天来我卖血卖了四次，就像一天里从女人身上下来四次，这时候就不只是腿软了，这时候人会觉得一阵阵发冷……”
- ⏱ 2023-05-03 13:43:59

读书笔记

第三章

划线评论

📌 她父亲说：“你就去对他说，你要结婚了，新郎叫许三观，新郎不叫何小勇。”

“这话我怎么说得出口？他要是想不开，一头往墙上撞去，我可怎么办？”

“他要是一头撞死了，”她父亲说，“你就可以不说话了。”

许玉兰的心里放不下那个名叫何小勇的男人，那个说话时双手喜欢握住自己手腕的男人，他差不多天天都要微笑着来到她家，隔上几天就会在手里提上一瓶黄酒，与她的父亲坐在一起，喝着酒说着话，有时是嘿嘿地笑。有那么两次，趁着她的父亲去另一条街上的厕所时，他突然把她逼到了门后，用他的身体把她的身体压在了墙上，把她吓得心里咯咯乱跳。
- 💭 有牛
- ⏱ 2023-04-22 23:09:43

本书评论

毛泽东选集（全四卷）

2023-07-02T03:21:50Z

元数据

[!abstract] 毛泽东选集（全四卷）

书名：毛泽东选集（全四卷）

作者：

简介：这部选集，包括了毛泽东同志在中国革命各个时期中的重要著作。几年前各地方曾经出过几种不同版本的《毛泽东选集》，都是没有经过著者审查的，体例颇为杂乱，文字亦有错讹，有些重要的著作又没有收进去。现在的这部选集，是按照中国共产党成立后所经历的各个历史时期并且按照著作年月次序而编辑的。这部选集尽可能地搜集了一些为各地方过去印行的集子还没有包括在内的重要著作。选集中的各篇著人，都经著者校阅过，其中有些地方著者曾作了一些文字上的修正，也有个别的文章曾作了一些内容上的补充和修改。

出版时间

ISBN：

分类：政治军事-政治

出版社：人民出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

第一次国内革命战争时期

📌 谁是我们的敌人？谁是我们的朋友？这个问题是革命的首要问题。
- ⏱ 2023-05-02 14:43:30
📌 我们的革命要有不领错路和一定成功的把握，不可不注意团结我们的真正的朋友，以攻击我们的真正的敌人。
- ⏱ 2023-05-02 14:50:54
📌 那些中间阶级，必定很快地分化，或者向左跑入革命派，或者向右跑入反革命派，没有他们“独立”的余地。
- ⏱ 2023-05-02 15:06:21

读书笔记

本书评论

让成熟的大脑自由

2023-07-02T03:21:50Z

元数据

[!abstract] 让成熟的大脑自由

书名：让成熟的大脑自由

作者：约翰·梅迪纳

简介：为什么我永远找不到我的钥匙？为什么我不像以前那样睡得好？为什么我的朋友不断重复同样的故事？我该怎么做才能保持头脑敏捷？著名发展分子生物学家、脑神经科学家约翰·梅迪纳博士基于多年的研究成果和广泛涉猎，告诉你大脑衰老的真相以及对抗衰老的处方。梅迪纳从社会脑、思维脑、身体与大脑、未来的大脑四个方面，总结出了中老年人最关心的关于友谊、压力、睡眠和长寿等领域的10条定律，每条定律之后都附有实用而可操作的建议，比如阅读、追忆或跳舞能恢复哪方面的机能等，并在最后都将之连接到一个维护大脑健康的计划中。全书每个观点背后都有扎实可考的科学理论做支撑，击碎流传甚广的谣言，用幽默的小故事来呈现抽象复杂的原理，深入浅出、通俗有趣。

出版时间 2021-07-01 00:00:00

ISBN： 9787557692988

分类：心理-心理学应用

出版社：天津科学技术出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

定律1 保持高质量的友谊

📌 社会交往就像老年人大脑的维生素和矿物质，具有非常强的影响力，即便是网上社交也是有益的。
- ⏱ 2023-05-14 16:12:02
📌 执行功能是行为变速箱，主要由前额叶皮层控制，前额叶是额头右后方的一个重要脑区
- ⏱ 2023-05-22 20:25:40
📌 执行功能包括认知控制（比如改变注意力状态的能力）、情绪调节（比如管理愤怒的能力）和短期记忆
- ⏱ 2023-05-22 20:55:11
📌 就像神经内分泌学家布鲁斯·麦克尤恩（Bruce McEwen）所说，积极的社会互动越多，你的适应负荷就会越轻
- ⏱ 2023-05-22 20:57:27
📌 当你婚姻不幸或长期承受其他压力时，应激激素（如皮质醇）的水平就会升高，这会杀死T细胞。
- ⏱ 2023-05-22 21:00:14

读书笔记

本书评论

认知驱动：做成一件对他人很有用的事

2023-07-02T03:21:50Z

元数据

[!abstract] 认知驱动：做成一件对他人很有用的事

书名：认知驱动：做成一件对他人很有用的事

作者：周岭

简介：做成一件有价值的事，成为一个有价值的人；成长的根本是做成事情、创造价值。做到，是更高等级的成长。一个人的成长也是通过主动做成一件对他人很有用的事来实现的。但在现实生活中，很多人虽然内心强烈希望变好，行动也非常努力，却始终无法做成事情，这背后的原因通常是缺少价值意识、输出意识、创造意识、作品意识、利他意识…… 《认知驱动：做成一件对他人很有用的事》将通过“做成一件事”的心法和技法两部分内容，和大家一起探索如何通过创造个人价值获取人生的成功、幸福和意义。从“习惯养成”到“技能培养”，从“对内输入”到“对外输出”，从成为“更好的人”到成为“更有价值的人”，这些刻意的转变会让我们走出焦虑的怪圈。单纯依靠意志力的努力往往是盲目的，所以人们会反反复复地起念，又反反复复地失败。一个人只有了解做成一件事的来龙去脉、看清事情本质后，才能走出反复尝试却劳而无功的困境。学会用认知来驱动自己，我们才能更好地到达成长的彼岸——做成一件对他人很有用的事，成为一个有价值的人。

出版时间 2021-08-01 00:00:00

ISBN： 9787115569455

分类：心理-认知与行为

出版社：人民邮电出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

前言为什么我们很努力却总是看不到希望

📌 打造技能必须有产出，即使刚开始不完美，但只要持续打磨，你的产出就会变得越来越精细
- ⏱ 2023-06-01 13:36:06
📌 在技能卓越的情况下，那些良好的习惯才会大放异彩！
- ⏱ 2023-06-01 13:37:28

第一章价值——改变自己的关键是创造价值

📌 改变自己的关键是创造价值。
- ⏱ 2023-06-02 21:58:20
📌 只有当自身创造的价值足够大时，我们才能被别人强烈需要，才能参与到更大的社会交换中去，并得到对方对等的回馈
- ⏱ 2023-06-02 21:58:40
📌 力求每篇文章都追求底层、不碰热点、不说个人碎碎念，砍掉浮夸的表情、无意义的插图及一切与主题无关的东西；同时力求每篇文章都能解决一个实际问题或改变一个观念，而不是让人情绪高涨一下之后就归于沉寂了。
- ⏱ 2023-06-02 22:04:01
📌 这篇文章在三年、五年甚至十年后再看还有价值吗？如果没有，那就没必要写了
- ⏱ 2023-06-02 22:04:21
📌 生产对别人有用的东西永远是写作的指南针，其他事情亦是如此，价值交换规律放在哪里都会起作用
- ⏱ 2023-06-02 22:05:25
📌 。顶级的知识可以给我们带来底层的认知、广阔的视角、丰富的素材和独特的关联
- ⏱ 2023-06-02 22:11:20
📌 经验这东西很容易枯竭，但知识不会。
- ⏱ 2023-06-02 22:11:35
📌 这也是我们要不断学习“新知”的原因，因为“新知”永远是增加价值的有效砝码
- ⏱ 2023-06-03 09:21:50
📌 利他的正确姿势不是无端付出，而是努力成为一个有价值的人。我们需要通过自身的能力或价值去影响他人、服务他人，而不是试图用某种条件去取悦或控制他人。
- ⏱ 2023-06-03 09:33:42
📌 想让对方听你的劝，最好的方式不是语言，而是你自己真的变好，而且比现在好很多、比他好很多，那时你的话才有分量。因为更好的建议不是劝说，而是影响。
- ⏱ 2023-06-03 09:36:21
📌 同质化的内容实在太多了
- ⏱ 2023-06-03 09:45:33
📌 越是在传播手段发达的社会里，越要坚守价值。因为这个世界已经不缺乏传播途径了，但价值依旧稀缺！
- ⏱ 2023-06-03 09:58:06

第二章身份——一切从信念开始

📌 理性，是将我们从低级本性的需求中解放出来的大救星，但同时也是一个严厉的看守，拒绝我们向智慧之上的层面逃离
- ⏱ 2023-06-04 11:00:10
📌 乐观构想、悲观计划、乐观实行
- ⏱ 2023-06-04 11:00:37
📌 比如在事情开始的阶段，他会让自己睡也想、醒也想，一天24小时不断地思考、透彻地思考，让自己从头顶到脚底，全身充满“非同寻常的、强烈的愿望”。他说：“如果从身上某处切开，流出来的不是血，而是这种‘愿望’。”比如在事情计划的阶段，他又会反复周密地推敲实现愿望的具体方法，将实现愿望的过程在头脑里进行模拟演练，直到像“看见了”它的结果一样才肯罢休。
- ⏱ 2023-06-04 11:04:24
📌 精彩的人生还需要浪漫、无畏和勇气。
- ⏱ 2023-06-04 11:06:21

第三章心理——清除成事路上的情绪障碍

📌 负面偏好”会使我们更多地注意负面信息和事件，不自觉地忽略大多数正面、美好的事情。
- ⏱ 2023-06-04 11:08:16
📌 在非黑即白的世界里，人们只能容纳自己喜欢的事物，只能接受自己喜欢的秩序
- ⏱ 2023-06-05 09:08:55
📌 复杂，意味着更多的变化和不确定，同时也意味着更多的丰富和精彩
- ⏱ 2023-06-05 09:10:14
📌 压力其实没有好坏之分，但有轻重之分，适度的压力反倒是我们保持活力的重要基石
- ⏱ 2023-06-05 09:18:57
📌 进入了舒适区，我们可以暂时松一口气，但不能一松到底，因为舒适区的消逝瓦解“不以人的意志为转移”
- ⏱ 2023-06-05 09:29:38

第四章策略——方法和路径

📌 因为真正的目标和动力来自我们对一件事情清晰而长远的认知，而非某个特殊的时间点。
- ⏱ 2023-06-05 09:36:41
📌 大多数人无法成功戒烟的主要原因是不清楚烟瘾形成的真正机制，只好依靠意志力戒烟
- ⏱ 2023-06-05 09:37:26
📌 。单纯依靠意志力的努力往往是盲目的，所以人们会反反复复地起念，又反反复复地失败。只有当一个人彻底了解了烟瘾的来龙去脉、看清了吸烟这件事的本质之后，才会从心底里觉得抽烟是一件极不划算的事情，才能不靠意志力轻松把烟戒掉。
- ⏱ 2023-06-05 09:37:34
📌 当我们通过原理机制彻底看清做一件事的好处时，便会觉得不做这件事是一种损失
- ⏱ 2023-06-05 09:38:56
📌 《有效学习》的作者乌尔里希·伯泽尔在谈到如何学习时曾说：“我们都愿意从事自己认为有价值感和意义的事情，因为动机是学习活动的终极动力，也是掌握任何一项技能的第一步，而获得独特的价值感和意义最好的方法就是主动去描述目标与自己的关联，换句话说就是调整看待事物的角度，看到这件事情的长远意义。
- ⏱ 2023-06-05 09:40:41
📌 一个人的成就往往在他的眼界之内，一个人在现实世界中能走多远，其实在他心里早就标记好了
- ⏱ 2023-06-05 09:41:38
📌 但困难之时正是进步之机。如果此时有人敢直视模糊、敢于对不确定性做出脑力范围内最大程度的“假设”，那他就能更大概率地突出重围，获取更多人生优势。
- ⏱ 2023-06-05 10:36:49
📌 我们所有的观点、结论，本质上都是一种假设。观点和结论的好坏，取决于我们的假设与事实相符的程度
- ⏱ 2023-06-05 10:42:56
📌 当你读到一本口碑很差或评分很低的书时，也不要鄙夷地将它拒之门外。更好的做法是，保持开放的心态去翻一翻、读一读，或许书中有那么一两句话触动了你、改变了你，那也是很有价值的。
- ⏱ 2023-06-05 10:47:17
📌 一是只做刚需之事
- ⏱ 2023-06-05 10:48:49
📌 二是没有期待之心
- ⏱ 2023-06-05 10:48:52
📌 我们长大后的多数烦恼都来自对自己和他人的过高期待
- ⏱ 2023-06-05 10:49:58
📌 主动削减欲望、降低期待的目的在于让自己丢掉精神包袱、轻装上阵，毕竟焦虑只会让我们停滞不前。
- ⏱ 2023-06-05 10:51:32
📌 但张同完的方法是：只看一部剧，但这一部剧要看100遍！他还提供了这一方法的具体步骤。第一步，关掉所有字幕观看第一遍；第二步，打开母语字幕观看第二遍，确认之前没有听懂的部分；第三步，换成英文字幕，把刚才没听懂的片段抄下来；第四步，反复练习听不清楚的片段，听完马上跟读；第五步，关掉所有字幕，观看剩下的97遍。这其中，关键要领是弄清楚每一句台词的意思，听完马上跟读，对不熟练的片段反复练习，使语气、语速、语调尽可能与剧中一样。换句话说，就是将剧中的情景对话强化为“大脑的肌肉记忆”，直到在类似的场景下不用思考就能脱口说出极为准确和地道的外语。
- ⏱ 2023-06-08 09:35:53
📌 对知识运用的频率、速度及熟练度也是学习能力的一部分
- ⏱ 2023-06-08 09:41:50
📌 凡是遇到卡壳、学不下去的情况，只有一个原因——你对此前学过的东西不熟练，没有达到掌握的程度
- ⏱ 2023-06-08 09:42:10
📌 如果有另一项差异极大的能力与自己的主业进行两个维度的复合，情况就不同了
- ⏱ 2023-06-08 09:49:31
📌 作为圈外人，没有身份标签的限制反而更能创新
- ⏱ 2023-06-08 09:52:35
📌 B计划最好是一个秘密的项目，至少在开始的时候是这样的
- ⏱ 2023-06-08 09:55:43
📌 所以无论何时，我们都要在本职工作之外培养一个甚至多个全新的技能，去创造一个或多个外界无法剥夺的价值和优势。
- ⏱ 2023-06-08 10:03:31

第五章战略——环境与多维

📌 因为孩子的镜像神经元只有在家长做出相应行为时才会被激活，所以一万句劝说抵不过自己的一次真实示范
- ⏱ 2023-06-08 10:08:12
📌 一是信息爆炸了，但知识并没有爆炸。海量的信息不仅增加了我们甄别筛选知识的难度，还让我们随时随地处于即时信息和肤浅信息的包围中
- ⏱ 2023-06-08 10:10:02
📌 要特别关注我们目之所及和触手可及的东西，因为离我们越近的东西就越会被关注，而越被关注的东西就越容易被放大
- ⏱ 2023-06-08 10:12:15
📌 移动到更好的环境中是借力“偷懒”的上上策
- ⏱ 2023-06-08 10:14:17
📌 学习的秘密之一就在于同时调动多维度感官
- ⏱ 2023-06-08 10:23:05
📌 我们不能只盯着单维度的语言和思维，而应该尽可能让自己的所有感官参与其中，不断地实践与练习。
- ⏱ 2023-06-08 10:25:36
📌 所以介入阅读更理想的时机，或许正是一个人既有一定的人生经历，又有一些人生困惑的时候，此时读书往往会以解决问题为目的，知识和阅历能相互融合，意识和潜意识的所有维度也能有效结合，可塑性最强
- ⏱ 2023-06-08 10:27:28

第六章成事——做到，是最高等级的成长

📌 至少主动做成一件对他人很有用的事
- ⏱ 2023-06-08 15:33:44
📌 花大量时间对作品（产品）进行持续的修改和打磨，每次做到当前最佳水平
- ⏱ 2023-06-08 15:51:15

读书笔记

第一章价值——改变自己的关键是创造价值

划线评论

📌 生产对别人有用的东西永远是写作的指南针，其他事情亦是如此，价值交换规律放在哪里都会起作用
- 💭 我能带给人家什么？人家就会给予相应的回报
- ⏱ 2023-06-02 22:08:19

第三章心理——清除成事路上的情绪障碍

划线评论

📌 我们要学会在简单世界和复杂世界中来回穿梭，而不是只取其一
- 💭 其实如果对二元对立抱持一种排斥的思想，又何尝不是陷入了二元对立中呢
- ⏱ 2023-06-05 09:16:09

第五章战略——环境与多维

划线评论

📌 二是被称为人体新器官的手机，随时可以把我们的时间撕成碎片
- 💭 深有感触，在测试Notion的这几天经常使用手机查找资料，而手机上的碎片信息一次又一次地把我的时间吸走（还是自制力不够）
- ⏱ 2023-06-08 10:11:32

本书评论

认知觉醒：开启自我改变的原动力

2023-07-02T03:21:50Z

元数据

[!abstract] 认知觉醒：开启自我改变的原动力

书名：认知觉醒：开启自我改变的原动力

作者：周岭

简介：为什么我们做事总是急于求成、避难趋易？所谓有耐心，就是要“咬牙坚持、死磕到底”？如何不再用“三分钟热情”和“打鸡血”的方式做事？如何保持极度专注？如何消除焦虑？如何提高学习能力？这是一部可以穿透时间的个人成长方法论。7大底层概念，20个成长关键词，助你彻底走出焦虑与迷茫，拥有清醒的认知、清楚的目标、清晰的路径、清爽的情绪。通过“大脑构造、潜意识、元认知”等思维规律，你将真正看清自己；通过“深度学习、关联、反馈”等事物规律，你将真正看清世界，提升自控力、专注力、学习力……只有洞悉底层的内在规律，我们才能真正开启自我改变的原动力。

出版时间 2020-06-01 00:00:00

ISBN： 9787115543424

分类：心理-认知与行为

出版社：人民邮电出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

第一章大脑——一切问题的起源

📌 我们在生活中做的大部分决策往往源于本能和情绪，而非理智
- ⏱ 2023-05-26 11:45:17
📌 本能脑和情绪脑的基因一直被生存压力塑造着，所以它们的天性自然成了目光短浅、即时满足。
- ⏱ 2023-05-26 11:45:48
📌 明明知道，但就是做不到；特别想要，但就是得不到
- ⏱ 2023-05-26 11:48:38
📌 事实上理智脑很少有主见，大多数时候我们以为自己在思考，其实都是在对自身的行为和欲望进行合理化
- ⏱ 2023-05-26 12:03:46
📌 习惯之所以难以改变，就是因为它是自我巩固的——越用越强，越强越用。要想从既有的习惯中跳出来，最好的方法不是依靠自制力，而是依靠知识
- ⏱ 2023-05-26 12:07:52
📌 上天赋予理智脑智慧，是让它驱动本能和情绪，而不是直接取代它们。
- ⏱ 2023-05-26 12:10:21
📌 无论个体还是群体，人类的安全感都源于自己在某一方面拥有的独特优势：或能力，或财富，或权力，或影响力。
- ⏱ 2023-05-26 12:11:06
📌 读书的“艰难”与买书的“惬意”简直相差十万八千里。
- ⏱ 2023-05-26 12:11:34
📌 归结起来，焦虑的原因就两条：想同时做很多事，又想立即看到效果
- ⏱ 2023-05-26 12:44:23
📌 复利效应显示了价值积累的普遍规律：前期增长非常缓慢，但到达一个拐点后会飞速增长
- ⏱ 2023-05-26 12:59:55
📌 舒适区边缘另一个重要的规律是它揭示了能力成长的普遍法则：无论个体还是群体，其能力都以“舒适区—拉伸区[插图]—困难区”的形式分布
- ⏱ 2023-05-26 13:02:30
📌 学习之后的思考、思考之后的行动、行动之后的改变更重要，如果不盯住内层的改变量，那么在表层投入再多的学习量也会事倍功半；因此，从权重上看，改变量﹥行动量﹥思考量﹥学习量
- ⏱ 2023-05-26 13:04:32
📌 学习进展和时间的关系并不是我们想象中的那种线性关系（学多少是多少），而是呈现一种波浪式上升曲线
- ⏱ 2023-05-26 13:07:52
📌 首先，面对天性，放下心理包袱，坦然接纳自己
- ⏱ 2023-05-26 13:10:06
📌 其次，面对诱惑，学会延迟满足，变对抗为沟通。
- ⏱ 2023-05-26 13:12:04
📌 该有的享受一点都不会少，只是不是现在享受，而是在完成重要的事情之后。”这是一个有效的策略，因为放弃享受，它们是不会同意的，但延迟享受，它们是能接受的。
- ⏱ 2023-05-26 13:12:54
📌 这种“后娱乐”的好处是，将享乐的快感建立在完成重要任务后的成就感之上，很放松、踏实，就像一种奖赏
- ⏱ 2023-05-26 13:13:57
📌 最后，面对困难，主动改变视角，赋予行动意义
- ⏱ 2023-05-26 13:14:53
📌 当我们明白了深度学习的意义，就可能放弃听书、速读，转而开始精读和输出
- ⏱ 2023-05-26 13:15:26
📌 最高级的方法是请本能脑和情绪脑出动来解决困难。
- ⏱ 2023-05-26 13:15:57

第二章潜意识——生命留给我们的彩蛋

📌 学习知识的目的是“消除模糊”，而获取知识的方法也是“消除模糊”，目的和方法相统一
- ⏱ 2023-05-26 17:49:34
📌 提升思考能力的方法正是不断明确核心困难和心得感悟，并专注于此。
- ⏱ 2023-05-26 17:50:08
📌 德国心理治疗师伯特·海灵格曾这样描述人们对烦恼的态度：受苦比解决问题来得容易，承受不幸比享受幸福来得简单。这极符合人类不愿动脑的天性。
- ⏱ 2023-05-26 17:53:24
📌 行动力不足的真正原因是选择模糊。
- ⏱ 2023-05-26 18:02:03
📌 当我们没有足够清晰的指令或者目标时，就很容易选择享乐，放弃那些本该坚持但比较烧脑的选项。
- ⏱ 2023-05-26 18:03:16
📌 潜意识没有思维，只关心眼前的事物，喜欢即刻、确定、简单、舒适，这是属于天性的部分，同时，它处理信息的速度又极快，至少可达11 000 000次/秒，能极其敏锐地感知很多不易察觉的信息，这是属于感性的部分
- ⏱ 2023-05-27 07:07:07
📌 所谓“熔断不读书法”，意思就是在读书时一旦看到有启发的内容，就触发熔断点，立刻停止读书
- ⏱ 2023-05-27 07:10:19
📌 一眼看过去就头痛、不知道在说什么的题目，也不用理它；只有那种大致能看出点思路，但又要动点脑筋的题目，一定要多做。这个就是中间地带，是你能够进步最快的地方。
- ⏱ 2023-05-27 07:20:50

第三章元认知——人类的终极能能力

📌 元认知能力就是我们习以为常、见怪不怪的反思能力
- ⏱ 2023-05-28 23:12:29
📌 你能意识到自己在想什么，进而意识到这些想法是否明智，再进一步纠正那些不明智的想法，最终做出更好的选择
- ⏱ 2023-05-29 10:11:26
📌 学习前人的智慧可以让我们拥有更广的全局视角（高度）、掌握更深的底层规律（深度），帮我们从无知中跳出来，做出更加正确的选择
- ⏱ 2023-05-29 10:13:23
📌 我们总是这样，一开始只想找一根绳子，最后却牵出一头大象。
- ⏱ 2023-05-29 10:15:16
📌 元认知能力总能让你站在高处俯瞰全局，不会让你一头扎进生活的细节，迷失其中。如果你足够细心，还会发现未来视角总是当前行动的指南针，它可以在茫茫的生命中为你导航，让你主动选择去做那些更重要而不是更有趣的事情。
- ⏱ 2023-05-29 10:16:51
📌 监控自己的注意力，然后将其集中到自己需要关注的地方。
- ⏱ 2023-05-29 10:17:16
📌 教育的意义就是教你在遇到一件事的时候如何看待它。当你对这件事进行反应的时候，总是有你自己的天性在里面，比如说有人骂你，你就想骂回去，但是你在这个反应当中会有一个哪怕是零点几秒的间隔去思考或者审视，这个间隔就是你获得的教育或者经历的意义
- ⏱ 2023-05-29 10:25:06
📌 每当遇到需要选择的情况时，我们要是能先停留几秒思考一下，就有可能激活自己的理智脑，启用元认知来审视当前的思维，然后做出不一样的选择。
- ⏱ 2023-05-29 10:27:06
📌 一定要在选择节点上多花“元时间”
- ⏱ 2023-05-29 10:28:03
📌 元时间通常分布在“选择的节点”上，比如一件事情、一个阶段或一天开始或结束时。善用这些时间会极大程度地优化后续时间的质量。
- ⏱ 2023-05-29 10:28:40
📌 如果不在这些选择的节点想清楚，我们就会陷入模糊状态，而模糊是潜意识的领地，它会使我们产生本能的反应——娱乐。所以，基本的应对策略便是：在选择的节点审视自己的第一反应，并产生清晰明确的主张。
- ⏱ 2023-05-29 10:29:14
📌 比如我们希望成为一个会说话的人，那么遵守一个原则：想两遍再说。脱口而出的话往往出自本能，如果我们能在那句话说出口前先停一两秒，用理智脑再审视一遍，或许马上就会改变主意、换一种说法，甚至选择保持沉默，毕竟有时候最好的回答就是不回答。
- ⏱ 2023-05-29 10:29:50
📌 要想清楚，不仅要审视第一反应，同时还要有清晰明确的主张
- ⏱ 2023-05-29 10:30:59
📌 元认知能力强的一个突出表现是：对模糊零容忍。换句话说，就是想尽一切办法让自己找出那个最重要的、唯一的选项，让自己在某一个时间段里只有一条路可以走。这道理很简单，既然权重都差不多，那么做哪件事都没有损失。犹豫不决，什么都想做又什么都做不好，才是最大的损失。
- ⏱ 2023-05-29 10:31:38
📌 自己行动力弱的时候，脑子里对未来的具体行动肯定是模糊不清的
- ⏱ 2023-05-29 10:32:03
📌 元认知能力强的人就是这样：无论是当下的注意力、当天的日程安排，还是长期的人生目标，他们都力求想清楚意义、进行自我审视和主动控制，而不是随波逐流。
- ⏱ 2023-05-29 10:34:18
📌 高尔基曾经说：每一次克制自己，就意味着比以前更强大。
- ⏱ 2023-05-29 10:34:42

第四章专注力——情绪和智慧的交叉地带

📌 缺少感受的行动，就像失去灵魂的躯壳；缺少感受的人对凡事都心不在焉、视而不见、听而不闻。
- ⏱ 2023-05-29 10:41:19
📌 分心走神的原因无非两个：一是觉得当下太无聊，所以追求更有意思的事情；二是觉得当下太痛苦，于是追求更舒适的事情。因为身体受困于现实，只好让思想天马行空。
- ⏱ 2023-05-29 10:41:56
📌 因为走神时，我们要么沉浸过去，要么担忧将来，要么幻想不可能实现的情况，走神可以让我们活在任何时候，唯独不能让我们活在当下。
- ⏱ 2023-05-29 10:42:44
📌 分心走神还会造成拖延和低效，因为情绪总是滞后于行为，所以人们做事时进入状态往往很慢，需要情绪过渡。
- ⏱ 2023-05-29 10:43:41
📌 身体感受永远是进入当下状态的最好媒介，而感受事物消失的过程更是一种很好的专注力训练
- ⏱ 2023-05-29 10:47:35
📌 绝大多数人缺乏指导下的努力都属于“天真的练习”，即反复做某件事情，并指望只靠那种反复改善表现、提高水平
- ⏱ 2023-05-29 10:53:42
📌 第一，有定义明确的目标。
- ⏱ 2023-05-29 10:53:57
📌 目标定义越明确，注意力的感知精度就会越高，精力越集中，技能越精进。如果目标太大，那就将它分解成小目标，这样做也是为了使目标更具体、精细。
- ⏱ 2023-05-29 10:55:25
📌 第二，练习时极度专注
- ⏱ 2023-05-29 10:55:32
📌 因为专注的真正动力并不是毅力和耐心，而是不断发现技巧上的微妙差异和持续存在的关注点，精力越集中则感知越细微。
- ⏱ 2023-05-29 10:56:16
📌 即事前聚精会神，让意识极度投入；事后完全忘记，让意识彻底撒手。这样，灵感和答案就会大概率地出现。
- ⏱ 2023-05-29 10:57:19
📌 好的学习模式是，在做A的时候彻底关注A，在做B的时候彻底关注B,A和B两件事情之间有非常清晰的界线。
- ⏱ 2023-05-29 10:58:14
📌 李大钊也说过：“要学就学个踏实，要玩就玩个痛快！”
- ⏱ 2023-05-29 10:58:27
📌 第三，能获得有效的反馈
- ⏱ 2023-05-29 10:59:11
📌 闭门造车式的练习不仅容易让人分心走神，也会让自己长期在低水平层面徘徊。
- ⏱ 2023-05-29 10:59:39
📌 第四，始终在拉伸区练习。
- ⏱ 2023-05-29 10:59:58
📌 当人们对当前的活动感到厌倦时，说明应该提高难度；当人们对当前的活动感到焦虑时，说明应该保持这个水平专注练习，如此反复交替就可以让自己进入心流通道，沉浸其中
- ⏱ 2023-05-29 11:01:34

第五章学习力——学习不是一味地努力

📌 一个自己能坚持做下去的方式，比单纯按照标准化的时间和方式做更重要
- ⏱ 2023-05-29 11:10:48
📌 如果你已经为人父母，那就应该花大量的时间探寻孩子的拉伸区，然后指导他们在舒适区的边缘努力，而不是看到孩子考不好就一味冲着他们发脾气，说别人家的孩子如何如何，对标优等生，给孩子加学习量、加难度，这样做往往会适得其反。
- ⏱ 2023-05-29 11:15:16
📌 做选择是一件极为耗能的事情
- ⏱ 2023-05-29 11:17:52
📌 ：速成是不可能的
- ⏱ 2023-05-29 11:20:20
📌 好一点的情况是读原书，但若是读完从不回顾、思考，只满足于输入的过程，这类学习的知识留存率很低
- ⏱ 2023-05-29 11:26:44
📌 必须动用已有的知识去解释新知识
- ⏱ 2023-05-29 11:28:03
📌 所以，逼迫自己获取高质量的知识以及深度缝接新知识，再用自己的语言或文字教授他人，是为深度学习之道。
- ⏱ 2023-05-29 11:29:53
📌 深度学习有以下3个步骤：(1)获取高质量的知识；(2)深度缝接新知识；(3)输出成果去教授。
- ⏱ 2023-05-29 11:30:22
📌 正确的行动往往是反天性的，让你觉得舒服和容易的事往往得不到好结果，而一开始你认为难受和困难的事才能让你真正产生收获
- ⏱ 2023-05-29 11:30:46
📌 一是尽可能获取并亲自钻研一手知识
- ⏱ 2023-05-29 11:31:02
📌 二是尽可能用自己的话把所学的知识写出来
- ⏱ 2023-05-29 11:31:35
📌 人与人之间的差距不是来自年龄，甚至不是来自经验，而是来自经验总结、反思和升华的能力。
- ⏱ 2023-05-29 11:33:22
📌 深度学习除了能让我们不再浮躁，能磨炼理智，还能带来诸多好处，比如跨界能力的提升
- ⏱ 2023-05-30 10:08:46
📌 深度学习的三个层次：·知道信息点·关联信息点·行动和改变
- ⏱ 2023-05-30 10:19:27
📌 知识的获取不在于多少，而在于是否与自己有关联，以及这种关联有多充分。
- ⏱ 2023-05-30 10:24:30
📌 考试得了高分，不叫有知识；茶余饭后能高谈阔论，这也不叫有知识。这些场合下，知识虽然有用，但是这些知识都不太牵扯到具体的得失，所以只是智力游戏。只有当局势不明朗、没有人告诉你该怎么办，而错误的判断又会导致一些不良的后果时，你要是能因为有知识而敢于拿一个主意，这才算是真有知识。请注意，这不是在说，实用的知识才是知识，而是在说，只有当知识能够帮助你做实际决策的时候，它才是你的知识。
- ⏱ 2023-05-30 10:30:46
📌 所以在个人成长领域，没有最优、最确定、最权威的认知体系，只有最适合我们当前状态的认知体系
- ⏱ 2023-05-30 10:32:15
📌 寻找触动点
- ⏱ 2023-05-30 10:39:45
📌 而作者的知识体系和框架，又与我何干呢？
- ⏱ 2023-05-30 10:42:20
📌 处于认知圈边缘的知识与我们的实际需求贴合得最紧密，因此也更容易让我们产生触动，进而与现有的知识进行关联。而他人认知体系中的很多知识，纵使再有道理，如果距离我们的认知或需求太远，就相当于处在了学习的困难区
- ⏱ 2023-05-30 10:45:03
📌 体系的本质就是用独特的视角将一些零散的、独立的知识、概念或观点整合为应对这个世界的方法和技巧。
- ⏱ 2023-05-30 10:46:13
📌 ，每日反思不是记流水账，而是留意每天最触动自己的那件事，不管是好的启发还是坏的体验，都写下来复盘，写得越细越好。
- ⏱ 2023-05-30 10:51:50
📌 一是用自己的语言重新解释新知识，这会促使自己原有的知识体系对新知识做出反应
- ⏱ 2023-05-30 10:53:07
📌 二是在需要的时候能够顺利提取知识，提取不出来的知识就是伪触动。
- ⏱ 2023-05-30 10:54:49
📌 三是在生活中能够经常练习或使用这些知识，因为实践是产生强关联的终极方法。
- ⏱ 2023-05-30 10:55:04
📌 打卡活动自带任务心态，人们每打一次卡，都要面临一次任务闭合需求，这在开始时并无大碍，但动机一旦转移，人们的心理就会发生变化。
- ⏱ 2023-05-30 17:09:20
📌 至少在学习时，身心合一、极度专注是极为重要的前提条件，只有在这种状态下，人们才能从学习活动中收到精细、强烈的正向反馈。然而任务心态破坏了身心合一的状态，这种不良体验会加剧人们对学习活动的厌恶感，形成恶性循环。
- ⏱ 2023-05-30 17:13:48
📌 设下限，不设上限。
- ⏱ 2023-05-30 17:16:35
📌 这种策略的智慧之处在于规避了任务闭合需求，只要觉得有意思，你就可以一直学下去，直至自己觉得有些吃力。由于没有设置具体的上限，比起打卡模式，新策略的能动性要强很多，而且能动性还是可持续获取的。除此之外，这种策略也极其符合刻意练习的原则——让自己始终处于舒适区的边缘。因为这么做，你每次都可以刚好学到有点难但又不是太难的程度，而打卡却必须面对一个固定的任务值，很容易让人觉得无趣或困难，从而放弃。
- ⏱ 2023-05-30 17:18:01
📌 于学习而言，保持内在的动机最重要
- ⏱ 2023-05-30 17:19:04
📌 超强的欲望和情绪力量却是非常宝贵的行动力资源，如果能让它们感受到学习的乐趣，它们同样会展现强大的行动力，让自己像沉迷娱乐一样沉迷于学习。
- ⏱ 2023-05-30 17:23:12
📌 想创造全新的学习动机，就得放弃一味打卡输入的做法，想办法直接运用或产出作品，获取反馈。
- ⏱ 2023-05-30 17:26:11
📌 分享不是随意分享半成品，而是尽最大力气将作品打磨成自己当前能力范围内可完成的最好的样子。
- ⏱ 2023-05-30 18:48:15
📌 如果对方除了情绪上的攻击再无其他内容，那你大可哈哈一笑，忽略就好了。这说明对方不但嫉妒你，还不如你，因为他没法拿出更好的作品或观点来回应，只会发泄情绪、肆意谩骂。在鸡蛋里挑骨头，这事谁不会呢？
- ⏱ 2023-05-30 18:50:18
📌 但如果对方的质疑中包含严谨的反证，能准确指出你的问题，那就要认真对待了，因为这些批评就是极佳的反馈，它们会帮助你把问题想得更清楚，让作品变得更完善
- ⏱ 2023-05-30 18:50:44
📌 真正的学习成长不是“努力，努力再努力”，而是“反馈，反馈再反馈”
- ⏱ 2023-05-30 18:56:35
📌 定义明确的目标、极度的专注、有效的反馈、在拉伸区练习。
- ⏱ 2023-05-30 19:05:04
📌 从不过度消耗自己，只要感到精力不足，就停下来主动休息，这反而使他们精力桶的水位得到快速回升
- ⏱ 2023-05-30 19:12:28
📌 在生活中，最要不得的就是那种明明已经分心走神了，却还要强撑内耗，倒不如遵循“极度专注+主动休息”的模式，让自己先尽力保持短时间的极度专注，到有些累的时候就主动停下来，这是更加明智的生活和学习策略。
- ⏱ 2023-05-30 19:17:11
📌 克服困难和抵制诱惑都需要消耗意志力。
- ⏱ 2023-05-30 19:21:22
📌 所以，一个真正的自控高手，不是一个只知道冲刺的人，而是一个善于主动休息、保持平衡的人
- ⏱ 2023-05-30 19:21:31

第六章行动力——没有行动世界只是个概念

📌 注意力的使用同样遵循这个规律，最初的选择会影响行为自动增强的方向。
- ⏱ 2023-05-30 19:30:09
📌 在初始阶段，强迫自己先做重要的事情，一旦进入正向的增强回路，你便能拥有强大的行动力——这正是增强自制力、提升行动力的秘密
- ⏱ 2023-05-30 19:32:59
📌 清晰力，也就是把目标细化、具体化的能力——行动力只有在清晰力的支撑下才能得到重构。
- ⏱ 2023-05-30 19:34:53
📌 因为做规划的目的并不是让自己严格地按计划执行，而只是为了让自己心中有数
- ⏱ 2023-05-30 19:48:09
📌 从某种程度上说，有自己热爱的事，比行动力本身要重要得多
- ⏱ 2023-05-31 08:21:15
📌 你陷入怠惰、懒散、空虚的情绪中动弹不得时，往往是因为你的大脑处于模糊状态
- ⏱ 2023-05-31 08:21:40
📌 想先看到结果再行动的人往往无法看到结果
- ⏱ 2023-05-31 08:25:29
📌 如果你觉得别人讲的道理有理有据，而自己暂时无法反驳，碰巧自己又非常想做这件事，那就相信他们说的是对的，然后笃定地行动
- ⏱ 2023-05-31 08:33:01
📌 不发生真正改变的学习都是无效的学习
- ⏱ 2023-05-31 08:42:42
📌 懂得百点不如改变一点。真正的成长不在于自己懂得了多少道理，而在于自己改变了多少。
- ⏱ 2023-05-31 08:43:38

第七章情绪力——情绪是多角度看问题的智慧

📌 任何能制造压力的事件都会挤占我们的心智带宽
- ⏱ 2023-05-31 08:51:44
📌 只要我们的注意力被某一个巨大的事物吸引，我们就有可能进入稀缺状态，进而降低心智带宽，做出不明智的行为
- ⏱ 2023-05-31 08:51:48
📌 当一个人同时面临很多任务的时候，他的心智带宽就会降低，反而没有了行动力和自控力。
- ⏱ 2023-05-31 08:53:45
📌 现代生活虽然缓解了生存压力，却又带来了自控上的压力。抵制诱惑和欲望无一不消耗我们的心智带宽
- ⏱ 2023-05-31 08:55:22
📌 第一帖，保持环境觉知，理智选择。对于有些人来说，受影响最大的就是格局和远见。为了在压力环境中尽可能保持较大的格局和远见，我们就需要运用高级元认知能力保持对环境的觉知，因为在无觉知状态下，心智带宽会受到挤压，但在主动觉知状态下，人们就可以承受压力，集中心力做出理性的决定。
- ⏱ 2023-05-31 08:56:23
📌 第二帖，保持目标觉知，少即是多。知道自己的人生目标之所以最为重要，是因为它直接决定着我们如何使用自己的心智带宽。
- ⏱ 2023-05-31 08:56:45
📌 第三帖，保持欲望觉知，审视决策。对于一部分人来说，当前最大的压力莫过于过多欲望对心智带宽的冲击。
- ⏱ 2023-05-31 08:57:38
📌 脑子里存在大量任务和念头的时候，往往是我们行动力最弱的时候
- ⏱ 2023-05-31 08:57:59
📌 真正的行动力高手不是有能耐在同一时间做很多事的人，而是会想办法避免同时做很多事的人
- ⏱ 2023-05-31 08:58:41
📌 第四帖，保持情绪觉知，谨慎决定。不要在最兴奋的时候做决定，也不要在最愤怒的时候做决定，尤其是重大决定。大喜大悲的时候，我们的心智带宽往往很窄，判断力也很弱。
- ⏱ 2023-05-31 08:59:56
📌 第五帖，保持闲余觉知，自我设限。
- ⏱ 2023-05-31 09:00:39
📌 世界上任何一个人、任何一件物、任何一件事都是多维立体的
- ⏱ 2023-05-31 09:02:36
📌 当然，就识人而言，听一个人说话就能大致推断出他的学识和修养水平。比如那些对自己的观点、见解异常坚持，对别人的观点又油盐不进的人，基本上可以被视为学识浅薄或修养一般的人，因为学识浅薄的人除了自己的原始视角，通常很难感知到其他外部视角，所以就会抓着第一判断死死不放，因此，其修养表现也不高。反观那些学识或修养高的人，他们表达观点时通常非常谨慎，常用“也许”“可能”等表述。这真不是他们故意谦虚，而是因为懂的越多，看到的角度越多，就越知道用一句话或一个观点无法把事情描述清楚。
- ⏱ 2023-05-31 09:05:54
📌 只是有的人面对再好的事情时都盯着一点瑕疵不放，而有的人却能从任何一件糟糕的事情中找到闪光点并放大，忽视其他不足之处。
- ⏱ 2023-05-31 09:11:11
📌 困难和压力总能把人的情绪和注意力抓得死死的，让你很难看到其他角度。
- ⏱ 2023-05-31 09:30:08
📌 为自己而做，通常是为了应对外部的压力和要求，为玩而做，则是为了应对重复、枯燥的事情
- ⏱ 2023-05-31 09:35:29

第八章早冥读写跑，人生五件套——成本最低的成长之道

📌 人做决定时，分两个层次。第一个是“情绪决定”，比如看到人家健身、摄影、画画时，自己的肾上腺素开始飙升，马上表示自己也想做；第二个是“理智决定”，理智决定同样表示想要一样东西，但表示人必定已经想好了为什么要做、怎样去做以及可能遇到的困难等问题。习惯做“情绪决定”的人，凡事倾向于半途而废，而善于做“理智决定”的人则更容易让想法变成现实。
- ⏱ 2023-05-31 09:59:42
📌 很多时候我们都处于“假阅读”状态，并且没有意识到这是由低层次的“情绪决定”引起的
- ⏱ 2023-05-31 10:01:07
📌 想要快速成为一个行业的高手，最好的方法就是和行业专家交流，直接向他们请教——这大概是最高级的成长策略了。但现实是普通人很少有这样的机会和资源。
- ⏱ 2023-05-31 10:01:55
📌 读书就是用最低廉的成本获取最高级的成长策略
- ⏱ 2023-05-31 10:02:48
📌 阅读可以让我们的思维能随时与顶级的思想交锋，对一个主题进行深度全面的理解，并与自己的实际充分关联，这种思维状态在平淡生活中是很少有的，但是只要拿起书本就可以马上拥有。我们每天花费在阅读上的时间越多，花在无意义的娱乐活动上的时间就会越少，思维密度就会越来越大。通过长年累月的积累，坚持高密度思考的人会与习惯低密度思考的人产生巨大的差距，这正是我们现在要仰望智者的原因。
- ⏱ 2023-05-31 10:06:17
📌 一　读书要先学会选书。
- ⏱ 2023-05-31 10:06:41
📌 在初读的时候，一定要让兴趣、难度、需求三者尽可能匹配。
- ⏱ 2023-05-31 10:07:19
📌 只要紧紧盯住“改变”这个根本目标，很多阅读障碍就会立即消失。
- ⏱ 2023-05-31 10:12:33
📌 即无论学习什么东西，都要努力琢磨它们究竟在讲什么，它们的实际意义是什么，然后用自己的话将其重新讲出来
- ⏱ 2023-05-25 11:01:46
📌 向一个没有任何背景知识的人说清楚一件事是很难的。
- ⏱ 2023-05-31 20:49:52
📌 通过自己的语言，用最简单的话把一件事情讲清楚，最好让外行人也能听懂。
- ⏱ 2023-05-25 11:02:09
📌 你不能自己站在11层，然后假设你的读者站在第10层，指望着只要告诉他第11层有哪些内容就让他明白。你的读者站在第一层，你必须知道你脚下踩着的另外10层到底是怎么构造的。这就迫使你对所掌握的，或之前认为正确的那些东西做彻彻底底的、深刻的反思，你的受众越是不懂，你需要反思的就越深刻。
- ⏱ 2023-05-31 20:51:23
📌 特别是讲知识、讲道理的书籍，最好不要随意堆砌抽象概念，让人感觉很高深，看得云里雾里的
- ⏱ 2023-05-31 20:58:34
📌 比如采用像聊天一样的方式写作就会让文章显得很自然。很多初学写作的人都过于把写作当成一回事，写着写着就开始说教了，实际上，若是你把写作当成是与一位老朋友聊天，过程就会变得不一样了。你想啊，聊天是一件多轻松的事情啊，也是每个人都愿意做的事情。你在聊天的过程中必然不能显得太严肃，不能太高高在上，也不能只顾着讲自己，你肯定得观察对方的感受，所以好的写作就是聊天，好的聊天也是写作。
- ⏱ 2023-05-31 21:03:51
📌 大量使用类比，除了类比和排比，尽量不使用任何修辞
- ⏱ 2023-05-31 21:14:04
📌 只有当我们使用自己的语言去解释所学时，才会真正调动自己原有的知识，才能将松散的信息编织成紧密的体系和网络，甚至创造新的认知。换言之，用自己的语言重新表达就是在调动自己的千军万马。
- ⏱ 2023-05-31 21:15:35
📌 好的写作肯定要用自己的语言将所学之物重新解释。尽管这样做比较难，尽管一开始肯定做得不好，但它必定能让你迈进深度学习的殿堂，飞速进步。
- ⏱ 2023-05-31 23:44:34
📌 你自己想明白的，是从你的体系中萌芽生长出来的；而从书上看到的，非常容易停留在做个笔记画个线，涂个手绘画个圈，自以为懂了的层面。不要害怕书上早就写了，我们每个人都可以在这个世界上，刻画出一条与众不同的轨迹。
- ⏱ 2023-05-31 23:49:32
📌 所以运动不是关键，运动之后的活动安排及环境刺激才是关键。有效的模式是这样的：在运动后的1~2小时内进行高强度、高难度的脑力活动，比如阅读、解题、背记、写作、编程，等等，或是一些需要复杂技巧的体力活动，诸如舞蹈、钢琴，以及参加不同于以往的社交活动，如接触新的环境、人物或事物，这么做可以让新的神经元受到刺激，不断生长。换句话说，运动之后，脑子需要充分接受考验或挑战，才能让自己不断地变“聪明”
- ⏱ 2023-06-01 00:00:25
📌 所以绝大多数运动者的硬伤就在这里：运动之后缺乏主动学习的意识和习惯
- ⏱ 2023-06-01 08:36:07
📌 好的运动方式一定同时包含有氧运动和复杂运动
- ⏱ 2023-06-01 08:37:03

结语一流的生活不是富有，而是觉知

📌 好的反思是感知生活中最触动自己的点，难受的、欣喜的、念念不忘的
- ⏱ 2023-06-01 08:46:25
📌 越是好的反思，着眼点往往越细微
- ⏱ 2023-06-01 08:49:48
📌 一是不要被形式所缚。比如很多人以为每日反思必须一天不落，以致偶尔中断就会气馁放弃。其实“每日”只是提醒我们要持续行动，偶尔中断也没有关系，我们可以把反思的关键词先记下来，等有空了再整理。如果某天真的一点感触都没有，那不写也没有关系。另外也有一些人过于注重形式，用写正式文章的方式去写反思，以致消耗太多精力，丧失动力。
- ⏱ 2023-06-01 08:51:13
📌 反思的最终目的是改变，而不是形式的完美
- ⏱ 2023-06-01 08:51:18
📌 二是尽量提炼认知点或行动点。不要沉溺于情绪释放或碎碎念。因为反思的最终目的是改变，所以要尽可能提炼出具体可操作的认知点和行动点，以指导未来的生活，否则很容易让反思变成日记，效果大打折扣。
- ⏱ 2023-06-01 08:51:42

后记共同改变，一起前行

📌 一个人无论获得什么样的成绩，都不能忽略时代、运气和环境这样的大背景，只看到自身的努力和付出，是狭隘和不客观的；
- ⏱ 2023-06-01 08:59:01

读书笔记

第一章大脑——一切问题的起源

划线评论

📌 从现在开始，对自己表现出的任何急躁、焦虑、不耐烦，都不要感到自责和愧疚，一旦觉察自己开始失去耐心了，就温和地对自己说：“你看，我身体里那个原始人又出来了，让他离开丛林到城市生活，确实挺不容易的，要理解他
- 💭 在读这句话时我失去了继续集中注意力的耐心，它成功地将我放飞的思绪捕捉了回来
- ⏱ 2023-05-26 13:11:44

划线评论

📌 很多人之所以痛苦焦虑，就是因为只盯着表层的学习量。他们读了很多书、报了很多课，天天打卡、日日坚持，努力到感动自己，但就是没有深入关注过自己的思考、行动和改变，所以总是感到学无所获，甚至会认为是自己不够努力，应该继续加大学习量，结果陷入了“越学越焦虑，越焦虑越学”的恶性循环。
- 💭 一语中的
- ⏱ 2023-05-26 13:05:35

划线评论

📌 人类天性中最原始、最本能的部分——即时满足。
- 💭 即时满足同样适用于现在的网文，短视频等等
- ⏱ 2023-05-26 12:46:56

第二章潜意识——生命留给我们的彩蛋

划线评论

📌 围绕这个触发点对自己提问。
·为什么刚才这个点让我有启发？
·我能够把这个启发点用在3个不同的事情上吗？
·这个启发点有没有其他类似的知识？
- 💭 既然读到了这一段那就正好试一试这个方法

为什么会有启发：熔断读书法的内容与我的观点有部分契合，如前文提到的感觉对了极有可能是潜意识对这个观点的认同

该如何运用：在阅读时如果遇到对自己有感触的文段，或者阅读工具书时的知识点即停下来思考为什么？

类似的知识：暂时没有接触
- ⏱ 2023-05-27 07:19:35

第三章元认知——人类的终极能能力

划线评论

📌 为什么抖音、快手等短视频App让人看得根本停不下来？因为一个视频结束后系统会立即自动跳到下一个，在整个过程中，大脑都被本能和情绪劫持，理智脑根本没有主动启动的机会。如果你希望自己能从娱乐中抽身，只需提前告诉自己：“这个视频结束后暂停几秒。”一旦理智脑拥有了审视和反思的时间，我们通常都能控制住自己。
- 💭 在做任何事情前先停下来思考
- ⏱ 2023-05-29 10:26:25

划线评论

📌 实际上，这个时候我们最应该做的事情是起床、穿衣服、洗漱，等一切收拾妥当了再来查看信息，否则很可能受各种信息的牵引去看这个、看那个，最后，几十分钟过去了，人还在被窝里
- 💭 正是我每天想要避免的问题，信息实在太多等意识到我应该起床时已经很晚了
- ⏱ 2023-05-29 10:20:52

划线评论

📌 所以从实用角度讲，元认知能力可以被重新定义为：自我审视、主动控制，防止被潜意识左右的能力。
- 💭 即防止走神
- ⏱ 2023-05-29 10:18:41

第四章专注力——情绪和智慧的交叉地带

划线评论

📌 第一，有定义明确的目标。
- 💭 练钢琴的例子与我小时候联系吉他一样，做到连续十次不犯错误就算成功
- ⏱ 2023-05-29 10:55:06

划线评论

📌 计算机则会平等地处理所有信息，每次提取信息都要从数据库中挨个搜索一遍。
- 💭 并不是，数据库索引类似于之前提到过的通过名字声音时间想起一个人
- ⏱ 2023-05-29 10:45:52

第五章学习力——学习不是一味地努力

划线评论

📌 刷手机、玩游戏这些被动使用注意力的事情我不推荐，因为它们仍然是消耗精力的。
- 💭 我就是玩手机，确实效果不好，甚至会感觉更累
- ⏱ 2023-05-30 19:25:27

划线评论

📌 是否有及时、持续的正向反馈，正是产生学习效果差异的关键。
- 💭 做一件事得不到正向反馈是很容易放弃的
- ⏱ 2023-05-30 17:21:28

划线评论

📌 比如跑步时总想着还剩多少时间就可以结束，读书时总想着还剩多少页就可以完成，背单词时总想着还剩多少个就可以完事……这样的心态会使注意力处于分散状态，很难全身心投入事物本身，从而体会其中的要领和乐趣。
- 💭 任务心态会让人毛躁，失去感受学习的耐心
- ⏱ 2023-05-30 17:12:52

划线评论

📌 一件事若迟迟没有完成，心里就总是记挂，期盼着早点结束；此事一旦完成，做这件事的动机就会立即趋向于零。
- 💭 当完成一件任务后就会立刻将它抛到脑后
- ⏱ 2023-05-30 17:08:39

划线评论

📌 一件事若迟迟没有完成，心里就总是记挂，期盼着早点结束；此事一旦完成，做这件事的动机就会立即趋向于零。
- 💭 就像内存中的数据，如果没有被持久化到硬盘总一旦断电关机，数据就会被清空
- ⏱ 2023-05-30 17:07:38

划线评论

📌 阿健同学正是因为没有意识到自己的学习动机已经转移，所以疑惑为什么一旦打卡中断就不愿继续行动，因为他关心的是让打卡纪录保持完整，而不是让学习过程保持完整，其实对于学习来说，偶尔中断又有什么关系呢？
- 💭 不再是为了学习而学习，是为了打卡而学习
- ⏱ 2023-05-30 17:05:00

划线评论

📌 三是在生活中能够经常练习或使用这些知识，因为实践是产生强关联的终极方法。
- 💭 大话设计模式的内容我已经忘得的一干二净
- ⏱ 2023-05-30 10:55:43

划线评论

📌 寻找触动点
- 💭 与前文说的看到让自己触动的内容就停下一样，既然它能够触动你那这个知识点对你就是有价值的，因为它与你已经获得的知识可能存在某种关联，去挖掘它可能可以得到更大的收获
- ⏱ 2023-05-30 10:41:58

划线评论

📌 这其中最根本的阻碍在于他们意识不到新学习的知识点是孤立的
- 💭 双链笔记就是为了解决这一问题出现的
- ⏱ 2023-05-30 10:20:17

划线评论

📌 我们可以把浅学习作为了解新信息的入口，但不能把成长的需求全部寄托于此，更合理的态度是：专注于深度学习，同时对浅学习保持开放。
- 💭 可以利用浅层学习去接触新的知识，如果遇到感兴趣的则可以深度学习
- ⏱ 2023-05-30 10:15:42

划线评论

📌 深度之下的广度才是有效的。
- 💭 就像水面一样，在浅水层看到的和在水面上看到的并不是本质，只有足够深入才能看到真实，在深入的基础上再平行移动就能看到更广阔的真实
- ⏱ 2023-05-30 10:13:59

划线评论

📌 必须动用已有的知识去解释新知识
- 💭 就像费曼一样
- ⏱ 2023-05-29 11:28:19

第六章行动力——没有行动世界只是个概念

划线评论

📌 如果不行动，我们可能永远也找不到自己的人生目标，毕竟依靠低维度的认知和经历，我们很难看清自己真正想要什么。只有先依据前人的假设走到更高的层次，人生目标才可能慢慢浮现。
- 💭 低维看不见高维，或者说感知不到高维，但是低维能够进入高维
- ⏱ 2023-05-31 08:29:51

第七章情绪力——情绪是多角度看问题的智慧

划线评论

📌 事情本身并不重要，我们只是在通过它获取另外一种乐趣，顺便把这件事给做了。
- 💭 这一章内容我暂时没有什么感触，可能是因为生活阅历的不足导致内容处于我的“困难区”
- ⏱ 2023-05-31 09:32:34

划线评论

📌 很多人情绪不好，是因为他们把自己做的假设当成了事实，在不确定对方真实想法的情况下，直接把情绪发泄了出来
- 💭 对于功能开发我理解成了同事又要我修改功能，对于频繁改动功能需求我开始的情绪渐渐上来了于是对同事发了火，最后冷静下来仔细和同事聊了聊后才反应过来是我的理解错误
- ⏱ 2023-05-31 09:23:10

划线评论

📌 很多人情绪不好，是因为他们把自己做的假设当成了事实，在不确定对方真实想法的情况下，直接把情绪发泄了出来
- 💭 和前同事交流功能开发时我就犯了这个错误
- ⏱ 2023-05-31 09:15:32

第八章早冥读写跑，人生五件套——成本最低的成长之道

划线评论

📌 写作时如果不学会用自己的语言转述，则是无用的。
- 💭 在学习netty时我认为将书籍的内容梳理好后就不会忘，但其实没多久就将我认为不会忘的框架内容丢在了脑后，而那些同一本书中，同样是第一次接受的内容，经过我使用自己的语言去解释的内容至今映像深刻
- ⏱ 2023-05-31 23:52:30

划线评论

📌 我们大多数人都低估了类比（比喻）的作用，认为它只是文学中的一种修辞，事实上，它是我们的思维方式，更是我们的认知工具。认知语言学科的创始人乔治·莱考夫曾这样定义和评价“类比”。以一种事物认知另一种事物，恰恰是学习的本质！因为人类只能通过已知事物来解释未知事物，我们很难凭空去理解一个自己从未见过的东西。而类比，正是连接未知事物与已知事物的桥梁。
- 💭 费曼笔记法运用类比可以更好的去表述
- ⏱ 2023-05-31 21:12:05

划线评论

📌 三　高阶读书法。对于阅读来说，跳出误区也只是刚好回到平地，如果还想继续进阶，我想下面这两个建议非常值得你关注。第一个是要特别注意自己在阅读时产生的关联。如果一个知识点让你想起了其他的知识、引发了关联，一定要留意，并把它记下来。知识产生关联说明知识网络正在形成或加固，这么做还可能创造新知识，这正是学习的核心方法之一。第二个是读写不分家。如果你在阅读后还能把所学知识用自己的语言重新阐释，甚至将它们教授给他人，那这个知识将在你脑中变得非常牢固。
- 💭 我会这么做的
- ⏱ 2023-05-31 10:13:21

划线评论

📌 二　阅读是为了改变。很多人以为一本书只要读完，读书的过程就结束了。事实上，阅读只是整个过程的开始，阅读之后的思考、思考之后的实践比阅读本身更加重要（这里主要指非虚构类书籍）。很多人的阅读仅停留在表面，读的时候觉得这里好有道理、那里好有道理，读完之后就不闻不问了，然后迅速转移到下一本书中，这种满足于录入的阅读造成的一个直接后果便是，一段时间之后再去翻这本书就好像之前没有看过一样，所有的痕迹都烟消云散了。真正读好一本书，往往需要花费数倍于阅读的时间去思考和实践，并输出自己的东西——可能是一篇文章，也可能是养成一个习惯——这个过程比阅读本身要费力得多。
- 💭 拿我自己打比方，大话设计模式时我认为很好的一本书，我以为我在读完后代码水平会有很大的进步，于是我拼命地读，一刻不停地读，到最后我看完了也忘完了。或许我是有那么一点进步的，但是大部分的阅读时间都被我浪费了
- ⏱ 2023-05-31 10:11:28

划线评论

📌 脚步不能丈量的地方，文字可以；眼睛无法看到的地方，文字可以
- 💭 三体中描绘的宏伟世界时想象力无法触及的，文字赋予了它的磅礴大气
- ⏱ 2023-05-31 10:04:10

划线评论

📌 放弃闹钟的另一个好处是，不影响家人或室友的休息，这样更容易得到他们的支持。
- 💭 但是不用闹钟会迟到
- ⏱ 2023-05-31 09:41:47

结语一流的生活不是富有，而是觉知

划线评论

📌 甚至会无意识地“模仿”或被“同化”
- 💭 高中时我看到新的同学外八走的很"个性"会有意无意的去学,虽然没有养成习惯依然是正步走,但现在想起来还是很可笑的
- ⏱ 2023-06-01 08:56:26

划线评论

📌 一定要对自己极度坦诚，把心底最真实的想法挖出来
- 💭 有时我会刻意去欺骗自己,这是对自己的不坦诚也是不负责
- ⏱ 2023-06-01 08:52:48

划线评论

📌 无论何时，都要把对方的情绪和意见分开对待，这样，即使在最糟糕的事情中也能学到有用的东西。
- 💭 我应该记住这句话
- ⏱ 2023-06-01 08:44:21

本书评论

书评 No.1 看完这本书后会有意识地去改变自己

⏱ 2023-06-01 09:09:41

性格修正：如何突破你的原生性格

2023-07-02T03:21:50Z

元数据

[!abstract] 性格修正：如何突破你的原生性格

书名：性格修正：如何突破你的原生性格

作者：本杰明·哈迪

简介：沉迷于做九型人格、MBTI、DISC等各种性格测试，容易引起共鸣却慢慢发现所获寥寥？感觉人生陷入了停滞，却找不到破局的方法？因为受过创伤，便放弃了对新生活的期待？我们往往认为性格只能被找到、性格以类型划分、性格固定不变、性格来自过往经历、性格是真实自我的反映等，但这却往往使我们变得不再勇敢，逐渐走向平庸，甚至有深深的无力感或陷入困局。
本书通过丰富的心理学研究指出，利用性格测试和自身过去等定义“真实自我”和“原生性格”是片面甚至是错误的；并在阐述性格真相和常见五大性格误解的基础上，针对如何正确看待过往、自信定义自我、调整限制自我提升的错误观念和习惯等，在创伤、身份认同叙事、潜意识、环境四大性格影响因素等方面为读者提供了科学实用的建议，让读者可以从狭隘的性格观念中解放出来，走出困境，实现直接、高效的成长转变。

出版时间 2021-11-01 00:00:00

ISBN： 9787516660546

分类：心理-积极心理学

出版社：新华出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

导言性格测试险些毁了我的人生

📌 性格是表层的、易变的，是某种深刻得多的事物的副产物。
- ⏱ 2023-05-13 11:45:55

读书笔记

本书评论

影响力（全新升级版）

2023-07-02T03:21:50Z

元数据

[!abstract] 影响力（全新升级版）

书名：影响力（全新升级版）

作者：罗伯特·西奥迪尼

简介：自出版以来，《影响力》就一直是畅销佳作。由于它的影响，说服得以成为一门科学。无论你是普通人还是为某一产品或事业观点游说的人，这都是一本基本的必读书，是你理解他人心理的基石。心理学家罗伯特·西奥迪尼为我们解释了为什么有些人具有说服力，而我们总是容易上当受骗。隐藏在冲动地顺从他人行为背后的6大心理武器，正是这一切的根源。那些劝说高手们，总是熟练地运用它们，让我们就范。经过近7年的潜心研究，西奥迪尼发现了第7种心理武器——联盟，将6种心理武器扩展为7种；书中更新内容多达10万字，包括近10年行为心理学新研究与新发现，近5年上百个商业、管理、科技、个人成长、家庭教育等方面的全新案例。本书被引述率高居社会心理学之冠，曾获得美国心理学会、美国心理学基金会年度大奖提名。是《财富》杂志推荐的75本商业必读书；在中国，《影响力》系列书系常年位居各大网络、地面书店管理畅销榜单前10名。

出版时间 2021-10-30 00:00:00

ISBN： 9787559656438

分类：心理-社会心理学

出版社：北京联合出版公司

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

按一下就播放

📌 固定行为模式的基本特点是：构成模式的所有行为每一次几乎都是按相同的方式、顺序发生的
- ⏱ 2023-05-23 12:17:01
📌 我们在请别人帮忙的时候，要是能给出一个理由，成功的概率会更大
- ⏱ 2023-05-23 12:22:44

把赌注押在抄捷径上

📌 他们并没有煞费苦心地了解每一点能暗示绿宝石首饰价值的特点，力争稳操胜券，相反，他们只把宝押在价格这一点上。
- ⏱ 2023-05-23 12:33:25
📌 如果人们不熟悉一种产品或服务，就尤其可能会套用“贵=好”的原则
- ⏱ 2023-05-23 12:34:24
📌 模式化的自动行为在大部分人类活动中的出现频率都是相当高的，因为很多时候，它是最有效的行为方式，而另一些时候，它则是必要的。
- ⏱ 2023-05-23 12:40:56
📌 心理学家最近发现，我们在日常判断中会使用大量心理捷径。他们把这些捷径叫作“启发式判断”(judgmental heuristics)，其发挥作用的方式跟“价格高＝东西好”的原则是一样的，由此带来的简化思维在大多数时候都行之有效。
- ⏱ 2023-05-23 12:42:12
📌 我们不是先思考专家的论点，看看值不值得相信，而是直接忽视论点，仅仅因为专家是“专业人士”，就选择相信他们
- ⏱ 2023-05-23 12:46:28
📌 只有在人既有欲望也有能力的时候，才会以深思熟虑的可控方式做出反应。
- ⏱ 2023-05-23 12:53:17

渔利的奸商

📌 我们的自动磁带通常来自通过经验习得的心理学原理或范式
- ⏱ 2023-05-23 15:28:17
📌 人们往往会相信或去做自己身边人相信以及正在做的事
- ⏱ 2023-05-23 15:28:33
📌 “如果你发现有人说‘我不喜欢产品的某某方面’之类的话，就写一篇意见相反的评价。评价有着强大的力量，人们会通过他人所说的话来自我说服，并从别人的意见中寻找解开自己疑惑的答案。
- ⏱ 2023-05-23 15:40:31
📌 根据康奈尔大学的研究，你应该小心以下这样的评价：缺少细节。人很难描述自己没有真正体验过的东西，这就是为什么假评价往往只会做整体性的赞美，而不会深入具体细节。“比如，真实的酒店评价更有可能是跟酒店相关的具体词语，如‘浴室’、‘入住’或‘价格’。骗子写的评论则更多地跟场景铺垫有关，如‘度假’、‘出差’或者‘我丈夫’。”包括更多的第一人称代词。如果担心自己表现得不够真诚，你往往会更多地谈论自己。这就是为什么虚假评价里常常会出现更多的“我”字。动词比名词多。语言分析表明，假货中往往包含更多的动词，因为它们的作者经常用听起来很愉快或令人震惊的故事来代替实际的见解。真正的评价则更注重名词。
- ⏱ 2023-05-23 15:43:56
📌 “价格高＝东西好”原则的后一种用法，即吸引淘便宜货的买家
- ⏱ 2023-05-23 15:49:47

以柔克刚

📌 要是第二样东西跟第一样东西相当不同，那么，我们往往会认为两者的区别比实际上要大
- ⏱ 2023-05-23 16:17:51
📌 基于先前所发生事件的性质，相同的东西，即常温的水，会在之后显得极为不同
- ⏱ 2023-05-23 17:14:19
📌 先拿出便宜的东西，再拿出昂贵的东西，会使昂贵的东西显得更昂贵，而这定会给大多数销售组织造成不良后果
- ⏱ 2023-05-23 17:17:10

本章小结

📌 大部分的顺从技巧，即刺激一个人顺从另一个人的要求，都可以从人们自动化的捷径反应这一角度来理解。
- ⏱ 2023-05-23 21:01:46
📌 知觉对比是把两种不同事物之间的差异看得比实际上更大的倾向，是一些说服专业人士（销售、广告商等）喜欢利用的影响力杠杆。
- ⏱ 2023-05-23 21:00:56

第2章互惠

互惠原则怎样起作用

📌 我们通常都不怎么喜欢的人，比方说不请自来的讨厌的推销员、不愿交往的熟人、名字都没听说过的奇怪组织的代表，只要他们在向我们提出请求之前，先对我们施个小小的恩惠，最终都能极大地提高我们依其言行行事的概率。
- ⏱ 2023-05-25 12:45:18
📌 如果你刚刚因为帮了别人一把而收获感谢，请别说“没什么大不了的”“别想太多”“我对谁都会这么做”一类的老套客气话，这样只会削弱互惠原则带来的影响力。相反，你最好保留（应得的）影响力，不妨这么说：“如果我们的立场互换，我相信你也会这么做。”由此带来的好处应该相当可观。
- ⏱ 2023-05-25 12:48:43
📌 民选代表对一项法案或措施投出跟自己一贯主张完全相悖的支持票，大多都是为了回报法案发起人的人情。
- ⏱ 2023-05-25 13:38:25
📌 免费样品的真正妙处在于，它同时也是一份礼物，能把互惠原则应用起来。推销的人提供免费样品，表面上不过是为了让消费者知晓他们的商品，暗中却是把礼物天然具备的亏欠感给释放了出来，这完全是借力打力、四两拨千斤的柔道手法。
- ⏱ 2023-06-12 14:31:53
📌 一个人靠着硬塞给我们一些好处，就能触发我们的亏欠感。
- ⏱ 2023-06-12 14:54:45
📌 违背互惠原则，接受而不试图回报他人善举的人，是不受社会群体欢迎的
- ⏱ 2023-06-12 15:05:02
📌 在家庭或稳定的友谊这类长期关系中，纯粹的互惠交换并无必要，也不受欢迎
- ⏱ 2023-06-12 15:07:20

互惠式让步

📌 第一，面对接受的善意，我们感到有义务偿还；第二，倘若有人对我们让了步，我们便觉得有义务也退让一步
- ⏱ 2023-06-12 15:11:56
📌 第二项要求在客观上就可以是一项很大的要求，其只需要比第一项要求小就可以了
- ⏱ 2023-06-12 15:19:01
📌 拒绝-后撤策略似乎不仅会刺激人们答应请求，还会鼓励人们切身实践承诺，甚至人们还会自愿履行进一步的要求
- ⏱ 2023-06-13 14:35:29
📌 责任感　请求者运用拒绝-后撤策略主动让步，不仅提高了目标对象答应的概率，也令他们觉得最终协议是自己“说了算的”，进而产生了更多的责任感。人们要是对契约的条款感到负有责任，自然也更乐意遵守这一契约，因此，目标对象履行承诺也就不足为奇了。
- ⏱ 2023-06-13 14:39:12
📌 满意感　尽管平均而言，被试分给采用后撤策略的对手的钱最多，但这部分人对最终安排是最为满意的。这样看来，人们或许是这么想的：靠着自己的努力，对手“后撤”了。如此达成的协议自然分外圆满。
- ⏱ 2023-06-13 14:40:09

如何防范

📌 倘若别人的提议我们确实赞同，那就不妨接受它；倘若这一提议别有所图，我们就置之不理
- ⏱ 2023-06-13 15:10:43
📌 善意自然应当以善意回报，可对销售策略却没这个必要
- ⏱ 2023-06-13 15:14:08

第3章喜好

📌 要想改变感觉，就要用其他的感觉来抵消它
- ⏱ 2023-06-13 15:20:12

通过喜好赚钱

📌 。在决定是否购买该产品时，社会纽带的影响比对产品本身的好恶强两倍
- ⏱ 2023-06-13 15:25:51
📌 人们对好友的推荐更信任。但如果喜欢的朋友变成讨厌的人（如前女友或前男友），这种模式就会发生逆转
- ⏱ 2023-06-16 13:19:03
📌 先让人们喜欢他们
- ⏱ 2023-06-17 09:41:20

我喜欢你的理由

📌 光环效应指的是，一个人的某个正面特征就能主导其他人看待此人的眼光
- ⏱ 2023-06-17 14:55:03
📌 研究表明，我们会自动给长得好看的人添加一些正面特点，比如有才华、善良、诚实、聪明、随和与值得信任等。而且，我们在做出这些判断的时候并没有意识到外表魅力在其中发挥的作用
- ⏱ 2023-06-17 14:55:26
📌 长相好看的人更容易在需要的时候获得帮助，在改变听众意见时也更具说服力
- ⏱ 2023-06-17 15:00:04
📌 列夫·托尔斯泰就说过，“美即为善这一错觉是如此根深蒂固，真叫人难以置信”。
- ⏱ 2023-06-17 15:03:10
📌 我们喜欢与自己相似的人，不管相似之处是在观点、个性、背景还是生活方式上，我们从小（小至9个月的婴儿）都有这样的倾向
- ⏱ 2023-06-17 15:03:52
📌 请求者还有另一种利用相似点提高好感、增加顺从概率的办法，即假装跟目标人群有着相似的背景和兴趣。
- ⏱ 2023-06-17 15:05:25
📌 在最初联系的时候，千万不要对他们提出任何要求，要像对待朋友一样对待他们。
- ⏱ 2023-06-17 15:11:48
📌 。对看似不一样的人，我们可以寻找并关注跟他们的相似之处，以消除对他们期待过低的错误。
- ⏱ 2023-06-17 15:23:23
📌 利用“喜欢我们”这微不足道的信息，人们就能有效地诱使我们还以好感、答应请求
- ⏱ 2023-06-17 15:27:54
📌 得到餐馆服务员（“这道菜选得好”）或理发师（“你留什么样的发型都好看”）的赞美时，顾客往往会进行明显更慷慨的消费。同样，在求职面试时，如果求职者在跟面试官的互动中称赞了面试官，他们也可能会从面试官这里获得更有利的评价，并最终赢得工作机会。
- ⏱ 2023-06-17 15:28:07
📌 我们特别喜欢被人赞美奉承
- ⏱ 2023-06-17 15:30:54
📌 首先，只给了称赞的评估者最为被试们喜欢；其次，哪怕被试完全明白那人拍马屁只是为了讨好他们，也还是最喜欢那个人；最后，和其他两种情况不同，单纯的赞美无须准确。积极的评价，不管是真是假，都能让人产生对赞美者同等程度的喜欢。
- ⏱ 2023-06-17 15:32:01
📌 虽然接受奉承的人对真诚或者不真诚的赞美都容易相信，但不真诚的奉承是有代价的，旁观者会注意到其真实目的，并进而讨厌奉承者。
- ⏱ 2023-06-17 15:34:05
📌 找到并就你希望对方奉行不渝的地方做出真诚的赞美。人们接受赞美后会自我感觉良好，并对为自己带来称赞的特质或行为感到自豪。因此，如果别人做了一件我希望他继续做下去的事情，就不妨真诚地表达赞美。
- ⏱ 2023-06-17 15:38:44
📌 老师是不会囤积信息的，老师只会传播信息。
- ⏱ 2023-06-17 15:40:59
📌 不要仅仅把保护者或老师等角色分配给对方，而是可以诚实地赞美那些表现出乐于助人、富有责任心等值得赞许的品质的人
- ⏱ 2023-06-17 15:41:25
📌 课堂种族融合之所以会加剧种群偏见，大多是因为学生把其他族群的成员当成了竞争对手。于是这些教育工作者开始尝试一些新的学习形式，让孩子们通过合作而非竞争来学习。
- ⏱ 2023-06-17 19:00:35
📌 从竞争转向合作，是有可能让对手变成朋友的
- ⏱ 2023-06-17 19:05:33
📌 第一，虽然接触带来的熟悉往往能导致更大的好感，可要是接触本身蕴含了让人反感的体验，就会适得其反。
- ⏱ 2023-06-17 19:11:31
📌 第二，有证据表明，以团队为导向的学习能缓解这种混乱状态
- ⏱ 2023-06-17 19:11:36
📌 糟糕的消息会让报信人也染上不祥。人们总是自然而然地讨厌带来坏消息的人，哪怕报信人跟坏消息一点关系也没有
- ⏱ 2023-06-18 12:56:55
📌 不管是好事还是坏事，只要跟我们偶然地联系在了一起，都会影响人们对我们的感觉。
- ⏱ 2023-06-18 12:59:15
📌 关联原理能潜移默化地影响我们花钱的方式。
- ⏱ 2023-06-18 13:23:52
📌 拉茨兰把这套手法叫作“午宴术”，他发现，人们对就餐期间接触到的人或事物会更为喜爱
- ⏱ 2023-06-18 14:32:14
📌 当看照片上的面孔时，人们要是闻到潜意识里觉得愉快的味道，那么对这些面孔就更容易产生好感；要是闻到潜意识里觉得不快的味道，好感也会随之下降。
- ⏱ 2023-06-18 14:35:49
📌 人会强烈地倾向于将自己跟好消息联系起来，并竭力避开和坏消息的关联
- ⏱ 2023-06-18 14:40:21
📌 各种美好的东西都可以拿来替换食物的角色，把它们讨人喜欢的特质“出借”给人为地跟它们联系在一起的东西，如观念、产品和人民。
- ⏱ 2023-06-18 14:41:00
📌 人们深明关联原理的奥妙，并会努力把自己跟积极的事情联系起来，跟消极的事情保持距离，哪怕他们并非事情的起因。
- ⏱ 2023-06-18 14:48:07
📌 根据关联原理，倘若我们能用一些哪怕是非常表面的方式，比如我们的居住地，让自己跟成功联系起来，我们的公共形象也将显得光辉起来。
- ⏱ 2023-06-18 14:49:59

如何防范

📌 我们不需要识别出所有导致好感的因素，严防死守地不让它们对我们发挥作用。恰恰相反，我建议你听之任之，顺其自然。说服专业人士用来诱使我们产生好感的东西，我们不必提防，只要当心它们带来的过度好感就行。一旦我们觉得自己对说服专业人士的好感超出了该场合下的正常程度，那就到了唤出防御机制的时机了。
- ⏱ 2023-06-18 15:00:08
📌 们只需关注跟好感有关的一件事就行，即我们是不是觉得自己超乎寻常的迅速、热烈地喜欢上了对方？只要发现这种感觉，我们就该警惕了，因为对方可能采用了某种手法，而这时我们就可以采取必要的反击对策。
- ⏱ 2023-06-18 15:01:22
📌 ：不去压抑好感因素产生的影响力，听凭这些因素发挥力量，然后用这股力量反过来对付那些想从中获利的人
- ⏱ 2023-06-18 15:01:35
📌 在我们做出顺从决定时，把提出请求的人和请求本身从感性上分开，这是很明智的。
- ⏱ 2023-06-18 15:04:12

社会认同原则

📌 以符合社会规范的方式行事，总比跟它对着干犯的错误少。
- ⏱ 2023-06-18 15:18:18
📌 我们对社会认同的反应方式完全是无意识的、条件反射式的，这样一来，偏颇甚至伪造的证据也能愚弄我们。
- ⏱ 2023-06-18 15:18:44
📌 为什么这些牟利者这么乐意利用社会认同来捞钱呢？因为他们知道，人们在许多情况下都强烈地倾向于认为，如果一件事别人也在做，那它就更正确了
- ⏱ 2023-06-18 15:21:18
📌 95%的人都爱模仿别人，只有5%的人能率先发起行动，所以，要想说服别人，我们提供任何证据的效果都比不上别人的行动。
- ⏱ 2023-06-18 15:21:42
📌 如果当事人认为对亲密伴侣的暴力行为很普遍，那他日后更可能亲自施暴。
- ⏱ 2023-06-18 15:22:28
📌 认为一种想法正确的人越多，持有这种想法的人就越会觉得它正确。
- ⏱ 2023-06-18 15:56:19

最佳条件

📌 在自己不确定、情况不明或含糊不清、意外性太大时，我们最有可能觉得别人的行为是正确的。
- ⏱ 2023-06-18 15:59:33
📌 除了对特定环境的不熟悉，另一种不确定感来自我们对自己在某一问题上的既有偏好缺乏信心
- ⏱ 2023-06-18 16:01:20
📌 在审视他人反应，消除不确定感的过程中，我们很容易忽视一点微妙而重要的事实，即其他人有可能也在寻找社会证据。尤其是在局面模糊不清的时候，人人都倾向于观察别人在做什么，这会导致一种叫作“多元无知”的有趣现象。
- ⏱ 2023-06-18 16:05:10
📌 很多时候，紧急情况乍看起来并不会显得十分紧急。
- ⏱ 2023-06-18 16:06:27
📌 旁观者群体没能帮忙，不是因为他们无情，而是因为他们不能确定。
- ⏱ 2023-06-18 16:09:21
📌 在需要紧急救助的时候，你的最佳策略就是减少不确定状态，让周围的人注意到你的状况，搞清楚他们的责任
- ⏱ 2023-06-18 16:14:07
📌 实验表明，使用加工过的欢乐效果让观众笑得更频繁、更持久，并认为幽默素材更有趣。
- ⏱ 2023-06-18 21:52:23
📌 人们相信谣言往往是因为心中毫无根据的恐慌，而且谣言通过人们频繁的社交媒体动态变得更具传染性。很多时候，人们认定真相靠的并不是实体证据，而是社会认同。
- ⏱ 2023-06-18 22:01:54
📌 我们在观察与自己类似的人的行为时，社会认同原则能发挥出最大的影响力。
- ⏱ 2023-06-19 14:18:48
📌 而且值得一提的是，我们往往认为，青少年思想叛逆且独立。可事实上，这种态度其实只是针对家长。在同龄人群体中，青少年同样要根据社会认同来判断自己怎么做才合适
- ⏱ 2023-06-19 14:23:12
📌 这是社会认同原则的一个病态例证：这些人根据其他陷入困境的人的行动，决定了自己该怎么做。
- ⏱ 2023-06-19 17:41:16
📌 报道自杀的消息，促使一部分跟自杀者类似的人走向了绝路，因为现在他们发现自杀的念头更加站得住脚了
- ⏱ 2023-06-19 17:52:10
📌 同一地区的人们在态度、价值观和个性特征上是类似的
- ⏱ 2023-06-20 14:20:42

负面事件效应

📌 劝导性沟通不可在信息里把不良行为渲染得过分普遍，反而让它变得“正常”起来。
- ⏱ 2023-06-20 14:28:59
📌 社会公众对什么构成了可信赖的研究结果，是缺乏认识的。
- ⏱ 2023-06-20 14:31:02
📌 与其仅仅依赖于现有的社会认同，不如通过未来社会认同的证据来达到同样目的。
- ⏱ 2023-06-20 14:32:19

权威高压的力量

📌 在权威的命令下，成年人几乎愿意干任何事情
- ⏱ 2023-06-20 15:32:11
📌 即较之陌生人或普通的熟人，人们更有可能站在自己有着联盟感的一方，如朋友、邻居或亲属。
- ⏱ 2023-06-20 15:36:18

盲目服从的诱惑和危险

📌 无政府状态对文化群体是没什么好处的，社会哲学家托马斯·霍布斯(Thomas Hobbes)就言之凿凿地说，它必然会让生活变得“孤独、贫乏、污秽、粗野和短暂”
- ⏱ 2023-06-20 15:38:00

内涵不是内容

📌 头衔比当事人本人更能影响他人的行为。
- ⏱ 2023-06-20 15:56:06
📌 体格和地位之间存在联系。
- ⏱ 2023-06-20 16:00:37
📌 权力和权威的外部象征，说不定是靠假冒伪劣的材料编造出来的。
- ⏱ 2023-06-20 16:00:47
📌 在等级制组织中，享有权威地位的人会得到尊重对待，而没有权威地位的人则会得到无礼对待。
- ⏱ 2023-06-20 16:13:49
📌 衣着除了可以发挥制服的作用，还可以作为装饰，表现更广义上的权威。
- ⏱ 2023-06-20 16:13:59

让权威更加可信

📌 如果沟通者在陈述一开始就早早提到自己的提议或观点的缺陷，而不是只描述优点、在陈述末尾才少许提到缺点甚至完全不提，受众会立刻认为他很诚实。
- ⏱ 2023-06-21 14:24:42
📌 在政治演讲中，还有一个相关效应，使用负面词汇来为信息建立框架（15%的人失业），跟使用正面词汇建立框架（85%的人获得了就业）相比，前者的说服力更强，因为它们显得更值得信任。
- ⏱ 2023-06-21 14:44:13
📌 负面评价能建立可信度。研究中心认为，接近完美的评价会削弱可信赖感，负面评价的存在则会增加产品评估的可信度。
- ⏱ 2023-06-21 14:45:35

如何防范

📌 要用不太费劲的方式判断什么时候该遵循权威指示，什么时候该保持独立的见解。
- ⏱ 2023-06-21 14:48:43
📌 多想一想专家会不会因为我们的顺从而得到好处，我们就为自己又设立了一道安全网，防御权威不必要的影响。
- ⏱ 2023-06-21 14:56:01

第6章稀缺

📌 尤其是在存在风险和不确定感的条件下，人们更愿意去做出避免价值损失的选择，而不是选择去获得某种东西
- ⏱ 2023-06-21 15:17:26
📌 商业世界的管理者在做决定时更看重潜在损失而非潜在收益。
- ⏱ 2023-06-21 15:18:34
📌 “避免损失”优先于“获得收益”
- ⏱ 2023-06-21 15:20:52

物以稀为贵

📌 倘若瑕疵把一样东西变得稀缺了，垃圾也能化身成值钱的宝贝
- ⏱ 2023-06-21 15:22:11
📌 对失去某种东西的恐惧，似乎要比对获得同一物品的渴望，更能激发人们的行动力
- ⏱ 2023-06-21 15:24:17
📌 一件商品如果数量多，会降低人们对它的感知价值。
- ⏱ 2023-06-21 15:30:08
📌 拥有独特元素的产品和体验对消费者具有强烈的吸引力。稀缺物品恢复充分供应后，它就失去了对人们的吸引力
- ⏱ 2023-06-21 15:46:52

逆反心理

📌 机会越来越少的话，我们的自由也会随之减少，而我们又痛恨失去本来拥有的自由。保住既得利益的愿望，是心理逆反理论的核心
- ⏱ 2023-06-21 15:49:15
📌 “要是你很想做什么事情，那么有三种选择：自己做；出大价钱找人做；要不就故意禁止你家十几岁的孩子做。”
- ⏱ 2023-06-21 15:53:47
📌 每当有东西获取起来比从前难时，说明我们拥有它的自由受到了限制，那么我们就会越发地想要得到它。
- ⏱ 2023-06-21 16:04:38
📌 想让信息变得更宝贵，不一定非要封杀它，只要把它变得稀缺就行了
- ⏱ 2023-06-22 14:11:55

最佳条件

📌 较之一贯短缺，对从充裕变到短缺的饼干，人们的反应更为积极。
- ⏱ 2023-06-22 14:30:31
📌 一个国家经济和社会条件改善后，要是在短期内出现剧烈逆转，最有可能爆发革命。
- ⏱ 2023-06-22 14:37:07
📌 最容易起义的，不是那些传统上最受压迫的底层人民，这些人已经把自己的贫困潦倒看成社会的自然秩序了。相反，走上革命道路的，往往是至少品尝过了更美好生活的人。他们经历并习以为常的经济和社会进步突然之间可望不可求了，于是他们对进步产生了更为迫切的渴望，甚至不惜采取暴力来保护既得的进步
- ⏱ 2023-06-22 14:37:22
📌 自由这种东西，给一点又拿走，比完全不给更危险
- ⏱ 2023-06-22 14:41:30
📌 管教前后不一的父母，最容易教出反叛心强的孩子。
- ⏱ 2023-06-22 14:42:47
📌 参与竞争稀缺资源的感觉，有着强大的刺激性
- ⏱ 2023-06-22 14:49:08
📌 渴望拥有一件众人竞争的东西，几乎是本能的身体反应
- ⏱ 2023-06-22 14:51:33
📌 在碰到稀缺资源加竞争的魔鬼组合时，务必要小心谨慎。
- ⏱ 2023-06-22 14:57:05
📌 如果小圈子里大部分人都喜欢某一品牌的物品，那我们很可能也会这么做，但同时又会通过一个可见的维度（如物品的颜色）来区分自己。
- ⏱ 2023-06-22 15:00:37

如何防范

📌 一看到想要的东西就要得不到了，我们的身体就会亢奋起来。尤其是在涉及直接竞争的环境下，我们更是会血脉偾张、眼光短浅、情绪激昂。
- ⏱ 2023-06-22 15:11:55
📌 一旦在顺从环境下体验到高涨的情绪，我们就应该提醒自己，说不定有人在玩弄稀缺手法，必须谨慎行事。
- ⏱ 2023-06-22 15:13:50
📌 喜悦并非来自对稀缺商品的体验，而来自对它的占有。
- ⏱ 2023-06-22 15:15:52

第7章承诺与一致

📌 一旦做出了艰难的选择，人们总会很乐意地相信自己选对了。
- ⏱ 2023-06-22 15:38:40
📌 人人都有一种言行一致，同时也显得言行一致的愿望。
- ⏱ 2023-06-22 15:39:17

言出必行

📌 保持并显得前后一致的动力，是一种威力巨大的社会影响力武器，它经常令我们做出明显有违自己最佳利益的行为。
- ⏱ 2023-06-22 15:41:37

承诺是关键

📌 在接受琐碎请求时务必小心谨慎，因为一旦同意了，它就有可能影响我们的自我认知。它不仅能提高我们对分量更大的类似请求的顺从度，还能使我们更乐意去做一些跟先前答应的小要求毫不相关的事情。
- ⏱ 2023-06-25 12:22:14

发自内心地认同

📌 要想承诺达到这样的效果，必须满足一定的条件：它们得是当事人积极、公开、经过一番努力后自由选择的。
- ⏱ 2023-06-25 12:28:20
📌 行为是确定一个人自身信仰、价值观、态度以及他接下来想怎么做的主要信息源
- ⏱ 2023-06-25 14:43:10
📌 主动承诺似乎能给予我们用来塑造自我形象的合适信息，而自我形象又能塑造人们将来的行为，使之起到巩固自我形象的作用
- ⏱ 2023-06-25 14:45:21
📌 人们有一种天然的倾向，总认为声明反映了当事人的真实态度。出奇的地方在于，哪怕他们明知道当事人作的声明并非出于自愿，他们还是这么认为。
- ⏱ 2023-06-25 14:50:07
📌 一方面，人们内心有压力要把自我形象调整得与行为一致；另一方面，外部还存在一种更为鬼祟的压力，人们会按照他人对自己的感知来调整形象
- ⏱ 2023-06-25 14:58:49
📌 个人承诺是预防客户撕毁合同的一种重要心理机制
- ⏱ 2023-06-25 15:04:04
📌 每当一个人当众选择了一种立场，便会产生维持它的动机，因为这样才能显得前后一致
- ⏱ 2023-06-25 15:16:06
📌 为一个承诺付出的努力越多，它对承诺者的影响就越大
- ⏱ 2023-06-25 15:36:46
📌 “费尽周折才得到某样东西的人，比轻轻松松就得到的人，对这件东西往往会更为珍视。
- ⏱ 2023-06-25 15:52:46
📌 团队成员的忠诚和奉献精神，能极大地提高团队的凝聚力和生存概率。
- ⏱ 2023-06-25 15:56:36
📌 只有在认为外界不存在强大的压力时，我们才会为自己的行为发自内心地负责任。
- ⏱ 2023-06-25 16:01:30
📌 承诺一旦做出，就会开始长出腿来支撑自己。
- ⏱ 2023-06-25 16:28:14

如何防范

📌 “对金钱的热爱是万恶之源”。
- ⏱ 2023-06-26 11:04:28
📌 面对一样东西，我们总是先体验到感觉，过上短暂的一瞬间之后，才能将之理性化
- ⏱ 2023-06-26 11:10:58
📌 我们的情感和理性往往不在同一个方向上。
- ⏱ 2023-06-26 11:12:55

“我们”的力量

📌 人们倾向于顺从他们认为属于自己群体的人
- ⏱ 2023-06-26 11:26:12
📌 在大脑中，感受社会排斥带来的伤痛跟感受身体的伤痛一样，使用的是同样的脑区。
- ⏱ 2023-06-26 11:34:25
📌 如果人们对某个群体有着强烈的身份认同感，就会更乐于遵循该群体的规范，哪怕他们知道这些规范与现实脱节。
- ⏱ 2023-06-26 11:48:50

联盟1：身心合一

📌 从基因重叠的角度看，亲属关系越近（如父母或兄弟姐妹相较于叔叔或表亲），自我—他人重叠的感觉就越强烈
- ⏱ 2023-06-26 15:16:10
📌 不管是在家里还是家外，人们都会用相似性来判断基因重合，并偏爱与自己重合度更高的人。
- ⏱ 2023-06-26 15:31:06
📌 看到父母打开家门接待形形色色的人，很可能使孩子在成年之后也更愿意帮助陌生人。
- ⏱ 2023-06-26 15:33:07
📌 如果父母们希望孩子培养起广泛的慈悲心，不妨参考他的经历：让孩子在家里接触到来自不同背景的人，并像家人一样对待他们。
- ⏱ 2023-06-26 15:37:53

联盟2：行动合一

📌 人们统一行动时，就真的统一了
- ⏱ 2023-06-26 16:01:30
📌 “如果你无法用事实向受众证明你的观点，那就唱给他们听。
- ⏱ 2023-06-26 16:19:25
📌 说服沟通选用的思维模式，应该跟受众的思维模式相搭配，这才是最重要的教训
- ⏱ 2023-06-27 14:09:34
📌 文章的标题是《想爱上一个人，请这么做》，作者是曼迪·莱恩·卡特伦(Mandy Len Catron)，她声称发现了一种产生强烈的情感亲密性和爱情社会关系的有效途径，只需45分钟
- ⏱ 2023-06-27 14:18:37
📌 人都对自己亲手创造的东西有着特殊的亲近感。这是人类的共性。
- ⏱ 2023-06-27 14:39:20
📌 管理者越是认为项目的成功缘于自己，也就越是认为项目的成功和手下员工的能力密不可分。
- ⏱ 2023-06-27 14:43:08
📌 如果共同创作带来了暂时性的身份融合，那么，适用于一个人的，也适用于另一个人，不管逻辑怎么规定。
- ⏱ 2023-06-27 14:43:42
📌 六七岁的孩子在分享奖励上往往很自私，很少跟玩伴平均分配。但如果他们是跟玩伴合作努力赢得奖励的，那么绝大多数时候连3岁的孩子也会均分奖励。
- ⏱ 2023-06-27 14:44:17
📌 对消费者的建议提供高额奖金，会消除他们对该品牌的偏爱
- ⏱ 2023-06-27 14:51:21

跨群体大联盟

📌 孩子能学习并效法成年人对社会群体成员的非语言信号
- ⏱ 2023-06-27 19:23:23
📌 每当群体的福祉或声誉遭受威胁，我们就会猛烈还击：贬低对立群体的价值与价值观甚至人性。
- ⏱ 2023-06-28 14:45:26

原始的自动反应

📌 很多时候，我们在对某人或某事做判断的时候，并没有用上所有可用的相关信息；相反，我们只用到了所有信息里最具代表性的一条
- ⏱ 2023-06-28 15:51:15

捷径应受到尊重

📌 低等动物的认知能力从来就比较欠缺，可我们的问题却类似作茧自缚：是我们自己创造了一个太过复杂的世界，最终却搞得自己都应付不了。
- ⏱ 2023-06-28 16:03:54

读书笔记

按一下就播放

划线评论

📌 触发者并不是对手这个整体，而是对手具备的一些特征
- 💭 动物的固定行为模式的触发是依据被触发对象所抽象出来的特征，而不是被触发对象的整体
- ⏱ 2023-05-23 12:20:12

把赌注押在抄捷径上

划线评论

📌 在有愿望也有能力仔细分析信息时，人们会更多地按可控的方式去处理；可要是条件不允许，人们则更可能采取较为容易的“按一下就播放”式方法。
- 💭 网络与大模型便利了获取信息的渠道，使得人分析信息的能力大大提升
- ⏱ 2023-05-23 12:51:28

划线评论

📌 我们不是先思考专家的论点，看看值不值得相信，而是直接忽视论点，仅仅因为专家是“专业人士”，就选择相信他们
- 💭 正是因为滥用这一观点，导致现在的专家污名化
- ⏱ 2023-05-23 12:47:48

划线评论

📌 如果人们不熟悉一种产品或服务，就尤其可能会套用“贵=好”的原则
- 💭 对于不熟悉的领域人们往往选择的是走捷径，而不是去了解它，人会为了更轻松的方式而付出一些代价，这个代价可以是金钱，也可以是其他人们心中认为可以交易的东西
- ⏱ 2023-05-23 12:37:53

渔利的奸商

划线评论

📌 人们往往会相信或去做自己身边人相信以及正在做的事
- 💭 带货模式便运用这一原则
- ⏱ 2023-05-23 15:29:28

第2章互惠

划线评论

📌 在施恩行动完成之前，受惠者对施恩者最为感激。
- 💭 随着时间的推移，人们会逐渐失去库亏欠感
- ⏱ 2023-05-25 12:29:49

互惠原则怎样起作用

划线评论

📌 正是因为“纠正失误”是一种量身定制的行为，它才代表了个性化的礼物或服务。这一特点撬动了运用互惠原则的杠杆，使我们得以理解为什么失误反而带来了更高的满意度和忠诚度。简而言之，没碰到问题的人，或许不如“碰到问题但又得到了解决”的人感觉那么好。
- 💭 如果一个部门愿意为我的特殊原因特意开通绿色通道，相信我也会对这个部门拥有更好的印象
- ⏱ 2023-06-12 14:49:15

我喜欢你的理由

划线评论

📌 他们并不会尽力抬高他人成功与自己之间的可见联系，而是会尽力抬高与自己有着明显联系的人的成功。
- 💭 在我的学生时代我自己也是这样的，我会去寻找和我或者我的家乡有关的名人来寻求优越感
- ⏱ 2023-06-18 14:58:58

划线评论

📌 他们并不会尽力抬高他人成功与自己之间的可见联系，而是会尽力抬高与自己有着明显联系的人的成功。
- 💭 当吃饭的时候有人提起了一个其实很普通的朋友，这个朋友做成了一件事后，提起这个朋友的人会不遗余力的去夸赞这个朋友去提高他的地位，即便这个人的成就其实可能还不如我们在座的其他人
- ⏱ 2023-06-18 14:56:14

划线评论

📌 当然，制造商还乐意花大价钱让自己的产品跟当红明星联系起来
- 💭 在现在这个信息来源多元化的时代明星效应可能会越来越弱，指是与明星竞争的赛道更多了，制造联系的渠道更加多元化，会有更多的知名ip参与进来。比如网红带货，二次元联名手办等等。不同的渠道受众会倾向于这个特定渠道产生的关联，也更加信赖这个关联
- ⏱ 2023-06-18 14:30:43

划线评论

📌 自然
- 💭 这里应该指的是天然有机这一套话术
- ⏱ 2023-06-18 14:22:40

划线评论

📌 在值得称赞的人背后称赞他
- 💭 在背后夸人，不在背后骂人。
- ⏱ 2023-06-17 15:37:22

划线评论

📌 人类表达的赞美会刺激人们产生大量的喜好反应
- 💭 在完成一件事情后得到真诚赞美是一件多么开心的事
- ⏱ 2023-06-17 15:29:56

划线评论

📌 请求者还有另一种利用相似点提高好感、增加顺从概率的办法，即假装跟目标人群有着相似的背景和兴趣。
- 💭 或许是因为相似所以才会留下特殊的映像，因为这个映像更为深刻且不是负面映像，所以好感度更高
- ⏱ 2023-06-17 15:09:30

划线评论

📌 长相好看的人更容易在需要的时候获得帮助，在改变听众意见时也更具说服力
- 💭 对于个人的经历而言，我确实会更加愿意帮助相貌较好的人，同时也更愿意听取好看的人的意见。
- ⏱ 2023-06-17 15:02:26

划线评论

📌 光环效应指的是，一个人的某个正面特征就能主导其他人看待此人的眼光
- 💭 第一映像比较差的人甚至会拒绝接触
- ⏱ 2023-06-17 14:58:10

划线评论

📌 光环效应指的是，一个人的某个正面特征就能主导其他人看待此人的眼光
- 💭 想到了第一映像，一般第一映像好的人会更愿意和他接触
- ⏱ 2023-06-17 14:57:11

社会认同原则

划线评论

📌 他们发现，孩子们对狗的恐惧情绪的好转并未随着时间的推移而有所减退，孩子们甚至比从前更乐意跟狗互动了。
- 💭 是翻译错了吗？
- ⏱ 2023-06-18 15:29:06

划线评论

📌 他们发现，孩子们对狗的恐惧情绪的好转并未随着时间的推移而有所减退，孩子们甚至比从前更乐意跟狗互动了。
- 💭 ？这里是写错了吗
- ⏱ 2023-06-18 15:28:01

划线评论

📌 在判断何为正确时，我们会根据别人的意见行事。这一原则尤其适用于我们对正确行为的判断
- 💭 就像网购时会先看评论一样，当然现在这一套已经为刷好评的给玩烂了
- ⏱ 2023-06-18 15:17:37

最佳条件

划线评论

📌 影响力最强的领导者是那些知道怎样安排群体内部条件、让社会认同原则朝对自己有利的方向发挥作用的人。
- 💭 在琼斯镇的案例中，琼斯通过把教众带到陌生的南美洲来让教众跟随社会认同原则往对自己有利的方向发展
- ⏱ 2023-06-20 14:19:23

划线评论

📌 我们在观察与自己类似的人的行为时，社会认同原则能发挥出最大的影响力。
- 💭 在学生时代我会观察和我处于同一成绩段的同学在干什么，如果他在偷懒我也会偷懒，如果他很努力我也会很努力
- ⏱ 2023-06-19 14:20:16

负面事件效应

划线评论

📌 但要是他们得知，虽然现在做这件事的人还属少数，但会有越来越多的人参与其中，他们就会跳上潮流的大车去做这件事。
- 💭 有很多概念性的产品便利用了未来社会认同来达到目的，比如vr、ar元宇宙等等
- ⏱ 2023-06-20 14:35:35

物以稀为贵

划线评论

📌 要他们相信现在不买，以后就买不到了
- 💭 在学生时代买基金受到过这种影响，基金限时投买同时展示距离基金资金情况，还有多少额度能够购买等等
- ⏱ 2023-06-21 15:46:23

划线评论

📌 倘若瑕疵把一样东西变得稀缺了，垃圾也能化身成值钱的宝贝
- 💭 像错版币那样
- ⏱ 2023-06-21 15:22:28

发自内心地认同

划线评论

📌 个人承诺能建立起一套自圆其说的系统，能为最初的承诺找到新的理由。
- 💭 人喜欢在内心中不断地给自己找补，直到能够逻辑自洽
- ⏱ 2023-06-25 16:21:48

划线评论

📌 为一个承诺付出的努力越多，它对承诺者的影响就越大
- 💭 就像之前提到的邪教例子一样，教众即便是知道信仰是错误的，但是依然继续信仰。因为他们付出了太多，并且公开宣称了自己的信仰
- ⏱ 2023-06-25 15:38:23

划线评论

📌 在这种情况下，只有32%的顾客会选择生态香蕉。另外两组样本里的购物者看到的是两口箱子之间插着一块告示牌。一组人看到的告示牌通过生态香蕉的价格进行促销，说“生态香蕉与普通香蕉价格相同”
- 💭 小时候大人们经常会以这个小孩一看就很乖的打标签行为让我乖乖听长辈的话
- ⏱ 2023-06-25 14:53:40

“我们”的力量

划线评论

📌 这就是传染性呵欠，即别人打呵欠之后自己也打起呵欠来。
- 💭 读到这句话我开始不自觉地打了个哈欠
- ⏱ 2023-06-26 15:05:50

划线评论

📌 我们观看比赛，并不是因为它固有的表现形式或艺术意义，而是我们投入了自我
- 💭 就像我爸看比赛经常会随着赛况而转换心情
- ⏱ 2023-06-26 11:56:46

跨群体大联盟

划线评论

📌 人类的认知组织方式会让我们会把最容易接触到的态度视为对自己最重要的态度。
- 💭 第一映像是否适用呢？第一映像代表的就是一个人对于接触到的人最容易关注到的特点，所以第一映像对于态度来说是一个很重要的参考
- ⏱ 2023-06-28 14:53:08

原始的自动反应

划线评论

📌 在没有意愿、没有时间、没有精力或没有认知资源对情况进行全面分析的时候，我们最容易使用这些孤立的线索。
- 💭 在网络的评论中最常出现的情绪化评论就是只看到了孤证
- ⏱ 2023-06-28 16:00:13

本书评论

书评 No.1

⏱ 2023-06-28 16:12:33

资本论（超值白金版）

2023-07-02T03:21:50Z

元数据

[!abstract] 资本论（超值白金版）

书名：资本论（超值白金版）

作者：马克思

简介：这是马克思花费40年的光阴，用毕生的心血写成的一部著作，它既是政治经济学的光辉巨著，也是马克思主义的百科全书。这部巨著第一次深刻地分析了资本主义的全部发展过程，阐述了资本主义商品生产、流通和分配的基本理论，揭示了经济发展的客观规律，具有划时代的历史意义。

出版时间 2010-05-01 00:00:00

ISBN： 9787544238007

分类：哲学宗教-马克思哲学

出版社：南海出版公司

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

西方经济学派源流简表

📌 就像狼的本性凝固在血液中一样，资本主义的掠夺制度就是资本主义制度的生命本质
- ⏱ 2023-04-30 01:17:21

第1卷资本的生产过程

📌 劳动力独特的使用价值，能够创造出比自身价值大的价值，资本家正是看中这个价值差额，才去购买劳动力
- ⏱ 2023-04-30 01:20:09
📌 资本家不仅懂得用劳动力的低价值去换取劳动力创造的高价值，而且更懂得用延长的劳动过程去换取更多的价值。
- ⏱ 2023-04-30 01:20:21
📌 机器大工业标志着资本主义生产方式进入成熟阶段。像其他发展劳动生产力的方法一样，机器能够使商品便宜，缩短工人的工作日部分，从而无偿地延长工人给予资本家的工作时间。
- ⏱ 2023-04-30 01:20:57

第一篇商品和货币

📌 商品是为了交换而生产的劳动产品。一切商品都具有使用价值和价值两个因素，商品是使用价值和价值的统一体。缺少其中任何一个元素，就不能成为商品。
- ⏱ 2023-04-30 01:21:48
📌 商品的基本属性：使用价值和价值
- ⏱ 2023-04-30 01:35:50

读书笔记

本书评论

阿里云云原生

2023-07-02T03:21:50Z

元数据

[!abstract] 阿里云云原生

书名：阿里云云原生

作者：公众号

简介：发布云原生技术最新资讯、汇集云原生技术最全内容，定期举办云原生活动、直播，阿里产品及用户最佳实践发布。与你并肩探索云原生技术点滴，分享你需要的云原生内容。

出版时间

ISBN：

分类：

出版社：

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

Nacos 配置管理最佳实践

📌 使用 @Value 注解引用 nacos 中的参数值，当 nacos 中配置值发生变化时，value 的值会自动更新
- ⏱ 2023-04-22 11:22:22
📌 如果有 notify-listener 日志，但是没有 notify-ok 日志，则可能是监听器执行堵塞。
- ⏱ 2023-04-22 11:23:28
📌 配置中心的主要作用是发布 meta-data，而不是数据的存储服务。我们对所发布的单个配置数据内容大小 100k 以内。
- ⏱ 2023-04-22 11:24:21
📌 nacos 是个配置管理系统，不是流量链路产品，配置变更需小于 1 次/分钟。
- ⏱ 2023-04-22 11:24:08
📌 nacos 可能在网络状况欠佳时会向订阅者发送重复的数据通知，订阅者对数据通知的处理应满足幂等性，支持重复推送，相同配置回调多次不应产生异常预期外的情况。
- ⏱ 2023-04-22 11:25:02
📌 服务端不可用时且短时无法恢复时，用户可以在本地的容灾目录中手动更新配置内容，以达到模拟服务端配置发生变更的场
- ⏱ 2023-04-22 11:25:53
📌 。容灾目录中的配置内容具有最高优先级
- ⏱ 2023-04-22 11:26:50
📌 服务端的反脆弱机制包括连接限流，频繁变更限流，配置发布流量限流等机制来保证可用性。
- ⏱ 2023-04-22 11:28:18

读书笔记

本书评论

腾讯技术工程

2023-07-02T03:21:50Z

元数据

[!abstract] 腾讯技术工程

书名：腾讯技术工程

作者：公众号

简介：腾讯技术官方号。腾讯技术创新、前沿领域发布解读平台。

出版时间

ISBN：

分类：

出版社：

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

谷歌开源、高性能RPC框架：gRPC 使用体验

📌 gRPC 是谷歌推出的一个开源、高性能的 RPC 框架。默认情况下使用 protoBuf 进行序列化和反序列化，并基于 HTTP/2 传输报文，带来诸如多请求复用一个 TCP 连接(所谓的多路复用)、双向流、流控、头部压缩等特性。
- ⏱ 2023-04-24 08:33:23
📌 在 HTTP/2 中，帧是网络通信的基本单位，HTTP/2 主要定义了 10 种不同的帧类型，每种帧类型在建立和管理连接或者单个 stream 流有不同的作用
- ⏱ 2023-04-24 08:38:48
📌 Connection 连接：对应一个 TCP 连接，可以承载一个或者多个 Stream。
- ⏱ 2023-04-24 08:42:54
📌 Stream 流：对应一个双向通信的数据流，可以承载一个或者多个 Message
- ⏱ 2023-04-24 08:43:04
📌 单个 HTTP/2 连接可以承载多个并发的 stream 流，通信双方都可能交叉地收到多个 stream 流的数据帧；
- ⏱ 2023-04-24 08:43:53
📌 stream 流可以单方面建立与使用，也可以由客户端和服务器双方共享消息通道;
- ⏱ 2023-04-24 08:43:58
📌 客户端或者服务器都可以关闭 stream 流;
- ⏱ 2023-04-24 08:44:03
📌 发送方在 stream 流按顺序发送数据帧，接收到按照顺序接收数据帧。特别地，HEADS 帧和 DATA 帧的顺序在语言上是较为重要的；
- ⏱ 2023-04-24 08:44:09
📌 stream 流由无符号整数标识。stream 流标识符是由发起流的端点分配给 stream 流的。
- ⏱ 2023-04-24 08:44:16
📌 Message 消息：对应 HTTP/1.x 的请求 Request 或响应 response.包含一个或者多个 Frame 数据帧。
- ⏱ 2023-04-24 08:44:38
📌 Frame 数据帧：HTTP/2 网络通信的基本单位，承载的是压缩和编码后的二进制流，不同 Stream 数据流的帧可以交错发送，并根据帧头的流 ID(数据流标识符)进行区分和组装。
- ⏱ 2023-04-24 08:44:46

读书笔记

本书评论

技术自由圈

2023-07-02T03:21:50Z

元数据

[!abstract] 技术自由圈

书名：技术自由圈

作者：公众号

简介：疯狂创客圈（技术自由架构圈）：一个技术狂人、技术大神、高性能发烧友圈子。圈内一大波顶级高手、架构师、发烧友已经实现技术自由；另外一大波卷王，正在狠狠卷，奔向技术自由

出版时间

ISBN：

分类：

出版社：

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

一文搞懂：微服务核心组件 Nacos（史上最全）

📌 Raft 的数据一致性策略 Raft 协议强依赖 Leader 节点来确保集群数据一致性。即 client 发送过来的数据均先到达 Leader 节点，Leader 接收到数据后，先将数据标记为 uncommitted 状态，随后 Leader 开始向所有 Follower 复制数据并等待响应，在获得集群中大于 N/2 个 Follower 的已成功接收数据完毕的响应后，Leader 将数据的状态标记为 committed，随后向 client 发送数据已接收确认，在向 client 发送出已数据接收后，再向所有 Follower 节点发送通知表明该数据状态为committed。
- ⏱ 2023-04-22 11:29:38
📌 Sentinel：把流量作为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。
- ⏱ 2023-04-22 11:30:59

读书笔记

本书评论

哪吒编程

2023-07-02T03:21:50Z

元数据

[!abstract] 哪吒编程

书名：哪吒编程

作者：公众号

简介： CSDN博客之星Top1，专注Java硬核干货分享，立志做到Java赛道全网Top N

出版时间

ISBN：

分类：

出版社：

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

图解Nacos，注册中心演变 + Nacos核心功能

📌 如果Nacos在5秒内没有收到心跳，则表示服务挂了，Nacos会下线此服务。对于超过15秒没有收到客户端心跳的服务实例，会将它的healthy属性置为false，客户端无法调用healthy为false的服务。如果超过30秒没有收到心跳，Nacos会直接将此服务剔除。
- ⏱ 2023-04-22 11:15:47
📌 服务1调用服务2时，服务1会通过定时任务到Nacos中获取在线的服务，保证所调用的服务一直都是健康在线的状态。获取到之后，用缓存将其保存起来，然后通过负载均衡器调用服务2，此时，将不再使用服务端的负载均衡Nginx了。
- ⏱ 2023-04-22 11:16:25
📌 配置优先级profile > 默认配置文件 > extension-configs（下标越大优先级越高） > shared-configs（下标越大优先级越高）
- ⏱ 2023-04-22 11:18:14
📌 @RefreshScope一般都是通过@Value的形式读取配置文件中的信息，但是无法感知修改后的值，需要利用@RefreshScope动态刷新。
- ⏱ 2023-04-22 11:18:42
📌 Nacos使用长轮询更新配置
- ⏱ 2023-04-22 11:19:16

读书笔记

本书评论

掌控聊天：人际沟通中的关键策略

2023-07-02T03:21:50Z

元数据

[!abstract] 掌控聊天：人际沟通中的关键策略

书名：掌控聊天：人际沟通中的关键策略

作者：张超

简介：高质量的聊天，是维系人际关系的重要工具。然而，人们在聊天中经常会遇到各种棘手的问题：冷场、接不上话、词不达意、情绪失控；在谈判中，看不穿对方的意图，被人牵着鼻子走；遇到矛盾，无法理清思路，处于被动地位……

出版时间 2020-12-11 00:00:00

ISBN： 9787505749887

分类：个人成长-沟通表达

出版社：中国友谊出版公司

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

聊天能力是训练出来的

第一章掌控情绪：如何搞定双方的情绪

📌 。心理学上认为，负面情绪通常是从等级高的向等级低的传递，由强到弱传递。处于金字塔底部的人最弱小，往往就成为最终的受害者，比如“踢猫效应”里的那只猫。
- ⏱ 2023-06-01 00:15:16
📌 这件事情令我收获更多的是，我真切地明白了人不但是利益动物，还是面子动物。我在真实的生活中懂得了什么叫“面子是人的第二心脏”。
- ⏱ 2023-06-01 00:17:41
📌 跟一个人说话的时候，还要去看周围的环境，去了解对方想要在他人眼中树立什么样的形象，要兼顾真实的语境，不要因为对方的情绪影响判断。
- ⏱ 2023-06-01 00:18:33

合理性发怒：用愤怒扭转局面

📌 在所有情绪中，愤怒似乎是最能影响人际关系的情绪，因为愤怒容易引起彼此的对立。而且，一次发怒而导致关系出现的裂痕，可能需要用无数的行动来修复。
- ⏱ 2023-06-01 00:26:05
📌 愤怒提示着我们可能有一些心理需求没有得到满足，比如没有得到尊重，尤其在我们遇到不公平的对待时，愤怒可以帮助我们将心中的不满表达出来，为我们争取权利。此外，愤怒还可以帮助我们设立与他人的边界，我们可以用发怒来提醒对方——“我现在很生气，不要冒犯我”。
- ⏱ 2023-06-01 00:26:51
📌 在权力体系中，人们通常认为敢于发怒的人是掌握权力的人。
- ⏱ 2023-06-01 10:45:33
📌 有些情况下，不犯错就是正确
- ⏱ 2023-06-01 10:48:38

多角度判断：不同情况下如何表达

📌 高情商的人并不是虚伪的人。
- ⏱ 2023-06-01 10:52:42
📌 一个人处境不佳的时候，是很容易说话颠三倒四、态度直露的。但旁人不会站在你的角度去考虑你的情绪，而是时时刻刻都在通过你说的话来评价你。
- ⏱ 2023-06-01 10:54:59
📌 越是环境不利，越要注意自己表现出来的态度，这会决定别人是继续对你投资，还是让情况变得更糟。
- ⏱ 2023-06-01 10:55:12
📌 合理化是一种非常常见的心理防御机制。当出现了某些负面事件时，我们会找一些理由来为这个事件进行辩解，使自己心理上得到安慰，掩饰自己不愿承认的事实。
- ⏱ 2023-06-01 10:56:31

空隙法则：制造空隙，引导对话

发酵原则：切勿过早地袒露内心

📌 想要说服别人，并不需要多余的行为和语言来进行辅助，并不是所有备用工具一定要全部用上，才能证明你思虑周到。
- ⏱ 2023-06-01 11:08:49

你的大脑会对事实进行加工

📌 任何想象都不一定是事实！
- ⏱ 2023-06-03 08:55:03
📌 ，沟通的目的不是发泄情绪，而是阐述事实
- ⏱ 2023-06-03 08:56:03
📌 为什么现实中两个人在争吵时，总是容易越吵越激烈？正是因为双方都在对对方的话进行负面解读，然后进行攻击性的回应。而当我们以客观的事实去沟通，以平和的态度去提问，很可能会发现对方说的话并不像我们以为的那样充满恶意。
- ⏱ 2023-06-03 08:57:34

掌控冲突：如何处理矛盾与冲突

📌 在任何关系里，由于情绪积压，将该说的话藏在心底，都是一种伤害。因为我们没有通过沟通去理解彼此情绪背后的需求，情绪只是被压抑了，而永远不会被化解。
- ⏱ 2023-06-03 09:02:34
📌 敢于直面矛盾和分歧，用提问让对方说“不”
- ⏱ 2023-06-03 09:03:34
📌 洞察对方情绪背后的真实需求，找到他真正在乎的是什么。
- ⏱ 2023-06-03 09:05:30

读书笔记

聊天能力是训练出来的

划线评论

📌 因为世界上从不缺功利的人，缺的是每个人发自内心地对别人付出的真诚、无畏、关注和同情
- 💭 那遇到不喜欢聊天的人怎么办呢？比如我自己就不喜欢聊天，我该如何去应对呢？我觉得我应该好好想想这个问题
- ⏱ 2023-05-31 23:39:24

第一章掌控情绪：如何搞定双方的情绪

章节评论 No.1

这一小节主要是为了表达为什么要压制自己的情绪，情绪的传播链以及需要使用沟通去化解情绪
- ⏱ 2023-06-01 00:24:40

划线评论

📌 如果对方与你开始了情绪对抗，别着急反驳或者自证，对方正在气头上，与他据理力争只是自讨苦吃。
- 💭 这是我的一个缺点，面对与我对抗的对象不论是同事，领导，朋友甚至长辈，我都会立刻反驳
- ⏱ 2023-06-01 00:20:21

划线评论

📌 人群中常见的发脾气的对象，都是相对弱势的人。
- 💭 因为表现相对弱势的人一般不会对发泄情绪的对象产生威胁
- ⏱ 2023-06-01 00:14:19

合理性发怒：用愤怒扭转局面

划线评论

📌 比如，当别人劝你集资的时候，要知道对方的话术有可能早已包含了对人性的研究，进行了千变万化的包装，各种激发的手段也层出不穷。所以，无论对方说什么，不要跟随，不要好奇，不要被牵着鼻子走。这时，你也可以提前采用“唯一应对法”，用冰冷的回应代替内心的愤怒。
- 💭 如果顺应了他的话术,极有可能被一步一步拉进去,这个时候一个不会犯错对的应对方式就是正确的
- ⏱ 2023-06-01 10:50:35

划线评论

📌 如果我们在人际关系中一味地压抑愤怒情绪，就有可能逐渐丧失自己的权利。
- 💭 或者说会让人觉得软弱可欺
- ⏱ 2023-06-01 10:44:22

空隙法则：制造空隙，引导对话

划线评论

📌 总之，先处理自己内心的急切感，用“空”出来的技巧再植入到对话中，就会使看似平常的对话拥有惊人的说服力。
- 💭 给双方谈话中留下空间
- ⏱ 2023-06-01 11:06:39

划线评论

📌 最重要的是要为思想制造空隙，对问题进行解读，承认别人的行为让自己不舒服了，了解自己到底在焦虑什么，而不是回避问题的本质。
- 💭 就像认知觉醒中提到过得,在做一件事情之前用一两秒去想一想
- ⏱ 2023-06-01 11:02:07

发酵原则：切勿过早地袒露内心

划线评论

📌 在这个背景下，你要更多地包容和理解别人，有可能别人冒犯了你，他也会觉得理所当然。

我们会发现，人们和亲人说话的时候毫不客气、彼此伤害，因为“我们是亲人”已经成了一个背景。而和朋友、同事之间相处，则要避免过早地袒露你的内心，要让沟通交流慢慢地发酵。让你的好成为别人真正需要的“好”；让你的好，能真正打动别人。

- 💭 在与人对话时为自己和他人留足空间，在发言前给自己留足时间
- ⏱ 2023-06-02 22:41:01

划线评论

📌 客户觉得确实没有降价空间了，自然不会在价格上继续纠缠。
- 💭 让我想起了我出售我的二手手机时，我表现出可以降价的空间的话反而会招来手机贩子死皮赖脸要降价
- ⏱ 2023-06-02 22:30:50

你的大脑会对事实进行加工

划线评论

📌 心理学上有一个“ABC”理论，其中“A”代表某个事件，“C”代表我们的情绪。表面上，事件A导致了情绪C，比如，“这件事情让我感到很生气”，A指的是“这件事情”，C是产生的情绪，也就是生气。但不要忘了，“甲之砒霜，乙之蜜糖”，A与C之间，其实有一个桥梁，就是B。B是我们对于事件A的认知，它才是诱发情绪C的直接原因。
- 💭 对于同一个事件,不同的认知方式会带来不同的情绪,而情绪又会影响到接下来的的行动
- ⏱ 2023-06-03 08:53:00

本书评论

猫和老鼠：大电影

2023-05-21T00:38:00.000Z

枯燥的“大人”生活

最近一直在忙着看书，看各种工具书企图提升自己的技能以获得更高的工资待遇，让我的生活只剩下枯燥的的代码与专业词汇。我想我的生活不应该只有这些，我想要更多的乐趣去调剂一下自己。

平常我也有去看一些“名著”作出一些让自己觉得自己的精神世界十分充实的假象，但是这一天也就是 2023-04-28 日我在读过茶馆、四世同堂、Spring Boot进阶：原理、实战与面试题分析之后我感觉到我的精神世界急切的需要雨水浇灌，这时的我感觉就像身处荒漠感觉干燥难耐，就像暖风机将干燥的空气吹到我的脑前叶上，我的注意力开始涣散学习效率与阅读效率几乎为零。

我百无聊赖地打开了哔哩哔哩准备在虚拟的世界里寻求一下能让我暂时逃避现实的那一份快乐。我的首页上刷出了一个关于猫和老鼠的剪辑，有评论说:" 在《猫和老鼠：大电影》中有一幕 Tom 与 Jerry 互相认为对方不会说话所以平常追逐时都没有说话，在开口时互相吓了一跳。" 引起了我的兴趣。
猫和老鼠：大电影正片-电影-高清正版在线观看-bilibili-哔哩哔哩

猫和老鼠——童年的经典

猫和老鼠的这一部电影具有典型的时代色彩，是以歌剧电影的形式制作。我是 00 后对这种动画电影接触的并不多，至今为止映像最深刻的就是迪士尼的《白雪公主》我是七岁时才完整的把它看完。

有很多弹幕觉得这种形式的电影十分无聊，应该更快节奏的去展现故事。我并不抱有这种看法，我本来就是带着让自己慢下来的目的来观看这部影片。电影的中的歌曲都在阐释着这一时刻电影要传达给我们的信息，具有时代感的编曲与歌词在将我带入这个 Tom 和 Jerry 的世界的同时还在安抚我急躁的心灵。

游戏

2023-05-21T21:28:00.000Z

游戏 Overview

记录了平常玩的一些游戏，既然花费了时间在这件事上，那为什么不记下来呢？

本文件夹中总共有4 个文件

标签 2个

已发布笔记

File	tags	created	别名
Brotato元素模组暗杀星	游戏	2023-05-25 21:25	-
游戏	index	2023-05-21 21:27	游戏-index
Brotato	游戏	2023-05-21 20:57	土豆兄弟
Brotato元素模组的药剂师	游戏	2023-05-21 20:56	-

Brotato元素模组的药剂师

2023-05-22T14:23:00.000Z

最近又重新玩起了 Brotato,，当然原版任务已经玩腻了现在开始找 Mod 整点新的游戏体验，在通关 Steam 创意工坊::踽橘雾语的以 DTW 为原型制作的角色（锁血一点难度五有点折磨）后又开始索然无味起来。于是开始玩起了
Steam 创意工坊::元素兄弟Elemento v0.88d【CN/EN】，这个 MOD 添加了许多以元素属性为核心的人物与物品，让 Brotato 的体验更加多变有意思起来。

好久没玩过像药剂师这么爽的角色了，特殊技能将面板刷的飞起，召唤物的爆炸范围就像带着编写核弹一样。

Brotato元素模组暗杀星

2023-05-25T21:33:00.000Z

Brotato暗杀星如果只走精准流生存压力非常大，所以我选择使用袖箭暴击来触发暗杀星的冷却技能黑山羊来输出，这样就相当于获得一个低冷却的延时核弹。高输出大范围的低冷却 AOE，再配合黑山羊法杖的高面板，清怪秒 Boss 无压力。

Brotato

2023-05-21T21:09:00.000Z

Steam 上的土豆兄弟(Brotato)

设计模式

2023-05-21T00:42:00.000Z

设计模式 Overview

本文件夹中总共有11 个文件

标签 3个

已发布笔记

File	tags	created	别名
聚合复用原则	设计模式	2023-04-18 17:42	合成复用原则合成/聚合复用原则
迪米特法则	设计模式	2023-04-18 17:35	最少知识原则
里式替换原则	设计模式	2023-04-03 21:05	-
依赖倒转原则	设计模式	2023-04-02 21:35	-
开放封闭原则	设计模式	2023-04-02 21:10	-
单一职责原则	设计模式	2023-04-02 21:02	-
设计模式	设计模式, index	2023-04-02 21:00	设计模式-index
Reactor反应器模式	设计模式	2023-03-29 13:53	-

里式替换原则

2023-05-21T00:42:00.000Z

一个软件如果使用的是一个父类的话，那么它一定能使用其子类，并且无法察觉子类与父类的区别。也就是说，在软件中，把父类全都替换为子类，程序的行为没有变化。

[!note]
子类必须能够替换掉他们的父类

5.4 里氏代换原则

📌 一个软件实体如果使用的是一个父类的话，那么一定适用于其子类，而且它察觉不出父类对象和子类对象的区别。也就是说，在软件里面，把父类都替换成它的子类，程序的行为没有变化 ^3300047241-54-571-653
- ⏱ 2023-04-02 19:48:46
📌 里氏代换原则(LSP)：子类型必须能够替换掉它们的父类型。 ^3300047241-54-764-793
- ⏱ 2023-04-02 20:40:25
📌 能，只有当子类可以替换掉父类，软件单位的功能不受到影响时，父类才能真正被复用，而子类也能够在父类的基础上增加新的行为。 ^3300047241-54-1609-1687
- ⏱ 2023-04-02 20:41:38

迪米特法则

2023-05-21T00:42:00.000Z

[!note]
类之间的耦合越弱越有利于复用，处于弱耦合的类被修改，不会对有关系的类造成影响，所以当两个类之间没有通信的必要的话，那么这两个类就不应该发生直接的相互作用。当一个类需要调用另一个雷士可以通过第三者转发这个调用。

11.3 迪米特法则

📌 米特法则(LoD)'也叫最少知识原则 ^3300047241-92-509-527
- ⏱ 2023-04-15 02:51:32
📌 迪米特法则(LoD)：如果两个类不必彼此直接通信，那么这两个类就不应当发生直接的相互作用。如果其中一个类需要调用另一个类的某一个方法的话，可以通过第三者转发这个调用。 ^3300047241-92-621-704
- ⏱ 2023-04-15 02:51:47
📌 是在类的结构设计上，每一个类都应当尽量降低成员的访问权限 ^3300047241-92-816-863
- ⏱ 2023-04-15 02:52:09
📌 类之间的耦合越弱，越有利于复用，一个处在弱耦合的类被修改，不会对有关系的类造成波及 ^3300047241-92-1274-1315
- ⏱ 2023-04-15 02:53:01

聚合复用原则

2023-05-21T00:42:00.000Z

[!seealso]
尽量使用合成/聚合，尽量不要使用类继承

[!note]
聚合表示一种弱“拥有”关系，表示 A 对象可以包含 B 对象，但是 B 对象不是 A 对象的一部分；合成是一种强的“拥有”关系，体现出严格的部分和整体的关系。

22.3 合成／聚合复用原则

📌 合成／聚合复用原则(CARP)，尽量使用合成／聚合，尽量不要使用类继承。 ^3300047241-162-481-517
- ⏱ 2023-04-16 15:30:02
📌 聚合表示一种弱的'拥有'关系，体现的是A对象可以包含B对象，但B对象不是A对象的一部分；合成则是一种强的'拥有'关系，体现了严格的部分和整体的关系，部分和整体的生命周期一样 ^3300047241-162-713-799
- ⏱ 2023-04-16 15:30:37
📌 优先使用对象的合成／聚合将有助于你保持每个类被封装，并被集中在单个任务上。这样类和类继承层次会保持较小规模，并且不太可能增长为不可控制的庞然大物 ^3300047241-162-1216-1288
- ⏱ 2023-04-16 15:32:10

开放封闭原则

2023-05-21T00:42:00.000Z

一个实体应该可以扩展，但是不可以修改

无论模块多么的封闭都会存在一些无法应对的变化。既然不能完全的将功能封闭，那么我们在设计的时候就应该去猜测最有可能发生变化的种类，然后抽象这些变化进行隔离。

比如在设计一个计算器程序时我们将加减乘除都写在一个类里，如果我们需要增加开方运算等，我们就需要修改这一个大类。如果我们通过继承、多态来隔离具体大计算方式，我们就不需要去修改原来的计算类，只需要增加一个继承计算父类，然后根据业务去实现这个类的逻辑即可。

[!note]
面对需求，对程序的改动应该是通过增加新的代码，而不是去修改现有代码

不可能在实践中完全遵守这一原则，我们应该根据业务需求与现实情况去设计软件。拒绝不成熟的抽象和抽象本身一样重要。

单一职责原则

2023-05-21T00:42:00.000Z

[!note]
就一个类而言，应该仅有一个引起它变化的原因

如果一个类承担的职责过多，就等于把这些职责耦合在了一起, 一个职责发生了变化可能会削弱或者抑制这个类完成其他职责的能力。这种耦合回到值脆弱的设计，当发生变化是，设计会遭受到意想不到的破坏。人话就是修改一个承担过多职责的类可能会造成这个类的其他功能不可用。

📌 就一个类而言，应该仅有一个引起它变化的原因

依赖倒转原则

2023-05-21T00:42:00.000Z

[!note]
抽象不应依赖细节，细节应该依赖于抽象

高层模块不应该依赖底层模块，而是两个都应该依赖抽象
抽象不应该依赖细节，细节应该依赖抽象

5.3 依赖倒转原则

📌 抽象不应该依赖细节，细节应该依赖于抽象 ^3300047241-53-2274-2293
- ⏱ 2023-04-02 19:39:02
📌 针对接口编程，不要对实现编程 ^3300047241-53-2332-2346
- ⏱ 2023-04-02 19:39:09
📌 依赖倒转原则(1)高层模块不应该依赖低层模块。两个都应该依赖抽象。(2)抽象不应该依赖细节。细节应该依赖抽象。［ ^3300047241-53-2562-2774
- ⏱ 2023-04-02 19:42:46

《大话设计模式》一书中使用电脑的主板接口与各个配件的关系作为例子解释依赖倒转原则。

📌 依赖倒转其实可以说是面向对象设计的标志，用哪种语言来编写程序不重要，如果编写时考虑的都是如何针对抽象编程而不是针对细节编程，即程序中所有的依赖关系都是终止于抽象类或者接口，那就是面向对象的设计，反之那就是过程化的设计了

Reactor反应器模式

2023-05-21T00:42:00.000Z

Reactor 反应器模式简介

Reactor 反应器模式是高性能网络编程在设计和架构层面的基础模式，如 Nginx、Redis、Netty 这些鼎鼎大名的的开源项目都是基于反应器模式的

反应器模式是由 Reactor 反应线程、Handlers 处理器两大角色组成的。

Reactor 反应器线程负责响应 IO 事件，并分发到 Handlers 处理器。这里的 IO 事件就是 NIO的IO事件
Handlers 处理器的职责是非阻塞的执行业务处理逻辑

《Scalable IO in Java》

单线程 Reactor 反应器模式

总的说 Reactor 反应器模式有点类似事件驱动模式, 在事件驱动模式中，当有事件触发时，事件源会将事件 dispatch 分发到 handler 处理器执行事件处理。而反应器模式中反应器角色就类似于 dispatcher 事件分发器的角色

什么是单线程 Reactor 反应器

简单地说，Reactor 反应器和 Handers 处理器处于一个线程中执行就是单线程 Reactor 反应器。它是最简单的反应器模型。

基于 JAVA NIO 实现简单的反应器模式

需要使用到的 SelectionKey 选择键的接个重要成员方法：

void attach(Object o) 这个方法可以将任意 Java 实体对象作为附件添加到 SelectionKey 的实例中，类似于 setter 方法。因为在单线程的反应器模式中，需要将 handler 处理器实例，作为附件添加到 SelecttionKey 中
Object attachment()，这个方法的作用是取出之前通过 attach(Object o) 添加到 SelecttionKey 的附件

[!note]

📌 在选择键注册完成之后，调用attach方法，将Handler处理器绑定到选择键；当事件发生时，调用attachment方法，可以从选择键取出Handler处理器，将事件分发到Handler处理器中，完成业务处理。

[!warning] 单线程 Reactor 反应器模式的缺点
在单线程反应器模式下，Reactor 和 Handler 都在同一线程下，如果有一个 Handler 阻塞，那么其他的 Handler 就都不能执行。如果连负责监听的 Handler 都阻塞了，那么就会是的服务不可用。

多线程 Reactor 反应器模式

单 Reactor

一个主 Reactor 与子 Reactor

响应式编程的数据流

2023-05-21T00:42:00.000Z

[!info]
数据流 (Data Stream) 是由生产者生产并由一个或者多个消费者消费的元素序列

Spring Boot进阶：原理、实战与面试题分析#^3300019666-35-617-652
Spring Boot进阶：原理、实战与面试题分析#^3300019666-35-658-688

响应式编程

2023-05-21T00:42:00.000Z

[!info]
响应式编程的目的是为了构建响应式系统，任何时候都需要确保其具备及时相应性。

IOC

2023-05-21T00:42:00.000Z

[!info]
IOC（Inversion of Control）是一种设计思想，也称为依赖反转。它的核心思想是将对象的创建和依赖关系的管理从应用程序代码中抽离出来，交给容器来管理。应用程序只需要声明需要依赖的对象，容器会在运行时自动将依赖的对象注入到应用程序中。

IOC 的设计思想主要包括以下几个方面：

控制反转：容器控制对象的创建和依赖关系的管理，而不是应用程序。
依赖注入：容器通过自动注入依赖的对象来满足应用程序的需要。
松耦合：应用程序和依赖对象之间的关系变得松散，依赖的对象可以随时替换或升级，而不会对应用程序造成影响。
可扩展性：容器可以方便地添加或替换组件，从而提高应用程序的可扩展性。
可测试性：依赖注入使得应用程序的单元测试更加容易，可以方便地替换依赖的对象以进行测试。
配置管理：容器可以通过配置文件来管理对象的创建和依赖关系，从而使得应用程序的配置更加灵活和可管理。

综上所述，IOC 是一种面向对象设计的重要思想，通过将对象的创建和依赖关系的管理交给容器来管理，可以提高应用程序的可扩展性、可测试性和灵活性，从而更好地满足业务需求。

HATEOAS

2023-05-21T00:42:00.000Z

HATEOAS 全称 Hypermedia as the Engine of Application State，是一种 RESTful 架构设计风格的设计原则即超文本应用状态引擎。是一种使用超媒体作为应用状态的引擎，即应用状态变更将由客户端访问不同的超媒体资源驱动。

📌 HATEOAS的重要性在于打破了客户端和服务器之间严格的契约，使得客户端可以更加智能和自适应，而RESTful服务本身的演化和更新也变得更加容易。

HAL

2023-05-21T00:42:00.000Z

HAL 全称 Hypertext Application Language（超文本应用语言），是一种 HATEOAS 的实现方式。

与普通 RESTful 不同，对于每一个资源 HAL 又将其细分成状态（State）、链接（Links）和子资源（Embedded Resource）三个标准部分

[!note]
这里的资源状态是指资源本身固有的属性，链接定义了与当前资源相关的一组资源的链接集合，而子资源则描述当前资源的具体内容，提供嵌套资源的定义。

HAL+JSON 风格请求和响应示例代码:

//请求
GET  http://api.example.com/users/**
//响应
Content-Type: application/json
{
    _links: {
        self: {
        href: "/users/**"
        }
    }
    "id": "user1",
    "name": "**",
    "email": "**@email.com"
}

相较于传统 RESTful 这里多了 _links 属性，其中有一个 self.href 链接指向当前 user 资源。

[!note]
HAL 的出现主要弥补了普通 JSON 格式在 API 的交互不足，让 JSON 更具有自描述性和导航性。

心跳机制

2023-05-21T00:42:00.000Z

[!info]
在 TCP 保持长连接的过程中，如果因为网络波动或者其他异常因素导致其中某一方掉线，Client 和 Server 之间在没有交互的情况下无法发现对方已经掉线了。心跳机制的引入就是为了解决这个问题。

心跳机制的工作原理

在 Client 和 Server 之间如果在一定时间内没有数据交互（idle 状态），Client 和 Server 就会发送一个特殊的数据包给对方, 当接收方收到这个数据报文后, 也立即发送一个特殊的数据报文, 回应发送方, 此即一个 PING-PONG 交互。所以, 当某一端收到心跳消息后, 就知道了对方仍然在线, 这就确保 TCP 连接的有效性.

零拷贝

2023-05-21T00:42:00.000Z

[!info]
Zero-copy 技术是指计算机执行操作时，CPU 不需要先将数据从某处内存复制到另一个特定区域。这种技术通常用于通过网络传输文件时节省 CPU 周期和内存带宽。

[!info]
在 OS 层面上的 Zero-copy 通常指避免在用户态 (User-space) 与内核态 (Kernel-space) 之间来回拷贝数据。

进程与线程

2023-05-21T00:42:00.000Z

[!info]
线程可以理解为在进程中独立运行的子任务,而进程则负责向操作系统申请资源。在一个进程中多个线程可以共享进程中相同的文件资源和内存。先有进程后有线程。在一个进程中可以创建多个线程。

进程虽然相互独立，但是他们可以互相通信，如使用 http 和 socket 协议
进程拥有共享的资源，比如内存、网络端口，供内部线程使用
进程比较重，因为创建进程需要操作系统分配资源，会占用内存
线程存在于进程中，是进程的一个子集，先有进程后有线程
虽然线程更轻，但是线程的上下文切换时间成本非常高

进程

2023-05-21T00:42:00.000Z

[!info]
进程是指运行中的应用程序，每个进程都有自己独立的地址空间（内存空间）。
比如用户点击桌面的 IE 浏览器，就启动了一个进程，操作系统就会为该进程分配独立的地址空间。当用户再次点击左边的 IE 浏览器，又启动了一个进程，操作系统将为新的进程分配新的独立的地址空间。目前操作系统都支持多进程。

📌 进程是代码在数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，线程则是进程的一个执行路径，一个进程中至少有一个线程，进程中的多个线程共享进程的资源。

📌 操作系统在分配资源时是把资源分配给进程的，但是CPU资源比较特殊，它是被分配到线程的，因为真正要占用CPU运行的是线程，所以也说线程是CPU分配的基本单位。

线程安全

2023-05-21T00:42:00.000Z

[!info]
线程安全指的是在多线程环境下，多个线程同时访问同一个共享资源时，不会出现数据不一致、数据丢失、死锁等问题。线程安全的实现需要保证多个线程对共享资源的访问是互斥的，即同一时间只能有一个线程在访问共享资源，其他线程需要等待。常见的线程安全实现包括使用锁、原子操作、信号量等机制来保证共享资源的访问顺序和互斥性。

线程

2023-05-27T11:55:00.000Z

[!info]
进程是表示资源分配的基本单位。而线程则是进程中执行运算的最小单位，即执行处理机调度的基本单位。通俗来讲：一个程序有一个进程，而一个进程可以有多个线程。

多线程

2023-05-21T00:42:00.000Z

线程使用场景" tabindex="-1">多线程使用场景

阻塞：一旦系统中出现阻塞现象可以根据实际情况使用多线程提高运行效率
依赖：当 A 发生阻塞且 B 不依赖 A 的执行结果时可使用多线程提高执行效率

伪共享

2023-05-21T22:27:00.000Z

在理解伪共享之前我们需要先了解 Cache行,如下图所示，在 CPU 需要访问某个变量时会先去 CPU Cache 中查找是否存在该变量，如果存在则直接从中获取，如果不存在则会去主内存中获取这个变量，然后将该变量所在的内存区域中一个 Cache行大小的内存复制到 Cache 中。因为存放在同一个 Cache行中的是一个内存块而不是单个变量，所以在一个 Cache行会出现存在多个变量的情况。

[!note]
伪共享即是当多个线程（或处理器）同时处理修改一个缓存行时因为数据一致性的策略（即当前缓存行被修改时会导致缓存行的更新，这可能导致缓存行失效或需要重新加载）这种失效和重新加载会降低系统的性能。

[!tip]
为了避免伪共享，可以使用对齐或填充等技术来确保不同缓存行之间的距离足够远，从而减少多个处理器同时访问同一块缓存行的可能性。

参考

Java并发编程之美#2.11 伪共享

异步 Input-Output

2023-05-21T00:42:00.000Z

‌‌‌‌　　用户线程通过系统调用，向内核注册某个 IO 操作。内核在整个 IO 操作（包括数据准备、数据复制）完成后，通知用户程序，用户执行后续的业务操作。
‌‌‌‌　　Netty、Redis、Zookeeper高并发实战#^26174369-18-7286-7364

‌‌‌‌　　异步 IO 在内核等待数据和复制数据的两个阶段，用户线程都不是阻塞的。用户线程需要接收内核的 IO 操作完成事件，或者用户线程注册一个 IO 操作的回调函数，由内核完成操作后进行调用。而用户线程在执行 aio_read 调用后会立即返回，不会被阻塞。

‌‌‌‌　　
‌‌‌‌

四种主要的 Input-Output 模型

2023-05-21T00:42:00.000Z

‌‌‌‌　　四种主要的 IO 模型分别为同步阻塞 IO、同步非阻塞 IO、IO 多路复用、异步 IO

阻塞和非阻塞

‌‌‌‌　　阻塞指的是调用线程一直在等待，而不能干别的事情。

‌‌‌‌　　非阻塞是指用户空间的程序不需要等待内核 IO 操作彻底完成，而是拿到内核返回的状态值就返回自己的空间，IO 操作能做就做，不能做就干其他事

‌‌‌‌　　Netty、Redis、Zookeeper高并发实战#^26174369-18-1201-1287

阻塞 IO 和非阻塞 IO

‌‌‌‌　　阻塞 IO 指的是线程在调用 IO 操作时需要等待内核缓冲区的数据准备好后才能返回用户空间执行用户操作，在这个期间内线程都是阻塞状态.

‌‌‌‌　　非阻塞 IO，指的是用户空间的程序不需要等待内核 IO 操作彻底完成，可以立即返回用户空间执行用户的操作，即处于非阻塞的状态，与此同时内核会立即返回给用户一个状态值

‌‌‌‌　　Netty、Redis、Zookeeper高并发实战#^26174369-18-701-796
‌‌‌‌　　Netty、Redis、Zookeeper高并发实战#^26174369-18-1087-1166

同步 IO 和异步 IO

‌‌‌‌　　同步 IO，是一种用户空间和内核空间 IO 发起方式，指的是用户空间的线程是主动发起 IO 调用的一方，内核是被动接受方。

‌‌‌‌　　异步 IO 则是反过来，内核是主动调用的一方，用户空间的线程是被调用的一方。

‌‌‌‌　　Netty、Redis、Zookeeper高并发实战#^26174369-18-867-971

同步阻塞 IO

‌‌‌‌　　我们已经介绍过了同步 IO 和阻塞 IO，我们可以联想一下同步阻塞 IO 是不是就是这俩组合起来呢？也就是由用户空间的线程发起主动 IO 调用，在内核缓存区数据没有准备好时这个线程将阻塞挂起，直到内核缓存区的操作彻底完成后这个线程才回到用户空间。

‌‌‌‌　　

同步阻塞 IO 的优点

‌‌‌‌　　同步阻塞 IO 十分的简单易用，程序员不需要太多的处理，只需要调用对应 API 即可进行 IO 操作

同步阻塞 IO 的缺点

‌‌‌‌　　每一次 IO 调用都需要创建一个调用线程，而线程在等待内核执行操作时是阻塞的，虽然阻塞时线程是挂起的并不需要消耗很多 CPU 资源，但是在高并发场景下这样意味着短时间内会创建大量线程来维护网络连接，内存、线程切换的开销会非常巨大。

同步非阻塞 IO

‌‌‌‌　　同步非阻塞 IO 下应用的线程需要不断地进行 IO 系统的调用，轮询数据是否已经准备好，如果没有准备好久继续轮询，直到完成 IO 系统效用位置。在线程发起 IO 系统调用时，如果内核还在等待数据则线程立即返回，如果内核数据已经准备则线程会阻塞住等待内核缓冲区的操作彻底完成后返回用户空间。

‌‌‌‌　　

同步非阻塞 IO 的优点

‌‌‌‌　　线程在内核层面做到了异步，内核在等待数据时线程会立即返回进行其他操作，减少了 IO 操作的阻塞时间

同步非阻塞 IO 的缺点

‌‌‌‌　　线程会不断轮询内核，占用大量的 CPU 时间，效率低下。在高并发场景中性能非常的低。

IO 多路复用

‌‌‌‌　　IO 多路复用是使用 select 或 epoll、poll 同时箭筒多个 IO 事件，通过将多个 IO 请求交给内核进行监听。和同步非阻塞 Input-Output 类似多路复用 IO 也需要轮询。负责 selec 状态查询的线程需要不断的对 select 进行轮询，当查出 select 下有 IO 操作就绪时进行 IO 操作，将数据从内核缓冲区复制到用户缓冲区

IO 多路复用流程

‌‌‌‌　　

选择器注册。先将需要 read 操作的目标文件描述符（socket 连接）提前注册在选择器中，在 about_Java 中式 Selector 类。然后开启 IO 多路复用的轮询流程
就绪状态的轮询。通过选择器查询所有注册过的文件描述符的 IO 就绪状态。通过查询的系统调用，内核会返回一个就绪的 socket 列表。任何一个 socket 准备好了就代表内核缓存区有数据了。
用户线程获得就绪的 socket 列表后，根据其中的 socket 连接发起 read 调用，用户线程阻塞。内核将数据从内核缓冲区中复制到用户缓冲区。
复制完成后，内核返回结果，用户线程才会解除阻塞的状态，用户线程读取到了数据，继续执行

IO 多路复用的优点

可以同时处理多个 IO 事件，从而提高程序的并发性
一个线程可以处理多个 IO 事件，减少了系统调用和线程切换和维护的开销，提高了系统性能

IO 多路复用的缺点

‌‌‌‌　　本质上 select、epoll 系统效用还是阻塞的，属于同步 IO。需要在读写事件就绪后由系统调用本身负责读写，也就是说读写过程依然是阻塞的。要彻底的解除线程的阻塞，就必须使用异步 Input-Output

异步 IO

‌‌‌‌　　
‌‌‌‌

同步非阻塞 Input-Output

2023-05-21T00:42:00.000Z

‌‌‌‌　　

同步非阻塞 IO 的优点

‌‌‌‌　　线程在内核层面做到了异步，内核在等待数据时线程会立即返回进行其他操作，减少了 IO 操作的阻塞时间

同步非阻塞 IO 的缺点

‌‌‌‌　　线程会不断轮询内核，占用大量的 CPU 时间，效率低下。在高并发场景中性能非常的低。

同步阻塞 Input-Output

2023-05-21T00:42:00.000Z

‌‌‌‌　　

同步阻塞 IO 的优点

‌‌‌‌　　同步阻塞 IO 十分的简单易用，程序员不需要太多的处理，只需要调用对应 API 即可进行 IO 操作

同步阻塞 IO 的缺点

Input-Output 读写的基础原理

2023-05-21T00:42:00.000Z

Read 和 Write

‌‌‌‌　　用户程序在进行 IO 读写时依赖于操作系统底层的 IO 读写，也就是 read 和 write 两大系统的调用。

‌‌‌‌　　对于调用操作系统的 read，是把数据从内核缓冲区复制到用户缓冲区的操作；而 write 则是把数据从用户缓冲区复制到内核缓冲区的操作。

‌‌‌‌　　Read 和 write 两大系统的调用都不会负责数据在内核缓冲区和物理设备对的交换，这种底层的读写交换都是由操作系统内核（Kernel）完成的。

内存缓冲区

‌‌‌‌　　缓冲区的目的是为了减少频繁地和设备之间的物理交换，以及用于在进程与内核之间传递数据和信息的存储单元，以实现高效的数据传输处理。在发生系统中断（让硬件在需要的时候向内核发出信号（变内核主动为硬件主动））时，需要保存中断之前的进程数据和状态等信息，而在结束中断之后还需要回复之前保存的进程数据和状态信息。为了减少这种底层系统的时间损耗和性能损耗，于是内存缓冲区就诞生了。底层的操作会对内核缓冲区进行监控，当缓冲区达到一定数量时再进行 IO 设备的中断处理。至于什么时候中断（读、写中断）由操作系统的内核来决定，用户程序可以通过轮询或者阻塞等方式获知 IO 操作的结果，按时用户程序没有决定中断的权利，中断的触发和决定都是由内核完成的

‌‌‌‌　　IO 的读写操作大多并没有进行实际的 IO 操作，而是在进程缓冲区和内核缓冲区之间进行数据交换

‌‌‌‌　　Netty、Redis、Zookeeper高并发实战#2.1 IO读写的基础原理

Socket 的通信

‌‌‌‌　　是由操作系统通过网卡获取到所有 socket 分组后被复制到内核缓冲区。这个由操作系统自动完成。
‌‌‌‌　　Netty、Redis、Zookeeper高并发实战#^506504175-7GVyeTgpd

Input-Output 读写的原理与模型

2023-05-21T00:42:00.000Z

IO 读写的基础原理

Read 和 Write

‌‌‌‌　　用户程序在进行 IO 读写时依赖于操作系统底层的 IO 读写，也就是 read 和 write 两大系统的调用。

‌‌‌‌　　对于调用操作系统的 read，是把数据从内核缓冲区复制到用户缓冲区的操作；而 write 则是把数据从用户缓冲区复制到内核缓冲区的操作。

内存缓冲区

‌‌‌‌　　IO 的读写操作大多并没有进行实际的 IO 操作，而是在进程缓冲区和内核缓冲区之间进行数据交换

‌‌‌‌　　Netty、Redis、Zookeeper高并发实战#2.1 IO读写的基础原理

Socket 的通信

四种主要的 IO 模型

‌‌‌‌　　四种主要的 IO 模型分别为同步阻塞 IO、同步非阻塞 IO、IO 多路复用、异步 IO

阻塞和非阻塞

‌‌‌‌　　阻塞指的是调用线程一直在等待，而不能干别的事情。

‌‌‌‌　　Netty、Redis、Zookeeper高并发实战#^26174369-18-1201-1287

阻塞 IO 和非阻塞 IO

‌‌‌‌　　阻塞 IO 指的是线程在调用 IO 操作时需要等待内核缓冲区的数据准备好后才能返回用户空间执行用户操作，在这个期间内线程都是阻塞状态.

‌‌‌‌　　Netty、Redis、Zookeeper高并发实战#^26174369-18-701-796
‌‌‌‌　　Netty、Redis、Zookeeper高并发实战#^26174369-18-1087-1166

同步 IO 和异步 IO

‌‌‌‌　　同步 IO，是一种用户空间和内核空间 IO 发起方式，指的是用户空间的线程是主动发起 IO 调用的一方，内核是被动接受方。

‌‌‌‌　　异步 IO 则是反过来，内核是主动调用的一方，用户空间的线程是被调用的一方。

‌‌‌‌　　Netty、Redis、Zookeeper高并发实战#^26174369-18-867-971

同步阻塞 IO

‌‌‌‌　　

同步阻塞 IO 的优点

‌‌‌‌　　同步阻塞 IO 十分的简单易用，程序员不需要太多的处理，只需要调用对应 API 即可进行 IO 操作

同步阻塞 IO 的缺点

同步非阻塞 IO

‌‌‌‌　　

同步非阻塞 IO 的优点

‌‌‌‌　　线程在内核层面做到了异步，内核在等待数据时线程会立即返回进行其他操作，减少了 IO 操作的阻塞时间

同步非阻塞 IO 的缺点

‌‌‌‌　　线程会不断轮询内核，占用大量的 CPU 时间，效率低下。在高并发场景中性能非常的低。

IO 多路复用

IO 多路复用流程

‌‌‌‌　　

选择器注册。先将需要 read 操作的目标文件描述符（socket 连接）提前注册在选择器中，在 about_Java 中式 Selector 类。然后开启 IO 多路复用的轮询流程
就绪状态的轮询。通过选择器查询所有注册过的文件描述符的 IO 就绪状态。通过查询的系统调用，内核会返回一个就绪的 socket 列表。任何一个 socket 准备好了就代表内核缓存区有数据了。
用户线程获得就绪的 socket 列表后，根据其中的 socket 连接发起 read 调用，用户线程阻塞。内核将数据从内核缓冲区中复制到用户缓冲区。
复制完成后，内核返回结果，用户线程才会解除阻塞的状态，用户线程读取到了数据，继续执行

IO 多路复用的优点

可以同时处理多个 IO 事件，从而提高程序的并发性
一个线程可以处理多个 IO 事件，减少了系统调用和线程切换和维护的开销，提高了系统性能

IO 多路复用的缺点

异步 IO

‌‌‌‌　　
‌‌‌‌

Input-Output 多路复用

2023-05-21T00:42:00.000Z

IO 多路复用流程

‌‌‌‌　　

选择器注册。先将需要 read 操作的目标文件描述符（socket 连接）提前注册在选择器中，在 about_Java 中式 Selector 类。然后开启 IO 多路复用的轮询流程
就绪状态的轮询。通过选择器查询所有注册过的文件描述符的 IO 就绪状态。通过查询的系统调用，内核会返回一个就绪的 socket 列表。任何一个 socket 准备好了就代表内核缓存区有数据了。
用户线程获得就绪的 socket 列表后，根据其中的 socket 连接发起 read 调用，用户线程阻塞。内核将数据从内核缓冲区中复制到用户缓冲区。
复制完成后，内核返回结果，用户线程才会解除阻塞的状态，用户线程读取到了数据，继续执行

IO 多路复用的优点

可以同时处理多个 IO 事件，从而提高程序的并发性
一个线程可以处理多个 IO 事件，减少了系统调用和线程切换和维护的开销，提高了系统性能

IO 多路复用的缺点

Cache行

2023-05-22T14:58:00.000Z

[!info]
在 CPU Cache 中数据时按行存储的被称为 Cache 行，Cache 行是 Cache 与主内存进行交互的数据单位
Cache 行的大小一般为 2 的幂次数字节

知觉对比

2023-05-23T21:04:00.000Z

📌 知觉对比是把两种不同事物之间的差异看得比实际上更大的倾向，是一些说服专业人士（销售、广告商等）喜欢利用的影响力杠杆。

📌 要是第二样东西跟第一样东西相当不同，那么，我们往往会认为两者的区别比实际上要大

捷径反应

2023-05-23T20:59:00.000Z

人类的捷径反应类似于动物的固定行为模式。

优点

捷径反应的优点在于它的效率和经济型，只根据常见的信息触发特征自动做出反应能节省人们宝贵的时间、精力和心智能量。

缺点

而这种反应的缺点在于它易受愚弄，一犯错代价就很大。只根据可用信息的一个片段，甚至是一般都能预测出的某个片段做出反应，尤其是按无意识的自动方式做出反应，人们出错的概率就会大增。要是其他人通过故意的安排（如对触发特征加以操纵）让自己牟利，刺激对方在不恰当的时机做出合乎他们心意的行为，那么对方犯错的概率就更大了。

参考

影响力（全新升级版）#^506504175-7Iq9IkXb5
影响力（全新升级版）#^41504771-70-2689-3065

固定行为模式

2023-05-23T21:00:00.000Z

许多动物都动物存在着机械刻板的行为模式——即固定行为模式。这一种自动的行为模式往往是由该环境下的单一特征所触发的。对于这些特征个体大部分时候无需对每一条信息去进行详尽的分析即可决定正确的的行动方针

参考

影响力（全新升级版）#^41504771-68-592-633

Spring中Bean的注册

2023-05-21T00:42:00.000Z

利用 AnnotatedBeanDefinitionReader 工具类获取注解注册 Bean

public void register(Class<?>... componentClasses) {  
    Assert.notEmpty(componentClasses, "At least one component class must be specified");  
    StartupStep registerComponentClass = this.getApplicationStartup().start("spring.context.component-classes.register").tag("classes", () -> {  
        return Arrays.toString(componentClasses);  
    });  
    this.reader.register(componentClasses);  
    registerComponentClass.end();  
}

AnnotatedBeanDefinitionReader 会遍历所有传入 componentClasses 的注解类，然后通过 doRegisterBean 方法完成注册。

doRegisterBean 源码：

private <T> void doRegisterBean(Class<T> beanClass, @Nullable String name,  
      @Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier,  
      @Nullable BeanDefinitionCustomizer[] customizers) {  
  //将配置信息转换为BeanDefinition
   AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);  
   if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {  
      return;  
   }  
  
   abd.setInstanceSupplier(supplier);  
   //获取Bean作用域的元数据解析Bean的作用域
   ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);  
   //将Bean作用域写回
   abd.setScope(scopeMetadata.getScopeName());  
   String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));  
   //@Lazy和@Primary注解的解析
   AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);  
   if (qualifiers != null) {  
      for (Class<? extends Annotation> qualifier : qualifiers) {  
         if (Primary.class == qualifier) {  
            abd.setPrimary(true);  
         }  
         else if (Lazy.class == qualifier) {  
            abd.setLazyInit(true);  
         }  
         else {  
            abd.addQualifier(new AutowireCandidateQualifier(qualifier));  
         }  
      }  
   }  
   if (customizers != null) {  
      for (BeanDefinitionCustomizer customizer : customizers) {  
         customizer.customize(abd);  
      }  
   }  
  
   BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);  
   definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);  
   BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);  
}

Spring 中 Bean 的作用域

2023-05-21T00:42:00.000Z

Singleton

唯一 bean 实例，Spring 中的 bean 默认都是单例的。

Prototype

每次请求都会创建一个新的 bean 实例。

Request

每一次 HTTP 请求都会产生一个新的 bean，该 bean 仅在当前 HTTP request 内有效。

Session

每一次 HTTP 请求都会产生一个新的 bean，该 bean 仅在当前 HTTP session 内有效。

global-session

全局 session 作用域，仅仅在基于 Portlet 的 Web 应用中才有意义，Spring5中已经没有了。Portlet 是能够生成语义代码（例如 HTML）片段的小型 Java Web 插件。它们基于 Portlet 容器，可以像 Servlet 一样处理 HTTP 请求。但是与 Servlet 不同，每个 Portlet 都有不同的会话。

Spring IOC

2023-05-21T00:42:00.000Z

[!info]
IOC（Inversion of Controll，控制反转）是一种设计思想, 将原本在程序中手动创建对象的控制权交给 Spring 框架来管理，IOC 并非 Spring 特有. IOC 容器是 Spring 用来实现 IOC 的载体。IOC 容器实际上就是一个 Map，在其中存放各种对象。

将对象之间的依赖关系交由 IOC 容器管理，并且由 IOC 容器进行对象的注入。很大程度上简化了应用的开发，IOC 容器就像是一个工厂一样，当我们需要创建对象只需要配置好配置文件或者注解即可。

Spring

2023-05-21T00:42:00.000Z

Spring Overview

本文件夹中总共有11 个文件

标签 3个

已发布笔记

File	tags	created	别名
Spring中Bean的注册	Spring	2023-05-01 17:05	-
SpringBoot@SpringBootApplication注解	SpringBoot	2023-05-01 16:41	-
Spring 中 Bean 的作用域	Spring	2023-04-24 10:56	-
Spring IOC	Spring	2023-04-24 10:39	-
Spring 循环依赖	-	2023-04-20 11:21	-
SpringBoot的三级缓存	SpringBoot	2023-04-20 11:08	三级缓存
Spring	-	2023-04-19 20:51	Spring-index

SpringBoot@SpringBootApplication注解

2023-05-21T00:42:00.000Z

📌 @SpringBootApplication注解实际上由三个注解组合而成，分别是@SpringBootConfiguration、@EnableAutoConfiguration和@ComponentScan。

[!info]
由 exclude 和 excludeName 配置不需要自动装备的域名，scanBasePackages，scanBasePackageClasses 配置需要扫描的的包路径和类路径

源码：

@Target({ElementType.TYPE})  
@Retention(RetentionPolicy.RUNTIME)  
@Documented  
@Inherited  
@SpringBootConfiguration  
@EnableAutoConfiguration  
@ComponentScan(  
    excludeFilters = {@Filter(  
    type = FilterType.CUSTOM,  
    classes = {TypeExcludeFilter.class}  
), @Filter(  
    type = FilterType.CUSTOM,  
    classes = {AutoConfigurationExcludeFilter.class}  
)}  
)  
public @interface SpringBootApplication {  
    @AliasFor(  
        annotation = EnableAutoConfiguration.class  
    )  
    Class<?>[] exclude() default {};  
  
    @AliasFor(  
        annotation = EnableAutoConfiguration.class  
    )  
    String[] excludeName() default {};  
  
    @AliasFor(  
        annotation = ComponentScan.class,  
        attribute = "basePackages"  
    )  
    String[] scanBasePackages() default {};  
  
    @AliasFor(  
        annotation = ComponentScan.class,  
        attribute = "basePackageClasses"  
    )  
    Class<?>[] scanBasePackageClasses() default {};  
  
    @AliasFor(  
        annotation = ComponentScan.class,  
        attribute = "nameGenerator"  
    )  
    Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;  
  
    @AliasFor(  
        annotation = Configuration.class  
    )  
    boolean proxyBeanMethods() default true;  
}

SpringBoot的三级缓存

2023-05-21T00:42:00.000Z

[!info]
SpringBoot 依靠三级缓存方案解决循环依赖的问题，这三级缓存在 Spring 中表现为三个 Map 对象。这三个 Map 对象定义在 DefaultSingletonBeanRegistry 类中，该类是 DefaultListableBeanFactory 的父类。

DefaultSingletonBeanRegistry 中的三级缓存 Map 定义代码

Spring Boot进阶：原理、实战与面试题分析#^3300019666-15-797-823

[!info] 三级缓存分别是：
三级缓存分别为 singletonObjects、earlySingletonObjects、singletonFactories。

[!note] 一级缓存 singletonObjects
一级缓存用来持有完整的 Bean 实例。

[!note] 二级缓存 earlySingletonObjects
在二级缓存中存放的是那些提前暴露的对象（已经创建但是还没有完成属性注入的对象）

[!note] 三级缓存 singletonFactories
第三级缓存 singletonFactories 是用来存放二级缓存earlySingletonObjects 的工厂对象

Bean 实例化过程中的 addSingletonFactory()方法代码

author: Ten
aliases:

Bean 实例化过程中的 addSingletonFactory()方法代码
dg-publish: true
folder-index: false
created: 2023-04-20 12:10
date updated: 2023-04-20 12:11

Bean 实例化过程中的 addSingletonFactory()方法代码

//1. 初始化Bean，通过构造函数创建Bean 
instanceWrapper = createBeanInstance(beanName, mbd, args); 
//针对循环依赖问题暴露单例工厂类 
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); 
//2. 初始化Bean实例，完成Bean实例的完整创建 
populateBean(beanName, mbd, instanceWrapper);

Spring Boot进阶：原理、实战与面试题分析#^3300019666-15-1520-1689

Spring 循环依赖

2023-05-21T00:42:00.000Z

Spring 解决循环依赖的诀窍就在于三级缓存中的第三级缓存

三级缓存如何解决循环依赖的

首先分析一下获取 Bean 的代码流程：

获取Bean的getSingleton()方法代码

author: Ten
aliases: [获取Bean的getSingleton()方法代码]
tags: []
dg-publish: true
folder-index: false
created: 2023-04-20 11:50

获取 Bean 的 getSingleton()方法代码

protected Object getSingleton(String beanName, boolean allowEarlyReference) {  
    //首先从一级缓存singletonObjects中获取  
    Object singletonObject = this.singletonObjects.get(beanName);  
    //如果获取不到,就从二级缓存earlySingletonObjects中获取   
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {  
        synchronized (this.singletonObjects) {  
            singletonObject = this.earlySingletonObjects.get(beanName);  
            //如果还是获取不到,就从三级缓存singletonFactory中获取  
            if (singletonObject == null && allowEarlyReference) {  
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);  
                if (singletonFactory != null) {  
                    singletonObject = singletonFactory.getObject();  
                    //一旦获取成功,就把对象从第三级缓存移动到第二级缓存中   
this.earlySingletonObjects.put(beanName, singletonObject);  
                    this.singletonFactories.remove(beanName);  
                }  
            }  
  
        }  
    }  
    return singletonObject;  
}

通过这一段代码我们能够理解到对三级缓存的访问过程：

依靠三级缓存解决循环依赖问题的过程：

假设当 ClassA 和 ClassB 互相依赖。在初始化 ClassA 时会创建 ClassA 实例并且暴露到第三级缓存中，然后 ClassA 开始进行属性注入，这时发现需要依赖 ClassB 就会开始初始化 ClassB，将 ClassB 暴露到第三级缓存，进行属性注入，发现依赖 ClassA，开始从第三级缓存中获取 ClassA，完成 ClassB 的完整创建并放入一级缓存，ClassA 开始获取 ClassB 并完成创建。

消除循环依赖的思路

通过两个互相依赖的组件之间添加中间层，变循环依赖为间接依赖

元数据

[!abstract] Spring Boot进阶：原理、实战与面试题分析

书名： Spring Boot进阶：原理、实战与面试题分析

作者：郑天民

简介：这是一本能带领读者全方位掌握Spring Boot技术体系的功能、原理和Z佳实践的著作，能帮助读者在Spring Boot领域快速实现从入门到进阶。
　　　　全书涵盖Spring Boot的6大核心主题：核心容器、Web服务、缓存、数据访问、并发执行、监控与扩展，内容具有以下4大特性：
　　　　针对性：系统梳理了6个主题所包含技术的功能特性、工作原理、实践方案，读者能快速掌握其核心技术、底层设计理念和生态扩展；
　　　　创新性：与同类书不同，本书搜集并分析了每个主题下的高频面试题，旨在帮助读者在面试和晋升时事半功倍；
　　　　实战性：注重实用性，基于作者近15年的经验，通过丰富的场景案例提供了大量应用方案和Z佳实践；
　　　　前瞻性：不仅系统讲解了常用的核心技术，而且还讲解了时下流行的云原生、RSocket等前沿技术及其应用方案。

出版时间 2022-05-01 00:00:00

ISBN： 9787111706748

分类：计算机-编程设计

出版社：机械工业出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

1.2 开发Spring Boot应用程序

📌 度量监控。基于Spring Boot提供的Actuator组件，可以通过RESTful接口获取JVM性能指标、线程工作状态等运行时信息 ^3300019666-8-2075-2142
- ⏱ 2023-04-17 09:10:34
📌 @RestController注解是传统Spring MVC中所提供的@Controller注解的升级版，相当于@Controller和@ResponseEntity注解的结合体，会自动使用JSON实现序列化/反序列化操作。 ^3300019666-8-6635-6747
- ⏱ 2023-04-17 09:23:58
📌 配置文件可以是空的，开发人员如果不需要特别指定服务器端口的信息 ^3300019666-8-6828-6859
- ⏱ 2023-04-17 09:24:59
📌 如果我们不希望在全局配置文件中指定所需要激活的Profile，而是想把这个过程延迟到运行这个服务时，那么可以直接在java -jar命令中添加--spring.profiles.active参数， ^3300019666-8-11822-11920
- ⏱ 2023-04-17 09:32:17

1.3 Spring Boot实战内容和案例

📌 Spring的依赖注入机制在解决循环依赖问题时采用了三级缓存机制 ^3300019666-9-1094-1126
- ⏱ 2023-04-17 10:49:29
📌 相较Spring WebMVC，Spring WebFlux能够为我们实现异步、非阻塞的远程交互过程 ^3300019666-9-3382-3432
- ⏱ 2023-04-17 10:58:48
📌 Spring内置的响应式编程框架是Project Reactor ^3300019666-9-4550-4582
- ⏱ 2023-04-17 11:01:48
📌 Spring的缓存机制非常灵活，提供了一组包括@Cacheable、@CachePut和@CacheEvict在内的注解来简化系统缓存的使用过程，可以通过这些注解对容器中的任意Bean或者Bean的方法添加缓存功能 ^3300019666-9-5226-5333
- ⏱ 2023-04-17 11:03:07
📌 Spring Boot Actuator组件是承载系统监控功能的组件，通过一系列HTTP端点提供系统监控功能。 ^3300019666-9-11735-11790
- ⏱ 2023-04-17 11:17:10
📌 Spring也提供了专门针对云原生架构的Spring Native框架。Spring Native基于GraalVM虚拟机技术，为开发人员提供了更快的启动时间以及更少的内存占用 ^3300019666-9-12476-12564
- ⏱ 2023-04-17 11:18:52

2.1 Spring依赖注入类型

📌 构造器注入能够保证注入的组件不可变，并且确保需要的依赖不为空 ^3300019666-13-4129-4159
- ⏱ 2023-04-17 11:33:47

2.2 Spring依赖注入原理分析

📌 在刚开始阅读Spring源码时，我建议你直接从AnnotationConfigApplicationContext的启动流程切入，这一流程位于它的构造函数中 ^3300019666-14-1282-1360
- ⏱ 2023-04-17 15:21:08
📌 ListableBeanFactory是Spring中常用的一个BeanFactory，通过这个接口，我们可以一次获取多个Bean。 ^3300019666-14-4816-4882
- ⏱ 2023-04-17 11:47:13

2.3 Spring循环依赖案例分析

📌 所谓的三级缓存，在Spring中表现为三个Map对象 ^3300019666-15-797-823
- ⏱ 2023-04-17 12:03:42
📌 singletonObjects变量就是第一级缓存，用来持有完整的Bean实例。而earlySingletonObjects中存放的是那些提前暴露的对象，也就是已经创建但还没有完成属性注入的对象，属于第二级缓存。最后的singletonFactories存放用来创建earlySingleton-Objects的工厂对象，属于第三级缓存。 ^3300019666-15-1520-1689
- ⏱ 2023-04-17 12:05:32
📌 Spring解决循环依赖的诀窍就在于singletonFactories这个第三级缓存 ^3300019666-15-3552-3595
- ⏱ 2023-04-17 15:33:08
📌 相信你也理解了为什么构造器注入无法解决循环依赖问题。这是因为构造器注入过程是发生在Bean初始化的第一个步骤createBeanInstance()中，而这个步骤还没有调用addSingletonFactory()方法完成第三级缓存的构建，自然也就无法从该缓存中获取目标对象 ^3300019666-15-5857-5994
- ⏱ 2023-04-18 11:02:12
📌 消除循环依赖的基本思路也是这样，就是通过在两个相互循环依赖的组件之间添加中间层，变循环依赖为间接依赖。有三种方法可以做到这一点，分别是提取中介者、转移业务逻辑和引入回调 ^3300019666-15-8807-8891
- ⏱ 2023-04-18 11:07:23
📌 提取中介者的核心思想是把两个相互依赖的组件中的交互部分抽象出来形成一个新的组件，而新组件同时包含着对原有两个组件的引用，这样就把循环依赖关系剥离出来并提取到一个专门的中介者组件中 ^3300019666-15-8977-9066
- ⏱ 2023-04-18 11:09:59

2.4 Spring依赖注入实战经验

📌 在Spring IoC容器中，Bean的默认作用域是单例，也就是说不管有多少个对Bean的引用，容器只会创建一个实例。而原型作用域则不同，每次请求Bean时，Spring IoC容器都会创建一个新的对象实例。 ^3300019666-16-1495-1599
- ⏱ 2023-04-18 11:12:38
📌 从两种作用域的效果而言，我们总结出一条开发上的经验，即对于有状态的Bean，我们应该使用原型作用域，反之则应该使用单例作用域。 ^3300019666-16-1628-1691
- ⏱ 2023-04-18 11:12:48
📌 在Spring中，我们可以通过设置组件扫描范围来简化Bean的注入配置。因为任何类都位于某一个包结构之下，所以Spring提供了一个@ComponentScan注解，该注解在需要大规模对象注入的场景下非常有用 ^3300019666-16-3667-3771
- ⏱ 2023-04-18 11:18:03
📌 添加了@Lazy注解的效果是只有在使用到这个Bean时它才会去初始化，而不是在Spring IoC容器启动时直接初始化，这样就可以节省容器资源 ^3300019666-16-5458-5529
- ⏱ 2023-04-18 11:22:06

3.2 动态代理机制与Spring AOP

📌 。和Proxy只能代理接口不同，Enhancer既能够代理接口，也能够代理普通类，但不能拦截final类和方法。 ^3300019666-21-4591-4647
- ⏱ 2023-04-18 18:55:07

3.3 AOP代理机制对性能的影响案例分析

📌 @Scope注解还可以用来指定代理模式ScopedProxyMode ^3300019666-22-923-957
- ⏱ 2023-04-18 22:07:40

3.4 AOP实战经验

📌 代码清单3-22　execution()基本语法execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern)throws-pattern?)这个语法看似复杂，但是我们逐个分解所有的模式，它们其实就是描述了一个方法的特征。■modifiers-pattern：表示方法的修饰符。■ret-type-pattern：表示方法的返回值。■declaring-type-pattern：表示方法所在的类的路径。■name-pattern：表示方法名。■param-pattern：表示方法的参数。■throws-pattern：表示方法抛出的异常。 ^3300019666-23-1094-1687
- ⏱ 2023-04-18 22:14:56
📌 这是因为Spring AOP是通过代理实现的，而无论是JDK代理还是CGLIB代理，其运行机制是对某一个外部的接口或实现类进行代理，像上述代码中直接调用ServiceImpl类内的方法是不会应用代理的。 ^3300019666-23-3592-3693
- ⏱ 2023-04-18 22:22:34
📌 不要在已经受Spring管理的Bean类上使用@Configurable注解，否则它将执行双重初始化，一次是通过Spring容器，一次是通过AOP切面。 ^3300019666-23-4348-4424
- ⏱ 2023-04-18 22:26:44
📌 @Configurable这个注解的作用就是告诉Spring在构造函数运行之前将依赖关系注入对象中 ^3300019666-23-4429-4478
- ⏱ 2023-04-18 22:27:10
📌 Spring的推荐做法是尽可能使用JDK动态代理而不是CGLIB代理 ^3300019666-23-4577-4611
- ⏱ 2023-04-18 22:27:45

3.5 Spring AOP面试题分析

📌 常见的动态代理实现技术包括JDK自带的代理类、第三方的CGLIB和javassist。 ^3300019666-24-1175-1218
- ⏱ 2023-04-18 22:29:55

4.1 Spring WebMVC

📌 Spring Boot提供了一系列便捷有用的注解来简化对请求输入的控制过程，常用的包括上述UserController中所展示的@PathVariable和@RequestBody ^3300019666-28-2038-2128
- ⏱ 2023-04-19 11:27:50
📌 @PathVariable注解用于获取路径参数，即从类似url/{id}这种形式的路径中获取{id}参数的值 ^3300019666-28-2158-2212
- ⏱ 2023-04-19 11:27:57
📌 在HTTP中，content-type属性用来指定所传输的内容类型。而我们可以通过@Request-Mapping注解中的produces属性来对其进行设置，通常会将其设置为application/json ^3300019666-28-2686-2789
- ⏱ 2023-04-19 11:29:43
📌 InterceptingHttpAccessor应该包含两部分处理功能，一部分是设置和管理请求拦截器ClientHttpRequestInterceptor，另一部分则是获取用于创建客户端HTTP请求的工厂类ClientHttpRequestFactory ^3300019666-28-10958-11086
- ⏱ 2023-04-20 13:27:59
📌 通过RestTemplate的类层结构，我们可以理解它的设计思想。整个类层结构可以清晰地分成两条线，左边部分用于完成与HTTP请求相关的实现机制，而右边部分则提供了RESTful风格的操作入口，并使用了面向对象的接口和抽象类完成了对这两部分功能的聚合。 ^3300019666-28-12097-12223
- ⏱ 2023-04-22 00:07:31

4.2 Spring HATEOAS

📌 我们已经知道什么是多媒体（Multimedia），以及什么是超文本（Hypertext）。其中超文本特有的优势是拥有超链接（Hyperlink）。如果我们把超链接引入到多媒体中，那就得到了超媒体（Hypermedia），因此这里的关键角色还是超链接。从HATEOAS的字面上进行理解，使用超媒体作为应用状态的引擎，指的就是应用的状态变更将由客户端访问不同的超媒体资源来驱动。 ^3300019666-29-1201-1388
- ⏱ 2023-04-22 16:14:44
📌 HATEOAS的重要性在于打破了客户端和服务器之间严格的契约，使得客户端可以更加智能和自适应，而RESTful服务本身的演化和更新也变得更加容易。 ^3300019666-29-2074-2147
- ⏱ 2023-04-22 16:15:11
📌 HATEOAS更多是一种概念，而HAL（Hypertext Application Language，超文本应用语言）是HATEOAS的一种实现方式。与普通的RESTful风格不同，对每个资源，HAL又将其细分成状态（State）、链接（Links）和子资源（Embedded Resource）三个标准部分 ^3300019666-29-2348-2502
- ⏱ 2023-04-22 16:15:41
📌 HAL的出现主要弥补了普通JSON格式在API交互中的不足，让JSON更具有自描述性和导航性。 ^3300019666-29-3769-3816
- ⏱ 2023-04-22 16:18:58

4.3 Spring GraphQL

📌 RESTful API的第一个典型问题就是前端无法预判响应的数据格式 ^3300019666-30-1821-1855
- ⏱ 2023-04-22 16:22:54
📌 一旦服务端对数据结构做了任何改变，前端都只能被动接收，而无法在发起请求之前感知到这种改变。 ^3300019666-30-1869-1914
- ⏱ 2023-04-22 16:23:04
📌 RESTful API的第二个典型问题是无法根据请求控制对应的返回结果。 ^3300019666-30-1943-1979
- ⏱ 2023-04-22 16:23:10
📌 前端请求可能只想获取User对象中的name和age字段，而不需要address字段。 ^3300019666-30-1991-2034
- ⏱ 2023-04-22 16:23:27
📌 RESTful API的第四个典型问题，即请求地址过多的问题。如果针对各个具体场景我们都需要一一暴露专门的HTTP端点，那么在一个系统中HTTP端点数量会非常庞大，难以维护和管理 ^3300019666-30-2702-2791
- ⏱ 2023-04-22 16:26:09
📌 相比于REST，GraphQL可以说是一个比较新的技术，它于2012年诞生在Facebook内部，并于2015年正式开源。顾名思义，GraphQL是一种基于图（Graph）的查询语言（Query Language，QL），从根本上改变了前后端交互API的定义和实现方式。 ^3300019666-30-2906-3041
- ⏱ 2023-04-22 16:26:35
📌 针对RESTful API存在的多次请求问题，GraphQL可以把多次请求合并成一次。 ^3300019666-30-3725-3768
- ⏱ 2023-04-22 16:30:50
📌 Schema首先，我们需要引入一个核心组件，即Schema。所谓Schema，简单讲就是一种前后端交互的协议和规范，或者可以把它类比成RESTful API中的接口定义文档。 ^3300019666-30-5319-5435
- ⏱ 2023-04-22 16:32:27
📌 在Schema中，开发人员需要指定两部分内容。一方面，我们需要明确定义前后端交互的数据结构，包括具体的字段名称、类型、是否为空等属性。另一方面，GraphQL规定每一个Schema中可以存在一个根Query和根Mutation，分别用于执行查询和更新操作。 ^3300019666-30-5464-5592
- ⏱ 2023-04-22 16:32:53
📌 DataFetcher组件的作用就是在执行查询时获取字段对应的数据。 ^3300019666-30-6313-6347
- ⏱ 2023-04-22 16:39:11
📌 开发人员可以从DataFetchingEnvironment中获取传入的参数，并根据该参数来执行具体的数据查询操作 ^3300019666-30-6646-6703
- ⏱ 2023-04-22 16:39:28
📌 通过Runtime Wiring机制，我们可以把DataFetcher整合在GraphQL的运行环境中 ^3300019666-30-6872-6923
- ⏱ 2023-04-22 16:40:23
📌 开发人员本身并不需要了解这个GraphQlSource对象的构建过程，因为它的职责是在框架内部完成GraphQL执行引擎的初始化，这是Spring GraphQL框架自动会为我们做的事情。开发人员唯一要做的就是通过GraphQlSource获取一个GraphQL对象 ^3300019666-30-9657-9790
- ⏱ 2023-04-22 16:44:15
📌 GraphQL引擎所需要执行的数据查询操作与业务相关，这部分功能需要开发人员根据具体业务场景进行设计并实现，这时候就会使用到graphql-spring-boot-starter中的RuntimeWiringBuilderCustomizer接口。RuntimeWiringBuilderCustomizer接口简化了Runtime-Wiring的实现过程，开发人员通过实现这个接口就可以设置一系列的DataFetcher ^3300019666-30-10001-10212
- ⏱ 2023-04-22 16:45:23
📌 首先，如果你在公开的Maven仓库中搜索graphql-spring-boot-starter这个artifactId，会发现存在多个对应的groupId，这是因为老版本的GraphQL Java Spring框架已经实现了同名的artifactId。而我们在这里指定groupId为org.springframework.experimental，这是Spring GraphQL框架目前所属的groupId，可以看到它还属于试验（experimental）阶段，并没有发布到公开的Maven仓库中。所以，为了引入这个依赖包，我们需要指定Spring官方的Maven仓库地址 ^3300019666-30-12444-12732
- ⏱ 2023-04-22 16:48:09

4.4 轻量级Web实战经验

📌 并不推荐你在任何场景下都使用GraphQL ^3300019666-31-2240-2261
- ⏱ 2023-04-22 16:56:05
📌 对于那些API定义与资源概念匹配度较高，也不需要实现类似在用户信息内部嵌套家庭成员信息的复杂查询场景，传统的RESTful API仍然是首选，各个HTTP端点之间相互独立，职责非常明确 ^3300019666-31-2262-2354
- ⏱ 2023-04-22 16:56:13
📌 对于业务复杂度较高的场景，推荐使用GraphQL ^3300019666-31-2409-2433
- ⏱ 2023-04-22 16:56:21
📌 对于那些单一的RESTful服务，可以把GraphQL直接嫁接到已有的RESTful服务上 ^3300019666-31-4012-4057
- ⏱ 2023-04-22 16:58:01
📌 RESTful服务中已经实现的业务逻辑层、数据访问层组件都可以得到复用，我们要做的只是开放一个新的GraphQL访问入口而已 ^3300019666-31-4065-4127
- ⏱ 2023-04-22 16:58:15

5.1 响应式编程和Spring Boot

📌 对于响应式编程而言，首先要明确的概念是数据流（Data Stream） ^3300019666-35-617-652
- ⏱ 2023-04-22 17:00:46
📌 所谓的流就是由生产者生产并由一个或多个消费者消费的元素序列。 ^3300019666-35-658-688
- ⏱ 2023-04-22 17:00:54
📌 Java API版本的响应式流只包含四个接口，即Publisher、Subscriber、Subscription和Processor<T,R>。 ^3300019666-35-835-932
- ⏱ 2023-04-22 17:01:08
📌 发布者（Publisher）是潜在的包含无限数量的有序元素的生产者，它根据收到的请求向当前订阅者发送元素。 ^3300019666-35-961-1014
- ⏱ 2023-04-22 17:01:29
📌 订阅者（Subscriber）从发布者那里订阅并接收元素。发布者向订阅者发送订阅令牌（Subscription Token）。 ^3300019666-35-1292-1355
- ⏱ 2023-04-22 17:02:09
📌 处理器（Processor）充当订阅者和发布者之间的转换器（Transformer）。 ^3300019666-35-2539-2582
- ⏱ 2023-04-22 17:12:10
📌 1）当发布者使用subscribe()方法实现对该发布者的订阅时，首先会创建一个具有相应逻辑的Subscription对象，这个Subscription对象定义了如何处理请求，以及如何发出数据。2）然后发布者将这个Subscription通过订阅者的onSubscribe()方法传给订阅者。3）在订阅者的onSubscribe()方法中，需要通过Subscription的request ()方法发起第一次请求。4）Subscription收到请求，就可以通过回调订阅者的onNext()方法发出元素，有多少发多少，但不能超过请求的个数。5）订阅者在onNext()方法中通常定义对元素的处理逻辑，处理完成之后，可以继续发起请求。6）发布者根据需要继续满足订阅者的请求。7）如果发布者的元素序列正常结束，就通过订阅者的onComplete()方法予以告知。如果序列发送过程中有错误，则通过订阅者的onError()方法予以告知并传递错误提示。这两种情况都会导致序列终止，订阅过程结束。 ^3300019666-35-3400-4017
- ⏱ 2023-04-22 17:13:24
📌 Spring Cloud Gateway基于最新的Spring 5和Spring Boot 2以及用于响应式编程的Project Reactor框架，提供响应式、非阻塞式I/O模型。和其他API网关系统类似，Spring Cloud Gateway中的核心组件也是过滤器。 ^3300019666-35-8427-8563
- ⏱ 2023-04-22 17:21:18
📌 过滤器用于在响应HTTP请求之前或之后修改请求本身及对应的响应结果。Spring Cloud Gateway提供了一个全局过滤器（GlobalFilter）的概念，对所有路由都生效。 ^3300019666-35-8592-8683
- ⏱ 2023-04-22 17:21:34
📌 Spring WebFlux提供了完整的支持响应式开发的服务端技术栈。和Spring WebMVC相比，Spring WebFlux既支持基于@Controller、@RequestMapping等注解的传统开发模式，又支持基于Router Functions的函数式开发模式。 ^3300019666-35-11717-11856
- ⏱ 2023-04-22 17:24:16
📌 Spring WebFlux则是构建在响应式流以及它的实现框架Reactor基础之上的一个开发框架，因此可以基于HTTP实现异步非阻塞的Web服务。 ^3300019666-35-12029-12103
- ⏱ 2023-04-22 17:24:49

5.2 Spring WebFlux

📌 在Spring WebMVC中，对Web请求的处理机制也基于管道-过滤器（Pipe-Filter）架构模式。Spring WebMVC使用了Servlet中的过滤器链（FilterChain）来对请求进行拦截 ^3300019666-36-655-759
- ⏱ 2023-04-22 17:25:41
📌 当HTTP请求通过Servlet容器时就会被转换为一个ServletRequest对象，而处理的结果将以Servlet-Response对象的形式返回。当ServletRequest通过过滤器链中的一系列过滤器之后，最终就会到达作为前端控制器的DispatcherServlet。 ^3300019666-36-1117-1257
- ⏱ 2023-04-22 17:26:36
📌 就整体架构而言，Spring WebFlux和Spring WebMVC本质上并没有什么区别。 ^3300019666-36-3049-3096
- ⏱ 2023-04-22 17:30:39
📌 在WebFlux中，和DispatcherServlet相对应的组件是DispatcherHandler ^3300019666-36-3641-3693
- ⏱ 2023-04-22 17:32:19
📌 WebFlux同样实现了响应式版本的RequestMappingHandlerMapping和RequestMapping-HandlerAdapter，因此我们仍然可以采用注解的方法来构建Controller ^3300019666-36-4578-4683
- ⏱ 2023-04-22 17:33:23
📌 WebFlux还提供了RouterFunctionMapping和HandlerFunctionAdapter组合，专门用来提供基于函数式编程的开发模式。 ^3300019666-36-4687-4764
- ⏱ 2023-04-22 17:33:33
📌 使用函数式编程模型创建响应式Web API时，我们需要引入一组全新的编程对象，即ServerRequest、ServerResponse、HandlerFunction和RouterFunction。 ^3300019666-36-5961-6061
- ⏱ 2023-04-22 19:47:17
📌 相比retrieve()方法，exchange()方法对响应结果拥有更多的控制权 ^3300019666-36-9435-9475
- ⏱ 2023-04-22 20:01:17

5.3 Spring RSocket

📌 RSocket协议诞生于2015年，是一个与语言无关的二进制网络协议，用来解决单一的请求-响应模式以及现有网络传输协议所存在的问题 ^3300019666-37-1058-1123
- ⏱ 2023-04-22 21:34:36
📌 RSocket以异步消息的方式提供了四种交互模式，除了请求-响应（request/response）模式之外，还包括请求-响应流（request/stream）、即发-即忘（fire-and-forget）和通道（channel）这三种新的交互模式 ^3300019666-37-1153-1277
- ⏱ 2023-04-22 21:35:28
📌 请求-响应模式：这是最典型也最常见的交互模式。发送方在发送消息给接收方之后，等待与之对应的响应消息。 ^3300019666-37-1324-1374
- ⏱ 2023-04-22 21:36:07
📌 请求-响应流模式：发送方的每个请求消息，都对应于接收方的一个消息流作为响应。 ^3300019666-37-1404-1442
- ⏱ 2023-04-22 21:36:11
📌 即发-即忘模式：发送方的请求消息没有与之对应的响应。 ^3300019666-37-1472-1498
- ⏱ 2023-04-22 21:36:15
📌 通道模式：在发送方和接收方之间建立一个双向传输的通道。 ^3300019666-37-1528-1555
- ⏱ 2023-04-22 21:36:19
📌 @MessageMapping是Spring提供的，用来指定WebSocket、RSocket等协议中消息处理的目的地。 ^3300019666-37-7334-7394
- ⏱ 2023-04-22 22:07:44

5.4 响应式Web实战经验

📌 R2DBC是Reactive Relational DataBase Connectivity的简称，即响应式关系数据库连接。该规范允许驱动程序提供与数据库的完全响应式和非阻塞集成 ^3300019666-38-2923-3013
- ⏱ 2023-04-22 22:53:47

6.1 缓存注解

📌 @Cacheable注解可以标记在一个方法上，也可以标记在一个类上。当标记在一个类上时，该类所有的方法都是支持缓存的。 ^3300019666-43-2295-2354
- ⏱ 2023-04-23 09:50:30
📌 @CachePut注解也可以声明在一个方法中来启用缓存功能。与@Cacheable注解不同的是，添加了@CachePut注解的方法在执行前不会去检查缓存中是否存在之前执行过的结果，而是每次都会执行该方法，并将执行结果存入指定的缓存中。显然，从命名上看，@CachePut适合于执行更新操作的方法。 ^3300019666-43-4836-4984
- ⏱ 2023-04-23 19:21:55
📌 @CacheEvict可以指定的属性也包括value、key和condition。但因为清除缓存的操作可能涉及多个元素，所以@CacheEvict注解额外提供了一个allEntries属性来指定是否清除缓存中的所有元素。这个属性的默认值是false。而当指定了allEntries属性为true时，Spring将忽略指定的key，并清除缓存中的所有元素。 ^3300019666-43-5709-5886
- ⏱ 2023-04-23 19:23:09

6.2 缓存键管理

📌 在Spring缓存中，缓存键的生成有两种策略，一种是默认策略，另一种是自定义策略。 ^3300019666-44-393-434
- ⏱ 2023-04-23 19:28:17
📌 。除了上述将方法参数作为key之外，Spring还为我们提供了一个Root对象来生成key。通过该Root对象，开发人员可以获取到本地方法调用所涉及的一组元数据 ^3300019666-44-819-899
- ⏱ 2023-04-23 19:31:49
📌 如果没有指定key属性，那么Spring会帮我们自动生成键。默认的键生成策略是通过KeyGenerator生成的 ^3300019666-44-1533-1589
- ⏱ 2023-04-23 19:33:29
📌 默认键生成策略的具体运作方式是这样的：如果方法没有参数，则使用0作为key；如果只有一个参数，则使用该参数作为key；如果参数多于一个的话则使用所有参数的HashCode作为key。 ^3300019666-44-1861-1952
- ⏱ 2023-04-23 19:36:31

6.3 缓存配置

📌 在注解模式下想要启用Spring内置的缓存功能，需要在配置类上添加@EnableCaching ^3300019666-45-453-500
- ⏱ 2023-04-23 19:41:46
📌 除了基于Java API的ConcurrentMapCacheManager之外，EhCache、Redis、Caffeine、Guava等第三方缓存工具都已经被整合进了Spring框架 ^3300019666-45-1137-1230
- ⏱ 2023-04-23 19:43:09

6.5 缓存实现原理

📌 对于缓存而言，其核心思想是在调用一个缓存方法时把该方法的参数和返回结果作为一个键值对存放在缓存中，等到下次基于同样的参数来调用该方法时将不再执行该方法，而是直接从缓存中获取结果并进行返回。 ^3300019666-47-426-520
- ⏱ 2023-04-23 20:38:15
📌 在对缓存机制的整体设计上，Spring采用了典型的两层架构，即内核层和扩展层。所谓内核层，相当于对缓存本身的一种抽象，抽取了与缓存相关的最核心的操作方法； ^3300019666-47-614-691
- ⏱ 2023-04-23 20:46:05
📌 扩展层，则是基于内核层的抽象，分别集成业界主流的缓存工具，从而对缓存的核心操作方法提供实现方案。 ^3300019666-47-692-740
- ⏱ 2023-04-23 21:06:46

6.7 系统缓存面试题分析

📌 答案：Spring为开发人员提供的缓存注解数量并不多，比较容易让人理解和记忆。日常开发过程中比较常用的缓存注解包括@Cacheable注解、@CachePut注解和@CacheEvict注解，这三个注解分别对应查询、更新和删除操作 ^3300019666-49-915-1037
- ⏱ 2023-04-23 21:42:49

7.1 Spring Security安全框架

📌 Spring Security中所采用的最基本的架构就是管道-过滤器架构模式。 ^3300019666-52-794-833
- ⏱ 2023-04-23 21:54:17

7.3 Spring Security认证缓存案例分析

📌 在Web应用程序开发过程中，客户端访问RESTful服务端的过程应该是无状态的。如果不配置为无状态，则服务端会堆积海量的Session ID，导致出现性能问题 ^3300019666-54-8905-8984
- ⏱ 2023-04-24 01:03:08

7.4 认证缓存原理分析

📌 Spring Security中的认证过程由一组核心对象组成，这些对象可以分成两大类，一类是用户对象，另一类是认证对象。 ^3300019666-55-673-733
- ⏱ 2023-04-24 01:05:37

8.3 JdbcTemplate实现原理

📌 JdbcTemplate正是基于模板方法模式和回调机制解决了原生JDBC面临的复杂性问题。 ^3300019666-63-2243-2288
- ⏱ 2023-04-24 22:47:44

8.4 Spring JDBC实战经验

📌 Fetch Size可以用来指定一次从数据库中检索的行数，而大多数JDBC驱动程序的默认值是10 ^3300019666-64-1417-1465
- ⏱ 2023-04-28 00:01:43
📌 Fetch Size不应该采用硬编码，而需要确保它的可配置性，因为它影响到JVM堆内存大小，不同的环境会有所不同。 ^3300019666-64-1908-1965
- ⏱ 2023-04-28 00:02:36
📌 在大多数标准JDBC API中，默认的提交模式是自动提交（Auto Commit） ^3300019666-64-5448-5489
- ⏱ 2023-04-28 00:07:56

9.1 Spring Data架构与应用

📌 Spring Data基于Repository架构模式抽象出一套实现该模式的统一数据访问方式。 ^3300019666-68-506-553
- ⏱ 2023-04-28 00:10:45
📌 JPA全称是Java Persistence API，即Java持久化API，是一个Java应用程序接口规范，充当面向对象的领域模型和关系数据库系统之间的桥梁，所以属于一种ORM技术。 ^3300019666-68-3239-3331
- ⏱ 2023-04-28 00:14:46

9.3 Spring ORM实战经验

📌 所谓延迟加载（Lazy Load，有时也称为懒加载）是指在进行表的关联查询时，按照设置的延迟规则推迟对关联对象的查询 ^3300019666-70-1260-1318
- ⏱ 2023-04-28 09:17:14
📌 二级缓存是与命名空间（namespace）强关联的，即如果在不同的命名空间下存在相同的查询SQL，这两者之间也是不共享缓存数据的 ^3300019666-70-4138-4202
- ⏱ 2023-04-28 09:30:07

9.4 Spring ORM面试题分析

📌 在Spring Data JPA中，解决N+1问题的方式也很明确，就是使用JOIN FETCH机制。JOIN FETCH机制会强制Spring Data JPA在处理关联对象时使用INNER JOIN语句来执行关联查询，从而使用一条SQL语句完成对所有对象的查询。 ^3300019666-71-1581-1713
- ⏱ 2023-04-28 09:34:17

10.2 Spring @Async实现原理

📌 方法的实际执行过程将提交给Spring的任务执行器TaskExecutor进行执行。 ^3300019666-76-495-537
- ⏱ 2023-04-28 14:19:24
📌 一方面，@Async注解的运行过程依赖于Spring中对Bean生命周期的处理；另一方面，我们也需要充分利用基于代理的拦截器机制来实现异步操作 ^3300019666-76-6172-6243
- ⏱ 2023-04-28 14:39:07
📌 在Spring中，BeanPostProcessor的作用是在完成Bean实例化和依赖注入之后，在显式调用初始化方法的前后添加我们自己的逻辑，可以认为这里是添加代理机制的绝佳位置 ^3300019666-76-10244-10333
- ⏱ 2023-04-28 14:52:22

10.3 Spring Web异步处理

📌 相较于@Async注解，WebAsyncTask为开发人员提供了更灵活的异步任务处理机制，并内置了异步回调、超时处理和异常处理等功能特性。 ^3300019666-77-2720-2789
- ⏱ 2023-04-29 16:51:39

10.5 Spring Async面试题分析

📌 在日常Web开发过程中，常见的异步处理需求来自三方面的场景，包括常规的异步请求处理过程、不需要返回值的即发-即忘处理过程，以及耗时较长的大数据量请求处理。 ^3300019666-79-525-602
- ⏱ 2023-04-29 16:57:28

11.1 Java执行器模型

📌 所谓的Executor，本质上是在所有内部任务线程上提供了一个抽象层，从而管理线程的整个并发执行流。 ^3300019666-82-905-955
- ⏱ 2023-04-29 17:02:02
📌 Java并发API支持固定线程池（Fixed-Thread Pool）、缓存线程池（Cached-Thread Pool）、单线程池（Single-Thread Pool）和Fork/Join线程池等多种线程池类型。 ^3300019666-82-2157-2265
- ⏱ 2023-04-29 17:04:03

11.2 Spring任务执行器

📌 限流器的作用是在线程执行的并发度达到阈值时让后续的线程处于阻塞等待。 ^3300019666-83-5745-5779
- ⏱ 2023-04-29 17:56:33

12.1 Spring Boot Actuator组件

📌 pring Cloud中的Spring Cloud Config框架，该框架的客户端自动更新机制就依赖于Actuator的/actuator/bus-refresh端点 ^3300019666-90-12931-13015
- ⏱ 2023-05-01 16:00:11
📌 Spring Cloud Bus是Spring Cloud中用于实现消息总线的专用组件，集成了RabbitMQ、Kafka等主流消息中间件 ^3300019666-90-14405-14474
- ⏱ 2023-05-01 16:02:33
📌 Spring Cloud Config集成Spring Cloud Bus的目的就是想借助它的消息通信能力。 ^3300019666-90-14506-14560
- ⏱ 2023-05-01 16:02:46

12.2 Admin Server组件

📌 Spring Boot Admin组件并不是Spring家族官方提供的组件，而是来自一个叫作codecentric AG的团队。想要把普通的Spring Boot应用程序转变为Spring Boot Admin Server，只需要在Bootstrap类上添加一个注解即可，这个注解就是@EnableAdminServer。 ^3300019666-91-2048-2210
- ⏱ 2023-05-01 16:09:07

13.1 Spring Boot Starter原理与应用

📌 @SpringBootApplication注解实际上由三个注解组合而成，分别是@SpringBootConfiguration、@EnableAutoConfiguration和@ComponentScan。 ^3300019666-96-2478-2583
- ⏱ 2023-05-01 16:16:06
📌 根据所引入类的不同类型，Spring容器对@Import注解有以下四种处理方式。■如果该类实现了ImportSelector接口，Spring容器就会实例化该类，并且调用其selectImports()方法完成类的导入。■如果该类实现了DeferredImportSelector接口，则Spring容器也会实例化该类并调用其selectImports()方法。DeferredImportSelector继承了ImportSelector，区别在于DeferredImportSelector实例的selectImports()方法的调用时机晚于ImportSelector实例，要等到@Configuration注解中相关的业务全部都处理完了才会调用。■如果该类实现了ImportBeanDefinitionRegistrar接口，Spring容器就会实例化该类，并且调用其registerBeanDefinitions()方法。■如果该类没有实现上述三种接口中的任何一个，Spring容器就会直接实例化该类。 ^3300019666-96-4671-5244
- ⏱ 2023-05-01 16:19:28
📌 JDK提供了一个工具类java.util.ServiceLoader来实现SPI机制，该类用于实现服务查找和加载。当服务提供者提供了服务接口的一种实现之后，我们可以在JAR包的META-INF/services/目录下创建一个以该服务接口命名的文件，并在这个文件中配置一组Key-Value，用于指定服务接口与其具体实现类的映射关系。当外部程序装配这个JAR包时，它就能通过该JAR包META-INF/services/目录中的配置文件找到具体的实现类名，并装载实例化，从而完成目标服务的注入。 ^3300019666-96-10356-10603
- ⏱ 2023-05-01 16:26:22

13.3 Spring Boot与云原生

📌 Spring Native原生镜像的启动速度非常快，通常不会超过100ms，相比于传统模式下的启动时间可以说是瞬时的启动。同时，Spring Native原生镜像在运行时也具备更低的资源消耗。 ^3300019666-98-1560-1656
- ⏱ 2023-05-01 16:57:27

读书笔记

2.1 Spring依赖注入类型

划线评论

📌 该方法可以实现按需注入，帮助我们只在需要时注入依赖关系。 ^506504175-7HxjKFPFQ
- 💭 setter注入可以实现按需注入
- ⏱ 2023-04-17 11:37:51

划线评论

📌 一旦采用构造器注入，在Spring项目启动的时候，就会抛出一个循环依赖异常，从而提醒你避免使用循环依赖。 ^506504175-7HxjCbtXz
- 💭 因为构造器注入能够保证依赖不为空，所以在启动时能够提醒避免使用循环依赖
- ⏱ 2023-04-17 11:35:45

3.3 AOP代理机制对性能的影响案例分析

章节评论 No.1

性能上JDK动态代理比Cglib略有优势，但是不用太过于关注，因为差别不大 ^506504175-7HzvCs3p7
- ⏱ 2023-04-18 22:12:23

3.4 AOP实战经验

划线评论

📌 @Transactional ^506504175-7HzwoKRlp
- 💭 失效场景加一，在类内直接调用方法因为无法获得代理对象会导致事务失效
- ⏱ 2023-04-18 22:24:17

划线评论

📌 这里我们直接从AopContext中获取代理对象。 ^506504175-7HzweODkZ
- 💭 在类中调用类内部的方法无法获得代理对象，需要通过AOpContext上下文获取代理对象
- ⏱ 2023-04-18 22:21:50

4.3 Spring GraphQL

划线评论

📌 RESTful API的第三个典型问题就是多次请求。 ^506504175-7HFea3Uzw
- 💭 RESTful在需要获取不同接口的所组成的一组数据时需要多次访问服务器
- ⏱ 2023-04-22 16:25:51

6.7 系统缓存面试题分析

划线评论

📌 Spring缓存组件的核心优势在于设计并实现了一个抽象层，从而为开发人员提供了统一的缓存使用API ^506504175-7HH3cKvh0
- 💭 隔离了开发人员与细节的解除
- ⏱ 2023-04-23 21:11:54

本书评论

书评 No.1 ^506504175-7HSXhpYT1

⏱ 2023-05-01 17:01:29

继承Thread类创建线程

2023-05-21T00:42:00.000Z

[!note] 优点
使用继承方式创建线程的好处是方便传参，你可以在子类里面添加成员变量，通过 set 方法设置参数或者通过构造函数进行传递

[!warning] 缺点
Java 不支持多继承，如果继承了 Thread 类，那么就不能再继承其他类。
另外任务与代码没有分离，当多个线程执行一样的任务时需要多份任务代码，而 Runable 则没有这个限制。
任务没有返回值,可以使用 FutureTask创建线程

public class ThreadTest {  
    //继承Thread类并重写run方法  
    public static class MyThread extends Thread {  
        @Override  
        public void run() {  
            System.out.println("I am a child thread");  
        }  
  
    }  
  
    public static void main(String[] args) {  
        // 创建线程  
        MyThread thread = new MyThread();  
        // 启动线程  
        thread.start();  
    }  
}

[!tip]

📌 当创建完thread对象后该线程并没有被启动执行，直到调用了start方法后才真正启动了线程。

元数据

[!abstract] Java并发编程之美

书名： Java并发编程之美

作者：翟陆续薛宾田

简介： Java并发编程无处不在，涉及的知识点多，要掌握并用好它并非易事。作者加多拥有在大型互联网公司阿里巴巴的丰富工作经验，遇到并解决了业务场景中很多实际的并发问题。本书是他对自己实践经验的总结与升华。为帮助读者解决学习中的各类痛点，作者将全书明确地分为基础篇、高级篇和实践篇，脉络清晰；全书以代码说话，辅以图表，让初学者能一步一步地深入堂奥，掌握并发编程的精髓。

出版时间 2018-10-01 00:00:00

ISBN： 9787121349478

分类：计算机-编程设计

出版社：电子工业出版社

[!warning]
这里的内容仅为读书笔记，如果您需要阅读原版书籍，请购买正版以支持原创。感谢您的理解和支持。

高亮划线

第1章并发编程线程基础

📌 进程是代码在数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，线程则是进程的一个执行路径，一个进程中至少有一个线程，进程中的多个线程共享进程的资源。 ^25462418-7-535-615
- ⏱ 2023-05-02 16:23:54
📌 操作系统在分配资源时是把资源分配给进程的，但是CPU资源比较特殊，它是被分配到线程的，因为真正要占用CPU运行的是线程，所以也说线程是CPU分配的基本单位。 ^25462418-7-644-722
- ⏱ 2023-05-02 16:26:43
📌 一个进程中有多个线程，多个线程共享进程的堆和方法区资源，但是每个线程有自己的程序计数器和栈区域 ^25462418-7-1134-1181
- ⏱ 2023-05-02 16:42:38
📌 程序计数器是一块内存区域，用来记录线程当前要执行的指令地址。 ^25462418-7-1211-1241
- ⏱ 2023-05-02 16:42:49
📌 如果执行的是native方法，那么pc计数器记录的是undefined地址，只有执行的是Java代码时pc计数器记录的才是下一条指令的地址。 ^25462418-7-1433-1503
- ⏱ 2023-05-02 16:43:38
📌 堆是一个进程中最大的一块内存，堆是被进程中的所有线程共享的，是进程创建时分配的，堆里面主要存放使用new操作创建的对象实例。 ^25462418-7-1632-1694
- ⏱ 2023-05-02 16:44:17
📌 方法区则用来存放JVM加载的类、常量及静态变量等信息，也是线程共享的 ^25462418-7-1723-1757
- ⏱ 2023-05-02 16:44:26

1.2 线程创建与运行

📌 Java中有三种线程创建方式，分别为实现Runnable接口的run方法，继承Thread类并重写run的方法，使用FutureTask方式。 ^25462418-8-440-511
- ⏱ 2023-05-02 16:44:36
📌 当创建完thread对象后该线程并没有被启动执行，直到调用了start方法后才真正启动了线程。 ^25462418-8-1096-1143
- ⏱ 2023-05-02 16:46:58
📌 使用继承方式的好处是，在run（）方法内获取当前线程直接使用this就可以了，无须使用Thread.currentThread（）方法；不好的地方是Java不支持多继承，如果继承了Thread类，那么就不能再继承其他类。 ^25462418-8-1304-1414
- ⏱ 2023-06-01 09:46:42
📌 使用继承方式的好处是方便传参，你可以在子类里面添加成员变量，通过set方法设置参数或者通过构造函数进行传递，而如果使用Runnable方式，则只能使用主线程里面被声明为final的变量。不好的地方是Java不支持多继承，如果继承了Thread类，那么子类不能再继承其他类，而Runable则没有这个限制。前两种方式都没办法拿到任务的返回结果，但是Futuretask方式可以。 ^25462418-8-2931-3119
- ⏱ 2023-05-02 20:13:17

1.3 线程通知与等待

📌 当一个线程调用一个共享变量的wait（）方法时，该调用线程会被阻塞挂起，直到发生下面几件事情之一才返回：（1）其他线程调用了该共享对象的notify（）或者notifyAll（）方法；（2）其他线程调用了该线程的interrupt（）方法，该线程抛出InterruptedException异常返回。 ^25462418-9-588-738
- ⏱ 2023-05-06 15:35:59
📌 notify() 函数一个线程调用共享对象的notify（）方法后，会唤醒一个在该共享变量上调用wait系列方法后被挂起的线程。一个共享变量上可能会有多个线程在等待，具体唤醒哪个等待的线程是随机的。此外，被唤醒的线程不能马上从wait方法返回并继续执行，它必须在获取了共享对象的监视器锁后才可以返回，也就是唤醒它的线程释放了共享变量上的监视器锁后，被唤醒的线程也不一定会获取到共享对象的监视器锁，这是因为该线程还需要和其他线程一起竞争该锁，只有该线程竞争到了共享变量的监视器锁后才可以继续执行。类似wait系列方法，只有当前线程获取到了共享变量的监视器锁后，才可以调用共享变量的notify（）方法，否则会抛出IllegalMonitorStateException异常。 ^25462418-9-8627-9050
- ⏱ 2023-06-01 10:23:38
📌 notifyAll() 函数不同于在共享变量上调用notify（）函数会唤醒被阻塞到该共享变量上的一个线程，notifyAll（）方法则会唤醒所有在该共享变量上由于调用wait系列方法而被挂起的线程。 ^25462418-9-9086-9215
- ⏱ 2023-06-01 10:23:46

1.11 ThreadLocal

📌 ThreadLocal是JDK包提供的，它提供了线程本地变量，也就是如果你创建了一个ThreadLocal变量，那么访问这个变量的每个线程都会有这个变量的一个本地副本。当多个线程操作这个变量时，实际操作的是自己本地内存里面的变量，从而避免了线程安全问题。创建一个ThreadLocal变量后，每个线程都会复制一个变量到自己的本地内存 ^25462418-17-966-1132
- ⏱ 2023-06-02 11:05:50
📌 Thread类中有一个threadLocals和一个inheritableThreadLocals，它们都是ThreadLocalMap类型的变量，而ThreadLocalMap是一个定制化的Hashmap。在默认情况下，每个线程中的这两个变量都为null，只有当前线程第一次调用ThreadLocal的set或者get方法时才会创建它们 ^25462418-17-4239-4408
- ⏱ 2023-06-02 11:16:54
📌 每个线程的本地变量不是存放在ThreadLocal实例里面，而是存放在调用线程的threadLocals变量里面。也就是说，ThreadLocal类型的本地变量存放在具体的线程内存空间中。 ^25462418-17-4411-4505
- ⏱ 2023-06-02 11:16:29
📌 如果调用线程一直不终止，那么这个本地变量会一直存放在调用线程的threadLocals变量里面，所以当不需要使用本地变量时可以通过调用ThreadLocal变量的remove方法，从当前线程的threadLocals里面删除该本地变量。 ^25462418-17-4613-4731
- ⏱ 2023-06-02 11:17:36
📌 同一个ThreadLocal变量在父线程中被设置值后，在子线程中是获取不到的。 ^25462418-17-9161-9200
- ⏱ 2023-06-02 11:29:02

2.5 Java中的synchronized关键字

📌 synchronized块是Java提供的一种原子性内置锁，Java中的每个对象都可以把它当作一个同步锁来使用，这些Java内置的使用者看不到的锁被称为内部锁，也叫作监视器锁。线程的执行代码在进入synchronized代码块前会自动获取内部锁，这时候其他线程访问该同步代码块时会被阻塞挂起。拿到内部锁的线程会在正常退出同步代码块或者抛出异常后或者在同步块内调用了该内置锁资源的wait系列方法时释放该内置锁。内置锁是排它锁，也就是当一个线程获取这个锁后，其他线程必须等待该线程释放锁后才能获取该锁。 ^25462418-22-538-788
- ⏱ 2023-05-27 10:12:35
📌 由于Java中的线程是与操作系统的原生线程一一对应的，所以当阻塞一个线程时，需要从用户态切换到内核态执行阻塞操作，这是很耗时的操作，而synchronized的使用就会导致上下文切换 ^25462418-22-820-911
- ⏱ 2023-05-27 10:32:24
📌 其实这也是加锁和释放锁的语义，当获取锁后会清空锁块内本地内存中将会被用到的共享变量，在使用这些共享变量时从主内存进行加载，在释放锁时将本地内存中修改的共享变量刷新到主内存。 ^25462418-22-1294-1380
- ⏱ 2023-05-27 10:37:42

2.6 Java中的volatile关键字

2.7 Java中的原子性操作

📌 简单的++value由2、5、6、7四步组成，其中第2步是获取当前value的值并放入栈顶，第5步把常量1放入栈顶，第6步把当前栈顶中两个值相加并把结果放入栈顶，第7步则把栈顶的结果赋给value变量。因此，Java中简单的一句++value被转换为汇编后就不具有原子性了。 ^25462418-24-1167-1304
- ⏱ 2023-05-27 11:08:07

2.8 Java中的CAS操作

📌 CAS有四个操作数，分别为：对象内存位置、对象中的变量的偏移量、变量预期值和新的值 ^25462418-25-888-929
- ⏱ 2023-05-27 15:24:00
📌 如果对象obj中内存偏移量为valueOffset的变量值为expect，则使用新的值update替换旧的值expect。这是处理器提供的一个原子性指令。 ^25462418-25-937-1014
- ⏱ 2023-05-27 15:26:58
📌 JDK中的AtomicStampedReference类给每个变量的状态值都配备了一个时间戳，从而避免了ABA问题的产生。 ^25462418-25-1394-1455
- ⏱ 2023-05-28 15:45:48

2.9 Unsafe类

📌 JDK的rt.jar包中的Unsafe类提供了硬件级别的原子性操作，Unsafe类中的方法都是native方法，它们使用JNI的方式访问本地C++ 实现库。 ^25462418-26-522-600
- ⏱ 2023-05-28 15:48:33

2.10 Java指令重排序

📌 重排序在多线程下会导致非预期的程序执行结果，而使用volatile修饰ready就可以避免重排序和内存可见性问题。 ^25462418-27-2069-2126
- ⏱ 2023-05-28 16:07:21
📌 写volatile变量时，可以确保volatile写之前的操作不会被编译器重排序到volatile写之后。读volatile变量时，可以确保volatile读之后的操作不会被编译器重排序到volatile读之前。 ^25462418-27-2155-2261
- ⏱ 2023-05-28 16:07:30

2.11 伪共享

📌 在Cache内部是按行存储的，其中每一行称为一个Cache行 ^25462418-28-890-920
- ⏱ 2023-05-21 19:07:18
📌 Cache行（如图2-7所示）是Cache与主内存进行数据交换的单位，Cache行的大小一般为2的幂次数字节。 ^25462418-28-921-976
- ⏱ 2023-05-21 19:07:32
📌 当CPU访问某个变量时，首先会去看CPU Cache内是否有该变量，如果有则直接从中获取，否则就去主内存里面获取该变量，然后把该变量所在内存区域的一个Cache行大小的内存复制到Cache中 ^25462418-28-1239-1334
- ⏱ 2023-05-21 19:09:09
📌 由于存放到Cache行的是内存块而不是单个变量，所以可能会把多个变量存放到一个Cache行中 ^25462418-28-1335-1381
- ⏱ 2023-05-21 19:09:50
📌 当多个线程同时修改一个缓存行里面的多个变量时，由于同时只能有一个线程操作缓存行，所以相比将每个变量放到一个缓存行，性能会有所下降，这就是伪共享 ^25462418-28-1382-1453
- ⏱ 2023-05-21 19:10:22
📌 如果CPU只有一级缓存，则会导致频繁地访问主内存。 ^25462418-28-1920-1945
- ⏱ 2023-05-21 19:19:34
📌 伪共享的产生是因为多个变量被放入了一个缓存行中，并且多个线程同时去写入缓存行中不同的变量。 ^25462418-28-2051-2096
- ⏱ 2023-05-21 19:21:54
📌 地址连续的多个变量才有可能会被放到一个缓存行中。 ^25462418-28-2366-2390
- ⏱ 2023-05-21 19:22:43
📌 所以在单个线程下顺序修改一个缓存行中的多个变量，会充分利用程序运行的局部性原则，从而加速了程序的运行。而在多线程下并发修改一个缓存行中的多个变量时就会竞争缓存行，从而降低程序运行性能。 ^25462418-28-4192-4284
- ⏱ 2023-05-21 21:46:18
📌 JDK 8提供了一个sun.misc.Contended注解，用来解决伪共享问题。 ^25462418-28-4855-4896
- ⏱ 2023-05-21 21:47:32
📌 在默认情况下，@Contended注解只用于Java核心类，比如rt包下的类。如果用户类路径下的类需要使用这个注解，则需要添加JVM参数：-XX:-RestrictContended。填充的宽度默认为128，要自定义宽度则可以设置-XX:ContendedPaddingWidth参数。 ^25462418-28-5686-5829
- ⏱ 2023-05-21 21:48:27

2.12 锁的概述

📌 悲观锁指对数据被外界修改持保守态度，认为数据很容易就会被其他线程修改，所以在数据被处理前先对数据进行加锁，并在整个数据处理过程中，使数据处于锁定状态 ^25462418-29-595-669
- ⏱ 2023-05-28 16:08:35
📌 乐观锁是相对悲观锁来说的，它认为数据在一般情况下不会造成冲突，所以在访问记录前不会加排它锁，而是在进行数据提交更新时，才会正式对数据冲突与否进行检测。 ^25462418-29-1945-2020
- ⏱ 2023-05-28 16:11:41
📌 根据线程获取锁的抢占机制，锁可以分为公平锁和非公平锁，公平锁表示线程获取锁的顺序是按照线程请求锁的时间早晚来决定的，也就是最早请求锁的线程将最早获取到锁。而非公平锁则在运行时闯入，也就是先来不一定先得。 ^25462418-29-4257-4358
- ⏱ 2023-05-28 16:20:34
📌 ReentrantLock提供了公平和非公平锁的实现。● 公平锁：ReentrantLock pairLock = new ReentrantLock（true）。● 非公平锁：ReentrantLock pairLock = new ReentrantLock（false）。如果构造函数不传递参数，则默认是非公平锁。 ^25462418-29-4387-4607
- ⏱ 2023-05-28 16:20:47
📌 在没有公平性需求的前提下尽量使用非公平锁，因为公平锁会带来性能开销。 ^25462418-29-4797-4831
- ⏱ 2023-05-28 16:21:43
📌 根据锁只能被单个线程持有还是能被多个线程共同持有，锁可以分为独占锁和共享锁。 ^25462418-29-4936-4974
- ⏱ 2023-05-28 16:22:06
📌 独占锁保证任何时候都只有一个线程能得到锁，ReentrantLock就是以独占方式实现的。共享锁则可以同时由多个线程持有，例如ReadWriteLock读写锁，它允许一个资源可以被多线程同时进行读操作。 ^25462418-29-5003-5104
- ⏱ 2023-05-28 16:22:23
📌 独占锁是一种悲观锁，由于每次访问资源都先加上互斥锁，这限制了并发性，因为读操作并不会影响数据的一致性，而独占锁只允许在同一时间由一个线程读取数据，其他线程必须等待当前线程释放锁才能进行读取。共享锁则是一种乐观锁，它放宽了加锁的条件，允许多个线程同时进行读操作。 ^25462418-29-5133-5292
- ⏱ 2023-05-28 16:22:36
📌 当一个线程要获取一个被其他线程持有的独占锁时，该线程会被阻塞，那么当一个线程再次获取它自己已经获取的锁时是否会被阻塞呢？如果不被阻塞，那么我们说该锁是可重入的，也就是只要该线程获取了该锁，那么可以无限次数（在高级篇中我们将知道，严格来说是有限次数）地进入被该锁锁住的代码。 ^25462418-29-5397-5533
- ⏱ 2023-05-28 16:23:11
📌 synchronized内部锁是可重入锁 ^25462418-29-5965-5985
- ⏱ 2023-05-28 16:24:32
📌 可重入锁的原理是在锁内部维护一个线程标示，用来标示该锁目前被哪个线程占用，然后关联一个计数器。一开始计数器值为0，说明该锁没有被任何线程占用。当一个线程获取了该锁时，计数器的值会变成1，这时其他线程再来获取该锁时会发现锁的所有者不是自己而被阻塞挂起。 ^25462418-29-5986-6111
- ⏱ 2023-05-28 16:25:48
📌 但是当获取了该锁的线程再次获取锁时发现锁拥有者是自己，就会把计数器值加+1，当释放锁后计数器值-1。当计数器值为0时，锁里面的线程标示被重置为null，这时候被阻塞的线程会被唤醒来竞争获取该锁。 ^25462418-29-6140-6237
- ⏱ 2023-05-28 16:26:18
📌 自旋锁则是，当前线程在获取锁时，如果发现锁已经被其他线程占有，它不马上阻塞自己，在不放弃CPU使用权的情况下，多次尝试获取（默认次数是10，可以使用-XX:PreBlockSpinsh参数设置该值），很有可能在后面几次尝试中其他线程已经释放了锁。如果尝试指定的次数后仍没有获取到锁则当前线程才会被阻塞挂起。由此看来自旋锁是使用CPU时间换取线程阻塞与调度的开销，但是很有可能这些CPU时间白白浪费了。 ^25462418-29-6464-6664
- ⏱ 2023-05-28 16:32:32

3.1 Random类及其局限性

📌 每个Random实例里面都有一个原子性的种子变量用来记录当前的种子值，当要生成新的随机数时需要根据当前种子计算新的种子并更新回原子变量。在多线程下使用单个Random实例生成随机数时，当多个线程同时计算随机数来计算新的种子时，多个线程会竞争同一个原子变量的更新操作，由于原子变量的更新是CAS操作，同时只有一个线程会成功，所以会造成大量线程进行自旋重试，这会降低并发性能，所以ThreadLocalRandom应运而生。 ^25462418-33-2932-3142
- ⏱ 2023-05-28 16:37:35

3.2 ThreadLocalRandom

📌 ThreadLocal通过让每一个线程复制一份变量，使得在每个线程对变量进行操作时实际是操作自己本地内存里面的副本，从而避免了对共享变量进行同步。实际上ThreadLocalRandom的实现也是这个原理，Random的缺点是多个线程会使用同一个原子性种子变量，从而导致对原子变量更新的竞争 ^25462418-34-1013-1158
- ⏱ 2023-05-28 16:39:28

3.3 源码分析

📌 ThreadLocalRandom类继承了Random类并重写了nextInt方法，在ThreadLocalRandom类中并没有使用继承自Random类的原子性种子变量。在ThreadLocalRandom中并没有存放具体的种子，具体的种子存放在具体的调用线程的threadLocalRandomSeed变量里面。ThreadLocalRandom类似于ThreadLocal类，就是个工具类。当线程调用ThreadLocalRandom的current方法时，ThreadLocalRandom负责初始化调用线程的threadLocalRandomSeed变量，也就是初始化种子。 ^25462418-35-743-1035
- ⏱ 2023-05-28 16:45:01
📌 当调用ThreadLocalRandom的nextInt方法时，实际上是获取当前线程的threadLocalRandomSeed变量作为当前种子来计算新的种子，然后更新新的种子到当前线程的threadLocalRandomSeed变量，而后再根据新种子并使用具体算法计算随机数。这里需要注意的是，threadLocalRandomSeed变量就是Thread类里面的一个普通long变量，它并不是原子性变量。其实道理很简单，因为这个变量是线程级别的，所以根本不需要使用原子性变量 ^25462418-35-1064-1303
- ⏱ 2023-05-28 16:45:55
📌 seeder和probeGenerator是两个原子性变量，在初始化调用线程的种子和探针变量时会用到它们，每个线程只会使用一次。 ^25462418-35-1363-1427
- ⏱ 2023-05-28 16:48:02
📌 变量instance是ThreadLocalRandom的一个实例，该变量是static的。当多线程通过ThreadLocalRandom的current方法获取ThreadLocalRandom的实例时，其实获取的是同一个实例。但是由于具体的种子是存放在线程里面的，所以在ThreadLocalRandom的实例里面只包含与线程无关的通用算法，所以它是线程安全的 ^25462418-35-1459-1641
- ⏱ 2023-05-28 16:47:38

4.1 原子变量操作类

📌 这些原子操作类都使用CAS非阻塞算法，性能更好。但是在高并发情况下AtomicLong还会存在性能问题。JDK 8提供了一个在高并发下性能更好的LongAdder类 ^25462418-38-5883-5965
- ⏱ 2023-05-28 17:09:24

4.2 JDK 8新增的原子操作类LongAdder

📌 使用AtomicLong时，在高并发下大量线程会同时去竞争更新同一个原子变量，但是由于同时只有一个线程的CAS操作会成功，这就造成了大量线程竞争失败后，会通过无限循环不断进行自旋尝试CAS的操作，而这会白白浪费CPU资源。 ^25462418-39-612-723
- ⏱ 2023-05-28 17:09:51
📌 使用LongAdder时，则是在内部维护多个Cell变量，每个Cell里面有一个初始值为0的long型变量，这样，在同等并发量的情况下，争夺单个变量更新操作的线程量会减少，这变相地减少了争夺共享资源的并发量。另外，多个线程在争夺同一个Cell原子变量时如果失败了，它并不是在当前Cell变量上一直自旋CAS重试，而是尝试在其他Cell的变量上进行CAS尝试，这个改变增加了当前线程重试CAS成功的可能性。最后，在获取LongAdder当前值时，是把所有Cell变量的value值累加后再加上base返回的。 ^25462418-39-1513-1766
- ⏱ 2023-05-28 17:14:45
📌 LongAdder维护了一个延迟初始化的原子性更新数组（默认情况下Cell数组是null）和一个基值变量base。由于Cells占用的内存是相对比较大的，所以一开始并不创建它，而是在需要时创建，也就是惰性加载。 ^25462418-39-1795-1900
- ⏱ 2023-05-28 17:15:36
📌 当一开始判断Cell数组是null并且并发线程较少时，所有的累加操作都是对base变量进行的。保持Cell数组的大小为2的N次方，在初始化时Cell数组中的Cell元素个数为2，数组里面的变量实体是Cell类型。Cell类型是AtomicLong的一个改进，用来减少缓存的争用，也就是解决伪共享问题。 ^25462418-39-1929-2107
- ⏱ 2023-05-28 17:16:55
📌 对于大多数孤立的多个原子操作进行字节填充是浪费的，因为原子性操作都是无规律地分散在内存中的（也就是说多个原子性变量的内存地址是不连续的），多个原子变量被放入同一个缓存行的可能性很小。但是原子性数组元素的内存地址是连续的，所以数组内的多个元素能经常共享缓存行，因此这里使用@sun.misc.Contended注解对Cell类进行字节填充，这防止了数组中多个元素共享一个缓存行，在性能上是一个提升。 ^25462418-39-2136-2334
- ⏱ 2023-05-28 17:17:53
📌 LongAdder类继承自Striped64类，在Striped64内部维护着三个变量。LongAdder的真实值其实是base的值与Cell数组里面所有Cell元素中的value值的累加，base是个基础值，默认为0。cellsBusy用来实现自旋锁，状态值只有0和1，当创建Cell元素，扩容Cell数组或者初始化Cell数组时，使用CAS操作该变量来保证同时只有一个线程可以进行其中之一的操作 ^25462418-39-3020-3219
- ⏱ 2023-05-28 17:19:41

读书笔记

第1章并发编程线程基础

划线评论

📌 每个线程都有自己的栈资源，用于存储该线程的局部变量，这些局部变量是该线程私有的，其他线程是访问不了的，除此之外栈还用来存放线程的调用栈帧。 ^506504175-7IDE8BOMk
- 💭 线程中的栈资源就好像是工作中的git分支,一个任务一个分支,最后完成时再将处理好的结果刷回主分支,当然这个比喻不是很恰当.
- ⏱ 2023-06-01 09:42:43

划线评论

📌 其实程序计数器就是为了记录该线程让出CPU时的执行地址的，待再次分配到时间片时线程就可以从自己私有的计数器指定地址继续执行。 ^506504175-7IDDVNoSp
- 💭 就好比阅读时在要结束的时候添加一个书签在当前位置,这样下次再看这本书的时候就不用花时间去回想上次的进度了,只需要从书签的位置开始继续阅读
- ⏱ 2023-06-01 09:39:34

1.2 线程创建与运行

划线评论

📌 其实调用start方法后线程并没有马上执行而是处于就绪状态，这个就绪状态是指该线程已经获取了除CPU资源外的其他资源，等待获取CPU资源后才会真正处于运行状态。一旦run方法执行完毕，该线程就处于终止状态 ^506504175-7IDElaZ3i
- 💭 类比手头正在做的工作,已经把材料都准备好了,就等着自己将其他事情做完或者放下来处理这一件事情
- ⏱ 2023-06-01 09:45:49

1.3 线程通知与等待

划线评论

📌 在如上代码中假如生产者线程A首先通过synchronized获取到了queue上的锁，那么后续所有企图生产元素的线程和消费线程将会在获取该监视器锁的地方被阻塞挂起。线程A获取锁后发现当前队列已满会调用queue.wait（）方法阻塞自己，然后释放获取的queue上的锁，这里考虑下为何要释放该锁？如果不释放，由于其他生产者线程和所有消费者线程都已经被阻塞挂起，而线程A也被挂起，这就处于了死锁状态。这里线程A挂起自己后释放共享变量上的锁，就是为了打破死锁必要条件之一的持有并等待原则。关于死锁后面的章节会讲。线程A释放锁后，其他生产者线程和所有消费者线程中会有一个线程获取queue上的锁进而进入同步块，这就打破了死锁状态。 ^506504175-7IDFPguab
- 💭 简单来说就是生产者线程在获取到监视器锁后如果发现当前的人消费队列已满就会阻塞挂起并释放监视器锁,避免进入死锁状态
- ⏱ 2023-06-01 10:08:30

划线评论

📌 如果调用wait（）方法的线程没有事先获取该对象的监视器锁，则调用wait（）方法时调用线程会抛出IllegalMonitorStateException异常。 ^506504175-7IDEK8Rum
- 💭 这是为了避免最后执行结果与预期不符
- ⏱ 2023-06-01 09:51:58

1.11 ThreadLocal

划线评论

📌 Thread类中有一个threadLocals和一个inheritableThreadLocals ^506504175-7IFgyKdGz
- 💭 其中threadLocals中存放的的是由ThreadLocal通过set方法放入的value,因为它是ThreadLocalMap类型,是一个定制化的HashMap,它可一个关联多个ThreadLocal变量
- ⏱ 2023-06-02 11:16:03

2.5 Java中的synchronized关键字

划线评论

📌 进入synchronized块的内存语义是把在synchronized块内使用到的变量从线程的工作内存中清除，这样在synchronized块内使用到该变量时就不会从线程的工作内存中获取，而是直接从主内存中获取。退出synchronized块的内存语义是把在synchronized块内对共享变量的修改刷新到主内存。 ^506504175-7Iw6a0jNN
- 💭 进入synchronize块时会将使用的的变量从工作线程中清除，使得获取变量需要从主内存获取。退出时将块内的共享变量的修改刷新的主内存中
- ⏱ 2023-05-27 10:37:14

2.6 Java中的volatile关键字

划线评论

📌 那么一般在什么时候才使用volatile关键字呢？● 写入变量值不依赖变量的当前值时。因为如果依赖当前值，将是获取—计算—写入三步操作，这三步操作不是原子性的，而volatile不保证原子性。● 读写变量值时没有加锁。因为加锁本身已经保证了内存可见性，这时候不需要把变量声明为volatile的。 ^506504175-7Iw7PqFOb
- 💭 在单例模式下使用volatile关键字保证变量的可见性
- ⏱ 2023-05-27 11:02:42

划线评论

📌 那么一般在什么时候才使用volatile关键字呢？● 写入变量值不依赖变量的当前值时。因为如果依赖当前值，将是获取—计算—写入三步操作，这三步操作不是原子性的，而volatile不保证原子性。● 读写变量值时没有加锁。因为加锁本身已经保证了内存可见性，这时候不需要把变量声明为volatile的。 ^506504175-7Iw7FgUxJ
- 💭 例如可以使用volatile关键字修饰用来表示状态的共享值，由需要使用这一变量的线程监控这个值，当值修改时线程根据逻辑进行相应的变化如退出等等。
- ⏱ 2023-05-27 11:00:12

划线评论

📌 当线程写入了volatile变量值时就等价于线程退出synchronized同步块（把写入工作内存的变量值同步到主内存），读取volatile变量值时就相当于进入同步块（先清空本地内存变量值，再从主内存获取最新值）。 ^506504175-7Iw7ay94o
- 💭 但是synchronize是独占锁同时只有一个线程能够读取或者写入修饰的共享变量，同时其他的调用线程会被阻塞，同时也存在着线程上下文切换和线程重新调度的开销。而volatile关键字是非阻塞的，不会造成线程上下文切换的开销，但是volatile关键字不保证操作的原子性。
- ⏱ 2023-05-27 10:52:38

划线评论

📌 当一个变量被声明为volatile时，线程在写入变量时不会把值缓存在寄存器或者其他地方，而是会把值刷新回主内存。当其他线程读取该共享变量时，会从主内存重新获取最新值，而不是使用当前线程的工作内存中的值。 ^506504175-7Iw6MXAmd
- 💭 由volatile关键字修饰的变量在线程写入时会直接将值刷入主内存中，而当其他线程读取这个共享变量时会直接从主内存中获取最新值，而不是当前线程工作内存中的值
- ⏱ 2023-05-27 10:46:49

2.7 Java中的原子性操作

划线评论

📌 所谓原子性操作，是指执行一系列操作时，这些操作要么全部执行，要么全部不执行，不存在只执行其中一部分的情况。 ^506504175-7Iw82ejAG
- 💭 除不可控制因素外
- ⏱ 2023-05-27 11:05:51

2.8 Java中的CAS操作

划线评论

📌 CAS即Compare and Swap，其是JDK提供的非阻塞原子性操作，它通过硬件保证了比较—更新操作的原子性 ^506504175-7IxWBXDXw
- 💭 CAS是通过CPU提供的原子性操作指令实现的，当一个线程执行CAS操作时它会先读取内存中的值，然后将需要修改的值与内存中的值进行比较。如果两个值相等就会将新值写入内存并返回操作成功，否则失败不进行任何修改。当多个线程同时执行CAS操作时只有一个会成功，而其他的均失败且不会改变目标的值。因此CAS通过不可中断的原子性CPU指令和等待策略保证了非阻塞原子性操作
- ⏱ 2023-05-28 15:44:46

2.10 Java指令重排序

划线评论

📌 Java内存模型允许编译器和处理器对指令重排序以提高运行性能，并且只会对不存在数据依赖性的指令重排序。 ^506504175-7IxXNgaCL
- 💭 指令重排可以保证单线程下最终执行结果与预想结果一致，但是无法保证多线程最终结果与执行结果一致
- ⏱ 2023-05-28 16:02:49

2.12 锁的概述

划线评论

📌 乐观锁并不会使用数据库提供的锁机制，一般在表中添加version字段或者使用业务状态来实现。乐观锁直到提交时才锁定，所以不会产生任何死锁。 ^506504175-7IxYUtHlK
- 💭 乐观锁通过添加version字段来保证并发状态下只有一个线程能够成功执行，在线程修改数据库内容前会先查询相应数据并获取到version字段，在提交修改时通过检查version字段是否正确来判断数据是否已被修改，如果被修改则执行失败或者重试
- ⏱ 2023-05-28 16:19:52

3.2 ThreadLocalRandom

划线评论

📌 如果每个线程都维护一个种子变量，则每个线程生成随机数时都根据自己老的种子计算新的种子，并使用新种子更新老的种子，再根据新种子计算随机数，就不会存在竞争问题了，这会大大提高并发性能 ^506504175-7Iy0uuWU1
- 💭 ThreadLocalRandom通过每个线程都维护一个种子的方式解决了Random因为原子性种子变量导致的竞争问题，大大提高了并发性能
- ⏱ 2023-05-28 16:44:00

4.2 JDK 8新增的原子操作类LongAdder

划线评论

📌 JDK 8新增了一个原子性递增或者递减类LongAdder用来克服在高并发下使用AtomicLong的缺点 ^506504175-7Iy2soger
- 💭 LongAdder通过将变量分解为多个变量,让多个线程去竞争多个资源解决性能问题
- ⏱ 2023-05-28 17:14:01

本书评论

实现Runable接口创建线程

2023-05-21T00:42:00.000Z

[!info] 优点
相较于继承Thread类创建线程实现 Runable 的 run 方法不受父类继承的限制，并且可以多个线程同时执行通一份代码，不需要创建多个实例。

[!warning] 缺点
任务没有返回值,可以使用 FutureTask创建线程
只能使用主线程里面被声明为 final 的变量。

public static class RunableTask implements Runnable{  
    @Override  
    public void run() {  
        System.out.println("I am a child thread");  
    }  
}  
    public static void main(String[] args) throws InterruptedException{  
        RunableTask task = new RunableTask();  
        new Thread(task).start();  
        new Thread(task).start();  
    }

在Java中实现线程安全

2023-05-21T00:42:00.000Z

在 Java 中，实现线程安全的方式有很多，以下是几种常见的实现方式：

[!note] 使用 synchronized 关键字
通过在方法或代码块前加上 synchronized 关键字，可以保证在同一时间只有一个线程能够访问该方法或代码块，从而避免多个线程同时访问共享资源的问题。

[!note] 使用 ReentrantLock 类：
ReentrantLock 是 Java 提供的可重入锁，通过 lock () 和 unlock () 方法来实现对共享资源的互斥访问。

[!note] 使用 volatile 关键字
volatile 关键字可以保证变量的可见性，即当一个线程修改了该变量的值，其他线程能够立即看到该变量的最新值，从而避免数据不一致的问题。

[!note] 使用 Atomic 类
Java 提供了一些原子类，如 AtomicInteger、AtomicLong、AtomicReference 等，这些类提供了一些原子操作，能够保证多个线程对共享资源的访问是原子性的，从而避免数据不一致的问题。

[!note] 使用线程安全的集合类
Java 提供了一些线程安全的集合类，如 ConcurrentHashMap、CopyOnWriteArrayList 等，这些集合类能够保证在多线程环境下对集合的操作是线程安全的。

使用 FutureTask创建线程

2023-05-21T00:42:00.000Z

//创建任务类，类似Runable
public static class CallerTask implements Callable<String>{
        @Override
        public String call() throws Exception {
            return "hello";
        }
    }
    public static void main(String[] args) throws InterruptedException {
    // 创建异步任务
        FutureTask<String> futureTask  = new FutureTask<>(new CallerTask());
        //启动线程
        new Thread(futureTask).start();
        try {
          //等待任务执行完毕，并返回结果
            String result = futureTask.get();
            System.out.println(result);
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
}

如上代码中的 CallerTask 类实现了 Callable 接口的 call（）方法。在 main 函数内首先创建了一个 FutrueTask 对象（构造函数为 CallerTask 的实例），然后使用创建的 FutrueTask 对象作为任务创建了一个线程并且启动它，最后通过 futureTask.get（）等待任务执行完毕并返回结果。

Java解决伪共享问题

2023-05-22T17:39:00.000Z

[!info]
在 Java 8 中，可以使用 @Contended 注解来解决伪共享问题。该注解可以用于类、字段和方法上，它会让 JVM 在分配内存时，将注解的类、字段或方法所在的缓存行单独分配，从而避免多个线程访问同一缓存行。

如何使用@Contended 注解

@Contended 可以使用在类、字段和方法上

在类上使用@Contended

@Contended
public class MyClass {
    // fields and methods
}

[!tip]
这将会告诉 JVM 在分配内存时，将 MyClass 类所在的缓存行单独分配，从而避免多个线程访问同一缓存行。

在字段上使用@Contended 注解

public class MyClass {
    @Contended
    private long myField;
    // other fields and methods
}

[!tip]
这将会告诉 JVM 在分配内存时，将 myField 字段所在的缓存行单独分配，从而避免多个线程访问同一缓存行。

在方法上使用@Contended 注解

public class MyClass {
    @Contended
    public void myMethod() {
        // method body
    }
    // other fields and methods
}

[!tip]
这将会告诉 JVM 在分配内存时，将 myMethod 方法所在的缓存行单独分配，从而避免多个线程访问同一缓存行。

注意

[!warning]
@Contended 注解只在 Java 8 及以上版本的 HotSpot 虚拟机上才能生效。在使用@Contended 注解时，需要在启动 JVM 时添加参数“-XX:-RestrictContended”才能生效。此外@Contended 注解只在某些平台上才能生效，具体取决于 CPU 和操作系统的架构。例如，@Contended 注解在 x86 和 x64 架构上都可以生效，但在 ARM 架构上就不一定能够生效。

参考：

Java并发编程之美#^25462418-28-4855-4896

Java并发编程之美#^25462418-28-5686-5829

Java的响应式流

2023-05-21T00:42:00.000Z

Java API 版本的响应式流只包含四个接口，即 Publisher<T>、Subscriber<T>、Subscription 和 Processor<T,R>。

Publisher - 发布者

[!info]
发布者（Publisher）是潜在的包含无限数量的有序元素的生产者，它根据收到的请求向当前订阅者发送元素。

public interface Publisher<T> {
    public void subscribe(Subscriber<? super T> s);
}

Subscriber - 订阅者

[!info]
订阅者（Subscriber）从发布者那里订阅并接收元素。发布者向订阅者发送订阅令牌（Subscription Token）。通过订阅令牌，订阅者就可以向发布者请求多个元素。当元素准备就绪时，发布者就会向订阅者发送合适数量的元素。然后订阅者可以请求更多的元素，发布者也可能有多个来自订阅者的待处理请求

public interface Subscriber<T> {
    public void onSubscribe(Subscription s);
    public void onNext(T t);
    public void onError(Throwable t);
    public void onComplete();
}

当执行发布者的 subscribe() 方法时，发布者会回调订阅者的 onSubscribe() 方法。在这个方法中，通常订阅者会借助传入的 Subscription 对象向发布者请求 n 个数据。然后发布者通过不断调用订阅者的 onNext() 方法向订阅者发出最多 n 个数据。如果数据全部发完，则会调用 onComplete() 方法告知订阅者流已经发完；如果有错误发生，则通过 onError() 方法发出错误提示消息，这时同样也会终止数据流。

Subscription - 订阅

[!info]
订阅（Subscription）表示订阅者订阅的一个令牌。当订阅请求成功时，发布者将其传递给订阅者。订阅者使用订阅令牌与发布者进行交互，例如请求更多的元素或取消订阅

public interface Subscription {
    public void request(long n);
    public void cancel();
}

当发布者调用 subscribe() 方法注册订阅者时，会通过订阅者的回调方法 onSubscribe() 传入 Subscription 对象，之后订阅者就可以使用这个 Subscription 对象的 request() 方法向发布者请求数据。

Processor - 处理器

[!info]
处理器（Processor）充当订阅者和发布者之间的转换器（Transformer）。

核心接口交互流程

Lambda表达式

2023-05-21T00:42:00.000Z

[!note]
在 Lambda 表达式中，无需指定类型，程序依然可以编译。这是因为 javac 根据程序的上下文 (addActionListener 方法的签名) 在后台推断出参数类型

//不包含参数，实现了Runnable，返回类型为void  
Runnable noArgument = () -> System.out.println("Hello World");  
//只包含一个参数  
ActionListener oneArgument = i -> System.out.println("argument");  
//Lambda表达式猪蹄不仅可以是一个表达式，也可以是一段代码块  
Runnable multiStatement = () -> {  
    System.out.println("Hello");  
    System.out.println("World");  
};  
//不是两个数字的和，而是x+y这段代码  
BinaryOperator<Long> add = (x, y) -> x + y;  
  
BinaryOperator<Long> addExplicit = (x, y) -> x + y;

函数接口

函数接口是只有一个抽象方法的接口，用作 Lambda 表达式的类型。使用只有一个方法的接口来表示某特定方法并反复使用，接口中单一方法的命名并不重要，只要方法签名和 Lambda 表达式的类型匹配即可。

ActionListener 接口

public interface ActionListener extends EventListener {  
    public void actionPerformed(ActionEvent e);  
}

ActionListener 只有一个抽象方法 actionPerformed，被用来表示只接受一个参数返回空。

小结

Lambda 表达式是一个匿名方法，将行为像数据一样进行传递。
Lambda 表达式的常见结构： BinaryOperatoradd=(x, y) → x+y。
函数接口指仅具有单个抽象方法的接口，用来表示 Lambda 表达式的类型。

Java

2023-05-21T00:42:00.000Z

Java Overview

本文件夹中总共有37 个文件

标签 7个

已发布笔记

File	tags	created	别名
Java解决伪共享问题	Java/线程, 多线程	2023-05-22 17:25	-
Java的响应式流	Java	2023-05-03 16:42	-
使用 FutureTask创建线程	Java/线程	2023-05-02 21:00	-
实现Runable接口创建线程	Java/线程	2023-05-02 20:45	-
继承Thread类创建线程	Java/线程	2023-05-02 20:18	-
Java 的 Collection 接口	Java	2023-04-25 23:14	Collection
在Java中实现线程安全	Java	2023-04-24 17:23	线程安全 Java线程安全
Java的LinkedList	Java	2023-04-24 15:40	LinkedList
Java的ArrayList	Java	2023-04-24 14:59	ArrayList
Java的List接口	Java	2023-04-24 14:49	List List接口
Lambda表达式	-	2023-03-31 10:37	-
Java	index	2023-03-29 17:29	-
Buffer 类的重要方法	-	2023-03-25 17:43	Java NIO Buffer 类的重要方法
Channel 类	-	2023-03-25 17:43	Java NIO Channel 类
简介	-	2023-03-25 17:43	Java 的 NIO 简介
Selector 选择器	-	2023-03-25 17:43	Java NIO Selector 选择器
Java 的 new IO	Java	2023-03-24 20:47	Java 的 new IO Java的NIO

简介

2023-05-21T00:42:00.000Z

about_Java 的 NIO 是于 1.4 版本引入的 IO 库，被称为 Java New IO 类库，简称 Java NIO。而在 Java NIO 引入之前的 Java IO 类库是阻塞 IO 也被称为 OIO（Older IO）。

Java NIO 的三个核心组件

Channel（通道）
Buffer（缓冲区）
Selector（选择器）

是不是很眼熟呢？是的 Java NIO 属于 Input-Output 多路复用模型。由 NIO 组件提供了统一的 API，使得程序员能在应用层控制和实现多路复用 IO

NIO 可以随意地读取 Buffer 中任意的数据并且组装成一个完整的数据，而 OIO 则只能顺序读取一个流中的数据。

NIO 的 Channel

一个 Channel (通道) 便对应着一个网络连接或者说一个文件描述符，和 OIO 中一个网络连接需要关联两个流 (InputStream,OutputStrem) 通过这两个流进行不断的输入和输出不同，Channel 既可以读也可以写，相当于两个流的结合。

NIO 的 Buffer

Buffer 是应用与 Channel 的沟通桥梁。NIO 使用 Buffer 缓冲区进行数据交互，- hannel 的读取就是将 Channel 的数据读到 Buffer 中，而 Channel 的写入则是将数据从 Buffer 中读到 Channel 中。
Netty、Redis、Zookeeper高并发实战#^f99d9a

NIO 的 Buffer 缓冲区本质上是一个内存块，它既可以写入数据也可以读取数据。

NIO 的 Selector

基于操作系统的 select 等实现, 它是一个 IO 时间的查询器。通过 Selector 可以在应用层面完成对多个文件描述符进行监视。而且一个 Selector 只需要一个线程监视，一个 Selector 可以通过管理多个 Channel 来管理多个文件描述符的状态，这样系统就不需要为每一个网络连接（文件描述符）创建线程，极大的减少了系统的开销

Netty、Redis、Zookeeper高并发实战#3.5 详解NIO Selector选择器

Selector 选择器

2023-05-21T00:42:00.000Z

[!note]
选择器的使命就是完成 IO 多路复用，通过选择器可以同时监控多个通道的 IO 事件。选择器与通道的关系就是监控和被监控的关系

基于之前对 IO 多路复用的理解我们可以知道，一条线程处理一个选择器，而一个选择器可以监控很多的通道。所以这意味着通过选择器一条线程可以处理成百上千的通道，大量的减少了线程之间上下文切换的开销。

通道和选择器之间通过 register (注册) 的方式完成，调用通道的 Channel.register（Selector sel, int ops） 方法，可以将通道实例注册到一个选择器中。第一个参数指定选择器实例，第二个参数指定 IO 事件类型。

📌 可供选择器监控的通道IO事件类型，包括以下四种：（1）可读：SelectionKey.OP_READ（2）可写：SelectionKey.OP_WRITE（3）连接：SelectionKey.OP_CONNECT（4）接收：SelectionKey.OP_ACCEPT

事件类型的定义在 SelectionKey 类中。如果选择器要监控通道的多种时间，可以用 " 按位或 " 运算符来实现。

        //监控通道的多种事件，用“按位或”运算符来实现
        int key = SelectionKey.OP_READ | SelectionKey.OP_WRITE ;

[!warning] 注意
这里的 IO 事件指的不是对通道的 IO 操作，而是通道的某个 IO 操作的一种就绪状态，比如 SocketChannel 通道, 完成握手连接则处于 " 连接就绪状态 " (OP_CONNECT)

[!note] 判断一个通道能否被选择
一个通道是否能被选择，首先要看是否继承 SelectableChannel 类，如果继承了就可以被选择，否则不能。像 FileChannel 就没有继承 SelectableChannel，所以不可以选择的通道。

SelectionKey 选择键

一旦在通道中发生了某些 IO 事件（就绪状态达成），并且是在选择器中注册过的 IO 事件，就会被选择器选中，并放入 SelectionKey 选择键的集合中。

[!note]
SelectionKey 选择键就是那些被选择器选中的 IO 事件，那些没有被注册过的通道即使发生了 IO 事件也不会被选择器选中放入选择键集合中

通过选择键不仅仅可获得通道的 IO 事件类型，也可以获得 IO 事件所在的通道，还有选出选择键的选择器实例

Java 的 new IO

2023-05-21T00:42:00.000Z

Java 的 NIO 简介

about_Java 的 NIO 是于 1.4 版本引入的 IO 库，被称为 Java New IO 类库，简称 Java NIO。而在 Java NIO 引入之前的 Java IO 类库是阻塞 IO 也被称为 OIO（Older IO）。

Java NIO 的三个核心组件

Channel（通道）
Buffer（缓冲区）
Selector（选择器）

是不是很眼熟呢？是的 Java NIO 属于 Input-Output 多路复用模型。由 NIO 组件提供了统一的 API，使得程序员能在应用层控制和实现多路复用 IO

NIO 可以随意地读取 Buffer 中任意的数据并且组装成一个完整的数据，而 OIO 则只能顺序读取一个流中的数据。

NIO 的 Channel

NIO 的 Buffer

NIO 的 Buffer 缓冲区本质上是一个内存块，它既可以写入数据也可以读取数据。

NIO 的 Selector

Netty、Redis、Zookeeper高并发实战#3.5 详解NIO Selector选择器

Java NIO Buffer 类及其属性

Allocate（）创建缓冲区

在使用 Buffer（缓冲区）之前，我们首先需要获取 Buffer 子类的实例对象，并且分配内存空间。

获取一个 Buffer 实例对象不是使用 new，而是调用 Buffer 子类的 allocate 方法：

/**  
 * @author: Ten  
 * @date: 2023/3/25 13:44  
 */
static IntBuffer intBuffer=null;

public void allocateTest(){  
    intBuffer = IntBuffer.allocate(20);  
    logger.info("---------intBuffer已创建---------");  
    logger.info("capacity="+intBuffer.capacity());  
    logger.info("position="+intBuffer.position());  
    logger.info("limit="+intBuffer.limit());  
}

在这个例子中调用了 InterBuffer.allocate(20) 创建了一个 IntBuffer 的实例对象，并且分配了 20 个 int 对象的空间也就是 20*4 个字节的空间。

例子的运行结果：

三月 25, 2023 2:01:03 下午 com.hingyun.bufferdemo.UseBuffer allocateTest
信息: ---------intBuffer已创建---------
三月 25, 2023 2:01:03 下午 com.hingyun.bufferdemo.UseBuffer allocateTest
信息: capacity=20
三月 25, 2023 2:01:03 下午 com.hingyun.bufferdemo.UseBuffer allocateTest
信息: position=0
三月 25, 2023 2:01:03 下午 com.hingyun.bufferdemo.UseBuffer allocateTest
信息: limit=20

从例子的运行结果中不难看出一个缓冲区新建后处于写入模式，其中 position 的写入位置为 0，最大的 limit 上线为容量 capacity 的初始化值。

Put 写入缓冲区

在调用 allocate 方法分配内存并返回实例对象后，缓冲区默认处于写模式，可以写入对象。写入缓冲区用到的是 put 方法，put 方法只需要一个参数就是需要写入的对象，但是这个参数的类型必须和缓冲区的类型保持一致。

现在我们调用之前的例子创建的 Buffer 对象，向里面写入 5 个 Int 类型的对象，也就是五个整数:

/**  
 * @author: Ten  
 * @date: 2023/3/25 13:44  
 */
public void putTest() {  
    allocateTest();  
    for (int i = 0; i < 5; i++) {  
        //写入一个整数到Buffer中  
        intBuffer.put(i);  
    }  
    logger.info("-------after put-------");  
    logger.info("capacity=" + intBuffer.capacity());  
    logger.info("position=" + intBuffer.position());  
    logger.info("limit=" + intBuffer.limit());  
}

在例子中我们向 Buffer 对象中写入了五个整数元素，下面是日志输出结果：

三月 25, 2023 2:40:50 下午 com.hingyun.bufferdemo.UseBuffer putTest
信息: -------after put-------
三月 25, 2023 2:40:50 下午 com.hingyun.bufferdemo.UseBuffer putTest
信息: capacity=20
三月 25, 2023 2:40:50 下午 com.hingyun.bufferdemo.UseBuffer putTest
信息: position=5
三月 25, 2023 2:40:50 下午 com.hingyun.bufferdemo.UseBuffer putTest
信息: limit=20

其中 capacity 和 limit 的值都和初始化的值一样没有发生变化，而 position 则变成了 5 指向了第 6 个位置，也就是代表我们刚刚写入了五个元素到缓冲区中接下来一个元素的写入会在第六个位置。

Flip () 翻转

在往缓冲区写入数据后是不能直接从缓冲区中读取数据的，此时缓冲区还处于写模式下，如果需要读取数据则还需要将缓冲区转换为度模式，这个时候就需要用到我们的 flip（）翻转方法了。

紧接着前面的例子这是个 flip () 的方法的演示：

/**  
 * @author: Ten  
 * @date: 2023/3/25 13:44  
 */
public void flipTest(){  
    putTest();  
    intBuffer.flip();  
    logger.info("-------after flip-------");  
    logger.info("capacity=" + intBuffer.capacity());  
    logger.info("position=" + intBuffer.position());  
    logger.info("limit=" + intBuffer.limit());  
}

在调用 flip () 方法后缓冲区的属性就发生了变化：

信息: -------after flip-------
三月 25, 2023 2:52:23 下午 com.hingyun.bufferdemo.UseBuffer flipTest
信息: capacity=20
三月 25, 2023 2:52:23 下午 com.hingyun.bufferdemo.UseBuffer flipTest
信息: position=0
三月 25, 2023 2:52:23 下午 com.hingyun.bufferdemo.UseBuffer flipTest
信息: limit=5

从输出日志可以看出，在缓冲区翻转后缓冲区域的 capacity（容量）并没有发生变化，但是 position 的指向却到了 0 表示从头开始读取，而且 limit 的值也变成了之前 position 的值表示缓冲区中的最大可读数据量为 5。

由此我们可以得出缓冲区在写模式翻转成读模式时会先把 position 的值作为最大可读上限 limit 的值，然后设置 position 的值为 0 表示从头开始读。最后因为在例子中没有展示出来我提一嘴，在写模式翻转为读模式时会清除之前的 mark 标记，因为 mark 是写模式下的临时位置，如果在读模式下使用旧的 mark 标记会造成位置的混乱。

Flip () 方法的源码：

/**  
 * @author: Ten  
 * @date: 2023/3/25 13:44  
 */
public final Buffer flip() {  
	//把 position 的值作为最大可读上限 limit 的值
    limit = position;  
    //设置 position 的值为 0 表示从头开始读
    position = 0;  
    //清除mark标记
    mark = -1;  
    return this;  
}

Get () 从缓冲区读取

在调用 flip 方法将缓冲区翻转后，紧接着我们来看一下如何从缓冲区读取数据，读取数据非常的简单，只需要调用 get（）方法每次从 position 的位置读取一个数据，同时缓冲区的属性也会自动进行相应的调整。

演示：

/**  
 * @author: Ten  
 * @date: 2023/3/25 13:44  
 */
public void getTest() {  
    flipTest();  
    //读两个  
    for (int i = 0; i < 2; i++) {  
        logger.info("i=" + intBuffer.get());  
    }  
    logger.info("-------after get 1-------");  
    logger.info("capacity=" + intBuffer.capacity());  
    logger.info("position=" + intBuffer.position());  
    logger.info("limit=" + intBuffer.limit());  
    //再读三个  
    for (int i = 0; i < 3; i++) {  
        logger.info("i=" + intBuffer.get());  
    }  
    logger.info("-------after get 2-------");  
    logger.info("capacity=" + intBuffer.capacity());  
    logger.info("position=" + intBuffer.position());  
    logger.info("limit=" + intBuffer.limit());  
  
}

下面是输出日志：

三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: -------从缓冲区读两个元素-------
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: i=0
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: i=1
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: -------after get 1-------
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: capacity=20
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: position=2
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: limit=5
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: -------从缓冲区读三个元素-------
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: i=2
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: i=3
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: i=4
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: -------after get 2-------
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: capacity=20
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: position=5
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: limit=5

从输出日志我们可以看到读取操作会改变 position 的指向位置，而 limit 的值不会变，如果 position 和 limit 的值相等，则表示所有数据读取完毕，position 已经指向了一个没有数据的位置，已经无法读出任何数据了，如果此时再读就会抛出 BufferUnderflowException 异常。

那在我们在读完之后是否可以立刻进入写入模式对缓冲区进行写入呢？
这是不可以的，现在还是处于读模式，我们需要调用 Buffer.clear 或 Buffer.compact 对缓冲区进行清空或者压缩，才能变为写入模式，这两个方法我们放在后面说。

既然读完后不能立刻进入写模式，那缓冲区可不可以重复读呢？

可以

Rewind（）倒带

对于已经读完的数据，如果我们需要再读一遍的话可以使用 rewind（）方法
演示：

/**  
 * @author: Ten  
 * @date: 2023/3/25 13:44  
 */
public void rewindTest() {  
    getTest();  
    intBuffer.rewind();  
    logger.info("-------after rewind-------");  
    logger.info("capacity=" + intBuffer.capacity());  
    logger.info("position=" + intBuffer.position());  
    logger.info("limit=" + intBuffer.limit());  
}

输出日志：

/**  
 * @author: Ten  
 * @date: 2023/3/25 13:44  
 */
信息: -------after rewind-------
三月 25, 2023 3:43:08 下午 com.hingyun.bufferdemo.UseBuffer rewindTest
信息: capacity=20
三月 25, 2023 3:43:08 下午 com.hingyun.bufferdemo.UseBuffer rewindTest
信息: position=0
三月 25, 2023 3:43:08 下午 com.hingyun.bufferdemo.UseBuffer rewindTest
信息: limit=5

从日志中可以看出 rewind 主要是调整了 position 属性，让 position 指向第一个元素并清空 mark，其他的值不会发生改变
Rewin 源码：

public final Buffer rewind() {  
    position = 0;  
    mark = -1;  
    return this;  
}

Mark 和 Reset

Buffer.mark() 方法的作用就是将 position 的值保存起来放在 mark 属性中，让 mark 属性记住这个临时的位置，而 reset 方法则是把 mark 属性的值恢复到 position 中。

演示：

/**  
 * @author: Ten  
 * @date: 2023/3/25 13:44  
 */
public void markTest() {  
    flipTest();  
    for (int i = 0; i < 5; i++) {  
        int j = intBuffer.get();  
        //当到第三个元素时mark这个位置  
        //注意这里是在get操作后进行的mark操作，
        //所以获取的是get操作后的position值，也就是2+1=3
        if (i == 2) {  
            intBuffer.mark();  
            logger.info("---mark---");  
            logger.info("position=" + intBuffer.position());  
        }  
    }  
    logger.info("-----before reset------");  
    logger.info("capacity=" + intBuffer.capacity());  
    logger.info("position=" + intBuffer.position());  
    logger.info("limit=" + intBuffer.limit());  
  
  
    intBuffer.reset();  
    logger.info("-----after reset------");  
    logger.info("capacity=" + intBuffer.capacity());  
    logger.info("position=" + intBuffer.position());  
    logger.info("limit=" + intBuffer.limit());  
}

日志输出：

信息: ---mark---
三月 25, 2023 4:33:25 下午 com.hingyun.bufferdemo.UseBuffer markTest
信息: position=3
三月 25, 2023 4:33:25 下午 com.hingyun.bufferdemo.UseBuffer markTest
信息: -----before reset------
三月 25, 2023 4:33:25 下午 com.hingyun.bufferdemo.UseBuffer markTest
信息: capacity=20
三月 25, 2023 4:33:25 下午 com.hingyun.bufferdemo.UseBuffer markTest
信息: position=5
三月 25, 2023 4:33:25 下午 com.hingyun.bufferdemo.UseBuffer markTest
信息: limit=5
三月 25, 2023 4:33:25 下午 com.hingyun.bufferdemo.UseBuffer markTest
信息: -----after reset------
三月 25, 2023 4:33:25 下午 com.hingyun.bufferdemo.UseBuffer markTest
信息: capacity=20
三月 25, 2023 4:33:25 下午 com.hingyun.bufferdemo.UseBuffer markTest
信息: position=3
三月 25, 2023 4:33:25 下午 com.hingyun.bufferdemo.UseBuffer markTest
信息: limit=5

从日志中可以看到我们 mark 的位置是 3，在循环结束时 position 的指向为 5，而在我们调用 reset 方法后 position 又指向了 3，表示可以再次开始从第四个元素读取数据。

Clear 清空缓存区

在读取模式下，我们可以调用 clear() 方法将缓存区清空并切换为写入模式。这个方法会将 position 清零，limit 设置为 capacity 的最大容量值，可以一直写入，直到缓冲区写满。
演示：

/**  
 * @author: Ten  
 * @date: 2023/3/25 13:44  
 */
public void clearTest(){  
    //调用之前的读取方法  
    getTest();  
    //将缓存区清空  
    intBuffer.clear();  
    logger.info("-------after clear-------");  
    logger.info("capacity=" + intBuffer.capacity());  
    logger.info("position=" + intBuffer.position());  
    logger.info("limit=" + intBuffer.limit());  
  
    //写入buffer  
    for (int i = 0; i < 5; i++) {  
        intBuffer.put(i);  
    }  
    logger.info("-------after put-------");  
    logger.info("capacity=" + intBuffer.capacity());  
    logger.info("position=" + intBuffer.position());  
    logger.info("limit=" + intBuffer.limit());  
  
}

日志输出：

三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: i=0
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: i=1
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: -------after get 1-------
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: capacity=20
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: position=2
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: limit=5
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: -------从缓冲区读三个元素-------
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: i=2
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: i=3
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: i=4
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: -------after get 2-------
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: capacity=20
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: position=5
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: limit=5
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer clearTest
信息: -------after clear-------
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer clearTest
信息: capacity=20
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer clearTest
信息: position=0
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer clearTest
信息: limit=20
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer clearTest
信息: -------after put-------
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer clearTest
信息: capacity=20
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer clearTest
信息: position=5
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer clearTest
信息: limit=20

日志有一点长，不太适合阅读。总的来说 clear 方法的调用会让 position 值归零，limit = capacity，mark 值清空。
Clear 源码：

public final Buffer clear() {  
    position = 0;  
    limit = capacity;  
    mark = -1;  
    return this;  
}

小结

使用 Java NIO buffer 的基本步骤：

使用 allocate 创建子类实例
调用 put 向缓冲区写入数据
写入完成后，在读取之前调用 flip 方法将缓冲区转换为读取模式
调用 get 方法从缓冲区读取数据
读取完成后使用 clear 或者 compact 方法将缓冲区转换成写入模式

重要属性

Java NIO 的 Buffer 类是一个抽象类，它的内部是一个内存块（数组），与普通的 Java 数组不同的是：NIO Buffer 对象提供了一组更加有效的方法进行写入和读取的交替访问。为了记录读写的状态和位置 Buffer 类提供了一些重要的属性，其中有三个重要的成员属性：capacity（容量）、position（读写位置）、limit（读写的限制）。另外还有一个 Mark 属性介意将当前的 position 记录下来，当需要时可以从 mark 标记中将 position 恢复到记录的位置。

注意：Buffer 类是一个非线程安全类

Buffer 类

Buffer 类是一个抽象类，对应于 Java 的主要数据类型，在 NIO 中有 8 种缓冲区类，分别如下：ByteBuffer、CharBuffer、DoubleBuffer、FloatBuffer、IntBuffer、LongBuffer、ShortBuffer、MappedByteBuffer。

前七种类型包含了 about_Java 所有能在 IO 中传输的基本数据类型，Boolean 类型无法传输。第八种 MappedByteBuffer 是专门用于内存映射的 ByteBuffer 类型。

Buffer 类的重要属性

Capacity

Capacity（容量）限制着当前的 Buffer 缓冲区能存入的数据量。比如在 Buffer 类初始化对象时设置 capacity=20，则这个 Buffer 对象只能存入最多 20 个数据并且 capacity 属性一但初始化就不能更改。因为 Buffer 类在初始化时会按照 capacity 分配内部的内存，在内存分配好之后自然是不能改变了，而且 capacity 容量不是指内存 byte 的数量，而是指的写入的对象的数量（如一个 IntBuffer 初始化时 capacity 是 20 则这个 Buffer 最多只能存入 20 个 int 对象）

Position

Buffer 类中的 position 属性表示当前读或者写的位置。在读写模式下，position 属性是不同的，当缓冲区的读写模式转变后，position 会进行调整。Buffer 使用 flip 方法进行读写模式的切换，当 Buffer 进行 flip 翻转后，position 会由原来的写入位置变成新的可读位置，也就是 0，表示从头开始读。

在写入模式下 Position 的变化规则：

在刚进入写模式下 position 值为 0，表示当前写入位置从头开始。
每有一个数据写入 Buffer 中 position 就会向后移动一个可写位置，也就是 +1
当 position=limit 时，缓冲区就已经无空间可写。

在读模式下 Position 的变化规则：

当缓冲区进入读模式时，position 会重置为 0，意味着从头开始读取
当从缓冲区读取时，也是从 position 的位置开始读，在读取数据后 position 会移动到下一个可读的位置。
Position 最大的值为最大可读上限 limit，当 position=limit 时代表缓冲区已经没有数据可读了。

Limiti

Buffer 类中的 limit 属性表示读写的最大上线，在读、写模式下 limit 表示的含义是不同的。在写模式下 limit 表示这个 Buffer 可以写入数据的最大上限，在 Buffer 初始化时 limit 默认等于 capacity；在读模式下 limit 的含义为能从 Buffer 中读到多少数据量。

一般来说 Buffer 的使用都是先写入再读取，毕竟去读一个空的 Buffer 是没有意义的。当缓冲区写入完成后可以使用 flip 翻转方法将模式改为写模式，这时 limit 的值会设置成写模式下的 position 值作为可读取得最大上限。

Mark

这时一个比较简单的属性，它的作用主要是记录当前 position 的值，以备需要时调用 reset 方法将 mark 值恢复到 position 中。

Java NIO Buffer 类的重要方法

Allocate（）创建缓冲区

在使用 Buffer（缓冲区）之前，我们首先需要获取 Buffer 子类的实例对象，并且分配内存空间。

获取一个 Buffer 实例对象不是使用 new，而是调用 Buffer 子类的 allocate 方法：

/**  
 * @author: Ten  
 * @date: 2023/3/25 13:44  
 */
static IntBuffer intBuffer=null;

public void allocateTest(){  
    intBuffer = IntBuffer.allocate(20);  
    logger.info("---------intBuffer已创建---------");  
    logger.info("capacity="+intBuffer.capacity());  
    logger.info("position="+intBuffer.position());  
    logger.info("limit="+intBuffer.limit());  
}

在这个例子中调用了 InterBuffer.allocate(20) 创建了一个 IntBuffer 的实例对象，并且分配了 20 个 int 对象的空间也就是 20*4 个字节的空间。

例子的运行结果：

三月 25, 2023 2:01:03 下午 com.hingyun.bufferdemo.UseBuffer allocateTest
信息: ---------intBuffer已创建---------
三月 25, 2023 2:01:03 下午 com.hingyun.bufferdemo.UseBuffer allocateTest
信息: capacity=20
三月 25, 2023 2:01:03 下午 com.hingyun.bufferdemo.UseBuffer allocateTest
信息: position=0
三月 25, 2023 2:01:03 下午 com.hingyun.bufferdemo.UseBuffer allocateTest
信息: limit=20

从例子的运行结果中不难看出一个缓冲区新建后处于写入模式，其中 position 的写入位置为 0，最大的 limit 上线为容量 capacity 的初始化值。

Put 写入缓冲区

现在我们调用之前的例子创建的 Buffer 对象，向里面写入 5 个 Int 类型的对象，也就是五个整数:

/**  
 * @author: Ten  
 * @date: 2023/3/25 13:44  
 */
public void putTest() {  
    allocateTest();  
    for (int i = 0; i < 5; i++) {  
        //写入一个整数到Buffer中  
        intBuffer.put(i);  
    }  
    logger.info("-------after put-------");  
    logger.info("capacity=" + intBuffer.capacity());  
    logger.info("position=" + intBuffer.position());  
    logger.info("limit=" + intBuffer.limit());  
}

在例子中我们向 Buffer 对象中写入了五个整数元素，下面是日志输出结果：

三月 25, 2023 2:40:50 下午 com.hingyun.bufferdemo.UseBuffer putTest
信息: -------after put-------
三月 25, 2023 2:40:50 下午 com.hingyun.bufferdemo.UseBuffer putTest
信息: capacity=20
三月 25, 2023 2:40:50 下午 com.hingyun.bufferdemo.UseBuffer putTest
信息: position=5
三月 25, 2023 2:40:50 下午 com.hingyun.bufferdemo.UseBuffer putTest
信息: limit=20

Flip () 翻转

紧接着前面的例子这是个 flip () 的方法的演示：

/**  
 * @author: Ten  
 * @date: 2023/3/25 13:44  
 */
public void flipTest(){  
    putTest();  
    intBuffer.flip();  
    logger.info("-------after flip-------");  
    logger.info("capacity=" + intBuffer.capacity());  
    logger.info("position=" + intBuffer.position());  
    logger.info("limit=" + intBuffer.limit());  
}

在调用 flip () 方法后缓冲区的属性就发生了变化：

信息: -------after flip-------
三月 25, 2023 2:52:23 下午 com.hingyun.bufferdemo.UseBuffer flipTest
信息: capacity=20
三月 25, 2023 2:52:23 下午 com.hingyun.bufferdemo.UseBuffer flipTest
信息: position=0
三月 25, 2023 2:52:23 下午 com.hingyun.bufferdemo.UseBuffer flipTest
信息: limit=5

Flip () 方法的源码：

/**  
 * @author: Ten  
 * @date: 2023/3/25 13:44  
 */
public final Buffer flip() {  
	//把 position 的值作为最大可读上限 limit 的值
    limit = position;  
    //设置 position 的值为 0 表示从头开始读
    position = 0;  
    //清除mark标记
    mark = -1;  
    return this;  
}

Get () 从缓冲区读取

演示：

/**  
 * @author: Ten  
 * @date: 2023/3/25 13:44  
 */
public void getTest() {  
    flipTest();  
    //读两个  
    for (int i = 0; i < 2; i++) {  
        logger.info("i=" + intBuffer.get());  
    }  
    logger.info("-------after get 1-------");  
    logger.info("capacity=" + intBuffer.capacity());  
    logger.info("position=" + intBuffer.position());  
    logger.info("limit=" + intBuffer.limit());  
    //再读三个  
    for (int i = 0; i < 3; i++) {  
        logger.info("i=" + intBuffer.get());  
    }  
    logger.info("-------after get 2-------");  
    logger.info("capacity=" + intBuffer.capacity());  
    logger.info("position=" + intBuffer.position());  
    logger.info("limit=" + intBuffer.limit());  
  
}

下面是输出日志：

三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: -------从缓冲区读两个元素-------
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: i=0
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: i=1
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: -------after get 1-------
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: capacity=20
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: position=2
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: limit=5
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: -------从缓冲区读三个元素-------
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: i=2
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: i=3
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: i=4
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: -------after get 2-------
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: capacity=20
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: position=5
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: limit=5

既然读完后不能立刻进入写模式，那缓冲区可不可以重复读呢？

可以

Rewind（）倒带

对于已经读完的数据，如果我们需要再读一遍的话可以使用 rewind（）方法
演示：

/**  
 * @author: Ten  
 * @date: 2023/3/25 13:44  
 */
public void rewindTest() {  
    getTest();  
    intBuffer.rewind();  
    logger.info("-------after rewind-------");  
    logger.info("capacity=" + intBuffer.capacity());  
    logger.info("position=" + intBuffer.position());  
    logger.info("limit=" + intBuffer.limit());  
}

输出日志：

/**  
 * @author: Ten  
 * @date: 2023/3/25 13:44  
 */
信息: -------after rewind-------
三月 25, 2023 3:43:08 下午 com.hingyun.bufferdemo.UseBuffer rewindTest
信息: capacity=20
三月 25, 2023 3:43:08 下午 com.hingyun.bufferdemo.UseBuffer rewindTest
信息: position=0
三月 25, 2023 3:43:08 下午 com.hingyun.bufferdemo.UseBuffer rewindTest
信息: limit=5

从日志中可以看出 rewind 主要是调整了 position 属性，让 position 指向第一个元素并清空 mark，其他的值不会发生改变
Rewin 源码：

public final Buffer rewind() {  
    position = 0;  
    mark = -1;  
    return this;  
}

Mark 和 Reset

演示：

/**  
 * @author: Ten  
 * @date: 2023/3/25 13:44  
 */
public void markTest() {  
    flipTest();  
    for (int i = 0; i < 5; i++) {  
        int j = intBuffer.get();  
        //当到第三个元素时mark这个位置  
        //注意这里是在get操作后进行的mark操作，
        //所以获取的是get操作后的position值，也就是2+1=3
        if (i == 2) {  
            intBuffer.mark();  
            logger.info("---mark---");  
            logger.info("position=" + intBuffer.position());  
        }  
    }  
    logger.info("-----before reset------");  
    logger.info("capacity=" + intBuffer.capacity());  
    logger.info("position=" + intBuffer.position());  
    logger.info("limit=" + intBuffer.limit());  
  
  
    intBuffer.reset();  
    logger.info("-----after reset------");  
    logger.info("capacity=" + intBuffer.capacity());  
    logger.info("position=" + intBuffer.position());  
    logger.info("limit=" + intBuffer.limit());  
}

日志输出：

信息: ---mark---
三月 25, 2023 4:33:25 下午 com.hingyun.bufferdemo.UseBuffer markTest
信息: position=3
三月 25, 2023 4:33:25 下午 com.hingyun.bufferdemo.UseBuffer markTest
信息: -----before reset------
三月 25, 2023 4:33:25 下午 com.hingyun.bufferdemo.UseBuffer markTest
信息: capacity=20
三月 25, 2023 4:33:25 下午 com.hingyun.bufferdemo.UseBuffer markTest
信息: position=5
三月 25, 2023 4:33:25 下午 com.hingyun.bufferdemo.UseBuffer markTest
信息: limit=5
三月 25, 2023 4:33:25 下午 com.hingyun.bufferdemo.UseBuffer markTest
信息: -----after reset------
三月 25, 2023 4:33:25 下午 com.hingyun.bufferdemo.UseBuffer markTest
信息: capacity=20
三月 25, 2023 4:33:25 下午 com.hingyun.bufferdemo.UseBuffer markTest
信息: position=3
三月 25, 2023 4:33:25 下午 com.hingyun.bufferdemo.UseBuffer markTest
信息: limit=5

Clear 清空缓存区

/**  
 * @author: Ten  
 * @date: 2023/3/25 13:44  
 */
public void clearTest(){  
    //调用之前的读取方法  
    getTest();  
    //将缓存区清空  
    intBuffer.clear();  
    logger.info("-------after clear-------");  
    logger.info("capacity=" + intBuffer.capacity());  
    logger.info("position=" + intBuffer.position());  
    logger.info("limit=" + intBuffer.limit());  
  
    //写入buffer  
    for (int i = 0; i < 5; i++) {  
        intBuffer.put(i);  
    }  
    logger.info("-------after put-------");  
    logger.info("capacity=" + intBuffer.capacity());  
    logger.info("position=" + intBuffer.position());  
    logger.info("limit=" + intBuffer.limit());  
  
}

日志输出：

三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: i=0
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: i=1
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: -------after get 1-------
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: capacity=20
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: position=2
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: limit=5
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: -------从缓冲区读三个元素-------
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: i=2
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: i=3
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: i=4
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: -------after get 2-------
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: capacity=20
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: position=5
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: limit=5
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer clearTest
信息: -------after clear-------
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer clearTest
信息: capacity=20
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer clearTest
信息: position=0
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer clearTest
信息: limit=20
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer clearTest
信息: -------after put-------
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer clearTest
信息: capacity=20
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer clearTest
信息: position=5
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer clearTest
信息: limit=20

日志有一点长，不太适合阅读。总的来说 clear 方法的调用会让 position 值归零，limit = capacity，mark 值清空。
Clear 源码：

public final Buffer clear() {  
    position = 0;  
    limit = capacity;  
    mark = -1;  
    return this;  
}

小结

使用 Java NIO buffer 的基本步骤：

使用 allocate 创建子类实例
调用 put 向缓冲区写入数据
写入完成后，在读取之前调用 flip 方法将缓冲区转换为读取模式
调用 get 方法从缓冲区读取数据
读取完成后使用 clear 或者 compact 方法将缓冲区转换成写入模式

重要属性

注意：Buffer 类是一个非线程安全类

Buffer 类

前七种类型包含了 about_Java 所有能在 IO 中传输的基本数据类型，Boolean 类型无法传输。第八种 MappedByteBuffer 是专门用于内存映射的 ByteBuffer 类型。

Buffer 类的重要属性

Capacity

Position

在写入模式下 Position 的变化规则：

在刚进入写模式下 position 值为 0，表示当前写入位置从头开始。
每有一个数据写入 Buffer 中 position 就会向后移动一个可写位置，也就是 +1
当 position=limit 时，缓冲区就已经无空间可写。

在读模式下 Position 的变化规则：

当缓冲区进入读模式时，position 会重置为 0，意味着从头开始读取
当从缓冲区读取时，也是从 position 的位置开始读，在读取数据后 position 会移动到下一个可读的位置。
Position 最大的值为最大可读上限 limit，当 position=limit 时代表缓冲区已经没有数据可读了。

Limiti

Mark

这时一个比较简单的属性，它的作用主要是记录当前 position 的值，以备需要时调用 reset 方法将 mark 值恢复到 position 中。

Java NIO Channel 类

[!info]
之前提到过在 NIO 中一个连接就是使用一个 channel 表示，也就是一个通道可以表示一个底层的文件描述符，比如硬件设备、文件、网络连接等。其实不止如此，除了了对应底层的文件描述符外，Java NIO 的通道还可以细化到不同的网络传输协议，对于不同的协议 Java NIO 都有不同的实现。

Channel 的主要类型

Channel 使用比较多的类型主要有四种

名称	说明	备注
FileChannel	文件通道，主要用于文件读写	只有阻塞模式，因为对于文件的读写不需要去轮询内核数据是否准备好
SocketChannel	用于 socket 套接字 TCP 链接的数据读写	在客户端和服务端都存在
ServerSocketChannel	服务器套接字通道，允许程序监听 TCP 连接请求，为每个监听到的请求创建一个 SocketChannel 通道	只存在于服务端
DatagramChannel	用于 UDP 协议的数据读写

FileChannel 文件通道

获取 filechannel 通道

可以通过文件的输入流、输出流获取FileChannel通道，又或者通过RandomAccessFile文件随机访问类获取通道

1680087161

从filechannel通道中读取数据

在大部分的应用场景中，从通道读取数据都会调用通道的int read 写入到Buffer 中，也就是之前说过的ByteBufferbuf方法，它将从通道的读取的数据写入到ByteBuffer缓冲区中

从FileChannel中读取数据代码示例

注意

通道读取数据对于Buffer缓冲区来说是写入数据，此时缓冲区处于写入模式

写入filechannel通道

同样的大部分应用场景在往通道写入数据时是int write (ByteBufferbuf) 方法，此时缓冲区就是写入数据的来源。通过调用write()方法从Buffer中读取数据，然后写入到通道中，返回值就是写入成功的字节数

写入FileChannel通道代码示例

注意

在向通道中写入数据时要求缓冲区是可读的，需要缓冲区翻转成读模式。

在使用完通道后一定要关闭通道，使用close即可

channel.close

强制刷新到磁盘

在将缓冲数据写入通道时，出于对性能考虑，操作系统不能每次都实时将数据写入磁盘。如果需要保证将缓冲数据立刻写入磁盘需要调用force()方法强制刷新到磁盘

channel.force(true)

SocketChannel 套接字通道

在 NIO 中 SocketChannel 与 ServerSocketChannel 是相辅相成的，一个负责连接传输，一个负责连接监听。他们两个都支持阻塞和非阻塞两种模式。调用 socketChannel.configureBlocking（Boolean） 方法即可修改模式，考虑到效率方面，阻塞模式基本不会使用到。

获取 SocketChannel 通道

客户端获取通道

通过 SocketChannel 的 open 方法获得一个传输通道
将 socket 设置为非阻塞模式
对服务器 IP 和端口发起连接

1680087190

服务器端获取套接字

通过调用服务器端 ServerSocketChannel 监听套接字的 accept() 方法，来获取新连接的套接字通道

20230328

Java NIO Selector 选择器

[!note]
选择器的使命就是完成 IO 多路复用，通过选择器可以同时监控多个通道的 IO 事件。选择器与通道的关系就是监控和被监控的关系

📌 可供选择器监控的通道IO事件类型，包括以下四种：（1）可读：SelectionKey.OP_READ（2）可写：SelectionKey.OP_WRITE（3）连接：SelectionKey.OP_CONNECT（4）接收：SelectionKey.OP_ACCEPT

事件类型的定义在 SelectionKey 类中。如果选择器要监控通道的多种时间，可以用 " 按位或 " 运算符来实现。

        //监控通道的多种事件，用“按位或”运算符来实现
        int key = SelectionKey.OP_READ | SelectionKey.OP_WRITE ;

[!warning] 注意
这里的 IO 事件指的不是对通道的 IO 操作，而是通道的某个 IO 操作的一种就绪状态，比如 SocketChannel 通道, 完成握手连接则处于 " 连接就绪状态 " (OP_CONNECT)

^93799f

[!note] 判断一个通道能否被选择
一个通道是否能被选择，首先要看是否继承 SelectableChannel 类，如果继承了就可以被选择，否则不能。像 FileChannel 就没有继承 SelectableChannel，所以不可以选择的通道。

SelectionKey 选择键

一旦在通道中发生了某些 IO 事件（就绪状态达成），并且是在选择器中注册过的 IO 事件，就会被选择器选中，并放入 SelectionKey 选择键的集合中。

[!note]
SelectionKey 选择键就是那些被选择器选中的 IO 事件，那些没有被注册过的通道即使发生了 IO 事件也不会被选择器选中放入选择键集合中

通过选择键不仅仅可获得通道的 IO 事件类型，也可以获得 IO 事件所在的通道，还有选出选择键的选择器实例

Channel 类

2023-05-21T00:42:00.000Z

[!info]
之前提到过在 NIO 中一个连接就是使用一个 channel 表示，也就是一个通道可以表示一个底层的文件描述符，比如硬件设备、文件、网络连接等。其实不止如此，除了了对应底层的文件描述符外，Java NIO 的通道还可以细化到不同的网络传输协议，对于不同的协议 Java NIO 都有不同的实现。

Channel 的主要类型

Channel 使用比较多的类型主要有四种

名称	说明	备注
FileChannel	文件通道，主要用于文件读写	只有阻塞模式，因为对于文件的读写不需要去轮询内核数据是否准备好
SocketChannel	用于 socket 套接字 TCP 链接的数据读写	在客户端和服务端都存在
ServerSocketChannel	服务器套接字通道，允许程序监听 TCP 连接请求，为每个监听到的请求创建一个 SocketChannel 通道	只存在于服务端
DatagramChannel	用于 UDP 协议的数据读写

FileChannel 文件通道

获取 filechannel 通道

可以通过文件的输入流、输出流获取FileChannel通道，又或者通过RandomAccessFile文件随机访问类获取通道

1680087161

从filechannel通道中读取数据

从FileChannel中读取数据代码示例

注意

通道读取数据对于Buffer缓冲区来说是写入数据，此时缓冲区处于写入模式

写入filechannel通道

写入FileChannel通道代码示例

注意

在向通道中写入数据时要求缓冲区是可读的，需要缓冲区翻转成读模式。

在使用完通道后一定要关闭通道，使用close即可

channel.close

强制刷新到磁盘

channel.force(true)

SocketChannel 套接字通道

获取 SocketChannel 通道

客户端获取通道

通过 SocketChannel 的 open 方法获得一个传输通道
将 socket 设置为非阻塞模式
对服务器 IP 和端口发起连接

1680087190

服务器端获取套接字

通过调用服务器端 ServerSocketChannel 监听套接字的 accept() 方法，来获取新连接的套接字通道

20230328

Buffer 类的重要方法

2023-05-21T00:42:00.000Z

Allocate（）创建缓冲区

在使用 Buffer（缓冲区）之前，我们首先需要获取 Buffer 子类的实例对象，并且分配内存空间。

获取一个 Buffer 实例对象不是使用 new，而是调用 Buffer 子类的 allocate 方法：

/**  
 * @author: Ten  
 * @date: 2023/3/25 13:44  
 */
static IntBuffer intBuffer=null;

public void allocateTest(){  
    intBuffer = IntBuffer.allocate(20);  
    logger.info("---------intBuffer已创建---------");  
    logger.info("capacity="+intBuffer.capacity());  
    logger.info("position="+intBuffer.position());  
    logger.info("limit="+intBuffer.limit());  
}

在这个例子中调用了 InterBuffer.allocate(20) 创建了一个 IntBuffer 的实例对象，并且分配了 20 个 int 对象的空间也就是 20*4 个字节的空间。

例子的运行结果：

三月 25, 2023 2:01:03 下午 com.hingyun.bufferdemo.UseBuffer allocateTest
信息: ---------intBuffer已创建---------
三月 25, 2023 2:01:03 下午 com.hingyun.bufferdemo.UseBuffer allocateTest
信息: capacity=20
三月 25, 2023 2:01:03 下午 com.hingyun.bufferdemo.UseBuffer allocateTest
信息: position=0
三月 25, 2023 2:01:03 下午 com.hingyun.bufferdemo.UseBuffer allocateTest
信息: limit=20

从例子的运行结果中不难看出一个缓冲区新建后处于写入模式，其中 position 的写入位置为 0，最大的 limit 上线为容量 capacity 的初始化值。

Put 写入缓冲区

现在我们调用之前的例子创建的 Buffer 对象，向里面写入 5 个 Int 类型的对象，也就是五个整数:

/**  
 * @author: Ten  
 * @date: 2023/3/25 13:44  
 */
public void putTest() {  
    allocateTest();  
    for (int i = 0; i < 5; i++) {  
        //写入一个整数到Buffer中  
        intBuffer.put(i);  
    }  
    logger.info("-------after put-------");  
    logger.info("capacity=" + intBuffer.capacity());  
    logger.info("position=" + intBuffer.position());  
    logger.info("limit=" + intBuffer.limit());  
}

在例子中我们向 Buffer 对象中写入了五个整数元素，下面是日志输出结果：

三月 25, 2023 2:40:50 下午 com.hingyun.bufferdemo.UseBuffer putTest
信息: -------after put-------
三月 25, 2023 2:40:50 下午 com.hingyun.bufferdemo.UseBuffer putTest
信息: capacity=20
三月 25, 2023 2:40:50 下午 com.hingyun.bufferdemo.UseBuffer putTest
信息: position=5
三月 25, 2023 2:40:50 下午 com.hingyun.bufferdemo.UseBuffer putTest
信息: limit=20

Flip () 翻转

紧接着前面的例子这是个 flip () 的方法的演示：

/**  
 * @author: Ten  
 * @date: 2023/3/25 13:44  
 */
public void flipTest(){  
    putTest();  
    intBuffer.flip();  
    logger.info("-------after flip-------");  
    logger.info("capacity=" + intBuffer.capacity());  
    logger.info("position=" + intBuffer.position());  
    logger.info("limit=" + intBuffer.limit());  
}

在调用 flip () 方法后缓冲区的属性就发生了变化：

信息: -------after flip-------
三月 25, 2023 2:52:23 下午 com.hingyun.bufferdemo.UseBuffer flipTest
信息: capacity=20
三月 25, 2023 2:52:23 下午 com.hingyun.bufferdemo.UseBuffer flipTest
信息: position=0
三月 25, 2023 2:52:23 下午 com.hingyun.bufferdemo.UseBuffer flipTest
信息: limit=5

Flip () 方法的源码：

/**  
 * @author: Ten  
 * @date: 2023/3/25 13:44  
 */
public final Buffer flip() {  
	//把 position 的值作为最大可读上限 limit 的值
    limit = position;  
    //设置 position 的值为 0 表示从头开始读
    position = 0;  
    //清除mark标记
    mark = -1;  
    return this;  
}

Get () 从缓冲区读取

演示：

/**  
 * @author: Ten  
 * @date: 2023/3/25 13:44  
 */
public void getTest() {  
    flipTest();  
    //读两个  
    for (int i = 0; i < 2; i++) {  
        logger.info("i=" + intBuffer.get());  
    }  
    logger.info("-------after get 1-------");  
    logger.info("capacity=" + intBuffer.capacity());  
    logger.info("position=" + intBuffer.position());  
    logger.info("limit=" + intBuffer.limit());  
    //再读三个  
    for (int i = 0; i < 3; i++) {  
        logger.info("i=" + intBuffer.get());  
    }  
    logger.info("-------after get 2-------");  
    logger.info("capacity=" + intBuffer.capacity());  
    logger.info("position=" + intBuffer.position());  
    logger.info("limit=" + intBuffer.limit());  
  
}

下面是输出日志：

三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: -------从缓冲区读两个元素-------
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: i=0
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: i=1
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: -------after get 1-------
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: capacity=20
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: position=2
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: limit=5
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: -------从缓冲区读三个元素-------
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: i=2
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: i=3
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: i=4
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: -------after get 2-------
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: capacity=20
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: position=5
三月 25, 2023 3:20:35 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: limit=5

既然读完后不能立刻进入写模式，那缓冲区可不可以重复读呢？

可以

Rewind（）倒带

对于已经读完的数据，如果我们需要再读一遍的话可以使用 rewind（）方法
演示：

/**  
 * @author: Ten  
 * @date: 2023/3/25 13:44  
 */
public void rewindTest() {  
    getTest();  
    intBuffer.rewind();  
    logger.info("-------after rewind-------");  
    logger.info("capacity=" + intBuffer.capacity());  
    logger.info("position=" + intBuffer.position());  
    logger.info("limit=" + intBuffer.limit());  
}

输出日志：

/**  
 * @author: Ten  
 * @date: 2023/3/25 13:44  
 */
信息: -------after rewind-------
三月 25, 2023 3:43:08 下午 com.hingyun.bufferdemo.UseBuffer rewindTest
信息: capacity=20
三月 25, 2023 3:43:08 下午 com.hingyun.bufferdemo.UseBuffer rewindTest
信息: position=0
三月 25, 2023 3:43:08 下午 com.hingyun.bufferdemo.UseBuffer rewindTest
信息: limit=5

从日志中可以看出 rewind 主要是调整了 position 属性，让 position 指向第一个元素并清空 mark，其他的值不会发生改变
Rewin 源码：

public final Buffer rewind() {  
    position = 0;  
    mark = -1;  
    return this;  
}

Mark 和 Reset

演示：

/**  
 * @author: Ten  
 * @date: 2023/3/25 13:44  
 */
public void markTest() {  
    flipTest();  
    for (int i = 0; i < 5; i++) {  
        int j = intBuffer.get();  
        //当到第三个元素时mark这个位置  
        //注意这里是在get操作后进行的mark操作，
        //所以获取的是get操作后的position值，也就是2+1=3
        if (i == 2) {  
            intBuffer.mark();  
            logger.info("---mark---");  
            logger.info("position=" + intBuffer.position());  
        }  
    }  
    logger.info("-----before reset------");  
    logger.info("capacity=" + intBuffer.capacity());  
    logger.info("position=" + intBuffer.position());  
    logger.info("limit=" + intBuffer.limit());  
  
  
    intBuffer.reset();  
    logger.info("-----after reset------");  
    logger.info("capacity=" + intBuffer.capacity());  
    logger.info("position=" + intBuffer.position());  
    logger.info("limit=" + intBuffer.limit());  
}

日志输出：

信息: ---mark---
三月 25, 2023 4:33:25 下午 com.hingyun.bufferdemo.UseBuffer markTest
信息: position=3
三月 25, 2023 4:33:25 下午 com.hingyun.bufferdemo.UseBuffer markTest
信息: -----before reset------
三月 25, 2023 4:33:25 下午 com.hingyun.bufferdemo.UseBuffer markTest
信息: capacity=20
三月 25, 2023 4:33:25 下午 com.hingyun.bufferdemo.UseBuffer markTest
信息: position=5
三月 25, 2023 4:33:25 下午 com.hingyun.bufferdemo.UseBuffer markTest
信息: limit=5
三月 25, 2023 4:33:25 下午 com.hingyun.bufferdemo.UseBuffer markTest
信息: -----after reset------
三月 25, 2023 4:33:25 下午 com.hingyun.bufferdemo.UseBuffer markTest
信息: capacity=20
三月 25, 2023 4:33:25 下午 com.hingyun.bufferdemo.UseBuffer markTest
信息: position=3
三月 25, 2023 4:33:25 下午 com.hingyun.bufferdemo.UseBuffer markTest
信息: limit=5

Clear 清空缓存区

/**  
 * @author: Ten  
 * @date: 2023/3/25 13:44  
 */
public void clearTest(){  
    //调用之前的读取方法  
    getTest();  
    //将缓存区清空  
    intBuffer.clear();  
    logger.info("-------after clear-------");  
    logger.info("capacity=" + intBuffer.capacity());  
    logger.info("position=" + intBuffer.position());  
    logger.info("limit=" + intBuffer.limit());  
  
    //写入buffer  
    for (int i = 0; i < 5; i++) {  
        intBuffer.put(i);  
    }  
    logger.info("-------after put-------");  
    logger.info("capacity=" + intBuffer.capacity());  
    logger.info("position=" + intBuffer.position());  
    logger.info("limit=" + intBuffer.limit());  
  
}

日志输出：

三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: i=0
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: i=1
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: -------after get 1-------
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: capacity=20
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: position=2
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: limit=5
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: -------从缓冲区读三个元素-------
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: i=2
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: i=3
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: i=4
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: -------after get 2-------
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: capacity=20
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: position=5
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer getTest
信息: limit=5
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer clearTest
信息: -------after clear-------
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer clearTest
信息: capacity=20
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer clearTest
信息: position=0
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer clearTest
信息: limit=20
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer clearTest
信息: -------after put-------
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer clearTest
信息: capacity=20
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer clearTest
信息: position=5
三月 25, 2023 4:53:28 下午 com.hingyun.bufferdemo.UseBuffer clearTest
信息: limit=20

日志有一点长，不太适合阅读。总的来说 clear 方法的调用会让 position 值归零，limit = capacity，mark 值清空。
Clear 源码：

public final Buffer clear() {  
    position = 0;  
    limit = capacity;  
    mark = -1;  
    return this;  
}

小结

使用 Java NIO buffer 的基本步骤：

使用 allocate 创建子类实例
调用 put 向缓冲区写入数据
写入完成后，在读取之前调用 flip 方法将缓冲区转换为读取模式
调用 get 方法从缓冲区读取数据
读取完成后使用 clear 或者 compact 方法将缓冲区转换成写入模式

重要属性

注意：Buffer 类是一个非线程安全类

Buffer 类

前七种类型包含了 about_Java 所有能在 IO 中传输的基本数据类型，Boolean 类型无法传输。第八种 MappedByteBuffer 是专门用于内存映射的 ByteBuffer 类型。

Buffer 类的重要属性

Capacity

Position

在写入模式下 Position 的变化规则：

在刚进入写模式下 position 值为 0，表示当前写入位置从头开始。
每有一个数据写入 Buffer 中 position 就会向后移动一个可写位置，也就是 +1
当 position=limit 时，缓冲区就已经无空间可写。

在读模式下 Position 的变化规则：

当缓冲区进入读模式时，position 会重置为 0，意味着从头开始读取
当从缓冲区读取时，也是从 position 的位置开始读，在读取数据后 position 会移动到下一个可读的位置。
Position 最大的值为最大可读上限 limit，当 position=limit 时代表缓冲区已经没有数据可读了。

Limiti

Mark

这时一个比较简单的属性，它的作用主要是记录当前 position 的值，以备需要时调用 reset 方法将 mark 值恢复到 position 中。

Java的List接口

2023-05-21T00:42:00.000Z

[!info]
List 是 Collection 的子接口，用来存储有序的数据集合。
List 可以存放重复的元素。

Java的LinkedList

2023-05-21T00:42:00.000Z

[!info]
LinkedList 是 Java 中实现 List 和 Deque 接口的双向链表，它可以用来存储任意类型的对象，支持快速插入和删除操作，但是访问元素的效率比较低。

以下是 LinkedList 的一些特点：

底层实现是双向链表，支持快速插入和删除操作，时间复杂度为 O (1)。
不支持随机访问，只能通过迭代器或者遍历链表来访问元素，时间复杂度为 O (n)。
可以存储任意类型的对象，包括基本类型的包装类。
允许插入 null 元素。
不是线程安全的，如果多个线程同时操作同一个 LinkedList 对象，可能会出现并发问题。
可以用作栈、队列或双端队列等数据结构。
支持动态添加和删除元素，但是删除元素时不会导致其他元素的移动，时间复杂度为 O (1)。

[!tip]
由于 LinkedList 的底层实现是双向链表，所以它的插入和删除操作比较快，特别是在链表的中间位置进行操作时，只需要修改前后节点的指针即可。但是访问元素的效率比较低，因为需要遍历整个链表才能找到目标元素。因此，在需要频繁进行访问操作的情况下，建议使用 ArrayList 等其他数据结构来代替 LinkedList。

Java的ArrayList

2023-05-21T00:42:00.000Z

[!info]
ArrayList 是 Java 中实现 List接口的动态数组，它可以自动扩容，支持快速随机访问和迭代，是 Java 集合框架中最常用的类之一。

特点

底层实现是数组，支持随机访问，时间复杂度为 O(1)。
可以自动扩容，当数组容量不足时会自动增加容量。
允许插入 null 元素。
不是线程安全的，如果多个线程同时操作同一个 ArrayList 对象，可能会出现并发问题。
可以存储任意类型的对象，包括基本类型的包装类。
可以通过索引访问元素，也可以通过迭代器遍历元素。
支持动态添加和删除元素，但是删除元素时会导致数组元素的移动，时间复杂度为 O(n)。

[!tip]
由于 ArrayList 的底层实现是数组，所以它的查询和修改操作比较快，但是插入和删除操作比较慢，特别是在数组的中间位置进行操作时，需要移动大量元素。因此，在需要频繁进行插入和删除操作的情况下，建议使用 LinkedList 等其他数据结构来代替 ArrayList。

Java 的 Collection 接口

2023-05-21T00:42:00.000Z

[!info]
Java 的 Collection 接口是 Java 集合框架中的一个基础接口，它定义了一组操作集合元素的通用方法，包括添加、删除、遍历、查找等。在 Java 中，数组是最基本的数据结构，而 Collection 接口则是对数组的一种抽象，提供了更加丰富的操作方式和更好的性能。

Collection 接口主要定义了以下几个方法：

Add (Object obj)：向集合中添加一个元素。
Remove (Object obj)：从集合中移除一个元素。
Contains (Object obj)：判断集合中是否包含指定的元素。
IsEmpty ()：判断集合是否为空。
Size ()：返回集合中元素的个数。
Iterator ()：返回一个迭代器，用于遍历集合中的元素。
ToArray ()：将集合转换为数组。

Collection 接口还有两个重要的子接口，分别是 List 和 Set 接口。List 接口表示一个有序的集合，可以包含重复元素；Set 接口表示一个无序的集合，不允许包含重复元素。这两个接口都继承了 Collection 接口，并且提供了一些额外的方法来支持它们自己特有的功能。

Java 集合框架中还有一些其他的接口和类，如 Map 接口、Queue 接口、Stack 类等，它们都是在 Collection 接口的基础上进行扩展的。这些接口和类提供了更加丰富的数据结构和操作方法，可以满足不同场景下的需求。

code-20230420121048

2023-07-02T03:21:50Z

Bean 实例化过程中的 addSingletonFactory()方法代码

//1. 初始化Bean，通过构造函数创建Bean 
instanceWrapper = createBeanInstance(beanName, mbd, args); 
//针对循环依赖问题暴露单例工厂类 
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); 
//2. 初始化Bean实例，完成Bean实例的完整创建 
populateBean(beanName, mbd, instanceWrapper);

code-20230420115040

2023-07-02T03:21:50Z

获取 Bean 的 getSingleton()方法代码

protected Object getSingleton(String beanName, boolean allowEarlyReference) {  
    //首先从一级缓存singletonObjects中获取  
    Object singletonObject = this.singletonObjects.get(beanName);  
    //如果获取不到,就从二级缓存earlySingletonObjects中获取   
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {  
        synchronized (this.singletonObjects) {  
            singletonObject = this.earlySingletonObjects.get(beanName);  
            //如果还是获取不到,就从三级缓存singletonFactory中获取  
            if (singletonObject == null && allowEarlyReference) {  
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);  
                if (singletonFactory != null) {  
                    singletonObject = singletonFactory.getObject();  
                    //一旦获取成功,就把对象从第三级缓存移动到第二级缓存中   
this.earlySingletonObjects.put(beanName, singletonObject);  
                    this.singletonFactories.remove(beanName);  
                }  
            }  
  
        }  
    }  
    return singletonObject;  
}

code-20230420113646

2023-07-02T03:21:50Z

DefaultSingletonBeanRegistry中的三级缓存Map定义代码

/** 单例对象的缓存: bean name --> bean instance */ 
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); 
/** 单例对象工厂的缓存: bean name --> ObjectFactory */ 
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16); 
/** 提前暴露的单例对象的缓存: bean name --> bean instance */ 
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

20230329114605

2023-07-02T03:21:50Z

熊卡录播bot命令

熊卡录播 bot 国内 docker 镜像启动配置

 sudo docker run -d --restart=always --name auto-bilibili-recorder -v /root/lb/videos:/storage ghcr.dockerproxy.com/valkjsaaa/auto-bilibili-recorder:master

删除容器

 sudo docker rm -f auto-bilibili-recorder

公共站镜像

sudo docker run -d --restart=always --name biliup -v /root/lb/biliup:/opt -d ghcr.io/biliup/caution:master

20230329114121

2023-06-06T20:41:00.000Z

accounts:
  
  defeault_bot:                                     # 录播账号 ID 用来在房间里对应
  
    name: bot                             # 录播账号的名字，可以用于模版
  
    # sessdata 和 bili_jct 获取见：https://bili.moyu.moe/#/get-credential
  
    sessdata: ""                        # SESSDATA cookie
  
    bili_jct: ""                         # bili_jct cookie
  
rooms:
  
  - id: 22637644                                   # 需要上传的直播间 ID，请填写完整号码，而不是短号，否则可能不会上传
  
    uploader: defeault_bot                           # 上传所应使用的账号 ID
  
    tags: "录播,直播录屏,申䒕雅_小雅Official,申䒕雅"              # 上传视频所使用的 tag
  
    channel_id: 21                               # 上传视频所用的分区 ID，参考：https://github.com/greats3an/bilibili-toolman#分区表
  
    title: 【$name】$yy年$mm月$dd日 $title         # 视频标题，可以使用模版
  
    source: "https://live.bilibili.com/22637644"      # 转载来源，建议填写直播间短号（如果有的话）链接
  
    description: >-                              # 视频描述，可以使用模版
  
      BB空间：https://space.bilibili.com/2138676495 \n
  
      录播文件：https://sxy.gachi.cn/
  
      感谢：\n
  
      录播脚本来自：https://github.com/valkjsaaa/auto-bilibili-recorder

20230329

2023-07-02T03:21:50Z

version: '3.1'

services:

    danmuji: # 变更命名

    image: zzcabc/danmuji

    container_name: danmuji # 变更容器名

    restart: always

    privileged: true

    environment:

      TZ: Asia/Shanghai

      JAVA_OPTS: "-Xms64m -Xmx128m"

    build:

      context: .

      dockerfile: Dockerfile

    ports:

      - "23333:23333" # 变更端口

    volumes:

      - ./Danmuji_log:/danmuji/Danmuji_log

      - ./guardFile:/danmuji/guardFile

      - ./log:/danmuji/log

    logging:

      driver: json-file

      options:

        max-size: "1m"

        max-file: "2"

20230328174338

2023-07-02T03:21:50Z

写入FileChannel通道代码示例

//如果buf刚写完数据，需要flip翻转buf，使其变成读取模式         
buf.flip();         
int outlength = 0;         
//调用write方法，将buf的数据写入通道         
while ((outlength = outchannel.write(buf)) ! = 0) {                 System.out.println("写入的字节数：" + outlength);         
}

20230328172812

2023-07-02T03:21:50Z

从FileChannel中读取数据代码示例

RandomAccessFileaFile = new RandomAccessFile(fileName, "rw");
//获取通道 
FileChannelinChannel=aFile.getChannel(); 
//获取一个字节缓冲区 
ByteBufferbuf = ByteBuffer.allocate(CAPACITY); 
int length = -1; 
//调用通道的read方法，读取数据并买入字节类型的缓冲区 
while ((length = inChannel.read(buf)) ! = -1) { 
//省略……处理读取到的buf中的数据 
}

1680087190

2023-07-02T03:21:50Z

SocketChannel客户端获取通道示例

              //获得一个套接字传输通道
        SocketChannel socketChannel = SocketChannel.open();
             //设置为非阻塞模式
        socketChannel.configureBlocking(false);
              //对服务器的IP和端口发起连接
        socketChannel.connect(new InetSocketAddress("127.0.0.1",80));

		while(! socketChannel.finishConnect() ){ 
		//不断地自旋、等待，或者做一些其他的事情…… 
		}

布隆过滤器

2023-05-21T00:37:00.000Z

参考:

43-Redis 缓存击穿（失效）、缓存穿透、缓存雪崩怎么解决？-51CTO_COM@annote#^sran-1678436330215

布隆过滤器是一种过滤算法，首先分配一块内存空间做 bit 数组，数组的 bit 位初始值全部设为 0.

加入元素时，采用 k 个互相独立的 Hash 函数计算，然后将元素 Hash 映射的 K 个位置全部设置为 1

检查 key 是否存在，仍然用这 k 个 Hash 函数计算出 k 个位置，如果全部设置为 1，则表明 key 存在，否则不存在。

Redis的缓存雪崩

2023-05-21T00:37:00.000Z

参考：

RssRead/【Redis】Redis面试题详解与使用案例（金三银四面试专栏启动）
43-Redis 缓存击穿（失效）、缓存穿透、缓存雪崩怎么解决？-51CTO_COM@annote#^sran-1678436358693

造成缓存雪崩的原因

大量的数据同时过期导致本来应该请求缓存对的数据打到了数据库上导致数据库宕机

解决方案：

给缓存设置随机过期时间，过期时间=base 过期时间 + 随机过期时间 (随机过期时间应该在一个小时间范围内，如 1~5 分钟，这样既保证了在相近时间过期，也能防止热点数据大面积过期)
添加互斥锁，构建缓存后释放锁，如果缓存中不存在该数据则返回空值或者默认值
采用双 key 策略，主 key 是原始缓存，备 key 是副本缓存。当主 key 访问失败时访问备 key
使用定时任务或者消息队列类更新或者删除 Redis 里的缓存
接口限流

Redis 故障，无法处理请求

解决方案：

服务熔断或者请求限流
使用主从节点来构建集群 Redis集群

Redis的缓存穿透

2023-05-21T00:37:00.000Z

参考:

RssRead/【Redis】Redis面试题详解与使用案例（金三银四面试专栏启动）#^d302df
43-Redis 缓存击穿（失效）、缓存穿透、缓存雪崩怎么解决？-51CTO_COM@annote#^sran-1678436321160

缓存穿透是指在缓存和数据库中都不存在的数据被不断发起请求。这时的用户就很有可能是攻击者了，这种请求有可能会导致数据库压力过大

缓存请求一般发生在缓存和数据库中的数据被错误删除导致都没有数据，或者是恶意攻击故意访问大量不存在的数据

解决方案

对非法请求进行限制，比如在接收参数的时候过滤业务接口中的非法值、空值、负值
布隆过滤器：一种类似哈希表的算法。它使用所有可能的查询条件来生成位图，这个位图将用于在数据库查询之前进行过滤。如果数据不存在则这个查询就会被直接过滤掉，减轻数据库的压力
缓存空值：在第一次查询不存在的数据后，会对对应的 key 生成一个空的 value ，然后设置一个比较短的过期时间

Redis的缓存击穿

2023-05-21T00:37:00.000Z

参考：

43-Redis 缓存击穿（失效）、缓存穿透、缓存雪崩怎么解决？-51CTO_COM\@annote#^sran-1678435861304
Redis 缓存击穿（失效）、缓存穿透、缓存雪崩怎么解决？-51CTO.COM

Redis 的缓存击穿是指缓存中没有数据，但是数据库中有数据。一般发生在热点数据过期后，同时又有大量的并发访问该数据，就只能去数据库中查询，大量的请求打到数据库上导致数据库崩溃

解决方案

过期时间设置随机过期时间，过期时间=base 时间 + 随机过期时间。在基础过期时间上加上随机过去时间，就是在未来一段时间缓慢过期，然后避免大量数据同时过期，造成数据库压力过大。
设置一个缓存预热，然后就是提前把热点数据存入 Redis，然后避免瞬时数据库压力过大。
在发现缓存数据不存在，不直接去读取数据库，而是先获取一个锁，如果没有拿到锁就等待其他线程将数据刷入 Redis。

Redis的数据结构

2023-05-21T00:37:00.000Z

Redis 有五种数据结构，分别为 String、Hash、List、Set、Zset

String（字符串）

String 可以存储字符串、整数、二进制数据，是最常用的一种类型

Hash（哈希）

Key-value 集合，可以存储多个字段和值

List (有序的字符串列表)

一个有序的字符串列表，可以在列表的任意一端推入或者弹出元素

Set（无序集合）

可以添加、查找、删除元素

Zset（带权重的集合）

Zset 的每一个元素都会关联一个 score 值，用来表示每个成员的权重排序，这使得 zset 可以用来实现排行榜等需求，可以使用 zrank 和 zrerank 来获取排序

Redis的持久化机制

2023-05-21T00:37:00.000Z

Redis 提供两种持久化机制：RDB（Redis Data Base）、AOF（Append Only File）

Redis 的 RDB 机制

RDB 是将数据库以二进制的方式在指定时间间隔中进行快照备份，将内存中的数据写入硬盘上的 RDB 文件中。
优点：快速而且节省时间
缺点：在备份时间内宕机会造成数据丢失

Redis 的 AOF 持久化机制

AOF 是将数据库的所有写操作以追加的方式记录到一个文件中，以便在重启时重新执行这些操作。
优点：可以更加精确的数据恢复
缺点：相比于 RDB 性能损耗更大

Redis事务机制

2023-05-21T00:37:00.000Z

概念

[!info]
Redis 事务的本质是一组命令的集合，在事务的执行过程中所有的命令都会被序列化并按照顺序串行执行队列中的命令，由其他客户端提交的命令不会插入到事务执行的命令序列中。

[!info]
Redis 的事务具有一次性、顺序性、排他性，但是没有隔离级别的概念。批量操作在发送 EXEC 命令前被放入队列缓存，并不会被实际执行，也就不存在事务内的查询要看到事务里的更新，事务外查询不能看到。

[!info]
Redis 的命令执行是原子性执行但是 Redis 事务不保证原子性，并且没有回滚。事务中任意命令执行失败，其余的命令仍会被执行。

Redis 事务的三个阶段

开始事务
命令入队
执行事务

Redis 事务相关命令

watch key1 key2 … : 监视一或多个 key,如果在事务执行之前，被监视的 key 被其他命令改动，则事务被打断（类似乐观锁）
multi : 标记一个事务块的开始（ queued ）
exec : 执行所有事务块的命令（一旦执行 exec 后，之前加的监控锁都会被取消掉）
discard : 取消事务，放弃事务块中的所有命令
unwatch : 取消 watch 对所有 key 的监控

Redis中的热key处理

2023-05-21T00:37:00.000Z

对热 key 进行分散处理。比如：在 key 上加上不同的前后缀，缓存多个 key，使得各个 key 分散到不同的节点上。
采用多级缓存。

Redis

2023-05-21T00:37:00.000Z

Redis Overview

Redis 是一个高性能、基于键值对的 NoSQL 数据库，它支持多种数据类型，包括字符串、哈希、列表、集合和有序集合等。Redis 主要特点包括：

非阻塞的异步 IO 模型，能够处理数百万的并发请求；
数据库存放在内存中，提供一定程度的容错和持久化；
提供类似于事务的功能，能够保证一系列操作的原子性；
提供发布/订阅模式，支持消息传递和通知机制；
提供丰富的数据结构，可以实现复杂的计算和数据处理。
Redis 的 AOF持久化机制: -
Redis 的 RDB 机制: -
Redis 的过期策略: -
Redis 的淘汰策略: -
Redis 的过期策略：定期删除: -
Redis: -
Redis 的过期策略：惰性删除: -
Redis 集群: -
Redis事务机制: -
Redis的缓存击穿: -
Redis中的热key处理: -
Redis的缓存穿透: -
Redis的持久化机制: -
布隆过滤器: -
Redis的缓存雪崩: -
Redis的数据结构: -

Redis 的过期策略：惰性删除

2023-05-21T00:37:00.000Z

当客户端发起请求时会检查是否过期，如果过期了就会删除该数据。避免了频繁的删除操作造成的性能损耗，但是也无法保证删除时间的精度

Redis 的过期策略：定期删除

2023-05-21T00:37:00.000Z

Redis 每过一段时间就会遍历所有数据，删除过期键值对

Redis 的过期策略

2023-05-21T00:37:00.000Z

Redis 的过期策略主要分为定期删除和惰性删除

Redis 的过期策略：定期删除

Redis 每过一段时间就会遍历所有数据，删除过期键值对

Redis 的过期策略：惰性删除

当客户端发起请求时会检查是否过期，如果过期了就会删除该数据。避免了频繁的删除操作造成的性能损耗，但是也无法保证删除时间的精度

Redis 的淘汰策略

2023-05-21T00:37:00.000Z

[!info]
Redis 的内存淘汰策略是指在 Redis 的用于缓存的内存不足时，怎么处理需要新写入且需要申请额外空间的数据。

[! Warning]
Redis 的内存淘汰策略不等于 Redis 的过期策略

Redis 的内存淘汰策略

no-eviction：当内存不足以容纳新写入数据时，新写入操作会报错。

allkeys-lru：当内存不足以容纳新写入数据时，在键空间中，移除最近最少使用的 key。

allkeys-random：当内存不足以容纳新写入数据时，在键空间中，随机移除某个 key。

volatile-lru：当内存不足以容纳新写入数据时，在设置了过期时间的键空间中，移除最近最少使用的 key。

volatile-random：当内存不足以容纳新写入数据时，在设置了过期时间的键空间中，随机移除某个 key。

volatile-ttl：当内存不足以容纳新写入数据时，在设置了过期时间的键空间中，有更早过期时间的 key 优先移除。

Redis 的 RDB 机制

2023-05-21T00:37:00.000Z

Redis 的 AOF持久化机制

2023-05-21T00:37:00.000Z

Netty的零拷贝

2023-05-21T00:35:00.000Z

[!info]
Netty 层面，零拷贝主要体现在对于数据操作的优化。

[!note] 使用 CompositeByteBuf 实现零拷贝
使用 Netty 提供的 CompositeByteBuf 类可以将多个 ByteBuf 合并为一个逻辑上的 ByteBuf，避免了各个 ByteBuf 之间的拷贝

[!note] slice 操作
使用 slice 操作将 ByteBuf 分解为共享一个区域的多个 ByteBuf，避免了内存拷贝。

[!note] FileRegion
通过 FileRegion 包装的 FileChannel.tranferTo 实现文件传输, 可以直接将文件缓冲区的数据发送到目标 Channel,避免了传统通过循环 write 方式导致的内存拷贝问题。

Netty的EventLoop组件

2023-05-21T00:35:00.000Z

主要功能

注册和移除 Channel 的读、写事件
轮询出感兴趣的 IO 事件
将 IO 事件分发给 ChannelHandler 进行处理

[!tip]
一个 EventLoop 在它的生命周期内只和一个 Thread 绑定,这样可以保证 ChannelHandler 的处理逻辑在同一个 Thread 中执行。

原理

EventLoop 包含一个事件循环,它会不断进行事件轮询,看是否有感兴趣的 IO 事件发生。
EventLoop 包含一个 [基础知识/操作系统/线程|线程],这个线程执行所有的 IO 事件和事件处理逻辑。一个 EventLoop 绑定一个线程,这样可以保证一个 Channel 的 IO 事件和业务逻辑处理始终在同一个线程中执行。
EventLoop 中维护一个 Selector(NIO 实现) 或者 EpollSelector(Epoll 实现),用于轮询 IO 事件。当有感兴趣的 IO 事件发生时,会将对应的 Channel 返回。
EventLoop 中维护一个 Channel 集合,这些 Channel 都绑定到该 EventLoop 上,EventLoop 负责处理这些 Channel 上的 IO 事件。
当 EventLoop 的 Selector/EpollSelector 轮询出有 IO 事件发生的 Channel 时,会将这个 Channel 和对应的 IO 事件 (CONNECT、READ、WRITE 等) 分发给 ChannelPipeline 进行处理。
事件处理完成后,如果 Channel 还对某些 IO 事件感兴趣,则会将 Channel 再次注册到 Selector/EpollSelector 上。

Netty的Channel组件

2023-05-21T00:35:00.000Z

[!info]
在 Netty 中通道是核心概念之一，由通道负责进行网络通信，它既可以对对端写入数据，也可以从对端读取数据

Netty的执行流程

2023-05-21T00:35:00.000Z

创建 ServerBootStrap 实例
设置并绑定 Reactor 线程池：EventLoopGroup，EventLoop 就是处理所有注册到本线程的 Selector 上面的 Channel
设置并绑定服务端的 channel
创建处理网络事件的 ChannelPipeline 和 handler，网络时间以流的形式在其中流转，handler 完成多数的功能定制：比如编解码 SSl 安全认证
绑定并启动监听端口
当轮训到准备就绪的 channel 后，由 Reactor 线程：NioEventLoop 执行 pipline 中的方法，最终调度并执行 channelHandler

Netty的应用场景

2023-05-21T00:35:00.000Z

[!info]
Netty 主要应用于网络通信场景，作为一款 RPC 框架的网络通信工具可以使用 Netty 调用服务节点，也可以使用 Netty 制作一款即时通讯系统。

Netty

2023-05-21T00:37:00.000Z

Netty Overview

[!info]
Netty 是一个基于 NIO 的 client-server(客户端服务器) 框架，使用它可以快速简单地开发网络应用程序。
它极大地简化并优化了 TCP 和 UDP 套接字服务器等网络编程,并且性能以及安全性等很多方面甚至都要更好。
支持多种协议如 FTP，SMTP，HTTP 以及各种二进制和基于文本的传统协议。

本文件夹中总共有8 个文件

标签 3个

已发布笔记

File	tags	created	别名
Netty的EventLoop组件	-	2023-05-18 16:42	EventLoop
Netty的执行流程	Netty	2023-04-23 15:49	-
Netty的Channel组件	Netty, todo	2023-04-23 15:37	Channel
Netty 的心跳机制	Netty	2023-04-23 15:13	-
Netty的零拷贝	Netty	2023-04-23 15:01	-
Netty的应用场景	Netty	2023-04-23 14:52	-
Netty	index	2023-04-02 15:23	Netty-index

Netty 的心跳机制

2023-05-21T00:35:00.000Z

[!info]
Netty 通过 IdleStateHandler 实现心跳机制

Netty 支持的心跳类型

readerIdleTime：读超时时间（即测试端一定时间内未接受到被测试端消息）。
writerIdleTime：写超时时间（即测试端一定时间内向被测试端发送消息）。
allIdleTime：所有类型的超时时间。

Welcom

2023-05-21T21:32:00.000Z

欢迎来到我的数字花园

[!info]
建立这个数字花园的目的主要是督促自己平时要努力学习，人在有动力支撑的情况下才会去认真对待某件事，希望能看到本站的朋友也可以和我共同进步。当然有兴趣的朋友也可以关注一下我的微信公众号码世纪

File	别名	tags	创建时间	更新时间
如何在线变更有限责任公司登记	-	公司	2023-06-28 10:57	2023-07-02 11:15
01-利用滴答清单与Notion形成高效的工作流	-	Notion 滴答清单教程工作流	2023-06-07 08:36	2023-06-09 20:20
20230329114121	熊卡录播 bot 配置文件	-	2023-03-29 11:41	2023-06-06 20:41
线程	-	操作系统	2023-04-23 14:34	2023-05-27 11:55
Brotato元素模组暗杀星	-	游戏	2023-05-25 21:25	2023-05-25 21:33
发布方案	-	obsidian	2023-03-27 14:32	2023-05-24 23:36
Digital Garden已经支持中文搜索了	-	obsidian	2023-05-24 23:08	2023-05-24 23:22
Digital Garden国内访问大框问题	-	obsidian	2023-05-02 22:21	2023-05-24 22:17
知觉对比	-	心理	2023-05-23 21:02	2023-05-23 21:04
固定行为模式	-	心理	2023-05-23 20:28	2023-05-23 21:00

导航目录

总共有423 个文件

标签 52个

File	别名	tags	路径
Others	-	index	Others
Redis	-	index, 数据库, Redis	WorkNotes/Redis
Netty	Netty-index	index	WorkNotes/Netty
Java	-	index	基础知识/Java
Spring	Spring-index	-	基础知识/Spring
设计模式	设计模式-index	设计模式, index	基础知识/设计模式
读书笔记	读书笔记-index	index	读书笔记
游戏	游戏-index	index	生活日常/游戏
obsidian	-	index	软件使用/obsidian

本站子域

站名	简介	域名
故事机	用于存放我的不成熟故事	todo
雅憨憨的录播鸡	用于存放申䒕雅的录播提供粉丝二创	sxy.gachi.cn

关于我对阅读和写作的看法

[!tip]

我认为阅读是一个知识的累计过程，就像仓库一样，阅读的时候就是往仓库里搬东西，记笔记就是为物品添加标签和注解。但是这只是在仓库堆砌物品而已，我们只是知道有这么回事，但是却没办法去描述这个物品的详细特征，所以我们需要剖析理解这个事物，而写作正好可以帮助我们去内化阅读所得来的知识，这也是我创建网站的一个原因。

关于申䒕雅的录播机方案

2023-05-21T00:38:00.000Z

BiliUp

Cos-intn 的上传线路失效后就没什么优势了，之前走 cos 上传速度非常的快

20230329

熊卡录播 Bot

GitHub - valkjsaaa/auto-bilibili-recorder: Automatically record, burn danmaku, and transcode Bilibili live streams

熊卡录播bot命令

author: Ten
aliases: [熊卡录播bot命令]
tags: []
dg-publish: true
folder-index: false
created: 2023-03-29 11:46

熊卡录播bot命令

熊卡录播 bot 国内 docker 镜像启动配置

 sudo docker run -d --restart=always --name auto-bilibili-recorder -v /root/lb/videos:/storage ghcr.dockerproxy.com/valkjsaaa/auto-bilibili-recorder:master

删除容器

 sudo docker rm -f auto-bilibili-recorder

公共站镜像

sudo docker run -d --restart=always --name biliup -v /root/lb/biliup:/opt -d ghcr.io/biliup/caution:master

熊卡录播 bot 配置文件

如何在线变更有限责任公司登记

2023-07-02T11:15:00.000Z

最近朋友的公司因为和合伙人在运营上有一点分歧需要变更公司监事，我也正好趁着这个机会一起了解了一下如何线上变更公司信息。

现在企业信息变更已经全程电子化了不再需要去到市政中心填写一大堆表格和排队了，但是线上操作的入口可能是在开发时没有规划好还存在着一些大大小小的问题。比如我们这次就是入口始终定向不到正确的页面中去，可能是正巧碰到了系统升级？直到有一次碰了运气才进到了信息变更的页面中。

因为我朋友的公司是在湖南注册的，所以本篇文章主要适用于湖南地区的同学进行参考。而其他地区的同学也可以当做参考，但是具体操作需要视当地政策而定。

需要准备的材料

法人和相关股东的身份证
相关网址：湖南一件事一次办_湖南省人民政府

变更登记步骤

进入湖南一件事一次办_湖南省人民政府
点击法人服务
进入法人服务后在猜你办选项卡下的企业登记注册一栏中选择“有限 (责任) 公司变更登记”，点击进入
进入有限 (责任) 公司变更登记后点击在线办理
登录即可，这里因为隐私问题就不放演示图了，在站点里有变更指引
将公司信息变更成功后需要将营业执照进行更新，将老的执照和法人身份证等材料带到市政中心变更即可。

写在最后

如果和合伙人存在分歧并且双方都无法达成共识，可能分道扬镳并不是一件坏事。

Others

2023-05-21T00:38:00.000Z

Others Overview

本文件夹中总共有4 个文件

标签 2个

已发布笔记

File	tags	created	别名
如何在线变更有限责任公司登记	公司	2023-06-28 10:57	-
Others	index	2023-03-29 11:27	-
关于申䒕雅的录播机方案	-	2023-03-29 11:27	-

AboutMe

2023-05-21T21:19:00.000Z

感兴趣的同学可以扫码关注我的微信公众号码世纪