绿联DX4600内网穿透方法

发表于 2026-02-26

绿联 DX4600 NAS 支持Docker服务，可惜只能在内网使用，必须掌握内网穿透技术，才能在外网访问Docker提供的服务。下面介绍如何在绿联 DX4600 NAS 配置内网穿透的方法。

基本原理

NAT

NAT 是网络地址转换的缩写。它是一种在网络中广泛使用的技术，主要作用是在数据包通过路由器或防火墙时，修改数据包中的源IP地址或目标IP地址。

NAT主要解决以下问题：

解决 IPv4 地址短缺问题：NAT 允许一个家庭或公司里的所有设备（电脑、手机、平板等）共享同一个公网 IP 地址上网。
安全与隐私（天然的防火墙）：因为外界只能看到 NAT 路由器的公网 IP，无法直接访问到你内网的具体设备。
网络灵活性：你可以在家里随意增加或更换设备，只要它们使用的是私有 IP 地址（如 192.168.0.10）

NAT常见类型主要有三种：

静态 NAT ：一个私有 IP 地址固定映射到一个公网 IP 地址（一对一）
动态 NAT ：多个私有 IP 地址竞争使用一个公网 IP 地址池（多对多）
PAT / NAPT：多对一。让家里所有设备共用路由器上的同一个公网 IP。路由器除了记录 IP 地址，还会记录端口号。当你手机和电脑同时上网时，路由器把它们的请求发出去，但给它们分配不同的源端口。
- 例如：手机请求用的是公网IP:10001，电脑请求用的是公网IP:10002。当数据返回时，路由器根据端口号 10001 或 10002，就知道该把数据转发给手机还是电脑。

内网穿透

内网穿透的核心原理，可以通俗地理解为：让没有公网IP的设备，通过一个有公网IP的中转服务器，和外部设备建立数据通道。

其工作流程分为两步：

第一步：建立隧道（内网设备主动连接服务器）
第二步：数据转发（打给服务器，转给内网）
这个过程就是内网穿透的本质：数据全部经过服务器中转。

进阶版：P2P（点对点）打洞

为了提高速度，更高级的穿透（如P2P模式，即点对点模式）会尝试让两个内网设备直接连接。原理如下：

中介牵线：服务器依然存在，但它只负责“牵线搭桥”，帮双方交换IP和端口信息。
打洞：双方利用UDP协议的特性，互相往对方的公网IP和端口发送数据。虽然一开始会被路由器拒绝，但当双方都发送时，路由器会误以为是之前请求的回复，从而打开一个临时通道。
直连：一旦通道打开，两台设备就可以直接通信了，数据不再经过服务器中转，速度取决于双方各自的宽带。

这就是P2P打洞技术，也是P2P（如BT下载）和视频通话流畅运行的基础。

P2P（点对点）打洞限制

NAT的不同“性格”（类型）直接决定了打洞的成败。主要有以下四种类型：

NAT类型	工作原理	打洞成功率
完全锥型	映射关系建立后，任何外部主机都可以通过这个公网端口访问内网主机。	✅ 最容易
受限锥型	只有内网主机主动发送过数据的外部主机（不限端口），才能通过公网端口向内网发起通信。	✅ 较容易
端口受限锥型	要求更严格，只有内网主机主动发送过数据的特定（IP+端口）组合，才能向内网通信。	✅ 有条件
对称型	最严格。每次内网主机向不同目标主机发起连接，NAT都会重新分配一个新的公网端口，导致无法预测对方的“入口”。	❌ 基本无效

实现方法

使用Docker服务

请参考：

小白也能轻松上手，深度体验绿联私有云DX4600 Docker功能

目前绿联DX4600提供的Docker镜像仓库均无法下载Docker镜像，可修改使用轩辕镜像下载Docker镜像。

使用cpolar服务

使用cpolar提供的免费内网穿透服务，可实现远程登陆绿联 DX4600 进行操作。

DX4600操作系统是基于OpenWrt系统的，因此安装 cpolar 请参考：

OpenWrt路由器上的安装教程

具体步骤如下：

开启绿联 DX4600 调试功能
使用 MobaXterm 远程登陆绿联 DX4600系统
使用如下命令安装 cpolar

# 下载公钥
wget -O cpolar-public.key http://openwrt.cpolar.com/releases/public.key
opkg-key add cpolar-public.key

# 更新包管理器
opkg update

# 安装cpolar插件

opkg install cpolar

用浏览器访问 http://nas_ip:9200 ，创建访问绿联 DX4600的 SSH隧道。注意绿联 DX4600 ssh服务的端口为922。
登录 cpolar官网，注册账号，可以看到创建的 ssh 隧道，后续可以在外网通过该 ssh 隧道远程登录内网的绿联 DX4600。

参考链接

外网SSH远程连接linux服务器「cpolar内网穿透」,by 不会kao代码的小王.
手把手教你：零基础实现绿联NAS外网访问，随时随地访问Docker服务,by 黑衣教主.
NAS探索篇一：绿联DX4600利用DDNS-GO和阿里云免费部署动态解析,by 墨鱼的猪.
原来Docker这么好用，绿联DX4600,Docker上手实际操作体验,by 鼠鼠的鼠.
NAS用户必备！170 多个好玩的，好用的docker容器,by 什么值得买.

Transformers工具使用帮助

发表于 2026-01-24 | 更新于 2026-01-25

Transformers是为 PyTorch 打造的先进的机器学习工具。Transformers 充当跨文本、计算机视觉、音频、视频与多模态的最先进机器学习模型的「模型定义框架」，同时覆盖推理与训练。

它将模型的定义集中化，使整个生态系统对该定义达成一致。transformers 是跨框架的枢纽：一旦某模型定义被支持，它通常就能兼容多数训练框架（如 Axolotl、Unsloth、DeepSpeed、FSDP、PyTorch‑Lightning 等）、推理引擎（如 vLLM、SGLang、TGI 等），以及依赖 transformers 模型定义的相关库（如 llama.cpp、mlx 等）。

基础

pip 下载的包太大，需要清除，可使用如下命令查看：

# 查看 pip 下载包缓存位置
pip cache dir

# 清理所有缓存
pip cache purge

# 查看 pip 安装包位置
pip show package_name

安装

Transformers 支持 Python 3.9+，以及 PyTorch 2.1+。

创建虚拟环境

使用 venv 或 uv（一个基于 Rust 的快速 Python 包与项目管理器）创建并激活虚拟环境：

1
2
3

# venv
python -m venv .my-env
source .my-env/bin/activate

安装 Transformers

在虚拟环境中安装 Transformers：

# pip安装 pytorch gpu 版本
pip install torch==2.4.1 torchvision==0.19.1 torchaudio==2.4.1  --index-url https://download.pytorch.org/whl/cu121
pip install transformers

# pip安装默认 pytorch cpu 版本
pip install torch==2.4.1 torchvision==0.19.1 torchaudio==2.4.1 --index-url https://download.pytorch.org/whl/cpu
pip install transformers

# 方括号 [] 的作用是指定额外的可选依赖包。
pip install "transformers[torch]"

检查PyTorch GPU 版本安装是否成功

import torch
print(torch.__version__)  # 应该显示 2.4.1+cu121
print(torch.cuda.is_available())  # 应该为 True（GPU版本）
print(torch.version.cuda)  # 应该显示 12.1

快速上手

官方示例

使用 Pipeline API 一步上手。Pipeline 是一个高级推理类，支持文本、音频、视觉与多模态任务，负责输入预处理并返回适配的输出。

实例化一个用于文本生成的 pipeline，指定使用的模型。模型会被下载并缓存，方便复用。最后传入文本作为提示：

from transformers import pipeline

pipeline = pipeline(task="text-generation", model="Qwen/Qwen2.5-1.5B")
pipeline("the secret to baking a really good cake is ")

transformers自动下载模型的保存位置：C:\Users\jack.cache\huggingface\hub\，在模型下载以后，可以保存到其他位置。

下载模型

由于某些原因，国内的服务器可能无法直接访问huggingface.co。可以通过配置使用其镜像站。例如:hf-mirror.com。

hf-mirror.com是用于镜像 huggingface.co 域名。作为一个公益项目，致力于帮助国内AI开发者快速、稳定的下载模型、数据集。

下面介绍从 hf-mirror.com 下载大模型的方法：

激活 python 虚拟环境

1	Script\activate

设置环境变量

1 2	set HF_ENDPOINT=https://hf-mirror.com echo %HF_ENDPOINT%

下载大模型

# 下载大模型默认保存位置：C:\Users\jack\.cache\huggingface\hub\
hf download Qwen/Qwen2.5-0.5B

# 自定义大模型保存位置
hf download Qwen/Qwen2.5-0.5B --local-dir ./LLM/Qwen/Qwen2.5-0.5B

下载数据集

1 2	# 自定义数据集保存位置 hf download --repo-type dataset --local-dir DataSet/glue glue

参考链接

Transformers简介,by huggingface.
Transformers,by huggingface.
transformers无法连接huggingface，无法从huggingface下载模型,by Alley cat.
大模型文件从huggingface下载失败的解决办法,by AI8ge8888888.
transformers用pipeline下载的模型路径,by 小怪兽会微笑.
HF Transformers Pipelines,by MKY-门可意.
PyTorch中GPU可用性验证与模型训练加速实践,by comate.
使用huggingface-cli下载模型,by 青蛙小白.
最简单的一文安装Pytorch+CUDA,by crownyouyou.
安装PyTorch 2.4.1+cu121（本机电脑cuda支持12.7）,by 程序改变世界&.
hf-mirror,by hf-mirror.
从模型到前端，你应该知道的LLM生态系统指南,by deephub.
7个用于运行LLM的最佳开源WebUI,by Python编程杰哥.

银河麒麟桌面版V4远程桌面访问方法

发表于 2026-01-13

对于银河麒麟桌面版4.0.2，可使用系统已集成的 vino-server 进行远程桌面访问。具体步骤如下：

打开终端，输入vino-preferences，配置vnc连接密码
使用vncviewer，输入银河麒麟桌面版4.0.2的ip地址，输入vnc连接密码，即可远程访问银河麒麟。

参考链接

银河麒麟桌面操作系统：手把手教你开启VNC远程桌面并修改默认端口,by 码农拿铁.

DDS学习笔记

发表于 2026-01-09 | 更新于 2026-01-11

最近接触到 DDS 中间件，学习一下。

定义

针对实时系统的数据分发服务( DDS )是对象管理组织(OMG)的机器对机器（有时称为中间件或连接框架）标准，旨在通过发布-订阅模式实现可靠、高性能、可互操作、实时、可扩展的数据交换。

DDS 满足航空航天、国防、空中交通管制、自动驾驶车辆、医疗设备、机器人、发电、仿真和测试、智能电网管理、交通运输系统等应用领域的实时数据交换需求。

开源实现

Fast-DDS (原名 Fast RTPS)
Dust DDS
OpenDDS

编译安装

下面从源代码编译安装 Fast-DDS。

安装依赖

使用 vcpkg 安装 Fast-DDS 所需依赖库。

1	vcpkg install openssl asio tinyxml2 fastcdr foonathan-memory --triplet x64-windows

编译安装

在Windows平台编译安装使用 Visual Studio 2019.

foonathan_memory_vendor (可选，当找不到库时)

FastDDS 依赖 Foonathan Memory（内存管理库），通过源代码编译安装：

cd i:\project\Fast-DDS\
git clone https://github.com/eProsima/foonathan_memory_vendor.git
cd foonathan_memory_vendor
mkdir build && cd build
cmake -DCMAKE_INSTALL_PREFIX=i:/install/foonathan_memory_vendor ..
cmake --build . --config Release --target install

FastCDR (可选，当找不到库)

FastDDS 依赖 FastCDR（序列化库），通过源代码编译安装：

cd i:\project\Fast-DDS\
git clone https://github.com/eProsima/Fast-CDR.git
cd Fast-CDR
mkdir build && cd build
cmake -A x64 -DCMAKE_INSTALL_PREFIX=i:/install/fastcdr ..
cmake --build . --config Release --target install

eProsima Fast DDS

当所有依赖库都安装后，开始安装eProsima Fast DDS，打开 VS2019的X64本地命令提示符，按如下步骤输入命令：

cd i:\project\Fast-DDS\
git clone https://github.com/eProsima/Fast-DDS.git
cd Fast-DDS
mkdir build && cd build
cmake -DCMAKE_INSTALL_PREFIX=i:/install/fastdds   ..
cmake --build . --config Release --target install

当执行 cmake -DCMAKE_INSTALL_PREFIX=i:/install/fastdds .. 可能会报找不到 ASIO 的错误，可以编辑 CMakeLists.txt，注释如下代码，再重新运行。

1	eprosima_find_thirdparty(Asio asio VERSION 1.13.0)

当执行 cmake –build . –config Release –target install 可能会报如下错误：

1	警告 C4819 该文件包含不能在当前代码页(936)中表示的字符。请将该文件保存为 Unicode 格式以防止数据丢失

请参考以下链接进行处理，主要是配置C++编译选项 /utf-8：

警告 C4819 该文件包含不能在当前代码页(936)中表示的字符。请将该文件保存为 Unicode 格式以防止数据丢失

fastddsgen

fastddsgen 是 FastDDS 官方提供的 IDL（Interface Definition Language）编译器，用于将 IDL 定义的数据类型转换为 FastDDS 兼容的代码（支持 C++、Python 等语言），自动生成数据序列化 / 反序列化逻辑、类型注册代码等，是 FastDDS 开发的基础工具。

具体安装步骤请参考：

通信中间件 Fast DDS(三) ：fastddsgen的安装与利用

简单示例

Fast-DDS的简单示例请参考：

1.3. Writing a simple C++ publisher and subscriber application

参考链接

Data Distribution Service,by wikipedia.
What is DDS?,by dds.
通信中间件 Fast DDS(一) ：编译、安装和测试,by 流星雨爱编程.
1. Getting Started,by fast-dds.
Fast DDS官方文档机翻之「入门介绍」,by 卢飞腾.
1.3. Writing a simple C++ publisher and subscriber application,by fast-dds.
通信中间件 Fast DDS(三) ：fastddsgen的安装与利用 ,by ycfenxi.
不使用默认路径的 cmake 项目管理,by 怀中落霞.
fastdds在windows下的编译和使用,by 飞羽.
警告 C4819 该文件包含不能在当前代码页(936)中表示的字符。请将该文件保存为 Unicode 格式以防止数据丢失,by 匈牙利认真的小菠萝.

图解大模型读书笔记

发表于 2025-12-24 | 更新于 2026-01-08

阅读书籍《图解大模型：生成式AI原理与实战》,做些笔记。

第一章：大语言模型入门

第二章：词元和嵌入

第三章：图解大语言模型

第四章：文本分类

第五章：文本聚类和主题建模

第六章：提示工程

第七章：高级文本生成技术和工具

第八章：语义搜索和检索增强生成（RAG）

第九章：多模态大语言模型

第十章：创建文本嵌入模型

第十一章：为分类任务微调表示型模型

第十二章：微调生成模型

参考链接

《图解大模型》配套阅读——大模型面试题 200 问,by 李博杰.
Prompt caching: 10x cheaper LLM tokens, but how?,by Sam Rose.

DLL导入库生成的方法

发表于 2025-12-23

当使用隐式链接的方法调用 DLL 中的导出函数时，需要代码的头文件、导入库lib和动态链接库。如何缺失导入库lib，将无法使用隐式链接的方式调用 DLL中的函数。幸运的是，通过一些手段可以从DLL中直接生成导入库lib。

生成导入库流程

步骤如下：

从Dll中生成对应def文件，内容如下：

include '..\implib.inc'

; XYZLIBRARY.??4CXyz@@QAEAAV0@$$QAV0@@Z ord.1
implib XyzLibrary.dll, ??4CXyz@@QAEAAV0@$$QAV0@@Z
; XYZLIBRARY.??4CXyz@@QAEAAV0@ABV0@@Z ord.2
implib XyzLibrary.dll, ??4CXyz@@QAEAAV0@ABV0@@Z
; XYZLIBRARY.?Foo@CXyz@@QAEHH@Z ord.3
implib XyzLibrary.dll, ?Foo@CXyz@@QAEHH@Z
; XYZLIBRARY.GetXyz ord.4
implib XyzLibrary.dll, GetXyz
; XYZLIBRARY._GetXyz@0 ord.5
implib XyzLibrary.dll, _GetXyz@0
; XYZLIBRARY._XyzFoo@8 ord.6
implib XyzLibrary.dll, _XyzFoo@8
; XYZLIBRARY._XyzRelease@4 ord.7
implib XyzLibrary.dll, _XyzRelease@4

endlib

根据def文件生成DLL的导入库lib

自动生成导入库

生成DLL导入库lib的方案有很多，最便利的方法是使用 ImpLib SDK 工具。具体教程如下：

从官网下载最新的 ImpLib SDK 并解压，将 ImpLib SDK 的bin目录添加到系统环境变量 PATH 下。
使用工具dll2def自动生成DLL的def文件

1	\bin\dll2def c:\windows\system32\kernel32.dll kernel32.def

将生成的kernel32.def文件复制到 ImpLib SDK\src\Win32 文件下，然后运行 build_libs.bat，或者运行如下命令：

1	\bin\fasm kernel32.def kernel32.lib

参考链接

DLL导出类和函数,by huangwang.
ImpLib SDK Guide,by implib.

CPlusPlus多线程编程

发表于 2025-12-14 | 更新于 2025-12-15

最近需要使用C++的多线程编写一个处理程序，因此学习记录一下C++多线程的编程知识。

基本概念

多线程（英语：multithreading），是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能。

应用场景

Web服务与服务器:
- Web服务器: Tomcat等处理大量用户请求，每个请求分配一个线程。
- 游戏服务器: 同时处理多个玩家的连接和游戏逻辑。
后台与异步处理:
- 定时任务: 定期发送邮件、数据备份、数据分析。
- 日志记录: 将写日志操作放到后台线程，不阻塞主程序。
- 异步操作: 发送消息、处理图片上传。
桌面应用与用户界面:
- 响应性: 将耗时计算移到后台线程，前台显示进度条，避免UI冻结。
- Swing/JavaFX: 事件处理和耗时操作。
数据处理与计算:
- CPU密集型任务: 图像/视频处理、密码破解、大规模数据分析（利用多核）。
- I/O密集型任务: 并行下载文件、同时读写多个文件/数据库。
网络爬虫:
- 并行抓取: 同时爬取多个网页或API接口，提高效率。
数据库与中间件:
- 连接池管理: 并发管理数据库连接。
- 数据迁移与分析: 分块处理大数据。

编程实现

传统的C++（C++11标准之前）中并没有引入线程这个概念，在C++11出来之前，如果我们想要在C++中实现多线程，需要借助操作系统平台提供的API，比如Linux的<pthread.h>，或者windows下的<windows.h> 。

C++11提供了语言层面上的多线程，包含在头文件中。它解决了跨平台的问题，提供了管理线程、保护共享数据、线程间同步操作、原子操作等类。C++11 新标准中引入了5个头文件来支持多线程编程。

这5个头文件分别是：

thread
mutex
atomic
condition_variable
future

创建线程

创建线程的基本方法如下所示：

# 示例1

std::thread myThread ( thread_fun);
//函数形式为void thread_fun()
myThread.join();
//同一个函数可以代码复用，创建多个线程

# 示例2

std::thread myThread ( thread_fun(100));
myThread.join();
//函数形式为void thread_fun(int x)
//同一个函数可以代码复用，创建多个线程

# 示例3

std::thread (thread_fun,1).detach();
//直接创建线程，没有名字
//函数形式为void thread_fun(int x)

主线程与子线程的处理方法：

detach方式，启动的线程自主在后台运行，当前的代码继续往下执行，不等待新线程结束。
join方式，等待启动的线程完成，才会继续往下执行。

可以使用joinable判断是join模式还是detach模式。

1	if (myThread.joinable()) foo.join();

多线程编程示例

#include <iostream>                // std::cout
#include <thread>                // std::thread
#include <mutex>                // std::mutex, std::unique_lock
#include <condition_variable>    // std::condition_variable

std::mutex mtx; // 全局互斥锁.
std::condition_variable cv; // 全局条件变量.
bool ready = false; // 全局标志位.

void do_print_id(int id)
{
	std::unique_lock <std::mutex> lck(mtx);
	while (!ready) // 如果标志位不为 true, 则等待...
		cv.wait(lck); // 当前线程被阻塞, 当全局标志位变为 true 之后,
	   // 线程被唤醒, 继续往下执行打印线程编号id.
	std::cout << "thread " << id << '\n';
}

void go()
{
	std::unique_lock <std::mutex> lck(mtx);
	ready = true; // 设置全局标志位为 true.
	cv.notify_all(); // 唤醒所有线程.
}

int main()
{
	std::thread threads[10];
	// spawn 10 threads:
	for (int i = 0; i < 10; ++i)
		threads[i] = std::thread(do_print_id, i);

	std::cout << "10 threads ready to race...\n";
	go(); // go!

	for (auto & th : threads)
		th.join();

	return 0;
}

创建线程池

因为程序边运行边创建线程是比较耗时的，所以我们通过池化的思想：在程序开始运行前创建多个线程，这样，程序在运行时，只需要从线程池中拿来用就可以了．大大提高了程序运行效率．一般线程池都会有以下几个部分构成：

线程池管理器（ThreadPoolManager）:用于创建并管理线程池，也就是线程池类
工作线程（WorkThread）: 线程池中线程
任务队列task: 用于存放没有处理的任务。提供一种缓冲机制。
append：用于添加任务的接口

线程池示例

#include <iostream>
#include <vector>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <functional>
#include <future>


class ThreadPool {
public:
    ThreadPool(size_t numThreads) : stop(false) {
        for (size_t i = 0; i < numThreads; ++i) {
            workers.emplace_back([this] {
                while (true) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(queueMutex);
                        condition.wait(lock, [this] { return stop || !tasks.empty(); });
                        if (stop && tasks.empty()) {
                            return;
                        }
                        task = std::move(tasks.front());
                        tasks.pop();
                    }
                    task();
                }
            });
        }
    }

    template<typename F, typename... Args>
    auto enqueue(F&& f, Args&&... args) -> std::future<typename std::result_of<F(Args...)>::type> {
        using return_type = typename std::result_of<F(Args...)>::type;

        auto task = std::make_shared<std::packaged_task<return_type()>>(std::bind(std::forward<F>(f), std::forward<Args>(args)...));

        std::future<return_type> result = task->get_future(); // 返回一个futur对象，result通过result.get()获取线程函数的返回值 如果线程函数没有执行完就会阻塞在result.get()
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            if (stop) {
                throw std::runtime_error("enqueue on stopped ThreadPool");
            }
            tasks.emplace([task]() { (*task)(); }); // Lambda函数是一种可调用对象 Lambda函数的语法为[捕获列表](参数列表) { 函数体 }。
        }
        condition.notify_one();
        return result;
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            stop = true;
        }
        condition.notify_all();
        for (std::thread& worker : workers) {
            worker.join();
        }
    }

private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    std::mutex queueMutex;
    std::condition_variable condition;
    bool stop;
};

// 示例任务函数
int  printHello(int num) {
    std::cout << "Hello from thread " << std::this_thread::get_id() << "! Num: " << num << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));
    return num;
}

int main() {
    ThreadPool pool(4);

    std::vector<std::future<int>> results; 

    // 提交任务到线程池
    std::cout << "Enqueuing tasks..." << std::endl;
    for (int i = 0; i < 8; ++i) {
        results.push_back(pool.enqueue(printHello, i));
    }

    for (int i = 0; i < 8; ++i) {
        int num = results[i].get(); // 获取线程函数的返回值
        std::cout<< "获取到线程函数的返回值：" << num << std::endl;    // 获取线程函数的返回值  
    }

    // 等待任务完成
    std::this_thread::sleep_for(std::chrono::seconds(5));

    return 0;
}

参考链接

c++中的多线程：概念、基本用法、锁以及条件变量和优先级调度策略,by 青山牧云人.
【C++】多线程(thread)使用详解,by OpenC++.
C++多线程详解（全网最全）,by cpp后端技术.
多线程,by wikipedia.
详解 C++ 多线程的condition_variable,by CPP加油站.
C++11之std::future对象使用说明,by Jimmy1224.
C++11实现的简单线程池、模板的使用实例：1.向队列中放待执行函数，2.取出队列中待执行函数,by 好人~.
手把手带你实现std::function，弄懂底层原理,by QZQ54188.
一文读懂C++11的Lambda表达式的原理与使用场景,by linux.
C++ 函数声明(后置返回类型),by CG6316.
【C++11 多线程】future与promise（八）,by fengMisaka.
C++ 中 typename 关键字的完整指南,by 香草美人.
std::future和std::promise详解(原理、应用、源码）,by 孙梓轩.
1. std::result_of是什么？为什么它出现？,by 讳疾忌医_note.
C++之std::queue::emplace,by jzjhome.
c++11多线程之packaged_task＜＞介绍与实例,by 荆楚闲人.
【C++】std::make_shared 详解,by 快起床啊你.
C++11中的std::bind 简单易懂,by 云飞扬_Dylan.
C++编程系列笔记（3）——std::forward与完美转发详解,by 小龙爱学习.

GO语言安装配置

发表于 2025-11-27

最近找了一个 NTP 时间同步工具，使用 GO 语言编写，能够跨平台在 Windows 、 Linux 、 Mac 上运行，挺实用的，但是需要配置 GO 语言环境，于是记录一下过程。

安装

GO 语言环境的安装请参考：

Download and install

配置

加速下载

下载 GO 语言相关模块时可能被墙，需要设置代理加速下载，方法如下：

# 执行下面的指令
go env -w  GOPROXY=https://goproxy.cn,direct
 
# 输出确认一下，找到有 GOPROXY 的这一行，看是否有https://goproxy.cn,direct
go env

参考链接

ntp-timer,by seraphique.
Go设置GOPROXY国内加速,by ShengOasis.

IDEA控制台中文乱码解决方法

发表于 2025-09-27

使用 IDEA 集成开发环境运行 Sprint Boot 应用程序时，控制台中文乱码，参考文章1分钟解决IntelliJ IDEA 控制台中文乱码，统一设置 utf-8，再也不会乱码了中第一种方法解决了中午乱码问题。

参考链接

1分钟解决IntelliJ IDEA 控制台中文乱码，统一设置 utf-8，再也不会乱码了,by 程序员徐师兄.

消息队列学习笔记

发表于 2025-09-26

消息队列是一种常用的软件架构，有必要了解和学习它。

基本知识

定义

消息队列（Message Queue，简称MQ）是一种在计算机系统中用于在不同应用程序或服务之间进行异步通信的中间件技术，它通过一个存储消息的队列作为中间人，允许发送者（生产者）将消息放入队列，接收者（消费者）则在准备好时从队列中取出并处理，从而实现系统解耦、异步处理和流量削峰等目标。消息队列的出现解决了分布式系统中数据丢失、服务故障、处理能力不足以及业务系统间强耦合等问题。

核心概念

生产者（Producer）：负责创建和发送消息到消息队列的应用程序或服务。
消费者（Consumer）：负责从消息队列中接收消息并进行处理的应用程序或服务。
消息（Message）：在应用程序之间传递的数据包，可以是简单的文本或复杂的数据结构。
消息队列（Message Queue）：一个存储消息的容器，它本身是一个队列（先进先出）数据结构。
代理（Broker）：消息队列的核心组件，负责存储消息、确认消息的传递和重试等。

主要作用

系统解耦：生产者和消费者之间不需要直接通信，降低了系统之间的依赖性。
异步通信：消息的发送和接收不需要同时发生，大大提高了系统的吞吐量和响应速度。
削峰填谷：在高并发场景下，消息队列能够缓冲瞬时的大量请求，将高并发的流量“削峰”，让后端系统有足够的时间处理。
流量控制：通过控制消费者对消息的处理速度，可以有效避免后端服务因过载而崩溃。
可靠投递：消息队列能够持久化存储消息，即使接收者暂时不可用，消息也不会丢失，保证了数据的安全。

常见用例

分布式事务：:实现不同服务之间的数据最终一致性。
日志处理：:将日志数据异步地从各个服务发送到集中的日志处理系统。
实时数据处理：:在流处理和大数据场景下，用于数据流的缓冲和转发。

主流技术

RabbitMQ：一个老牌的开源消息队列，功能强大，支持多种消息协议。
Kafka：由LinkedIn开发，以高性能和高吞吐量著称，常用于大数据流式处理场景。
RocketMQ：由阿里巴巴开发，是轻量级的高性能分布式消息中间件。
ActiveMQ：一个由Apache开发的开源消息中间件，支持多种传输协议。

与模型对比

消息队列与发布/订阅的对比

消息队列使用点对点消息传递模式，在该模式中，一个应用程序（称为“发送者”）向队列提交消息，另一个应用程序（称为“接收者”）则从队列中获取并使用消息。发送者和使用者之间存在紧密耦合的一对一关系，并且每条消息只能使用一次。

如果您的应用程序需要将消息分发给多方，则可以组合多个消息队列，或者使用发布/订阅 (pub/sub) 消息传递模型。

在发布/订阅消息传递中，生成消息的应用程序称为发布者，而使用该消息的应用程序称为订阅者。每条消息都会发布到一个主题，订阅该主题的每个应用程序都会获得发布到它的所有消息的副本。

大多数消息传递中间件解决方案都支持消息队列（点对点）和发布/订阅消息模型。

消息队列与消息总线的对比

消息总线是一种企业服务总线 (ESB)，它允许服务随处访问数据，同时确保它们在分布式系统架构中保持解耦和独立运行。当使用消息总线时，所有服务或应用程序必须共用通用数据类型、通用命令集和通用通信协议（尽管它们可能用不同的语言编写）。使用者可以决定如何使用信息。

如果解耦的应用程序要通过消息总线进行通信，则必须转换消息以使其归属于同一类型。相反，消息队列可传输各类消息，无论其类型是否相同。

参考链接

Kafka、ActiveMQ、RabbitMQ、RocketMQ 区别以及高可用原理,by 爱撸猫的杰.
消息队列,by wikipedia.
什么是消息队列？,by ibm.
消息总线和消息队列有何区别？,by kimmking.
企业服务总线,by wikipedia.