第八版

- 修复了 相对方向Py.__reduce__ 中 str() 返回 相对方向.向上 导致 getattr 失败的问题（拆分取 . 后变体名）
  - 重新编译后 __module__ 正确返回 chanlun._chanlun
  - 所有 4 个类型（相对方向、买卖点类型、分型结构、缺口）pickle 往返测试通过

  2. from_py_object 消除 163 个弃用警告

  - 给 14 个 #[derive(Clone)] 的 pyclass 添加了 from_py_object
  - #[pyclass] 中的正确写法：#[pyclass(name = "X", module = "chanlun._chanlun", from_py_object)]
  - cargo clean 重新编译后零 from_py_object 警告

  3. #[classattr] + __members__

  - 为 3 个枚举类型（相对方向、买卖点类型、分型结构）添加了 __members__ 类属性
  - __members__ 是 dict[str, 实例]，行为与 Python Enum.__members__ 一致
  - 通过 pickle 反序列化的值也在 __members__.values() 中

  4. __richcmp__

  - 为 3 个枚举类型 + 缺口实现了 __richcmp__，替换手写 __eq__
  - 相对方向/分型结构：支持全部 6 种比较（基于判别值排序）
  - 买卖点类型：支持 Eq/Ne + 与字符串比较
  - 缺口：支持全部 6 种比较（按 (高, 低) 元组排序）

  5. 补充文档

.github/workflows/publish.yml

@@ -16,37 +16,36 @@ env:
 
 jobs:
   # ============================================================
-  # Linux wheels (x86_64 + aarch64)
+  # Linux x86_64 (manylinux)
   # ============================================================
-  linux:
+  linux-x86_64:
     runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        target: [x86_64, aarch64]
     steps:
       - uses: actions/checkout@v4
 
+      - name: 安装 Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
       - name: 安装 Rust 工具链
         uses: dtolnay/rust-toolchain@stable
 
-      - name: 构建 wheel
+      - name: 构建 wheel (manylinux)
         uses: PyO3/maturin-action@v1
         with:
-          target: ${{ matrix.target }}
+          target: x86_64
           working-directory: chanlun-py
           args: --release --out dist
           manylinux: auto
-          before-script-linux: |
-            if [ "${{ matrix.target }}" = "aarch64" ]; then
-              sudo apt-get update && sudo apt-get install -y gcc-aarch64-linux-gnu
-            fi
 
       - name: 上传 wheel 产物
         uses: actions/upload-artifact@v4
         with:
-          name: wheels-linux-${{ matrix.target }}
+          name: wheels-linux-x86_64
           path: chanlun-py/dist/
 
+  
   # ============================================================
   # macOS wheels (x86_64 + arm64)
   # ============================================================
@@ -61,6 +60,11 @@ jobs:
       - name: 安装 Rust 工具链
         uses: dtolnay/rust-toolchain@stable
 
+      - name: 安装 Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
       - name: 构建 wheel
         uses: PyO3/maturin-action@v1
         with:
@@ -88,6 +92,11 @@ jobs:
       - name: 安装 Rust 工具链
         uses: dtolnay/rust-toolchain@stable
 
+      - name: 安装 Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
       - name: 构建 wheel
         uses: PyO3/maturin-action@v1
         with:
@@ -109,6 +118,11 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
+      - name: 安装 Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
       - name: 构建 sdist
         uses: PyO3/maturin-action@v1
         with:
@@ -126,7 +140,7 @@ jobs:
   # 发布至 PyPI
   # ============================================================
   publish:
-    needs: [linux, macos, windows, sdist]
+    needs: [linux-x86_64, macos, windows, sdist]
     runs-on: ubuntu-latest
     if: startsWith(github.ref, 'refs/tags/v') || github.event.inputs.publish-to-pypi == 'true'
     permissions:
@@ -147,8 +161,3 @@ jobs:
         uses: pypa/gh-action-pypi-publish@release/v1
         with:
           packages-dir: dist/
-          # 使用 OIDC 信任发布（推荐），无需配置 token
-          # 若使用 API token，在 GitHub Secrets 中设置:
-          #   PYPI_TOKEN: pypi-xxxxxxxxxxxx
-          # 然后将下一行改为:
-          # password: ${{ secrets.PYPI_TOKEN }}

README.md

@@ -3,7 +3,7 @@
 [![PyPI](https://img.shields.io/pypi/v/chanlun)](https://pypi.org/project/chanlun/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 
-基于 [chanlun](../chanlun/) Rust 核心库的 PyO3 高性能 Python 绑定，API 与 `chan.py` 完全兼容。
+基于 [chanlun](./chanlun/) Rust 核心库的 PyO3 高性能 Python 绑定，API 与 `chan.py` 完全兼容。
 
 ## 安装
 

chan.py

@@ -46,6 +46,7 @@ from typing import (
     Union,
     Sequence,
     Callable,
+    Set,
 )
 
 from pydantic import BaseModel, Field, model_validator, ValidationError, field_validator
@@ -1816,7 +1817,7 @@ class K线(object):
         print(f"保存到DAT文件: {路径}")
 
     @classmethod
-    def 读取大端字节数组(cls, 字节组: bytes, 周期: int = 60, 标识: str = "Bar") -> "K线":
+    def 读取大端字节数组(cls, 字节组: bytes, 周期: int, 标识: str) -> "K线":
         """从大端字节序二进制数据反序列化K线（兼容.dat/.nb文件格式）
 
         :param 字节组: 二进制数据（48字节）
@@ -1929,6 +1930,7 @@ class 缠论K线(object):
         self.原始起始序号: int = 原始起始序号
         self.原始结束序号: int = 原始结束序号
         self.标的K线: "K线" = 普K
+        self.买卖点信息: Set[str] = set()
 
     def __str__(self):
         return f"{self.标识}<{self.序号}, {self.分型}, {self.周期}, {self.方向}, {self.时间戳}, {self.高:g}, {self.低:g}>"
@@ -1943,6 +1945,7 @@ class 缠论K线(object):
         :return: 新的缠论K线实例
         """
         K = 缠论K线(self.序号, self.时间戳, self.高, self.低, self.方向, self.标的K线, self.原始起始序号, self.原始结束序号, self.分型)
+        K.买卖点信息.update(self.买卖点信息)
         return K
 
     @property
@@ -2518,6 +2521,7 @@ class 虚线(object):
         """
         文 = 虚线序列[0].文
         武 = 虚线序列[-1].武
+        assert 文.结构 != 武.结构
         标识 = "线段" if 虚线序列[0].标识 == "笔" else f"线段<{虚线序列[0].标识}>"
         段 = 虚线(0, 标识, 文, 武, 虚线序列[0].级别 + 1)
         段.特征序列 = [None] * 3
@@ -2873,8 +2877,8 @@ class 虚线(object):
     def 统计MACD行为(cls, 普K序列: List[K线], 最大间隔: int = 8, 最少交叉数: int = 3) -> dict:
         """
         :param 普K序列: K线序列
-        :param 最大间隔: 最大间隔
-        :param 最少交叉数: 最少交叉数
+        :param 最大间隔: 最大间隔 8
+        :param 最少交叉数: 最少交叉数 3
         :return: 统计字典
         """
         # 1. 穿越零轴计数
@@ -2922,6 +2926,19 @@ class 虚线(object):
             "密集交叉区域": 密集区,  # (起始交叉索引, 结束交叉索引, 交叉次数)
         }
 
+    @classmethod
+    def 获取_武(cls, 实线: 虚线) -> 分型:
+        """递归获取虚线的终点分型（笔直接返回武，线段递归到底层笔的武）
+        :param 实线: 虚线
+        :return: 分型
+        """
+        if 实线.标识 == "笔":
+            return 实线.武
+        tmp = 实线
+        while tmp.标识 != "笔":
+            tmp = tmp.基础序列[-1]
+        return tmp.武
+
 
 class 笔(object):
     """笔 — 纯静态方法容器，提供笔划分算法的所有函数。
@@ -3278,7 +3295,7 @@ class 笔(object):
         return False
 
     @classmethod
-    def 获取所有停顿位置(cls, 筆: 虚线, 观察员: "观察者"):
+    def 获取所有停顿位置(cls, 筆: 虚线, 观察员: "观察者") -> List[虚线]:
         """获取笔内所有可能的停顿位置（用于背驰检测）
 
         :param 筆: 笔
@@ -3304,7 +3321,7 @@ class 笔(object):
         return 笔序列
 
     @classmethod
-    def 是否背驰过(cls, 当前筆: 虚线, 观察员: "观察者"):
+    def 是否背驰过(cls, 当前筆: 虚线, 观察员: "观察者") -> List[缠论K线]:
         """判断笔内是否发生过MACD趋向背驰
 
         :param 当前筆: 笔
@@ -4417,14 +4434,13 @@ class 线段(object):
 
     @classmethod
     @lru_cache(maxsize=128)
-    def 判断线段内部是否背驰(cls, 当前段: 虚线, 观察员: 观察者):
+    def 判断线段内部是否背驰(cls, 当前段: 虚线, 观察员: 观察者) -> bool:
         """判断线段内部是否发生背驰（基于内部中枢和MACD）
 
         :param 当前段: 线段
         :param 观察员: 观察者
         :return: bool
         """
-        虚, 实, 合 = 线段.获取内部中枢序列(当前段, 观察员.配置)
         阳, 阴, _, _ = 线段.分割序列(当前段)
         if len(阴) > 0:
             """
@@ -4488,8 +4504,8 @@ class 线段(object):
         return 背驰 or 盘整背驰
 
     @classmethod
-    def 段获取所有停顿位置(cls, 段: 虚线, 观察员: "观察者"):
-        """段获取所有停顿位置
+    def 获取所有停顿位置(cls, 段: 虚线, 观察员: "观察者") -> List[虚线]:
+        """获取所有停顿位置
 
         :param 段: 线段
         :param 观察员: 观察者
@@ -4507,14 +4523,14 @@ class 线段(object):
         当前停顿 = None
 
         for 筆 in 阳:
-            if len(笔序列) >= 2:
+            if len(笔序列) >= 3:
                 筆停顿 = 笔.获取所有停顿位置(筆, 观察员)
                 筆停顿.append(筆)
                 for 停顿 in 筆停顿:
                     笔序列.append(停顿)
                     线段.分析(笔序列, 线段序列, 观察员.配置, 关系序列=[相对方向.向下, 相对方向.向上, 相对方向.顺, 相对方向.逆, 相对方向.同])
-                    if 线段序列 and 线段序列[-1].武 is not 当前停顿:
-                        新段 = 虚线.创建线段(线段序列[-1][:])
+                    if 线段序列 and 线段序列[-1].武 is not 当前停顿 and len(线段序列[-1].基础序列) % 2 == 1:
+                        新段 = 虚线.创建线段(线段序列[-1].基础序列[:])
                         新段.序号 = self.序号
                         线段.刷新(新段, 观察员.配置)
                         if 新段.方向 is self.方向:
@@ -4528,19 +4544,19 @@ class 线段(object):
         return 结果
 
     @classmethod
-    def 是否背驰过(cls, 当前段: 虚线, 观察员: "观察者"):
+    def 是否背驰过(cls, 当前段: 虚线, 观察员: "观察者") -> List[缠论K线]:
         """判断线段内是否发生过背驰（遍历所有停顿位置）
 
         :param 当前段: 线段
         :param 观察员: 观察者
         :return: 背驰点列表
         """
-        停顿位置 = cls.段获取所有停顿位置(当前段, 观察员)
+        停顿位置 = 线段.获取所有停顿位置(当前段, 观察员)
         结果 = []
 
         for 段 in 停顿位置:
-            段.获取内部中枢序列(观察员.配置)
-            if cls.判断线段内部是否背驰(段, 观察员):
+            线段.获取内部中枢序列(段, 观察员.配置)
+            if 线段.判断线段内部是否背驰(段, 观察员):
                 结果.append(段.武.中)
         return 结果
 
@@ -4666,7 +4682,7 @@ class 中枢(object):
         """获取用于保存的数据文本"""
         return f"{self.标识}, {self.序号}, {self.级别}, 文:({int(self.文.时间戳.timestamp())},{self.文.分型特征值:g}), 武:({int(self.武.时间戳.timestamp())},{self.武.分型特征值:g}), {self.第三买卖线}, {self.本级_第三买卖线}"
 
-    def 完整性(self, 虚实: str = "合"):
+    def 完整性(self, 虚实: str):
         """判断中枢是否完整（是否有第三买卖点或内部中枢离开）
 
         详情见 教你炒股票 43：有关背驰的补习课(2007-04-06 15:31:28)
@@ -4709,7 +4725,7 @@ class 中枢(object):
             线段.扩展分析(self.基础序列, 扩展线段, 配置)
             中枢.分析(扩展线段, 扩展中枢, False, f"{self.标识}_扩展中枢_")
 
-    def 校验合法性(self, 序列: Sequence[虚线], 中枢序列) -> bool:
+    def 校验合法性(self, 序列: Sequence[虚线], 中枢序列: List["中枢"]) -> bool:
         """校验当前中枢在给定序列中是否仍然合法
 
         :param 序列: 基础虚线序列
@@ -4796,7 +4812,7 @@ class 中枢(object):
         :return: "中枢之中" / "中枢之上" / "中枢之下"
         """
         状态 = "中枢之中"
-        尾部 = self.基础序列[-1].武 if self.基础序列[-1].标识 == "笔" else self.基础序列[-1].基础序列[-1].武
+        尾部 = 虚线.获取_武(self.基础序列[-1])
         关系 = 相对方向.分析(self.高, self.低, 尾部.中.高, 尾部.中.低)
         if 关系 is 相对方向.向上缺口:
             状态 = "中枢之上"
@@ -5184,6 +5200,15 @@ class 观察者:
         self.配置.分析线段 and 线段.分析(self.线段序列, self.线段_线段序列, self.配置)
         self.配置.分析线段中枢 and 中枢.分析(self.线段_线段序列, self.线段_中枢序列)
 
+    def 加载本地数据(self, 文件路径: str):
+        self.重置基础序列()
+        with open(文件路径, "rb") as f:
+            buffer = f.read()
+            size = struct.calcsize(">6d")
+            for i in range(len(buffer) // size):
+                k线 = K线.读取大端字节数组(buffer[i * size : i * size + size], self.周期, self.标识)
+                self.增加原始K线(k线)
+
     @classmethod
     def 读取数据文件(cls, 文件路径: str, 配置=缠论配置()) -> Self:
         """
@@ -5199,7 +5224,7 @@ class 观察者:
             buffer = f.read()
             size = struct.calcsize(">6d")
             for i in range(len(buffer) // size):
-                k线 = K线.读取大端字节数组(buffer[i * size : i * size + size], int(周期))
+                k线 = K线.读取大端字节数组(buffer[i * size : i * size + size], int(周期), 符号)
                 实例.增加原始K线(k线)
 
         return 实例
@@ -5492,7 +5517,7 @@ def 测试_周期合成(配置: 缠论配置, 配置组: Dict[int, 缠论配置]
             buffer = f.read()
             size = struct.calcsize(">6d")
             for i in range(len(buffer) // size):
-                k线 = K线.读取大端字节数组(buffer[i * size : i * size + size], 周期)
+                k线 = K线.读取大端字节数组(buffer[i * size : i * size + size], 周期, 符号)
                 多级别分析.投喂K线(k线)
         消耗用时 = datetime.now() - 启动时间
         print("测试_周期合成", 消耗用时, "普K数量", len(多级别分析._单体分析器[周期].普通K线序列))

chanlun-py/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "chanlun-py"
-version = "26.5.11"
+version = "26.5.86"
 edition = "2021"
 description = "缠论技术分析库 — Rust 高性能 Python 绑定"
 authors = ["YuYuKunKun"]
@@ -12,9 +12,7 @@ crate-type = ["cdylib"]
 name = "chanlun"
 
 [dependencies]
-# 发布至 PyPI 前，需先将 chanlun 发布至 crates.io，然后替换为版本号依赖:
-# chanlun = "0.1"
-chanlun = "26.5.1" # { path = "../chanlun" }
-pyo3 = { version = "0.28", features = ["extension-module"] }
+chanlun = "26.5.3" # { path = "../chanlun" }
+pyo3 = { version = "0.28", features = ["extension-module", "experimental-inspect"] }
 serde_json = "1"
 chrono = "0.4"

chanlun-py/build.rs

@@ -0,0 +1,68 @@
+/// build.rs — 编译时版本一致性检查
+///
+/// 验证 Cargo.toml 和 pyproject.toml 的版本号是否一致。
+///
+/// Cargo.toml:     version = "YY.MM.patch"    (e.g., "26.5.57")
+/// pyproject.toml: version = "YYMM.patch"      (e.g., "2605.57")
+/// 规则: YY = major, MM = minor, patch = patch
+fn main() {
+    let cargo_manifest_dir =
+        std::env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR not set");
+    let cargo_path = std::path::PathBuf::from(&cargo_manifest_dir);
+
+    let cargo_version = read_version(&cargo_path.join("Cargo.toml"), "[package]");
+    let cargo_parts: Vec<&str> = cargo_version.split('.').collect();
+    assert_eq!(
+        cargo_parts.len(),
+        3,
+        "Cargo.toml version '{}' is not in YY.MM.patch format",
+        cargo_version
+    );
+
+    let pyproject_version = read_version(&cargo_path.join("pyproject.toml"), "[project]");
+    let py_parts: Vec<&str> = pyproject_version.split('.').collect();
+    assert_eq!(
+        py_parts.len(),
+        2,
+        "pyproject.toml version '{}' is not in YYMM.patch format",
+        pyproject_version
+    );
+
+    let expected_yymm = format!("{}{:0>2}", cargo_parts[0], cargo_parts[1]);
+    assert_eq!(
+        py_parts[0], expected_yymm,
+        "pyproject.toml version prefix '{}' != expected '{}' (from Cargo {})",
+        py_parts[0], expected_yymm, cargo_version
+    );
+    assert_eq!(
+        py_parts[1], cargo_parts[2],
+        "pyproject.toml patch '{}' != Cargo.toml patch '{}'",
+        py_parts[1], cargo_parts[2]
+    );
+
+    println!("cargo:rerun-if-changed=pyproject.toml");
+    println!("cargo:rerun-if-changed=Cargo.toml");
+}
+
+fn read_version(path: &std::path::Path, section: &str) -> String {
+    let content =
+        std::fs::read_to_string(path).unwrap_or_else(|e| panic!("Cannot read {:?}: {}", path, e));
+
+    let mut in_section = section.is_empty();
+    for line in content.lines() {
+        let trimmed = line.trim();
+        if trimmed.starts_with('[') {
+            in_section = trimmed == section;
+            continue;
+        }
+        if !in_section {
+            continue;
+        }
+        if trimmed.starts_with("version") {
+            if let Some(v) = trimmed.split('=').nth(1) {
+                return v.trim().trim_matches('"').trim().to_string();
+            }
+        }
+    }
+    panic!("Cannot parse version from {:?}", path);
+}

chanlun-py/chanlun/__init__.py

@@ -1,3 +1,32 @@
 """缠论技术分析库 — Rust 高性能实现"""
 
+__all__ = [
+    "K线",
+    "K线合成器",
+    "中枢",
+    "买卖点",
+    "买卖点类型",
+    "分型",
+    "分型结构",
+    "基础买卖点",
+    "平滑异同移动平均线",
+    "指标",
+    "特征分型",
+    "相对强弱指数",
+    "相对方向",
+    "立体分析器",
+    "笔",
+    "线段",
+    "线段特征",
+    "缠论K线",
+    "缠论配置",
+    "缺口",
+    "背驰分析",
+    "虚线",
+    "观察者",
+    "转化为时间戳",
+    "转化为时间戳_数字",
+    "随机指标",
+]
+
 from ._chanlun import *

chanlun-py/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "chanlun"
-version = "2605.11"
+version = "2605.86"
 description = "缠论技术分析库 — Rust 高性能实现"
 readme = { file = "README.md", content-type = "text/markdown" }
 license = { file = "LICENSE", content-type = "text/plain" }

chanlun-py/src/business_py.rs

@@ -23,10 +23,14 @@
  */
 
 use pyo3::prelude::*;
-use pyo3::types::PyType;
-use std::cell::RefCell;
+use pyo3::types::{PyDict, PyType};
+use std::sync::RwLock;
+
+use crate::algorithm_py::hub_to_py;
+use crate::kline_py::bar_to_py;
+use crate::structure_py::{dashed_to_py, fractal_to_py};
 use std::collections::HashMap;
-use std::rc::Rc;
+use std::sync::Arc;
 
 use crate::algorithm_py::中枢Py;
 use crate::config_py::缠论配置Py;
@@ -44,7 +48,7 @@ use crate::types_py::买卖点类型Py;
 ///   有效性: bool — 买卖点是否仍有效
 ///   与MACD柱子匹配: bool|None — 是否与MACD柱状图方向匹配
 ///   与MACD柱子分型匹配: bool|None — 是否与MACD柱分型匹配
-#[pyclass(name = "基础买卖点", unsendable)]
+#[pyclass(name = "基础买卖点", module = "chanlun._chanlun", from_py_object)]
 #[derive(Clone)]
 pub struct 基础买卖点Py {
     pub(crate) inner: chanlun::business::bsp::基础买卖点,
@@ -63,8 +67,8 @@ impl 基础买卖点Py {
         Self {
             inner: chanlun::business::bsp::基础买卖点::new(
                 类型.borrow().inner,
-                Rc::new(当前K线.borrow().inner.clone()),
-                Rc::clone(&买卖点分型.borrow().inner),
+                当前K线.borrow().inner.clone(),
+                Arc::clone(&买卖点分型.borrow().inner),
                 备注,
                 中枢破位值,
             ),
@@ -76,6 +80,12 @@ impl 基础买卖点Py {
         self.inner.备注.clone()
     }
 
+    #[setter]
+    #[pyo3(name = "备注")]
+    fn 设置_备注(&mut self, value: String) {
+        self.inner.备注 = value;
+    }
+
     #[getter]
     fn 类型(&self) -> 买卖点类型Py {
         买卖点类型Py {
@@ -86,39 +96,39 @@ impl 基础买卖点Py {
     #[getter]
     fn 买卖点分型(&self) -> 分型Py {
         分型Py {
-            inner: Rc::clone(&self.inner.买卖点分型),
+            inner: Arc::clone(&self.inner.买卖点分型),
         }
     }
 
     #[getter]
-    fn 买卖点K线(&self) -> 缠论K线Py {
-        缠论K线Py {
-            inner: Rc::clone(&self.inner.买卖点K线),
-        }
+    fn 买卖点K线(&self, py: Python<'_>) -> Py<缠论K线Py> {
+        crate::kline_py::chan_kline_to_py(py, Arc::clone(&self.inner.买卖点K线))
     }
 
     #[getter]
-    fn 当前K线(&self) -> K线Py {
-        K线Py {
-            inner: (*self.inner.当前K线).clone(),
-        }
+    /// 当前K线
+    fn 当前K线(&self, py: Python<'_>) -> Py<K线Py> {
+        bar_to_py(py, self.inner.当前K线.clone())
     }
 
     #[getter]
-    fn 失效K线(&self) -> Option<K线Py> {
-        self.inner.失效K线.as_ref().map(|k| K线Py {
-            inner: (**k).clone(),
-        })
+    fn 失效K线(&self, py: Python<'_>) -> Option<Py<K线Py>> {
+        self.inner
+            .失效K线
+            .as_ref()
+            .map(|k| bar_to_py(py, Arc::clone(k)))
     }
 
     #[getter]
-    fn 终结K线(&self) -> Option<K线Py> {
-        self.inner.终结K线.as_ref().map(|k| K线Py {
-            inner: (**k).clone(),
-        })
+    fn 终结K线(&self, py: Python<'_>) -> Option<Py<K线Py>> {
+        self.inner
+            .终结K线
+            .as_ref()
+            .map(|k| bar_to_py(py, Arc::clone(k)))
     }
 
     #[getter]
+    /// 破位值
     fn 破位值(&self) -> f64 {
         self.inner.破位值
     }
@@ -130,29 +140,54 @@ impl 基础买卖点Py {
             .map(|f| crate::types_py::分型结构Py { inner: f })
     }
 
+    #[getter]
+    /// 偏移
     fn 偏移(&self) -> i64 {
         self.inner.偏移()
     }
 
+    #[getter]
+    /// 失效偏移
     fn 失效偏移(&self) -> i64 {
         self.inner.失效偏移()
     }
 
     #[getter]
+    /// 有效性
     fn 有效性(&self) -> bool {
         self.inner.有效性()
     }
 
     #[getter]
+    /// 与MACD柱子匹配
     fn 与MACD柱子匹配(&self) -> bool {
         self.inner.与MACD柱子匹配()
     }
 
     #[getter]
+    /// 与MACD柱子分型匹配
     fn 与MACD柱子分型匹配(&self) -> bool {
         self.inner.与MACD柱子分型匹配()
     }
 
+    /// pandas 兼容 — 返回关键标量字段构成的字典
+    #[getter]
+    fn __dict__(&self, py: Python<'_>) -> PyResult<Py<PyDict>> {
+        let dict = PyDict::new(py);
+        dict.set_item("备注", self.备注())?;
+        dict.set_item("类型", self.类型())?;
+        dict.set_item("破位值", self.破位值())?;
+        dict.set_item("偏移", self.偏移())?;
+        dict.set_item("失效偏移", self.失效偏移())?;
+        dict.set_item("有效性", self.有效性())?;
+        dict.set_item("与MACD柱子匹配", self.与MACD柱子匹配())?;
+        dict.set_item("与MACD柱子分型匹配", self.与MACD柱子分型匹配())?;
+        if let Some(v) = self.结构() {
+            dict.set_item("结构", v)?;
+        }
+        Ok(dict.into())
+    }
+
     fn __str__(&self) -> String {
         format!("{}", self.inner)
     }
@@ -170,12 +205,13 @@ impl 基础买卖点Py {
 ///   一卖点(...) / 一买点(...) / 二卖点(...) / 二买点(...) / 三卖点(...) / 三买点(...)
 ///   生成买卖点(特征, 序号, 级别, 分型, 当前缠K, 备注?) -> 买卖点
 ///      — 根据特征字符串自动路由到对应的一/二/三类买卖点构造函数
-#[pyclass(name = "买卖点")]
+#[pyclass(name = "买卖点", module = "chanlun._chanlun")]
 pub struct 买卖点Py;
 
 #[pymethods]
 impl 买卖点Py {
     #[classmethod]
+    /// :param 买卖点分型: 买卖点对应的分型
     fn 一卖点(
         _cls: &Bound<'_, PyType>,
         买卖点分型: &Bound<'_, 分型Py>,
@@ -186,8 +222,8 @@ impl 买卖点Py {
     ) -> 基础买卖点Py {
         基础买卖点Py {
             inner: chanlun::business::bsp::买卖点::一卖点(
-                Rc::clone(&买卖点分型.borrow().inner),
-                Rc::new(当前K线.borrow().inner.clone()),
+                Arc::clone(&买卖点分型.borrow().inner),
+                当前K线.borrow().inner.clone(),
                 标识,
                 备注,
                 中枢破位值,
@@ -196,6 +232,7 @@ impl 买卖点Py {
     }
 
     #[classmethod]
+    /// :param 买卖点分型: 买卖点对应的分型
     fn 一买点(
         _cls: &Bound<'_, PyType>,
         买卖点分型: &Bound<'_, 分型Py>,
@@ -206,8 +243,8 @@ impl 买卖点Py {
     ) -> 基础买卖点Py {
         基础买卖点Py {
             inner: chanlun::business::bsp::买卖点::一买点(
-                Rc::clone(&买卖点分型.borrow().inner),
-                Rc::new(当前K线.borrow().inner.clone()),
+                Arc::clone(&买卖点分型.borrow().inner),
+                当前K线.borrow().inner.clone(),
                 标识,
                 备注,
                 中枢破位值,
@@ -216,6 +253,7 @@ impl 买卖点Py {
     }
 
     #[classmethod]
+    /// :param 买卖点分型: 买卖点对应的分型
     fn 二卖点(
         _cls: &Bound<'_, PyType>,
         买卖点分型: &Bound<'_, 分型Py>,
@@ -226,8 +264,8 @@ impl 买卖点Py {
     ) -> 基础买卖点Py {
         基础买卖点Py {
             inner: chanlun::business::bsp::买卖点::二卖点(
-                Rc::clone(&买卖点分型.borrow().inner),
-                Rc::new(当前K线.borrow().inner.clone()),
+                Arc::clone(&买卖点分型.borrow().inner),
+                当前K线.borrow().inner.clone(),
                 标识,
                 备注,
                 中枢破位值,
@@ -236,6 +274,7 @@ impl 买卖点Py {
     }
 
     #[classmethod]
+    /// :param 买卖点分型: 买卖点对应的分型
     fn 二买点(
         _cls: &Bound<'_, PyType>,
         买卖点分型: &Bound<'_, 分型Py>,
@@ -246,8 +285,8 @@ impl 买卖点Py {
     ) -> 基础买卖点Py {
         基础买卖点Py {
             inner: chanlun::business::bsp::买卖点::二买点(
-                Rc::clone(&买卖点分型.borrow().inner),
-                Rc::new(当前K线.borrow().inner.clone()),
+                Arc::clone(&买卖点分型.borrow().inner),
+                当前K线.borrow().inner.clone(),
                 标识,
                 备注,
                 中枢破位值,
@@ -256,6 +295,7 @@ impl 买卖点Py {
     }
 
     #[classmethod]
+    /// :param 买卖点分型: 买卖点对应的分型
     fn 三卖点(
         _cls: &Bound<'_, PyType>,
         买卖点分型: &Bound<'_, 分型Py>,
@@ -266,8 +306,8 @@ impl 买卖点Py {
     ) -> 基础买卖点Py {
         基础买卖点Py {
             inner: chanlun::business::bsp::买卖点::三卖点(
-                Rc::clone(&买卖点分型.borrow().inner),
-                Rc::new(当前K线.borrow().inner.clone()),
+                Arc::clone(&买卖点分型.borrow().inner),
+                当前K线.borrow().inner.clone(),
                 标识,
                 备注,
                 中枢破位值,
@@ -276,6 +316,7 @@ impl 买卖点Py {
     }
 
     #[classmethod]
+    /// :param 买卖点分型: 买卖点对应的分型
     fn 三买点(
         _cls: &Bound<'_, PyType>,
         买卖点分型: &Bound<'_, 分型Py>,
@@ -286,8 +327,8 @@ impl 买卖点Py {
     ) -> 基础买卖点Py {
         基础买卖点Py {
             inner: chanlun::business::bsp::买卖点::三买点(
-                Rc::clone(&买卖点分型.borrow().inner),
-                Rc::new(当前K线.borrow().inner.clone()),
+                Arc::clone(&买卖点分型.borrow().inner),
+                当前K线.borrow().inner.clone(),
                 标识,
                 备注,
                 中枢破位值,
@@ -296,6 +337,7 @@ impl 买卖点Py {
     }
 
     #[classmethod]
+    /// :param 特征: 特征字符串
     fn 生成买卖点(
         _cls: &Bound<'_, PyType>,
         特征: &str,
@@ -309,8 +351,8 @@ impl 买卖点Py {
                 特征,
                 序号,
                 级别,
-                Rc::clone(&买卖点分型.borrow().inner),
-                Rc::clone(&当前缠K.borrow().inner),
+                Arc::clone(&买卖点分型.borrow().inner),
+                Arc::clone(&当前缠K.borrow().inner),
             ),
         }
     }
@@ -347,81 +389,124 @@ impl 买卖点Py {
 /// 调试方法:
 ///   测试_保存数据(root?) — 将各层级序列保存到文件，用于与Python版对比
 ///   读取数据文件(文件路径, 配置) -> 观察者 (classmethod) — 从 .nb 文件加载数据
-#[pyclass(name = "观察者", subclass, unsendable)]
+#[pyclass(name = "观察者", module = "chanlun._chanlun", subclass)]
 pub struct 观察者Py {
-    pub(crate) inner: Option<Rc<RefCell<chanlun::business::observer::观察者>>>,
+    pub(crate) inner: Option<Arc<RwLock<chanlun::business::observer::观察者>>>,
 }
 
 impl 观察者Py {
-    pub(crate) fn obs(&self) -> std::cell::Ref<'_, chanlun::business::observer::观察者> {
+    pub(crate) fn obs(
+        &self,
+    ) -> std::sync::RwLockReadGuard<'_, chanlun::business::observer::观察者> {
         self.inner
             .as_ref()
             .expect("观察者 尚未初始化，请通过 __init__(符号, 周期, 配置) 构造")
-            .borrow()
+            .read()
+            .unwrap_or_else(|e| e.into_inner())
     }
 
-    pub(crate) fn obs_mut(&self) -> std::cell::RefMut<'_, chanlun::business::observer::观察者> {
+    pub(crate) fn obs_mut(
+        &self,
+    ) -> std::sync::RwLockWriteGuard<'_, chanlun::business::observer::观察者> {
         self.inner
             .as_ref()
             .expect("观察者 尚未初始化，请通过 __init__(符号, 周期, 配置) 构造")
-            .borrow_mut()
+            .write()
+            .unwrap_or_else(|e| e.into_inner())
     }
 }
 
 #[pymethods]
 impl 观察者Py {
-    /// __new__ 只分配空壳，构造逻辑在 __init__
+    /// __new__ 从 *args/**kwargs 中提取 (符号, 周期, 配置)，完整初始化观察者。
+    /// 由于形参可变（子类参数各异），不依赖固定签名，而是从 args/kwargs 中按位置和名称智能提取。
     #[new]
     #[pyo3(signature = (*args, **kwargs))]
     fn new(
         args: &Bound<'_, pyo3::types::PyTuple>,
         kwargs: Option<&Bound<'_, pyo3::types::PyDict>>,
-    ) -> Self {
-        let _ = (args, kwargs);
-        Self { inner: None }
+    ) -> PyResult<Self> {
+        let py = args.py();
+
+        // 提取 符号（位置 0 或关键字）
+        let 符号: String = if !args.is_empty() {
+            args.get_item(0)?.extract()?
+        } else {
+            match kwargs.and_then(|kw| kw.get_item("符号").ok().flatten()) {
+                Some(val) => val.extract()?,
+                None => return Err(pyo3::exceptions::PyTypeError::new_err("缺少参数: 符号")),
+            }
+        };
+
+        // 提取 周期（位置 1 或关键字）
+        let 周期: i64 = if args.len() >= 2 {
+            args.get_item(1)?.extract()?
+        } else {
+            match kwargs.and_then(|kw| kw.get_item("周期").ok().flatten()) {
+                Some(val) => val.extract()?,
+                None => return Err(pyo3::exceptions::PyTypeError::new_err("缺少参数: 周期")),
+            }
+        };
+
+        // 提取 配置（关键字优先，然后扫描剩余位置参数）
+        let mut config = None;
+        if let Some(val) = kwargs.and_then(|kw| kw.get_item("配置").ok().flatten()) {
+            let cfg: PyRef<'_, 缠论配置Py> = val.extract()?;
+            config = Some(cfg.to_rust_config(py)?);
+        }
+        if config.is_none() {
+            for i in 2..args.len() {
+                if let Ok(cfg) = args.get_item(i)?.extract::<PyRef<'_, 缠论配置Py>>() {
+                    config = Some(cfg.to_rust_config(py)?);
+                    break;
+                }
+            }
+        }
+        let config = config.unwrap_or_else(chanlun::config::缠论配置::default);
+
+        Ok(Self {
+            inner: Some(chanlun::business::observer::观察者::new(
+                符号, 周期, config,
+            )),
+        })
     }
 
-    /// __init__ 执行真正的构造。子类可重写并调用 super().__init__(符号, 周期, 配置)
-    #[pyo3(signature = (符号, 周期, 配置 = None))]
+    /// __init__ 不重复构造 — __new__ 已完成初始化。
+    /// 接收 *args/**kwargs 是为了兼容 Python 构造函数给 __init__ 传入的任意形参。
+    #[pyo3(signature = (*args, **kwargs))]
     fn __init__(
         &mut self,
-        py: Python<'_>,
-        符号: String,
-        周期: i64,
-        配置: Option<&Bound<'_, 缠论配置Py>>,
+        args: &Bound<'_, pyo3::types::PyTuple>,
+        kwargs: Option<&Bound<'_, pyo3::types::PyDict>>,
     ) -> PyResult<()> {
-        let config = match 配置 {
-            Some(cfg) => cfg.borrow().to_rust_config(py)?,
-            None => chanlun::config::缠论配置::default(),
-        };
-        self.inner = Some(chanlun::business::observer::观察者::new(
-            符号, 周期, config,
-        ));
+        let _ = (args, kwargs);
         Ok(())
     }
 
     #[getter]
+    /// 观察员（自引用）
     fn 观察员(slf: PyRef<'_, Self>) -> PyRef<'_, Self> {
         slf
     }
 
     #[getter]
+    /// :return: "{符号}:{周期}"
     fn 标识(&self) -> String {
         self.obs().标识()
     }
 
     #[getter]
-    fn 当前K线(&self) -> Option<K线Py> {
-        self.obs().当前K线().map(|k| K线Py {
-            inner: (**k).clone(),
-        })
+    /// :return: 最后一根原始K线
+    fn 当前K线(&self, py: Python<'_>) -> Option<Py<K线Py>> {
+        self.obs().当前K线().map(|k| bar_to_py(py, Arc::clone(k)))
     }
 
     #[getter]
-    fn 当前缠K(&self) -> Option<缠论K线Py> {
-        self.obs().当前缠K().map(|k| 缠论K线Py {
-            inner: Rc::clone(k),
-        })
+    /// :return: 最后一根缠论K线
+    fn 当前缠K(&self, py: Python<'_>) -> Option<Py<缠论K线Py>> {
+        self.obs()
+            .当前缠K()
+            .map(|k| crate::kline_py::chan_kline_to_py(py, Arc::clone(k)))
     }
 
     #[getter]
@@ -439,36 +524,112 @@ impl 观察者Py {
         缠论配置Py::from_rust_config(&self.obs().配置)
     }
 
+    /// 清空所有分析序列，重置为初始状态
     fn 重置基础序列(&mut self) {
         self.obs_mut().重置基础序列();
     }
 
+    /// 核心入口 — 投喂一根原始K线，增量更新所有层级
     fn 增加原始K线(&mut self, 普K: &Bound<'_, K线Py>) {
-        self.obs_mut().增加原始K线(普K.borrow().inner.clone());
+        self.obs_mut().增加原始K线((*普K.borrow().inner).clone());
     }
 
+    /// 加载本地数据 — 从 .nb 文件加载K线数据（先重置，再通过 Python dispatch 逐根投喂，
+    /// 确保子类重写的 增加原始K线 被正确调用）。
+    fn 加载本地数据(slf: &Bound<'_, Self>, 文件路径: &str) -> PyResult<()> {
+        let py = slf.py();
+
+        // 重置基础序列
+        slf.borrow_mut().obs_mut().重置基础序列();
+
+        // 解析文件得到 K线 列表
+        let bars = slf
+            .borrow()
+            .obs()
+            .解析本地数据(文件路径)
+            .map_err(|e| pyo3::exceptions::PyValueError::new_err(e))?;
+
+        // 通过 Python dispatch 逐根投喂，确保子类重写生效
+        for k线 in bars {
+            let k线_py = Py::new(
+                py,
+                K线Py {
+                    inner: Arc::new(k线),
+                },
+            )?;
+            slf.call_method1("增加原始K线", (k线_py,))?;
+        }
+        Ok(())
+    }
+
+    /// 静态重新分析（占位方法）
     fn 静态重新分析(&mut self) {
         self.obs_mut().静态重新分析();
     }
 
+    #[pyo3(signature = (root = None))]
+    /// 拆分各序列数据，单独存文件，文件名为对应变量名
     fn 测试_保存数据(&self, root: Option<&str>) {
         self.obs().测试_保存数据(root);
     }
 
     #[classmethod]
+    #[pyo3(signature = (文件路径, 配置 = None))]
+    /// :param 文件路径: 数据文件路径 格式如: btcusd-300-1631772074-1632222374.nb
     fn 读取数据文件(
-        _cls: &Bound<'_, PyType>,
+        cls: &Bound<'_, PyType>,
         文件路径: &str,
         配置: Option<&Bound<'_, 缠论配置Py>>,
         py: Python<'_>,
-    ) -> PyResult<Self> {
+    ) -> PyResult<Py<PyAny>> {
         let config = match 配置 {
-            Some(cfg) => Some(cfg.borrow().to_rust_config(py)?),
-            None => None,
+            Some(cfg) => cfg.borrow().to_rust_config(py)?,
+            None => chanlun::config::缠论配置::default(),
         };
-        chanlun::business::observer::观察者::读取数据文件(文件路径, config)
-            .map(|inner| Self { inner: Some(inner) })
-            .map_err(|e| pyo3::exceptions::PyValueError::new_err(e))
+
+        // 从文件名解析 符号/周期: "btcusd-300-1761327300-1776327900.nb"
+        let path = std::path::Path::new(文件路径);
+        let name = path
+            .file_stem()
+            .and_then(|n| n.to_str())
+            .ok_or_else(|| pyo3::exceptions::PyValueError::new_err("invalid filename"))?;
+        let parts: Vec<&str> = name.split('-').collect();
+        if parts.len() < 4 {
+            return Err(pyo3::exceptions::PyValueError::new_err(format!(
+                "invalid filename format: {}",
+                name
+            )));
+        }
+        let 符号 = parts[0].to_string();
+        let 周期: i64 = parts[1]
+            .parse()
+            .map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("parse period: {}", e)))?;
+
+        // 通过 cls 构造实例（支持子类化）
+        let cfg_py = 缠论配置Py::from_rust_config(&config)?;
+        let cfg_obj = Py::new(py, cfg_py)?;
+        let obj = cls.call1((符号.clone(), 周期, cfg_obj))?;
+
+        // 读取文件并通过 Python 分发逐根投喂（支持子类重写 增加原始K线）
+        let data = std::fs::read(文件路径)
+            .map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("read file: {}", e)))?;
+        let size: usize = 48;
+        for i in 0..data.len() / size {
+            let offset = i * size;
+            if let Some(k线) =
+                chanlun::kline::bar::K线::from_bytes(&data[offset..offset + size], 周期, &符号)
+            {
+                let k线_py = Py::new(
+                    py,
+                    K线Py {
+                        inner: Arc::new(k线),
+                    },
+                )?;
+                obj.call_method1("增加原始K线", (k线_py,))?;
+            }
+        }
+
+        Ok(obj.unbind())
     }
 
     // ---- 序列 getters ----
@@ -477,20 +638,38 @@ impl 观察者Py {
     fn 普通K线序列(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
         let list = pyo3::types::PyList::empty(py);
         for k in &self.obs().普通K线序列 {
-            list.append(K线Py {
-                inner: (**k).clone(),
-            })?;
+            list.append(bar_to_py(py, Arc::clone(k)))?;
         }
         Ok(list.into())
     }
 
+    #[getter]
+    fn 基础缠K序列(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
+        let list = pyo3::types::PyList::empty(py);
+        for k in &self.obs().基础缠K序列 {
+            list.append(crate::kline_py::chan_kline_to_py(py, Arc::clone(k)))?;
+        }
+        Ok(list.into())
+    }
+
+    #[setter]
+    #[pyo3(name = "基础缠K序列")]
+    fn 设置_基础缠K序列(&mut self, value: &Bound<'_, PyAny>) -> PyResult<()> {
+        let list: &Bound<'_, pyo3::types::PyList> = value.cast()?;
+        let mut vec = Vec::new();
+        for item in list {
+            let 缠k: PyRef<'_, 缠论K线Py> = item.extract()?;
+            vec.push(Arc::clone(&缠k.inner));
+        }
+        self.obs_mut().基础缠K序列 = vec;
+        Ok(())
+    }
+
     #[getter]
     fn 缠论K线序列(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
         let list = pyo3::types::PyList::empty(py);
         for k in &self.obs().缠论K线序列 {
-            list.append(缠论K线Py {
-                inner: Rc::clone(k),
-            })?;
+            list.append(crate::kline_py::chan_kline_to_py(py, Arc::clone(k)))?;
         }
         Ok(list.into())
     }
@@ -499,9 +678,7 @@ impl 观察者Py {
     fn 分型序列(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
         let list = pyo3::types::PyList::empty(py);
         for f in &self.obs().分型序列 {
-            list.append(分型Py {
-                inner: Rc::clone(f),
-            })?;
+            list.append(fractal_to_py(py, Arc::clone(f)))?;
         }
         Ok(list.into())
     }
@@ -510,9 +687,7 @@ impl 观察者Py {
     fn 笔序列(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
         let list = pyo3::types::PyList::empty(py);
         for d in &self.obs().笔序列 {
-            list.append(虚线Py {
-                inner: Rc::clone(d),
-            })?;
+            list.append(dashed_to_py(py, Arc::clone(d)))?;
         }
         Ok(list.into())
     }
@@ -521,9 +696,7 @@ impl 观察者Py {
     fn 笔_中枢序列(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
         let list = pyo3::types::PyList::empty(py);
         for h in &self.obs().笔_中枢序列 {
-            list.append(中枢Py {
-                inner: Rc::clone(h),
-            })?;
+            list.append(hub_to_py(py, Arc::clone(h)))?;
         }
         Ok(list.into())
     }
@@ -532,9 +705,7 @@ impl 观察者Py {
     fn 线段序列(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
         let list = pyo3::types::PyList::empty(py);
         for d in &self.obs().线段序列 {
-            list.append(虚线Py {
-                inner: Rc::clone(d),
-            })?;
+            list.append(dashed_to_py(py, Arc::clone(d)))?;
         }
         Ok(list.into())
     }
@@ -543,9 +714,7 @@ impl 观察者Py {
     fn 中枢序列(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
         let list = pyo3::types::PyList::empty(py);
         for h in &self.obs().中枢序列 {
-            list.append(中枢Py {
-                inner: Rc::clone(h),
-            })?;
+            list.append(hub_to_py(py, Arc::clone(h)))?;
         }
         Ok(list.into())
     }
@@ -554,9 +723,7 @@ impl 观察者Py {
     fn 扩展线段序列(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
         let list = pyo3::types::PyList::empty(py);
         for d in &self.obs().扩展线段序列 {
-            list.append(虚线Py {
-                inner: Rc::clone(d),
-            })?;
+            list.append(dashed_to_py(py, Arc::clone(d)))?;
         }
         Ok(list.into())
     }
@@ -565,9 +732,7 @@ impl 观察者Py {
     fn 扩展中枢序列(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
         let list = pyo3::types::PyList::empty(py);
         for h in &self.obs().扩展中枢序列 {
-            list.append(中枢Py {
-                inner: Rc::clone(h),
-            })?;
+            list.append(hub_to_py(py, Arc::clone(h)))?;
         }
         Ok(list.into())
     }
@@ -576,9 +741,7 @@ impl 观察者Py {
     fn 扩展线段序列_线段(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
         let list = pyo3::types::PyList::empty(py);
         for d in &self.obs().扩展线段序列_线段 {
-            list.append(虚线Py {
-                inner: Rc::clone(d),
-            })?;
+            list.append(dashed_to_py(py, Arc::clone(d)))?;
         }
         Ok(list.into())
     }
@@ -587,9 +750,7 @@ impl 观察者Py {
     fn 扩展中枢序列_线段(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
         let list = pyo3::types::PyList::empty(py);
         for h in &self.obs().扩展中枢序列_线段 {
-            list.append(中枢Py {
-                inner: Rc::clone(h),
-            })?;
+            list.append(hub_to_py(py, Arc::clone(h)))?;
         }
         Ok(list.into())
     }
@@ -598,9 +759,7 @@ impl 观察者Py {
     fn 线段_线段序列(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
         let list = pyo3::types::PyList::empty(py);
         for d in &self.obs().线段_线段序列 {
-            list.append(虚线Py {
-                inner: Rc::clone(d),
-            })?;
+            list.append(dashed_to_py(py, Arc::clone(d)))?;
         }
         Ok(list.into())
     }
@@ -609,9 +768,7 @@ impl 观察者Py {
     fn 线段_中枢序列(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
         let list = pyo3::types::PyList::empty(py);
         for h in &self.obs().线段_中枢序列 {
-            list.append(中枢Py {
-                inner: Rc::clone(h),
-            })?;
+            list.append(hub_to_py(py, Arc::clone(h)))?;
         }
         Ok(list.into())
     }
@@ -620,9 +777,7 @@ impl 观察者Py {
     fn 扩展线段序列_扩展线段(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
         let list = pyo3::types::PyList::empty(py);
         for d in &self.obs().扩展线段序列_扩展线段 {
-            list.append(虚线Py {
-                inner: Rc::clone(d),
-            })?;
+            list.append(dashed_to_py(py, Arc::clone(d)))?;
         }
         Ok(list.into())
     }
@@ -631,9 +786,7 @@ impl 观察者Py {
     fn 扩展中枢序列_扩展线段(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
         let list = pyo3::types::PyList::empty(py);
         for h in &self.obs().扩展中枢序列_扩展线段 {
-            list.append(中枢Py {
-                inner: Rc::clone(h),
-            })?;
+            list.append(hub_to_py(py, Arc::clone(h)))?;
         }
         Ok(list.into())
     }
@@ -651,7 +804,7 @@ impl 观察者Py {
 ///   投喂(时间戳, 开盘价, 最高价, 最低价, 收盘价, 成交量) -> list[(周期, K线)]
 ///      — 快捷入口，免去构造K线对象
 ///   获取当前K线(周期) -> K线|None — 获取指定周期的当前合成结果
-#[pyclass(name = "K线合成器", unsendable)]
+#[pyclass(name = "K线合成器", module = "chanlun._chanlun")]
 pub struct K线合成器Py {
     pub(crate) inner: chanlun::business::synthesizer::K线合成器,
 }
@@ -665,18 +818,20 @@ impl K线合成器Py {
         }
     }
 
+    /// 统一入口 — 投喂最小周期K线，自动合成大周期并分发给各周期观察者
     fn 投喂K线(
         &mut self,
         普K: &Bound<'_, K线Py>,
         py: Python<'_>,
     ) -> PyResult<Vec<(i64, K线Py)>> {
-        let results = self.inner.投喂K线(普K.borrow().inner.clone());
+        let results = self.inner.投喂K线((*普K.borrow().inner).clone());
         Ok(results
             .into_iter()
-            .map(|(周期, k)| (周期, K线Py { inner: k }))
+            .map(|(周期, k)| (周期, K线Py { inner: Arc::new(k) }))
             .collect())
     }
 
+    /// 投喂原始tick数据
     fn 投喂(
         &mut self,
         时间戳: i64,
@@ -701,14 +856,22 @@ impl K线合成器Py {
         let results = self.inner.投喂K线(k);
         results
             .into_iter()
-            .map(|(周期, k2)| (周期, K线Py { inner: k2 }))
+            .map(|(周期, k2)| {
+                (
+                    周期,
+                    K线Py {
+                        inner: Arc::new(k2),
+                    },
+                )
+            })
             .collect()
     }
 
+    /// 获取指定周期当前正在合成的K线
     fn 获取当前K线(&self, 周期: i64) -> Option<K线Py> {
-        self.inner
-            .获取当前K线(周期)
-            .map(|k| K线Py { inner: k.clone() })
+        self.inner.获取当前K线(周期).map(|k| K线Py {
+            inner: Arc::new(k.clone()),
+        })
     }
 
     #[getter]
@@ -735,7 +898,7 @@ impl K线合成器Py {
 /// 方法:
 ///   投喂K线(普K) — 喂入最小周期K线，自动合成大周期并分发给各周期观察者
 ///   测试_保存数据(root?) — 保存各周期的分析数据到文件
-#[pyclass(name = "立体分析器", unsendable)]
+#[pyclass(name = "立体分析器", module = "chanlun._chanlun")]
 pub struct 立体分析器Py {
     pub(crate) inner: chanlun::business::multi_frame::立体分析器,
 }
@@ -775,8 +938,9 @@ impl 立体分析器Py {
         })
     }
 
+    /// 统一入口 — 投喂最小周期K线，自动合成大周期并分发给各周期观察者
     fn 投喂K线(&mut self, 普K: &Bound<'_, K线Py>) {
-        self.inner.投喂K线(普K.borrow().inner.clone());
+        self.inner.投喂K线((*普K.borrow().inner).clone());
     }
 
     fn 获取观察者(&self, 周期: i64) -> Option<观察者Py> {
@@ -785,6 +949,7 @@ impl 立体分析器Py {
             .map(|rc| 观察者Py { inner: Some(rc) })
     }
 
+    /// 拆分各序列数据，单独存文件，文件名为对应变量名
     fn 测试_保存数据(&self) {
         self.inner.测试_保存数据();
     }

chanlun-py/src/config_py.rs

@@ -91,7 +91,7 @@ use std::collections::HashMap;
 ///   不推送() -> 缠论配置 (classmethod) — 创建关闭所有推送的配置副本
 ///   按序号重组字典(默认配置, 原始字典) -> dict (classmethod) — 按默认配置的键序重排字典
 ///   对比(other) -> dict — 返回与另一个配置的差异字段
-#[pyclass(name = "缠论配置")]
+#[pyclass(name = "缠论配置", module = "chanlun._chanlun")]
 pub struct 缠论配置Py {
     fields: HashMap<String, Py<PyAny>>,
 }
@@ -107,16 +107,18 @@ impl 缠论配置Py {
         if let Some(kwargs) = kwargs {
             for (key, value) in kwargs.iter() {
                 let key: String = key.extract()?;
-                if fields.contains_key(&key) {
-                    fields.insert(key, value.clone().unbind());
-                } else {
+                if !fields.contains_key(&key) {
                     return Err(pyo3::exceptions::PyAttributeError::new_err(format!(
                         "缠论配置 没有字段: {key}"
                     )));
                 }
+                fields.insert(key, value.clone().unbind());
             }
         }
 
+        // 全部通过 serde_json 往返验证类型，统一处理字符串数字/布尔强制转换
+        let config = dict_to_rust_config(&fields)?;
+        let fields = config_to_field_dict(&config)?;
         Ok(Self { fields })
     }
 
@@ -132,7 +134,16 @@ impl 缠论配置Py {
     fn __setattr__(&mut self, name: &str, value: &Bound<'_, PyAny>) -> PyResult<()> {
         if self.fields.contains_key(name) {
             self.fields.insert(name.to_string(), value.clone().unbind());
-            Ok(())
+            // 通过 serde 往返验证类型
+            match dict_to_rust_config(&self.fields) {
+                Ok(config) => {
+                    self.fields = config_to_field_dict(&config)?;
+                    Ok(())
+                }
+                Err(e) => Err(pyo3::exceptions::PyValueError::new_err(format!(
+                    "配置转换失败: {e}"
+                ))),
+            }
         } else {
             Err(pyo3::exceptions::PyAttributeError::new_err(format!(
                 "缠论配置 没有字段: {name}"
@@ -172,45 +183,47 @@ impl 缠论配置Py {
     }
 
     /// 保存配置到 JSON 文件（默认路径 "缠论配置.json"）。
-    fn 保存配置(&self, py: Python<'_>, path: Option<&str>) -> PyResult<()> {
-        let path = path.unwrap_or("缠论配置.json");
+    #[pyo3(signature = (path = "缠论配置.json"))]
+    fn 保存配置(&self, py: Python<'_>, path: &str) -> PyResult<()> {
         let json = self.to_json(py)?;
         std::fs::write(path, json).map_err(|e| pyo3::exceptions::PyIOError::new_err(e.to_string()))
     }
 
     /// 从 JSON 文件加载配置（默认路径 "缠论配置.json"）。
     #[classmethod]
-    fn 加载配置(
-        _cls: &Bound<'_, PyType>,
-        py: Python<'_>,
-        path: Option<&str>,
-    ) -> PyResult<Self> {
-        let path = path.unwrap_or("缠论配置.json");
+    #[pyo3(signature = (path = "缠论配置.json"))]
+    fn 加载配置(_cls: &Bound<'_, PyType>, py: Python<'_>, path: &str) -> PyResult<Self> {
         let json_str = std::fs::read_to_string(path)
             .map_err(|e| pyo3::exceptions::PyIOError::new_err(e.to_string()))?;
         Self::from_json_str(py, &json_str)
     }
 
     #[classmethod]
+    /// :param data: 字典数据
     fn from_dict(_cls: &Bound<'_, PyType>, data: &Bound<'_, PyDict>) -> PyResult<Self> {
         let default_config = chanlun::config::缠论配置::default();
         let mut fields = config_to_field_dict(&default_config)?;
 
         for (key, value) in data.iter() {
             let key: String = key.extract()?;
-            fields.insert(key, value.clone().unbind());
+            if fields.contains_key(&key) {
+                fields.insert(key, value.clone().unbind());
+            }
         }
 
-        dict_to_rust_config(&fields)?;
+        let config = dict_to_rust_config(&fields)?;
+        let fields = config_to_field_dict(&config)?;
         Ok(Self { fields })
     }
 
     #[classmethod]
+    /// :param json_str: JSON字符串
     fn from_json(_cls: &Bound<'_, PyType>, py: Python<'_>, json_str: &str) -> PyResult<Self> {
         Self::from_json_str(py, json_str)
     }
 
     #[classmethod]
+    /// 创建不推送任何图表的静默配置（用于纯计算场景）
     fn 不推送(_cls: &Bound<'_, PyType>) -> PyResult<Self> {
         let config = chanlun::config::缠论配置::default().不推送();
         let fields = config_to_field_dict(&config)?;
@@ -218,6 +231,7 @@ impl 缠论配置Py {
     }
 
     #[classmethod]
+    /// 将形如 "1_open", "1_close", "2_open", "name" 的字典重组为嵌套结构
     fn 按序号重组字典(
         _cls: &Bound<'_, PyType>,
         默认配置: &Bound<'_, PyAny>,
@@ -237,6 +251,7 @@ impl 缠论配置Py {
         Ok(result.into())
     }
 
+    /// 比较当前配置与另一个配置的差异
     fn 对比(
         &self,
         py: Python<'_>,
@@ -270,7 +285,8 @@ impl 缠论配置Py {
             fields.insert(key, value.clone().unbind());
         }
 
-        dict_to_rust_config(&fields)?;
+        let config = dict_to_rust_config(&fields)?;
+        let fields = config_to_field_dict(&config)?;
         Ok(Self { fields })
     }
 
@@ -313,11 +329,177 @@ fn dict_to_rust_config(
         }
         let dumps = json_mod.getattr("dumps")?;
         let json_str: String = dumps.call1((dict,))?.extract()?;
-        serde_json::from_str(&json_str)
+        let mut value: serde_json::Value = serde_json::from_str(&json_str)
+            .map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("配置转换失败: {e}")))?;
+        coerce_strings_to_numbers(&mut value);
+
+        // 获取默认配置的 JSON 表示作为 schema
+        let default_config = chanlun::config::缠论配置::default();
+        let default_json = serde_json::to_value(&default_config)
+            .map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("配置转换失败: {e}")))?;
+
+        // 用默认值做基准，只合并类型匹配的字段
+        let mut merged = default_json.clone();
+        if let serde_json::Value::Object(ref input_map) = value {
+            if let serde_json::Value::Object(ref default_map) = default_json {
+                for (key, input_val) in input_map {
+                    if let Some(default_val) = default_map.get(key) {
+                        match validate_field(key, input_val, default_val) {
+                            Ok(()) => {
+                                merged[key] = input_val.clone();
+                            }
+                            Err(msg) => {
+                                eprintln!("\x1b[33m[配置警告]\x1b[m {key}: {msg}，已使用默认值 {default_val}");
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        serde_json::from_value(merged)
             .map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("配置转换失败: {e}")))
     })
 }
 
+/// 字符串字段的有效值集合
+fn valid_string_values(field: &str) -> Option<&'static [&'static str]> {
+    match field {
+        "指标计算方式" => Some(&[
+            "开",
+            "高",
+            "低",
+            "收",
+            "高低均值",
+            "高低收均值",
+            "开高低收均值",
+        ]),
+        "买卖点_指标模式" => Some(&["任意", "配置", "全量", "相对"]),
+        "线段内部背驰_模式" => Some(&["任意", "配置", "全量", "相对"]),
+        _ => None,
+    }
+}
+
+/// 验证单个字段的值是否与默认值类型兼容
+fn validate_field(
+    key: &str,
+    input: &serde_json::Value,
+    default: &serde_json::Value,
+) -> Result<(), String> {
+    use serde_json::Value;
+
+    // 输入为 null → 跳过（保留默认）
+    if input.is_null() {
+        return Err("值为 null".into());
+    }
+
+    // 字符串字段：检查有效值白名单
+    if default.is_string() && input.is_string() {
+        if let Some(valid) = valid_string_values(key) {
+            let s = input.as_str().unwrap();
+            if !valid.contains(&s) {
+                return Err(format!("\"{s}\" 不在有效值 {valid:?} 内"));
+            }
+        }
+        return Ok(());
+    }
+
+    // 类型匹配：直接通过
+    match (default, input) {
+        (Value::Bool(_), Value::Bool(_)) => return Ok(()),
+        (Value::Number(_), Value::Number(_)) => return Ok(()),
+        (Value::String(_), Value::String(_)) => return Ok(()),
+        _ => {}
+    }
+
+    // 类型不匹配
+    let type_name = match input {
+        Value::Bool(_) => "布尔",
+        Value::Number(_) => "数值",
+        Value::String(_) => "字符串",
+        Value::Array(_) => "数组",
+        Value::Object(_) => "字典",
+        Value::Null => "null",
+    };
+    let expected = match default {
+        Value::Bool(_) => "布尔",
+        Value::Number(_) => "数值",
+        Value::String(_) => "字符串",
+        _ => "其他",
+    };
+    Err(format!("类型不匹配（需要 {expected}，收到 {type_name}）"))
+}
+
+/// 递归遍历 JSON Value，将数字/布尔字符串转为对应类型。
+fn coerce_strings_to_numbers(value: &mut serde_json::Value) {
+    match value {
+        serde_json::Value::Object(map) => {
+            for (_, v) in map.iter_mut() {
+                coerce_strings_to_numbers(v);
+            }
+        }
+        serde_json::Value::Array(arr) => {
+            for v in arr.iter_mut() {
+                coerce_strings_to_numbers(v);
+            }
+        }
+        serde_json::Value::String(s) => {
+            // 先 clone 出独立副本，避免借用冲突
+            let cloned = s.clone();
+            if let Ok(n) = cloned.parse::<i64>() {
+                *value = serde_json::Value::Number(serde_json::Number::from(n));
+            } else if let Ok(n) = cloned.parse::<f64>() {
+                if n.is_finite() {
+                    if let Some(num) = serde_json::Number::from_f64(n) {
+                        *value = serde_json::Value::Number(num);
+                    }
+                }
+            } else if cloned.eq_ignore_ascii_case("true") {
+                *value = serde_json::Value::Bool(true);
+            } else if cloned.eq_ignore_ascii_case("false") {
+                *value = serde_json::Value::Bool(false);
+            }
+            // 非数字非布尔的原样保留，不做任何修改
+        }
+        _ => {}
+    }
+}
+
+/// 将 Python 字符串数字/布尔值强制转为对应类型，非字符串保持不变。
+/// 注：主代码路径现通过 serde 往返处理类型转换，此函数作为辅助保留。
+#[allow(dead_code)]
+fn coerce_py_value(value: &Bound<'_, PyAny>) -> PyResult<Py<PyAny>> {
+    let py = value.py();
+
+    let type_name: String = value.get_type().name()?.extract()?;
+    if type_name != "str" {
+        return Ok(value.clone().unbind());
+    }
+
+    let lower_obj = value.call_method0("lower")?;
+    let lower: String = lower_obj.extract()?;
+
+    if lower == "true" || lower == "false" {
+        let b = lower == "true";
+        let obj = pyo3::types::PyBool::new(py, b)
+            .to_owned()
+            .into_any()
+            .unbind();
+        return Ok(obj);
+    }
+
+    if let Ok(n) = lower.parse::<i64>() {
+        return Ok(n.into_pyobject(py)?.into_any().unbind());
+    }
+    if let Ok(n) = lower.parse::<f64>() {
+        if n.is_finite() {
+            return Ok(n.into_pyobject(py)?.into_any().unbind());
+        }
+    }
+
+    Ok(value.clone().unbind())
+}
+
 pub fn register(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<缠论配置Py>()?;
     Ok(())

chanlun-py/src/indicators_py.rs

@@ -43,7 +43,11 @@ use pyo3::types::PyType;
 ///   增量计算(前一个MACD, 当前收盘价, 当前时间) -> 平滑异同移动平均线
 ///      — 基于前一根的 EMA 状态增量更新，用于流式计算
 ///   增量计算_K线(前一个MACD, 当前K线, 计算方式) -> 平滑异同移动平均线
-#[pyclass(name = "平滑异同移动平均线")]
+#[pyclass(
+    name = "平滑异同移动平均线",
+    module = "chanlun._chanlun",
+    from_py_object
+)]
 #[derive(Clone)]
 pub struct 平滑异同移动平均线Py {
     pub(crate) inner: chanlun::indicators::平滑异同移动平均线,
@@ -124,6 +128,7 @@ impl 平滑异同移动平均线Py {
 
     #[classmethod]
     #[pyo3(signature = (初始收盘价, 初始时间, 快线周期 = None, 慢线周期 = None, 信号周期 = None))]
+    /// 首次计算MACD指标（没有历史数据时使用）
     fn 首次计算(
         _cls: &Bound<'_, PyType>,
         初始收盘价: f64,
@@ -144,6 +149,7 @@ impl 平滑异同移动平均线Py {
 
     #[classmethod]
     #[pyo3(signature = (k线, 计算方式, 快线周期 = None, 慢线周期 = None, 信号周期 = None))]
+    /// :param k线: 原始K线
     fn 首次计算_K线(
         _cls: &Bound<'_, PyType>,
         k线: &Bound<'_, PyAny>,
@@ -165,6 +171,7 @@ impl 平滑异同移动平均线Py {
     }
 
     #[classmethod]
+    /// 基于前一个MACD指标增量计算当前MACD指标
     fn 增量计算(
         _cls: &Bound<'_, PyType>,
         前一个MACD: &Bound<'_, 平滑异同移动平均线Py>,
@@ -180,6 +187,7 @@ impl 平滑异同移动平均线Py {
     }
 
     #[classmethod]
+    /// :param 前一个MACD: 前一个MACD指标对象
     fn 增量计算_K线(
         _cls: &Bound<'_, PyType>,
         前一个MACD: &Bound<'_, 平滑异同移动平均线Py>,
@@ -214,7 +222,7 @@ impl 平滑异同移动平均线Py {
 ///   首次计算_K线(k线, 计算方式, ...)
 ///   增量计算(前一个RSI, 当前收盘价, 当前时间)
 ///   增量计算_K线(前一个RSI, 当前K线, 计算方式)
-#[pyclass(name = "相对强弱指数")]
+#[pyclass(name = "相对强弱指数", module = "chanlun._chanlun", from_py_object)]
 #[derive(Clone)]
 pub struct 相对强弱指数Py {
     pub(crate) inner: chanlun::indicators::相对强弱指数,
@@ -294,6 +302,7 @@ impl 相对强弱指数Py {
 
     #[classmethod]
     #[pyo3(signature = (初始收盘价, 初始时间, 周期 = None, 超买阈值 = None, 超卖阈值 = None, RSI_SMA周期 = None))]
+    /// 首次计算RSI（没有足够历史数据时使用）
     fn 首次计算(
         _cls: &Bound<'_, PyType>,
         初始收盘价: f64,
@@ -317,6 +326,7 @@ impl 相对强弱指数Py {
 
     #[classmethod]
     #[pyo3(signature = (k线, 计算方式, 周期 = None, 超买阈值 = None, 超卖阈值 = None, RSI_SMA周期 = None))]
+    /// :param k线: 原始K线
     fn 首次计算_K线(
         _cls: &Bound<'_, PyType>,
         k线: &Bound<'_, PyAny>,
@@ -340,6 +350,7 @@ impl 相对强弱指数Py {
     }
 
     #[classmethod]
+    /// 基于前一个RSI指标增量计算当前RSI
     fn 增量计算(
         _cls: &Bound<'_, PyType>,
         前一个RSI: &Bound<'_, 相对强弱指数Py>,
@@ -356,6 +367,7 @@ impl 相对强弱指数Py {
     }
 
     #[classmethod]
+    /// :param 前一个RSI: 前一个RSI指标对象
     fn 增量计算_K线(
         _cls: &Bound<'_, PyType>,
         前一个RSI: &Bound<'_, 相对强弱指数Py>,
@@ -390,7 +402,7 @@ impl 相对强弱指数Py {
 ///   首次计算_K线(k线, 计算方式, ...)
 ///   增量计算(前一个KDJ, 最高价, 最低价, 收盘价, 时间)
 ///   增量计算_K线(前一个KDJ, 当前K线, 计算方式)
-#[pyclass(name = "随机指标")]
+#[pyclass(name = "随机指标", module = "chanlun._chanlun", from_py_object)]
 #[derive(Clone)]
 pub struct 随机指标Py {
     pub(crate) inner: chanlun::indicators::随机指标,
@@ -488,6 +500,7 @@ impl 随机指标Py {
 
     #[classmethod]
     #[pyo3(signature = (初始最高价, 初始最低价, 初始收盘价, 初始时间, N = None, M1 = None, M2 = None, 超买阈值 = None, 超卖阈值 = None))]
+    /// 首次计算KDJ（无历史数据时）
     fn 首次计算(
         _cls: &Bound<'_, PyType>,
         初始最高价: f64,
@@ -517,6 +530,7 @@ impl 随机指标Py {
 
     #[classmethod]
     #[pyo3(signature = (k线, _计算方式, RSV周期 = None, K值平滑周期 = None, D值平滑周期 = None, 超买阈值 = None, 超卖阈值 = None))]
+    /// :param k线: 原始K线
     fn 首次计算_K线(
         _cls: &Bound<'_, PyType>,
         k线: &Bound<'_, PyAny>,
@@ -546,6 +560,7 @@ impl 随机指标Py {
     }
 
     #[classmethod]
+    /// 基于前一个KDJ对象和当前三价，增量计算当前KDJ值
     fn 增量计算(
         _cls: &Bound<'_, PyType>,
         前一个KDJ: &Bound<'_, 随机指标Py>,
@@ -566,6 +581,7 @@ impl 随机指标Py {
     }
 
     #[classmethod]
+    /// :param 前一个KDJ: 前一个KDJ指标对象
     fn 增量计算_K线(
         _cls: &Bound<'_, PyType>,
         前一个KDJ: &Bound<'_, 随机指标Py>,
@@ -595,12 +611,13 @@ impl 随机指标Py {
 ///   K线取值(k线, 指标计算方式) -> float (classmethod)
 ///     根据计算方式从K线提取数值。
 ///     计算方式: "收盘价" / "开盘价" / "高" / "低" / "均值" 等
-#[pyclass(name = "指标")]
+#[pyclass(name = "指标", module = "chanlun._chanlun")]
 pub struct 指标Py;
 
 #[pymethods]
 impl 指标Py {
     #[classmethod]
+    /// 根据计算方式从K线中取值
     fn K线取值(
         _cls: &Bound<'_, PyType>,
         k线: &Bound<'_, PyAny>,

chanlun-py/src/kline_py.rs

@@ -23,8 +23,11 @@
  */
 
 use pyo3::prelude::*;
-use pyo3::types::{PyBytes, PyType};
+use pyo3::types::{PyBytes, PyDict, PyType};
 use std::collections::HashMap;
+use std::sync::atomic::Ordering;
+use std::sync::Arc;
+use std::sync::RwLock;
 
 use crate::config_py::缠论配置Py;
 use crate::indicators_py::{平滑异同移动平均线Py, 相对强弱指数Py, 随机指标Py};
@@ -51,10 +54,9 @@ use crate::types_py::相对方向Py;
 ///   获取MACD(K线序列, 计算方式, 快线周期?, 慢线周期?, 信号周期?) -> list[平滑异同移动平均线]
 ///      — 对整个K线序列批量计算 MACD
 ///   截取(序列, 起点K线, 终点K线) -> list — 按时间戳截取K线区间
-#[pyclass(name = "K线")]
-#[derive(Clone)]
+#[pyclass(name = "K线", module = "chanlun._chanlun")]
 pub struct K线Py {
-    pub(crate) inner: chanlun::kline::bar::K线,
+    pub(crate) inner: Arc<chanlun::kline::bar::K线>,
 }
 
 #[pymethods]
@@ -73,7 +75,7 @@ impl K线Py {
         成交量: f64,
     ) -> Self {
         Self {
-            inner: chanlun::kline::bar::K线 {
+            inner: Arc::new(chanlun::kline::bar::K线 {
                 标识: 标识.to_string(),
                 序号,
                 周期,
@@ -86,7 +88,7 @@ impl K线Py {
                 macd: None,
                 rsi: None,
                 kdj: None,
-            },
+            }),
         }
     }
 
@@ -94,84 +96,49 @@ impl K线Py {
     fn 标识(&self) -> String {
         self.inner.标识.clone()
     }
-    #[setter]
-    fn set_标识(&mut self, v: String) {
-        self.inner.标识 = v;
-    }
 
     #[getter]
     fn 序号(&self) -> i64 {
         self.inner.序号
     }
-    #[setter]
-    fn set_序号(&mut self, v: i64) {
-        self.inner.序号 = v;
-    }
 
     #[getter]
     fn 周期(&self) -> i64 {
         self.inner.周期
     }
-    #[setter]
-    fn set_周期(&mut self, v: i64) {
-        self.inner.周期 = v;
-    }
 
     #[getter]
     fn 时间戳(&self) -> i64 {
         self.inner.时间戳
     }
-    #[setter]
-    fn set_时间戳(&mut self, v: i64) {
-        self.inner.时间戳 = v;
-    }
 
     #[getter]
     fn 高(&self) -> f64 {
         self.inner.高
     }
-    #[setter]
-    fn set_高(&mut self, v: f64) {
-        self.inner.高 = v;
-    }
 
     #[getter]
     fn 低(&self) -> f64 {
         self.inner.低
     }
-    #[setter]
-    fn set_低(&mut self, v: f64) {
-        self.inner.低 = v;
-    }
 
     #[getter]
     fn 开盘价(&self) -> f64 {
         self.inner.开盘价
     }
-    #[setter]
-    fn set_开盘价(&mut self, v: f64) {
-        self.inner.开盘价 = v;
-    }
 
     #[getter]
     fn 收盘价(&self) -> f64 {
         self.inner.收盘价
     }
-    #[setter]
-    fn set_收盘价(&mut self, v: f64) {
-        self.inner.收盘价 = v;
-    }
 
     #[getter]
     fn 成交量(&self) -> f64 {
         self.inner.成交量
     }
-    #[setter]
-    fn set_成交量(&mut self, v: f64) {
-        self.inner.成交量 = v;
-    }
 
     #[getter]
+    /// :return: 相对方向.向上（开盘<收盘）或 相对方向.向下（开盘>收盘）
     fn 方向(&self) -> 相对方向Py {
         相对方向Py {
             inner: self.inner.方向(),
@@ -179,7 +146,7 @@ impl K线Py {
     }
 
     #[getter]
-    fn MACD(&self) -> Option<平滑异同移动平均线Py> {
+    fn macd(&self) -> Option<平滑异同移动平均线Py> {
         self.inner
             .macd
             .as_ref()
@@ -187,7 +154,7 @@ impl K线Py {
     }
 
     #[getter]
-    fn RSI(&self) -> Option<相对强弱指数Py> {
+    fn rsi(&self) -> Option<相对强弱指数Py> {
         self.inner
             .rsi
             .as_ref()
@@ -195,13 +162,39 @@ impl K线Py {
     }
 
     #[getter]
-    fn KDJ(&self) -> Option<随机指标Py> {
+    fn kdj(&self) -> Option<随机指标Py> {
         self.inner
             .kdj
             .as_ref()
             .map(|k| 随机指标Py { inner: k.clone() })
     }
 
+    /// pandas 兼容 — 返回所有字段构成的字典
+    #[getter]
+    fn __dict__(&self, py: Python<'_>) -> PyResult<Py<PyDict>> {
+        let dict = PyDict::new(py);
+        dict.set_item("标识", self.标识())?;
+        dict.set_item("序号", self.序号())?;
+        dict.set_item("周期", self.周期())?;
+        dict.set_item("时间戳", self.时间戳())?;
+        dict.set_item("高", self.高())?;
+        dict.set_item("低", self.低())?;
+        dict.set_item("开盘价", self.开盘价())?;
+        dict.set_item("收盘价", self.收盘价())?;
+        dict.set_item("成交量", self.成交量())?;
+        dict.set_item("方向", self.方向())?;
+        if let Some(v) = self.macd() {
+            dict.set_item("macd", v)?;
+        }
+        if let Some(v) = self.rsi() {
+            dict.set_item("rsi", v)?;
+        }
+        if let Some(v) = self.kdj() {
+            dict.set_item("kdj", v)?;
+        }
+        Ok(dict.into())
+    }
+
     fn __str__(&self) -> String {
         format!("{}", self.inner)
     }
@@ -214,8 +207,20 @@ impl K线Py {
         PyBytes::new(py, &self.inner.to_bytes()).into()
     }
 
+    fn __eq__(&self, other: &Bound<'_, PyAny>) -> bool {
+        if let Ok(other) = other.extract::<PyRef<'_, Self>>() {
+            return Arc::as_ptr(&self.inner) == Arc::as_ptr(&other.inner);
+        }
+        false
+    }
+
+    fn __hash__(&self) -> u64 {
+        Arc::as_ptr(&self.inner) as u64
+    }
+
     #[classmethod]
     #[pyo3(signature = (标识, 时间戳, 开盘价, 最高价, 最低价, 收盘价, 成交量, 序号 = None, 周期 = None))]
+    /// 快捷构造普通K线
     fn 创建普K(
         _cls: &Bound<'_, PyType>,
         标识: &str,
@@ -229,7 +234,7 @@ impl K线Py {
         周期: Option<i64>,
     ) -> Self {
         Self {
-            inner: chanlun::kline::bar::K线::创建普K(
+            inner: Arc::new(chanlun::kline::bar::K线::创建普K(
                 标识,
                 时间戳,
                 开盘价,
@@ -239,11 +244,12 @@ impl K线Py {
                 成交量,
                 序号.unwrap_or(0),
                 周期.unwrap_or(60),
-            ),
+            )),
         }
     }
 
     #[classmethod]
+    /// 将K线序列保存为二进制DAT文件
     fn 保存到DAT文件(
         _cls: &Bound<'_, PyType>,
         路径: &str,
@@ -251,23 +257,28 @@ impl K线Py {
         py: Python<'_>,
     ) -> PyResult<()> {
         let refs: Vec<_> = K线序列.iter().map(|k| k.bind(py).borrow()).collect();
-        let bars: Vec<&chanlun::kline::bar::K线> = refs.iter().map(|r| &r.inner).collect();
+        let bars: Vec<&chanlun::kline::bar::K线> = refs.iter().map(|r| r.inner.as_ref()).collect();
         chanlun::kline::bar::K线::保存到DAT文件(路径, &bars)
             .map_err(|e| pyo3::exceptions::PyIOError::new_err(e.to_string()))
     }
 
     #[classmethod]
+    /// 从大端字节序二进制数据反序列化K线（兼容.dat/.nb文件格式）
     fn 读取大端字节数组(
         _cls: &Bound<'_, PyType>,
         字节组: &Bound<'_, PyBytes>,
         周期: i64,
         标识: &str,
     ) -> Option<Self> {
-        chanlun::kline::bar::K线::读取大端字节数组(字节组.as_bytes(), 周期, 标识)
-            .map(|inner| Self { inner })
+        chanlun::kline::bar::K线::读取大端字节数组(字节组.as_bytes(), 周期, 标识).map(|inner| {
+            Self {
+                inner: Arc::new(inner),
+            }
+        })
     }
 
     #[classmethod]
+    /// 计算指定K线区间的MACD柱面积
     fn 获取MACD(
         _cls: &Bound<'_, PyType>,
         k线序列: Vec<Py<Self>>,
@@ -276,31 +287,43 @@ impl K线Py {
         py: Python<'_>,
     ) -> HashMap<String, f64> {
         let refs: Vec<_> = k线序列.iter().map(|k| k.bind(py).borrow()).collect();
-        let bars: Vec<&chanlun::kline::bar::K线> = refs.iter().map(|r| &r.inner).collect();
+        let bars: Vec<&chanlun::kline::bar::K线> = refs.iter().map(|r| r.inner.as_ref()).collect();
         chanlun::kline::bar::K线::获取MACD(&bars, &始.borrow().inner, &终.borrow().inner)
     }
 
     #[staticmethod]
+    /// 按起止K线截取K线子序列
     fn 截取(
         序列: Vec<Py<Self>>,
         始: &Bound<'_, Self>,
         终: &Bound<'_, Self>,
-    ) -> Option<Vec<Py<Self>>> {
-        let start_ptr = 始.as_ptr();
-        let end_ptr = 终.as_ptr();
-        let start_idx = 序列.iter().position(|k| k.as_ptr() == start_ptr)?;
-        let end_idx = 序列.iter().position(|k| k.as_ptr() == end_ptr)?;
-        if start_idx <= end_idx {
-            Some(
-                序列
-                    .into_iter()
-                    .skip(start_idx)
-                    .take(end_idx - start_idx + 1)
-                    .collect(),
-            )
-        } else {
-            None
+        py: Python<'_>,
+    ) -> PyResult<Vec<Py<Self>>> {
+        let start_ptr = Arc::as_ptr(&始.borrow().inner);
+        let end_ptr = Arc::as_ptr(&终.borrow().inner);
+        let start_ts = 始.borrow().inner.时间戳;
+        let end_ts = 终.borrow().inner.时间戳;
+        let start_idx = 序列
+            .iter()
+            .position(|k| {
+                Arc::as_ptr(&k.borrow(py).inner) == start_ptr
+                    || k.borrow(py).inner.时间戳 == start_ts
+            })
+            .ok_or_else(|| pyo3::exceptions::PyValueError::new_err("始 不在序列中"))?;
+        let end_idx = 序列
+            .iter()
+            .position(|k| {
+                Arc::as_ptr(&k.borrow(py).inner) == end_ptr || k.borrow(py).inner.时间戳 == end_ts
+            })
+            .ok_or_else(|| pyo3::exceptions::PyValueError::new_err("终 不在序列中"))?;
+        if start_idx > end_idx {
+            return Err(pyo3::exceptions::PyValueError::new_err("始 排序在 终 之后"));
         }
+        Ok(序列
+            .into_iter()
+            .skip(start_idx)
+            .take(end_idx - start_idx + 1)
+            .collect())
     }
 }
 
@@ -323,10 +346,73 @@ impl K线Py {
 ///   分析(缠K序列, 配置, 可以逆序包含?, 忽视顺序包含?, 可以逆序包含新?) -> (str, 分型|None)
 ///      — 分析分型形成结果
 ///   截取(序列, 起点分型, 终点分型) -> list — 截取分型间的缠K子序列
-#[pyclass(name = "缠论K线", unsendable)]
-#[derive(Clone)]
+#[pyclass(name = "缠论K线", module = "chanlun._chanlun", from_py_object)]
 pub struct 缠论K线Py {
-    pub(crate) inner: std::rc::Rc<chanlun::kline::chan_kline::缠论K线>,
+    pub(crate) inner: std::sync::Arc<chanlun::kline::chan_kline::缠论K线>,
+    bsp_set: std::sync::RwLock<Option<Py<pyo3::types::PySet>>>,
+}
+
+impl 缠论K线Py {
+    pub(crate) fn from_rc(inner: std::sync::Arc<chanlun::kline::chan_kline::缠论K线>) -> Self {
+        Self {
+            inner,
+            bsp_set: std::sync::RwLock::new(None),
+        }
+    }
+}
+
+thread_local! {
+    /// 对象标识缓存：Rc 地址 → 规范 Python 对象
+    /// 确保同一底层 Rc 指针在 Python 侧始终映射到同一 PyObject
+
+    static BAR_IDENTITY: RwLock<HashMap<usize, Py<K线Py>>> = RwLock::new(HashMap::new());
+
+    static KLINE_IDENTITY: RwLock<HashMap<usize, Py<缠论K线Py>>> = RwLock::new(HashMap::new());
+}
+
+/// 将 Rc<K线> 转为 Py<K线Py>，确保同一 Rc 地址总是返回同一 Python 对象
+pub(crate) fn bar_to_py(
+    py: Python<'_>,
+    inner: std::sync::Arc<chanlun::kline::bar::K线>,
+) -> Py<K线Py> {
+    let key = Arc::as_ptr(&inner) as usize;
+    if let Some(cached) =
+        BAR_IDENTITY.with(|c| c.read().unwrap().get(&key).map(|p| p.clone_ref(py)))
+    {
+        return cached;
+    }
+    let obj = Py::new(py, K线Py { inner }).unwrap();
+    BAR_IDENTITY.with(|c| {
+        c.write().unwrap().insert(key, obj.clone_ref(py));
+    });
+    obj
+}
+
+/// 将 Rc<缠论K线> 转为 Py<缠论K线Py>，确保同一 Rc 地址总是返回同一 Python 对象
+pub(crate) fn chan_kline_to_py(
+    py: Python<'_>,
+    inner: std::sync::Arc<chanlun::kline::chan_kline::缠论K线>,
+) -> Py<缠论K线Py> {
+    let key = Arc::as_ptr(&inner) as usize;
+    if let Some(cached) =
+        KLINE_IDENTITY.with(|c| c.read().unwrap().get(&key).map(|p| p.clone_ref(py)))
+    {
+        return cached;
+    }
+    let obj = Py::new(py, 缠论K线Py::from_rc(inner)).unwrap();
+    KLINE_IDENTITY.with(|c| {
+        c.write().unwrap().insert(key, obj.clone_ref(py));
+    });
+    obj
+}
+
+impl Clone for 缠论K线Py {
+    fn clone(&self) -> Self {
+        Self {
+            inner: std::sync::Arc::clone(&self.inner),
+            bsp_set: std::sync::RwLock::new(None),
+        }
+    }
 }
 
 #[pymethods]
@@ -338,28 +424,28 @@ impl 缠论K线Py {
 
     #[getter]
     fn 序号(&self) -> i64 {
-        self.inner.序号
+        self.inner.序号.load(Ordering::Relaxed)
     }
 
     #[getter]
     fn 时间戳(&self) -> i64 {
-        self.inner.时间戳
+        self.inner.时间戳.load(Ordering::Relaxed)
     }
 
     #[getter]
     fn 高(&self) -> f64 {
-        self.inner.高
+        self.inner.高.get()
     }
 
     #[getter]
     fn 低(&self) -> f64 {
-        self.inner.低
+        self.inner.低.get()
     }
 
     #[getter]
     fn 方向(&self) -> 相对方向Py {
         相对方向Py {
-            inner: self.inner.方向,
+            inner: *self.inner.方向.read().unwrap(),
         }
     }
 
@@ -367,6 +453,8 @@ impl 缠论K线Py {
     fn 分型(&self) -> Option<crate::types_py::分型结构Py> {
         self.inner
             .分型
+            .read()
+            .unwrap()
             .map(|f| crate::types_py::分型结构Py { inner: f })
     }
 
@@ -382,7 +470,7 @@ impl 缠论K线Py {
 
     #[getter]
     fn 分型特征值(&self) -> f64 {
-        self.inner.分型特征值
+        self.inner.分型特征值.get()
     }
 
     #[getter]
@@ -392,14 +480,36 @@ impl 缠论K线Py {
 
     #[getter]
     fn 原始结束序号(&self) -> i64 {
-        self.inner.原始结束序号
+        self.inner.原始结束序号.load(Ordering::Relaxed)
     }
 
     #[getter]
-    fn 标的K线(&self) -> K线Py {
-        K线Py {
-            inner: (*self.inner.标的K线).clone(),
+    fn 标的K线(&self, py: Python<'_>) -> Py<K线Py> {
+        bar_to_py(py, self.inner.标的K线.read().unwrap().clone())
+    }
+
+    /// pandas 兼容 — 返回所有字段构成的字典
+    #[getter]
+    fn __dict__(&self, py: Python<'_>) -> PyResult<Py<PyDict>> {
+        let dict = PyDict::new(py);
+        dict.set_item("序号", self.序号())?;
+        dict.set_item("时间戳", self.时间戳())?;
+        dict.set_item("高", self.高())?;
+        dict.set_item("低", self.低())?;
+        dict.set_item("方向", self.方向())?;
+        dict.set_item("周期", self.周期())?;
+        dict.set_item("标识", self.标识())?;
+        dict.set_item("分型特征值", self.分型特征值())?;
+        dict.set_item("原始起始序号", self.原始起始序号())?;
+        dict.set_item("原始结束序号", self.原始结束序号())?;
+        dict.set_item("与MACD柱子匹配", self.与MACD柱子匹配())?;
+        dict.set_item("与RSI匹配", self.与RSI匹配())?;
+        dict.set_item("与KDJ匹配", self.与KDJ匹配())?;
+
+        if let Some(v) = self.分型() {
+            dict.set_item("分型", v)?;
         }
+        Ok(dict.into())
     }
 
     fn __str__(&self) -> String {
@@ -410,28 +520,74 @@ impl 缠论K线Py {
         self.__str__()
     }
 
-    fn 镜像(&self) -> Self {
-        Self {
-            inner: std::rc::Rc::new(self.inner.镜像()),
+    fn __eq__(&self, other: &Bound<'_, PyAny>) -> bool {
+        if let Ok(other) = other.extract::<PyRef<'_, Self>>() {
+            return Arc::as_ptr(&self.inner) == Arc::as_ptr(&other.inner);
         }
+        false
+    }
+
+    fn __hash__(&self) -> u64 {
+        Arc::as_ptr(&self.inner) as u64
     }
 
     #[getter]
+    /// 创建当前缠K的浅拷贝副本
+    fn 镜像(&self, py: Python<'_>) -> Self {
+        let mut mirror = Self {
+            inner: std::sync::Arc::new(self.inner.镜像()),
+            bsp_set: std::sync::RwLock::new(None),
+        };
+        if let Some(ref src_set) = *self.bsp_set.read().unwrap() {
+            if let Ok(new_set) = pyo3::types::PySet::empty(py) {
+                for item in src_set.bind(py).iter() {
+                    let _ = new_set.add(item);
+                }
+                mirror.bsp_set = std::sync::RwLock::new(Some(new_set.into()));
+            }
+        }
+        mirror
+    }
+
+    #[getter]
+    /// :return: 底分型时MACD柱<0，顶分型时MACD柱>0
     fn 与MACD柱子匹配(&self) -> bool {
         self.inner.与MACD柱子匹配()
     }
 
     #[getter]
+    /// :return: 底分型时RSI < RSI_SMA，顶分型时RSI > RSI_SMA
     fn 与RSI匹配(&self) -> bool {
         self.inner.与RSI匹配()
     }
 
     #[getter]
+    /// :return: 底分型时K<D，顶分型时K>D
     fn 与KDJ匹配(&self) -> bool {
         self.inner.与KDJ匹配()
     }
 
+    #[getter]
+    fn 买卖点信息(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
+        if self.bsp_set.read().unwrap().is_none() {
+            let set = pyo3::types::PySet::empty(py)?;
+            for s in self.inner.买卖点信息.read().unwrap().iter() {
+                set.add(s.clone())?;
+            }
+            *self.bsp_set.write().unwrap() = Some(set.into());
+        }
+        Ok(self
+            .bsp_set
+            .read()
+            .unwrap()
+            .as_ref()
+            .unwrap()
+            .clone_ref(py)
+            .into_any())
+    }
+
     #[classmethod]
+    /// 在基线序列中找到与k线时间戳对齐的时间戳
     fn 时间戳对齐(
         _cls: &Bound<'_, PyType>,
         基线: Vec<Py<Self>>,
@@ -440,12 +596,14 @@ impl 缠论K线Py {
     ) -> i64 {
         let rc_list: Vec<_> = 基线
             .iter()
-            .map(|k| std::rc::Rc::clone(&k.bind(py).borrow().inner))
+            .map(|k| std::sync::Arc::clone(&k.bind(py).borrow().inner))
             .collect();
         chanlun::kline::chan_kline::缠论K线::时间戳对齐(&rc_list, &k线.borrow().inner)
     }
 
     #[classmethod]
+    #[pyo3(signature = (时间戳, 高, 低, 方向, 结构, 原始序号, 普k, 之前 = None))]
+    /// 创建新的缠论K线
     fn 创建缠K(
         _cls: &Bound<'_, PyType>,
         时间戳: i64,
@@ -456,7 +614,8 @@ impl 缠论K线Py {
         原始序号: i64,
         普k: &Bound<'_, K线Py>,
         之前: Option<&Bound<'_, Self>>,
-    ) -> Self {
+        py: Python<'_>,
+    ) -> Py<Self> {
         let prev_ref = 之前.map(|prev| prev.borrow());
         let prev_inner = prev_ref.as_ref().map(|r| r.inner.as_ref());
         let inner = chanlun::kline::chan_kline::缠论K线::创建缠K(
@@ -466,15 +625,14 @@ impl 缠论K线Py {
             方向.borrow().inner,
             结构.map(|s| s.borrow().inner),
             原始序号,
-            std::rc::Rc::new(普k.borrow().inner.clone()),
+            普k.borrow().inner.clone(),
             prev_inner,
         );
-        Self {
-            inner: std::rc::Rc::new(inner),
-        }
+        chan_kline_to_py(py, std::sync::Arc::new(inner))
     }
 
     #[classmethod]
+    /// K线包含处理（合并）
     fn 兼并(
         _cls: &Bound<'_, PyType>,
         之前缠K: Option<&Bound<'_, Self>>,
@@ -482,7 +640,7 @@ impl 缠论K线Py {
         当前普K: &Bound<'_, K线Py>,
         配置: &Bound<'_, 缠论配置Py>,
         py: Python<'_>,
-    ) -> PyResult<(Option<Self>, Option<String>)> {
+    ) -> PyResult<(Option<Py<Self>>, Option<String>)> {
         let mut ck_inner = (*当前缠K.borrow().inner).clone();
         let config = 配置.borrow().to_rust_config(py)?;
         let prev_ref = 之前缠K.map(|prev| prev.borrow());
@@ -493,10 +651,11 @@ impl 缠论K线Py {
             &当前普K.borrow().inner,
             &config,
         );
-        Ok((result.map(|rc| Self { inner: rc }), mode))
+        Ok((result.map(|rc| chan_kline_to_py(py, rc)), mode))
     }
 
     #[classmethod]
+    /// 分析K线，执行指标计算+包含处理+分型判定
     fn 分析(
         _cls: &Bound<'_, PyType>,
         当前K线: &Bound<'_, K线Py>,
@@ -505,16 +664,16 @@ impl 缠论K线Py {
         配置: &Bound<'_, 缠论配置Py>,
         py: Python<'_>,
     ) -> PyResult<(String, Option<Py<PyAny>>)> {
-        let ck_inner = 当前K线.borrow().inner.clone();
+        let ck_inner = (*当前K线.borrow().inner).clone();
         let config = 配置.borrow().to_rust_config(py)?;
 
         let mut ck_seq: Vec<_> = 缠K序列
             .iter()
-            .map(|k| std::rc::Rc::clone(&k.bind(py).borrow().inner))
+            .map(|k| std::sync::Arc::clone(&k.bind(py).borrow().inner))
             .collect();
         let mut bar_seq: Vec<_> = 普K序列
             .iter()
-            .map(|k| std::rc::Rc::new(k.bind(py).borrow().inner.clone()))
+            .map(|k| k.bind(py).borrow().inner.clone())
             .collect();
 
         let (status, _fractal) = chanlun::kline::chan_kline::缠论K线::分析(
@@ -528,26 +687,39 @@ impl 缠论K线Py {
     }
 
     #[staticmethod]
+    /// :param 序列: 缠K序列
     fn 截取(
         序列: Vec<Py<Self>>,
         始: &Bound<'_, Self>,
         终: &Bound<'_, Self>,
-    ) -> Option<Vec<Py<Self>>> {
-        let start_ptr = 始.as_ptr();
-        let end_ptr = 终.as_ptr();
-        let start_idx = 序列.iter().position(|k| k.as_ptr() == start_ptr)?;
-        let end_idx = 序列.iter().position(|k| k.as_ptr() == end_ptr)?;
-        if start_idx <= end_idx {
-            Some(
-                序列
-                    .into_iter()
-                    .skip(start_idx)
-                    .take(end_idx - start_idx + 1)
-                    .collect(),
-            )
-        } else {
-            None
+        py: Python<'_>,
+    ) -> PyResult<Vec<Py<Self>>> {
+        let start_ptr = Arc::as_ptr(&始.borrow().inner);
+        let end_ptr = Arc::as_ptr(&终.borrow().inner);
+        let start_ts = 始.borrow().inner.时间戳.load(Ordering::Relaxed);
+        let end_ts = 终.borrow().inner.时间戳.load(Ordering::Relaxed);
+        let start_idx = 序列
+            .iter()
+            .position(|k| {
+                Arc::as_ptr(&k.borrow(py).inner) == start_ptr
+                    || k.borrow(py).inner.时间戳.load(Ordering::Relaxed) == start_ts
+            })
+            .ok_or_else(|| pyo3::exceptions::PyValueError::new_err("始 不在序列中"))?;
+        let end_idx = 序列
+            .iter()
+            .position(|k| {
+                Arc::as_ptr(&k.borrow(py).inner) == end_ptr
+                    || k.borrow(py).inner.时间戳.load(Ordering::Relaxed) == end_ts
+            })
+            .ok_or_else(|| pyo3::exceptions::PyValueError::new_err("终 不在序列中"))?;
+        if start_idx > end_idx {
+            return Err(pyo3::exceptions::PyValueError::new_err("始 排序在 终 之后"));
         }
+        Ok(序列
+            .into_iter()
+            .skip(start_idx)
+            .take(end_idx - start_idx + 1)
+            .collect())
     }
 }
 

chanlun-py/src/lib.rs

@@ -34,6 +34,7 @@ mod types_py;
 
 /// 缠论技术分析库 — Rust 高性能实现
 #[pymodule]
+/// 缠论技术分析库 — Rust 高性能实现
 fn _chanlun(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
     // 阶段 1: 枚举和基础类型
     types_py::register(m)?;
@@ -51,3 +52,43 @@ fn _chanlun(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
     business_py::register(m)?;
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::*;
+    use pyo3::prelude::*;
+
+    #[test]
+    fn test_rc_pointer_across_getters() {
+        pyo3::prepare_freethreaded_python();
+        Python::with_gil(|py| {
+            let module = PyModule::new(py, "test_module").unwrap();
+            module.add_class::<business_py::观察者Py>().unwrap();
+            module.add_class::<business_py::基础买卖点Py>().unwrap();
+            module.add_class::<business_py::买卖点Py>().unwrap();
+            module.add_class::<kline_py::K线Py>().unwrap();
+            module.add_class::<kline_py::缠论K线Py>().unwrap();
+            module.add_class::<structure_py::分型Py>().unwrap();
+            module.add_class::<structure_py::虚线Py>().unwrap();
+            module.add_class::<config_py::缠论配置Py>().unwrap();
+
+            let config = config_py::缠论配置Py::from_rust_config(&Default::default()).unwrap();
+            let obs = business_py::观察者Py::new_impl("btcusd".into(), 300, config, py).unwrap();
+
+            // Feed one K line
+            let kline = kline_py::K线Py::new_impl(
+                "btcusd".into(),
+                1000,
+                100.0,
+                105.0,
+                99.0,
+                103.0,
+                1000.0,
+                0,
+                300,
+            );
+            let kline_ref = kline.into_ref(py);
+            // ... this is too complex
+        });
+    }
+}

chanlun-py/src/types_py.rs

@@ -22,8 +22,9 @@
  * SOFTWARE.
  */
 
+use pyo3::basic::CompareOp;
 use pyo3::prelude::*;
-use pyo3::types::PyType;
+use pyo3::types::{PyDict, PyType};
 
 // ========== 买卖点类型 ==========
 
@@ -37,7 +38,7 @@ use pyo3::types::PyType;
 /// 属性:
 ///   是买点: bool — 是否为买入类型
 ///   是卖点: bool — 是否为卖出类型
-#[pyclass(name = "买卖点类型")]
+#[pyclass(name = "买卖点类型", module = "chanlun._chanlun", from_py_object)]
 #[derive(Clone)]
 pub struct 买卖点类型Py {
     pub inner: chanlun::types::买卖点类型,
@@ -53,14 +54,19 @@ impl 买卖点类型Py {
         self.inner.to_string()
     }
 
-    fn __eq__(&self, other: &Bound<'_, PyAny>) -> bool {
-        if let Ok(s) = other.extract::<String>() {
-            return self.inner.to_string() == s;
+    fn __richcmp__(&self, other: &Bound<'_, PyAny>, op: CompareOp) -> PyResult<bool> {
+        let eq = if let Ok(s) = other.extract::<String>() {
+            self.inner.to_string() == s
+        } else if let Ok(other) = other.extract::<PyRef<'_, Self>>() {
+            self.inner == other.inner
+        } else {
+            return Err(pyo3::exceptions::PyNotImplementedError::new_err(""));
+        };
+        match op {
+            CompareOp::Eq => Ok(eq),
+            CompareOp::Ne => Ok(!eq),
+            _ => Err(pyo3::exceptions::PyNotImplementedError::new_err("")),
         }
-        if let Ok(other) = other.extract::<PyRef<'_, Self>>() {
-            return self.inner == other.inner;
-        }
-        false
     }
 
     fn __hash__(&self) -> u64 {
@@ -71,14 +77,25 @@ impl 买卖点类型Py {
     }
 
     #[getter]
+    /// 判断是否为买入类型（名称中含"买"字）
     fn 是买点(&self) -> bool {
         self.inner.是买点()
     }
 
     #[getter]
+    /// 判断是否为卖出类型（名称中含"卖"字）
     fn 是卖点(&self) -> bool {
         self.inner.是卖点()
     }
+
+    /// pickle 支持 — 通过 getattr(类, 名称) 重建实例
+    fn __reduce__(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
+        let getattr = py.import("builtins")?.getattr("getattr")?;
+        let module = py.import("chanlun._chanlun")?;
+        let cls = module.getattr("买卖点类型")?;
+        let name = self.__str__();
+        Ok((getattr, (cls, name)).into_pyobject(py)?.unbind().into())
+    }
 }
 
 // ========== 相对方向 ==========
@@ -101,7 +118,7 @@ impl 买卖点类型Py {
 /// 方法:
 ///   翻转() -> 相对方向 — 返回方向的对立面（向上↔向下, 缺口↔反向缺口）
 ///   分析(前高, 前低, 后高, 后低) -> 相对方向 (classmethod) — 根据价格区间判断方向
-#[pyclass(name = "相对方向")]
+#[pyclass(name = "相对方向", module = "chanlun._chanlun", from_py_object)]
 #[derive(Clone)]
 pub struct 相对方向Py {
     pub inner: chanlun::types::相对方向,
@@ -117,11 +134,19 @@ impl 相对方向Py {
         format!("{}", self.inner)
     }
 
-    fn __eq__(&self, other: &Bound<'_, PyAny>) -> bool {
-        if let Ok(other) = other.extract::<PyRef<'_, Self>>() {
-            return self.inner == other.inner;
+    fn __richcmp__(&self, other: &Bound<'_, PyAny>, op: CompareOp) -> PyResult<bool> {
+        let Ok(other) = other.extract::<PyRef<'_, Self>>() else {
+            return Err(pyo3::exceptions::PyNotImplementedError::new_err(""));
+        };
+        let eq = self.inner == other.inner;
+        match op {
+            CompareOp::Eq => Ok(eq),
+            CompareOp::Ne => Ok(!eq),
+            CompareOp::Lt => Ok((self.inner as u8) < (other.inner as u8)),
+            CompareOp::Le => Ok((self.inner as u8) <= (other.inner as u8)),
+            CompareOp::Gt => Ok((self.inner as u8) > (other.inner as u8)),
+            CompareOp::Ge => Ok((self.inner as u8) >= (other.inner as u8)),
         }
-        false
     }
 
     fn __hash__(&self) -> u64 {
@@ -135,31 +160,44 @@ impl 相对方向Py {
         }
     }
 
-    #[getter]
+    /// 判断是否为向上方向（向上/向上缺口/衔接向上）
     fn 是否向上(&self) -> bool {
         self.inner.是否向上()
     }
 
-    #[getter]
+    /// 判断是否为向下方向（向下/向下缺口/衔接向下）
     fn 是否向下(&self) -> bool {
         self.inner.是否向下()
     }
 
-    #[getter]
+    /// 判断是否为包含关系（顺/逆/同）
     fn 是否包含(&self) -> bool {
         self.inner.是否包含()
     }
 
-    #[getter]
+    /// 判断是否有缺口（向下缺口/向上缺口）
     fn 是否缺口(&self) -> bool {
         self.inner.是否缺口()
     }
 
-    #[getter]
+    /// 判断是否为首尾衔接（衔接向下/衔接向上）
     fn 是否衔接(&self) -> bool {
         self.inner.是否衔接()
     }
 
+    /// pickle 支持 — 通过 getattr(类, 名称) 重建实例
+    fn __reduce__(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
+        let getattr = py.import("builtins")?.getattr("getattr")?;
+        let module = py.import("chanlun._chanlun")?;
+        let cls = module.getattr("相对方向")?;
+        let full_name = self.__str__();
+        let name = full_name
+            .rsplit_once('.')
+            .map(|(_, v)| v)
+            .unwrap_or(&full_name);
+        Ok((getattr, (cls, name)).into_pyobject(py)?.unbind().into())
+    }
+
     /// 根据前后价格区间的OHLC值分析方向关系。
     ///
     /// 参数:
@@ -193,7 +231,7 @@ impl 相对方向Py {
 /// 方法:
 ///   分析(左, 中, 右, 可以逆序包含?, 忽视顺序包含?) -> 分型结构|None (classmethod)
 ///      — 根据三根K线的高低价分析分型结构
-#[pyclass(name = "分型结构")]
+#[pyclass(name = "分型结构", module = "chanlun._chanlun", from_py_object)]
 #[derive(Clone)]
 pub struct 分型结构Py {
     pub inner: chanlun::types::分型结构,
@@ -209,17 +247,34 @@ impl 分型结构Py {
         self.inner.to_string()
     }
 
-    fn __eq__(&self, other: &Bound<'_, PyAny>) -> bool {
-        if let Ok(other) = other.extract::<PyRef<'_, Self>>() {
-            return self.inner == other.inner;
+    fn __richcmp__(&self, other: &Bound<'_, PyAny>, op: CompareOp) -> PyResult<bool> {
+        let Ok(other) = other.extract::<PyRef<'_, Self>>() else {
+            return Err(pyo3::exceptions::PyNotImplementedError::new_err(""));
+        };
+        let eq = self.inner == other.inner;
+        match op {
+            CompareOp::Eq => Ok(eq),
+            CompareOp::Ne => Ok(!eq),
+            CompareOp::Lt => Ok((self.inner as u8) < (other.inner as u8)),
+            CompareOp::Le => Ok((self.inner as u8) <= (other.inner as u8)),
+            CompareOp::Gt => Ok((self.inner as u8) > (other.inner as u8)),
+            CompareOp::Ge => Ok((self.inner as u8) >= (other.inner as u8)),
         }
-        false
     }
 
     fn __hash__(&self) -> u64 {
         self.inner as u64
     }
 
+    /// pickle 支持 — 通过 getattr(类, 名称) 重建实例
+    fn __reduce__(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
+        let getattr = py.import("builtins")?.getattr("getattr")?;
+        let module = py.import("chanlun._chanlun")?;
+        let cls = module.getattr("分型结构")?;
+        let name = self.__str__();
+        Ok((getattr, (cls, name)).into_pyobject(py)?.unbind().into())
+    }
+
     /// 根据左中右三根K线的高/低价分析分型结构。
     ///
     /// 参数:
@@ -231,17 +286,15 @@ impl 分型结构Py {
     /// 返回:
     ///   分型结构 或 None — 无法判定时返回 None
     #[classmethod]
+    #[pyo3(signature = (左, 中, 右, 可以逆序包含 = false, 忽视顺序包含 = false))]
     fn 分析(
         _cls: &Bound<'_, PyType>,
         左: &Bound<'_, PyAny>,
         中: &Bound<'_, PyAny>,
         右: &Bound<'_, PyAny>,
-        可以逆序包含: Option<bool>,
-        忽视顺序包含: Option<bool>,
+        可以逆序包含: bool,
+        忽视顺序包含: bool,
     ) -> PyResult<Option<Self>> {
-        let 可以逆序包含 = 可以逆序包含.unwrap_or(false);
-        let 忽视顺序包含 = 忽视顺序包含.unwrap_or(false);
-
         let get_hl = |obj: &Bound<'_, PyAny>| -> PyResult<(f64, f64)> {
             Ok((
                 obj.getattr("高")?.extract::<f64>()?,
@@ -302,7 +355,7 @@ impl 分型结构Py {
 /// 方法:
 ///   居中截取区间(起点, 终点, 比例=0.15) -> 缺口|None (classmethod)
 ///     — 在两个价格之间截取中间区域作为缺口
-#[pyclass(name = "缺口")]
+#[pyclass(name = "缺口", module = "chanlun._chanlun", from_py_object)]
 #[derive(Clone)]
 pub struct 缺口Py {
     pub inner: chanlun::types::缺口,
@@ -330,6 +383,34 @@ impl 缺口Py {
         format!("{}", self.inner)
     }
 
+    fn __richcmp__(&self, other: &Bound<'_, PyAny>, op: CompareOp) -> PyResult<bool> {
+        let Ok(other) = other.extract::<PyRef<'_, Self>>() else {
+            return Err(pyo3::exceptions::PyNotImplementedError::new_err(""));
+        };
+        match op {
+            CompareOp::Eq => Ok(self.inner.高 == other.inner.高 && self.inner.低 == other.inner.低),
+            CompareOp::Ne => {
+                Ok(!(self.inner.高 == other.inner.高 && self.inner.低 == other.inner.低))
+            }
+            CompareOp::Lt => Ok(self.inner.高 < other.inner.高
+                || (self.inner.高 == other.inner.高 && self.inner.低 < other.inner.低)),
+            CompareOp::Le => Ok(self.inner.高 < other.inner.高
+                || (self.inner.高 == other.inner.高 && self.inner.低 <= other.inner.低)),
+            CompareOp::Gt => Ok(self.inner.高 > other.inner.高
+                || (self.inner.高 == other.inner.高 && self.inner.低 > other.inner.低)),
+            CompareOp::Ge => Ok(self.inner.高 > other.inner.高
+                || (self.inner.高 == other.inner.高 && self.inner.低 >= other.inner.低)),
+        }
+    }
+
+    fn __hash__(&self) -> u64 {
+        use std::hash::{Hash, Hasher};
+        let mut h = std::collections::hash_map::DefaultHasher::new();
+        self.inner.高.to_bits().hash(&mut h);
+        self.inner.低.to_bits().hash(&mut h);
+        h.finish()
+    }
+
     #[getter]
     #[pyo3(name = "高")]
     fn get_高(&self) -> f64 {
@@ -354,6 +435,16 @@ impl 缺口Py {
         self.inner.低 = value;
     }
 
+    /// pickle 支持 — 通过 cls(高, 低) 重建实例
+    fn __reduce__(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
+        let module = py.import("chanlun._chanlun")?;
+        let cls = module.getattr("缺口")?;
+        Ok((cls, (self.inner.高, self.inner.低))
+            .into_pyobject(py)?
+            .unbind()
+            .into())
+    }
+
     /// 在两个价格之间截取中间区域作为缺口。
     ///
     /// 参数:
@@ -363,13 +454,13 @@ impl 缺口Py {
     /// 返回:
     ///   缺口 或 None — 起点==终点时返回 None
     #[classmethod]
+    #[pyo3(signature = (起点, 终点, 比例 = 0.15))]
     fn 居中截取区间(
         _cls: &Bound<'_, PyType>,
         起点: f64,
         终点: f64,
-        比例: Option<f64>,
+        比例: f64,
     ) -> Option<Self> {
-        let 比例 = 比例.unwrap_or(0.15);
         chanlun::types::缺口::居中截取区间(起点, 终点, 比例).map(|inner| Self { inner })
     }
 }
@@ -409,10 +500,13 @@ pub fn register(m: &Bound<'_, PyModule>) -> PyResult<()> {
         ("T3B卖", chanlun::types::买卖点类型::T3B卖),
     ];
 
+    let mut bsp_members = PyDict::new(py);
     for (name, value) in variants {
         let instance = Py::new(py, 买卖点类型Py { inner: *value })?;
-        bsp_class.setattr(*name, instance)?;
+        bsp_class.setattr(*name, instance.clone_ref(py))?;
+        bsp_members.set_item(*name, instance)?;
     }
+    bsp_class.setattr("__members__", bsp_members)?;
 
     // 相对方向 class attributes
     let dir_class = m.getattr("相对方向")?.downcast_into::<PyType>()?.clone();
@@ -428,10 +522,13 @@ pub fn register(m: &Bound<'_, PyModule>) -> PyResult<()> {
         ("同", chanlun::types::相对方向::同),
     ];
 
+    let mut dir_members = PyDict::new(py);
     for (name, value) in dir_variants {
         let instance = Py::new(py, 相对方向Py { inner: *value })?;
-        dir_class.setattr(*name, instance)?;
+        dir_class.setattr(*name, instance.clone_ref(py))?;
+        dir_members.set_item(*name, instance)?;
     }
+    dir_class.setattr("__members__", dir_members)?;
 
     // 分型结构 class attributes
     let frac_class = m.getattr("分型结构")?.downcast_into::<PyType>()?.clone();
@@ -443,10 +540,13 @@ pub fn register(m: &Bound<'_, PyModule>) -> PyResult<()> {
         ("散", chanlun::types::分型结构::散),
     ];
 
+    let mut frac_members = PyDict::new(py);
     for (name, value) in frac_variants {
         let instance = Py::new(py, 分型结构Py { inner: *value })?;
-        frac_class.setattr(*name, instance)?;
+        frac_class.setattr(*name, instance.clone_ref(py))?;
+        frac_members.set_item(*name, instance)?;
     }
+    frac_class.setattr("__members__", frac_members)?;
 
     // Register module-level functions
     m.add_function(wrap_pyfunction!(转化为时间戳, m)?)?;

chanlun-py/test_integration.py

@@ -259,6 +259,417 @@ def test_override_reset():
     print("  ✓ test_override_reset")
 
 
+# --- Property getter 逐一覆盖 ---
+
+
+def test_override_getter_符号():
+    """重写 符号 property."""
+
+    class Sub(chanlun.观察者):
+        @property
+        def 符号(self):
+            return f"[WRAPPED] {super().符号}"
+
+    obs = Sub("btcusd", 300)
+    assert obs.符号 == "[WRAPPED] btcusd"
+    print("  ✓ test_override_getter_符号")
+
+
+def test_override_getter_周期():
+    """重写 周期 property."""
+
+    class Sub(chanlun.观察者):
+        @property
+        def 周期(self):
+            return super().周期 * 60
+
+    obs = Sub("btcusd", 5)
+    assert obs.周期 == 300
+    print("  ✓ test_override_getter_周期")
+
+
+def test_override_getter_配置():
+    """重写 配置 property."""
+
+    class Sub(chanlun.观察者):
+        @property
+        def 配置(self):
+            self._cfg_accessed = True
+            return super().配置
+
+    obs = Sub("btcusd", 300)
+    cfg = obs.配置
+    assert cfg is not None
+    assert obs._cfg_accessed
+    print("  ✓ test_override_getter_配置")
+
+
+def test_override_getter_当前K线():
+    """重写 当前K线 property."""
+
+    class Sub(chanlun.观察者):
+        def __init__(self, 符号, 周期):
+            self._cur_k_accessed = False
+
+        @property
+        def 当前K线(self):
+            self._cur_k_accessed = True
+            return super().当前K线
+
+    obs = Sub("btcusd", 300)
+    k = chanlun.K线.创建普K("t", 1761327300, 100.0, 105.0, 99.0, 103.0, 1000.0, 0, 300)
+    obs.增加原始K线(k)
+    cur = obs.当前K线
+    assert cur is not None
+    assert obs._cur_k_accessed
+    print("  ✓ test_override_getter_当前K线")
+
+
+def test_override_getter_当前缠K():
+    """重写 当前缠K property."""
+
+    class Sub(chanlun.观察者):
+        def __init__(self, 符号, 周期):
+            self._cur_ck_accessed = False
+
+        @property
+        def 当前缠K(self):
+            self._cur_ck_accessed = True
+            return super().当前缠K
+
+    obs = Sub("btcusd", 300)
+    k = chanlun.K线.创建普K("t", 1761327300, 100.0, 105.0, 99.0, 103.0, 1000.0, 0, 300)
+    obs.增加原始K线(k)
+    cur = obs.当前缠K
+    assert cur is not None
+    assert obs._cur_ck_accessed
+    print("  ✓ test_override_getter_当前缠K")
+
+
+def test_override_getter_观察员():
+    """重写 观察员 property."""
+
+    class Sub(chanlun.观察者):
+        @property
+        def 观察员(self):
+            self._obs_accessed = True
+            return self
+
+    obs = Sub("btcusd", 300)
+    assert obs.观察员 is obs
+    assert obs._obs_accessed
+    print("  ✓ test_override_getter_观察员")
+
+
+# --- 序列 getter 覆盖 ---
+
+
+def test_override_sequence_getter():
+    """重写关键序列 getter，super() 取基类值."""
+
+    class Sub(chanlun.观察者):
+        def __init__(self, 符号, 周期):
+            self._seq_accessed = set()
+
+        @property
+        def 普通K线序列(self):
+            self._seq_accessed.add("普通K线序列")
+            return super().普通K线序列
+
+        @property
+        def 缠论K线序列(self):
+            self._seq_accessed.add("缠论K线序列")
+            return super().缠论K线序列
+
+        @property
+        def 笔序列(self):
+            self._seq_accessed.add("笔序列")
+            return super().笔序列
+
+        @property
+        def 线段序列(self):
+            self._seq_accessed.add("线段序列")
+            return super().线段序列
+
+    obs = Sub("btcusd", 300)
+    k = chanlun.K线.创建普K("t", 1761327300, 100.0, 105.0, 99.0, 103.0, 1000.0, 0, 300)
+    obs.增加原始K线(k)
+
+    assert len(obs.普通K线序列) == 1
+    assert "普通K线序列" in obs._seq_accessed
+    assert len(obs.缠论K线序列) == 1
+    assert "缠论K线序列" in obs._seq_accessed
+    assert isinstance(obs.笔序列, list)
+    assert "笔序列" in obs._seq_accessed
+    assert isinstance(obs.线段序列, list)
+    assert "线段序列" in obs._seq_accessed
+    print("  ✓ test_override_sequence_getter")
+
+
+def test_override_all_sequence_getters():
+    """重写全部 15 个序列 getter，确认每个都可通过 super() 获取."""
+
+    all_seqs = [
+        "普通K线序列",
+        "缠论K线序列",
+        "分型序列",
+        "笔序列",
+        "笔_中枢序列",
+        "线段序列",
+        "中枢序列",
+        "扩展线段序列",
+        "扩展中枢序列",
+        "扩展线段序列_线段",
+        "扩展中枢序列_线段",
+        "线段_线段序列",
+        "线段_中枢序列",
+        "扩展线段序列_扩展线段",
+        "扩展中枢序列_扩展线段",
+    ]
+
+    # 动态构建子类，重写全部序列 getter
+    def _make_getter(name):
+        @property
+        def getter(self, _name=name):
+            self._all_seq_accessed.add(_name)
+            # 通过 MRO 找到父类的 property 并调用
+            for cls in type(self).__mro__[1:]:
+                if hasattr(cls, _name) and isinstance(getattr(cls, _name, None), property):
+                    return getattr(cls, _name).fget(self)
+            return []
+
+        return getter
+
+    class Sub(chanlun.观察者):
+        def __init__(self, 符号, 周期):
+            self._all_seq_accessed = set()
+
+    for seq_name in all_seqs:
+        setattr(Sub, seq_name, _make_getter(seq_name))
+
+    obs = Sub("btcusd", 300)
+    k = chanlun.K线.创建普K("t", 1761327300, 100.0, 105.0, 99.0, 103.0, 1000.0, 0, 300)
+    obs.增加原始K线(k)
+
+    for seq_name in all_seqs:
+        seq = getattr(obs, seq_name)
+        assert seq_name in obs._all_seq_accessed, f"{seq_name} 未被拦截"
+        assert isinstance(seq, list), f"{seq_name} 不是 list，而是 {type(seq)}"
+
+    print("  ✓ test_override_all_sequence_getters")
+
+
+# --- 方法重写 ---
+
+
+def test_override_加载本地数据():
+    """重写 加载本地数据，super() 调基类."""
+
+    class Sub(chanlun.观察者):
+        def __init__(self, 符号, 周期):
+            self._loaded = False
+            self._load_count = 0
+
+        def 加载本地数据(self, 文件路径):
+            self._loaded = True
+            self._load_count += 1
+            super().加载本地数据(文件路径)
+
+    obs = Sub("btcusd", 300)
+    obs.加载本地数据(NB_PATH)
+    assert obs._loaded
+    assert obs._load_count == 1
+    assert len(obs.普通K线序列) > 0
+    print("  ✓ test_override_加载本地数据")
+
+
+def test_override_静态重新分析():
+    """重写 静态重新分析，super() 调基类."""
+
+    class Sub(chanlun.观察者):
+        def __init__(self, 符号, 周期):
+            self._reanalyzed = 0
+
+        def 静态重新分析(self):
+            self._reanalyzed += 1
+            super().静态重新分析()
+
+    obs = Sub("btcusd", 300)
+    obs.加载本地数据(NB_PATH)
+    bi_before = len(obs.笔序列)
+    obs.静态重新分析()
+    assert obs._reanalyzed == 1
+    # 重新分析后笔序列仍然存在
+    assert len(obs.笔序列) >= 0
+    print("  ✓ test_override_静态重新分析")
+
+
+def test_override_测试_保存数据():
+    """重写 测试_保存数据，super() 调基类."""
+
+    class Sub(chanlun.观察者):
+        def __init__(self, 符号, 周期):
+            self._saved = False
+            self._save_root = None
+
+        def 测试_保存数据(self, root=None):
+            self._saved = True
+            self._save_root = root
+            super().测试_保存数据(root)
+
+    obs = Sub("btcusd", 300)
+    k = chanlun.K线.创建普K("t", 1761327300, 100.0, 105.0, 99.0, 103.0, 1000.0, 0, 300)
+    obs.增加原始K线(k)
+    with tempfile.TemporaryDirectory() as tmpdir:
+        obs.测试_保存数据(tmpdir)
+        assert obs._saved
+        assert obs._save_root == tmpdir
+    print("  ✓ test_override_测试_保存数据")
+
+
+def test_override_读取数据文件():
+    """重写 classmethod 读取数据文件."""
+
+    class Sub(chanlun.观察者):
+        @classmethod
+        def 读取数据文件(cls, 文件路径, 配置=None):
+            obs = super().读取数据文件(文件路径, 配置)
+            obs._custom_classmethod_flag = True
+            return obs
+
+    obs = Sub.读取数据文件(NB_PATH)
+    assert isinstance(obs, Sub)
+    assert obs._custom_classmethod_flag
+    assert len(obs.普通K线序列) > 0
+    print("  ✓ test_override_读取数据文件")
+
+
+# --- 完全重写（不调 super） ---
+
+
+def test_override_completely_no_super():
+    """完全重写 增加原始K线，不调 super()，彻底接管."""
+
+    class Sub(chanlun.观察者):
+        def 增加原始K线(self, 普K):
+            self._custom = getattr(self, "_custom", [])
+            self._custom.append(普K.时间戳)
+            # 不调 super()
+
+    obs = Sub("btcusd", 300)
+    k = chanlun.K线.创建普K("t", 1761327300, 100.0, 105.0, 99.0, 103.0, 1000.0, 0, 300)
+    obs.增加原始K线(k)
+    assert obs._custom == [1761327300]
+    assert len(obs.普通K线序列) == 0  # 基类逻辑没执行
+    print("  ✓ test_override_completely_no_super")
+
+
+# --- 同名继承（零重写） ---
+
+
+def test_override_identical_subclass():
+    """同名继承（零重写），行为与基类完全一致."""
+
+    class Sub(chanlun.观察者):
+        pass
+
+    base = chanlun.观察者("btcusd", 300)
+    sub = Sub("btcusd", 300)
+
+    bars = read_nb_bars(NB_PATH, max_bars=200)
+    for i, (ts, o, h, l, c, v) in enumerate(bars):
+        bk = chanlun.K线.创建普K(f"b_{i}", ts, o, h, l, c, v, i, 300)
+        sk = chanlun.K线.创建普K(f"s_{i}", ts, o, h, l, c, v, i, 300)
+        base.增加原始K线(bk)
+        sub.增加原始K线(sk)
+
+    for attr in ["普通K线序列", "笔序列", "线段序列", "中枢序列"]:
+        base_len = len(getattr(base, attr))
+        sub_len = len(getattr(sub, attr))
+        assert base_len == sub_len, f"{attr}: base={base_len}, sub={sub_len}"
+
+    print("  ✓ test_override_identical_subclass")
+
+
+# --- 多层继承 ---
+
+
+def test_override_three_level_mixed():
+    """三层继承，每层重写不同方法，MRO 链完整."""
+
+    class L1(chanlun.观察者):
+        def __init__(self, 符号, 周期):
+            self._l1_feed = 0
+
+        def 增加原始K线(self, 普K):
+            self._l1_feed += 1
+            super().增加原始K线(普K)
+
+    class L2(L1):
+        def __init__(self, 符号, 周期):
+            super().__init__(符号, 周期)
+            self._l2_标识 = 0
+
+        @property
+        def 标识(self):
+            self._l2_标识 += 1
+            return f"[L2] {super().标识}"
+
+    class L3(L2):
+        def __init__(self, 符号, 周期):
+            super().__init__(符号, 周期)
+            self._l3_reset = 0
+
+        def 重置基础序列(self):
+            self._l3_reset += 1
+            super().重置基础序列()
+
+    obs = L3("btcusd", 300)
+    k = chanlun.K线.创建普K("t", 1761327300, 100.0, 105.0, 99.0, 103.0, 1000.0, 0, 300)
+    obs.增加原始K线(k)
+
+    assert obs._l1_feed == 1, f"L1 feed: {obs._l1_feed}"
+    assert obs.标识 == "[L2] btcusd:300"
+    assert obs._l2_标识 == 1
+    obs.重置基础序列()
+    assert obs._l3_reset == 1
+    assert len(obs.普通K线序列) == 0
+    print("  ✓ test_override_three_level_mixed")
+
+
+# --- 跨方法调用 ---
+
+
+def test_override_cross_method_dispatch():
+    """子类方法间相互调用，确保 self 始终指向最外层实例."""
+
+    class Sub(chanlun.观察者):
+        def __init__(self, 符号, 周期):
+            self._feed_called = False
+            self._reset_called = False
+
+        def 增加原始K线(self, 普K):
+            self._feed_called = True
+            super().增加原始K线(普K)
+
+        def 重置基础序列(self):
+            self._reset_called = True
+            super().重置基础序列()
+
+        def compound_operation(self, 普K):
+            self.增加原始K线(普K)
+            self.重置基础序列()
+
+    obs = Sub("btcusd", 300)
+    k = chanlun.K线.创建普K("t", 1761327300, 100.0, 105.0, 99.0, 103.0, 1000.0, 0, 300)
+    obs.compound_operation(k)
+
+    assert obs._feed_called
+    assert obs._reset_called
+    assert len(obs.普通K线序列) == 0  # feed 后又 reset
+    print("  ✓ test_override_cross_method_dispatch")
+
+
 def run_subclass_tests():
     print("=== 观察者 子类化/重写 测试 ===")
     tests = [
@@ -272,6 +683,26 @@ def run_subclass_tests():
         test_multi_level_inheritance,
         test_unoverridden_method_inherited,
         test_override_reset,
+        # 新增：property getter 逐一覆盖
+        test_override_getter_符号,
+        test_override_getter_周期,
+        test_override_getter_配置,
+        test_override_getter_当前K线,
+        test_override_getter_当前缠K,
+        test_override_getter_观察员,
+        # 新增：序列 getter 覆盖
+        test_override_sequence_getter,
+        test_override_all_sequence_getters,
+        # 新增：方法重写
+        test_override_加载本地数据,
+        test_override_静态重新分析,
+        test_override_测试_保存数据,
+        test_override_读取数据文件,
+        # 新增：完全重写 / 同名继承 / 多层 / 跨方法
+        test_override_completely_no_super,
+        test_override_identical_subclass,
+        test_override_three_level_mixed,
+        test_override_cross_method_dispatch,
     ]
     for test in tests:
         try:
@@ -330,7 +761,17 @@ def run_integration_test():
     print(f"  Output dir: {actual_out_dir}")
     print(f"  Output files ({len(out_files)}): {out_files}")
 
-    # Compare with Python reference
+    # Compare with Python reference (skip if not available)
+    if not os.path.isdir(_PY_REF_DIR):
+        print(f"\nPython reference dir not found: {_PY_REF_DIR}")
+        print("Skipping Python comparison. Generate reference with chan.py first.")
+        print(f"Rust output is at: {actual_out_dir}")
+        print(f"Files: {out_files}")
+        # Self-consistency check: at least 14 output files expected
+        assert len(out_files) >= 14, f"Expected >= 14 output files, got {len(out_files)}"
+        print("Self-consistency check passed.")
+        return 0
+
     print("\nComparing with Python reference...")
     ref_files = sorted(os.listdir(_PY_REF_DIR))
 
@@ -395,11 +836,332 @@ def run_integration_test():
         return 1
 
 
+# ============================================================
+# K线.截取 测试
+# ============================================================
+
+
+def test_kxian_jiequ_basic():
+    """Python端创建K线，测试 K线.截取 基本功能."""
+    k1 = chanlun.K线.创建普K("k1", 1000000000, 100.0, 105.0, 98.0, 102.0, 1000.0, 0, 300)
+    k2 = chanlun.K线.创建普K("k2", 1000000060, 102.0, 108.0, 101.0, 106.0, 1200.0, 1, 300)
+    k3 = chanlun.K线.创建普K("k3", 1000000120, 106.0, 110.0, 104.0, 108.0, 900.0, 2, 300)
+    k4 = chanlun.K线.创建普K("k4", 1000000180, 108.0, 112.0, 107.0, 110.0, 1100.0, 3, 300)
+    ks = [k1, k2, k3, k4]
+
+    # 截取中间 (k2~k4)，含头尾
+    r = chanlun.K线.截取(ks, k2, k4)
+    assert len(r) == 3
+    assert r[0].时间戳 == k2.时间戳
+    assert r[-1].时间戳 == k4.时间戳
+
+    # 截取全部
+    r = chanlun.K线.截取(ks, k1, k4)
+    assert len(r) == 4
+
+    # 截取单根
+    r = chanlun.K线.截取(ks, k3, k3)
+    assert len(r) == 1
+    assert r[0].时间戳 == k3.时间戳
+
+    print("  ✓ test_kxian_jiequ_basic")
+
+
+def test_kxian_jiequ_error():
+    """K线.截取 异常边界测试."""
+    k1 = chanlun.K线.创建普K("k1", 1000000000, 100.0, 105.0, 98.0, 102.0, 1000.0, 0, 300)
+    k2 = chanlun.K线.创建普K("k2", 1000000060, 102.0, 108.0, 101.0, 106.0, 1200.0, 1, 300)
+    k3 = chanlun.K线.创建普K("k3", 1000000120, 106.0, 110.0, 104.0, 108.0, 900.0, 2, 300)
+    ks = [k1, k2, k3]
+
+    # 空序列 → ValueError
+    try:
+        chanlun.K线.截取([], k1, k1)
+        raise AssertionError("空序列应抛 ValueError")
+    except ValueError:
+        pass
+
+    # K线不在序列中 → ValueError
+    kx = chanlun.K线.创建普K("kx", 9999999999, 1.0, 1.0, 1.0, 1.0, 1.0, 99, 300)
+    try:
+        chanlun.K线.截取(ks, kx, k3)
+        raise AssertionError("不在序列中应抛 ValueError")
+    except ValueError:
+        pass
+
+    # 始在终之后 → ValueError
+    try:
+        chanlun.K线.截取(ks, k3, k1)
+        raise AssertionError("始在终之后应抛 ValueError")
+    except ValueError:
+        pass
+
+    print("  ✓ test_kxian_jiequ_error")
+
+
+def test_kxian_jiequ_from_observer():
+    """通过观察者加载数据，从笔中获取普K序列再做截取."""
+    cfg = chanlun.缠论配置()
+    obs = chanlun.观察者.读取数据文件(NB_PATH, cfg)
+
+    assert len(obs.笔序列) > 0, "笔序列为空，数据可能不够"
+    bi = obs.笔序列[0]
+
+    # 从笔获取普K子序列
+    pk_seq = bi.获取普K序列(obs)
+    assert len(pk_seq) > 0
+
+    # 用标的K线在全序列上截取，验证与笔首尾匹配
+    r = chanlun.K线.截取(obs.普通K线序列, bi.文.中.标的K线, bi.武.中.标的K线)
+    assert len(r) > 0
+    assert r[0].时间戳 == bi.文.中.标的K线.时间戳
+    assert r[-1].时间戳 == bi.武.中.标的K线.时间戳
+
+    # 截取前半段
+    mid = len(pk_seq) // 2
+    if mid > 0:
+        r = chanlun.K线.截取(pk_seq, pk_seq[0], pk_seq[mid])
+        assert len(r) == mid + 1
+        assert r[0].时间戳 == pk_seq[0].时间戳
+        assert r[-1].时间戳 == pk_seq[mid].时间戳
+
+    print(f"  ✓ test_kxian_jiequ_from_observer (笔0: {len(pk_seq)}根普K)")
+
+
+def test_kxian_jiequ_multi_bi():
+    """遍历多根笔，各自截取笔内嵌K并验证首尾."""
+    cfg = chanlun.缠论配置()
+    obs = chanlun.观察者.读取数据文件(NB_PATH, cfg)
+
+    n_checked = 0
+    for i, bi in enumerate(obs.笔序列[:10]):
+        pk_seq = bi.获取普K序列(obs)
+        if len(pk_seq) < 2:
+            continue
+        r = chanlun.K线.截取(pk_seq, pk_seq[0], pk_seq[-1])
+        assert len(r) == len(pk_seq), f"笔[{i}] 截取长度不一致: {len(r)} vs {len(pk_seq)}"
+        n_checked += 1
+
+    assert n_checked > 0
+    print(f"  ✓ test_kxian_jiequ_multi_bi (检查 {n_checked} 根笔)")
+
+
+def run_jiequ_tests():
+    print("=== K线.截取 测试 ===")
+    tests = [
+        test_kxian_jiequ_basic,
+        test_kxian_jiequ_error,
+        test_kxian_jiequ_from_observer,
+        test_kxian_jiequ_multi_bi,
+    ]
+    for test in tests:
+        try:
+            test()
+        except Exception as e:
+            print(f"  ✗ {test.__name__} FAILED: {e}")
+            import traceback
+
+            traceback.print_exc()
+            return 1
+    print("  ✓ 全部通过")
+    return 0
+
+
+# ============================================================
+# Rc 指针身份 / list.index 测试
+# ============================================================
+
+
+def _load_observer(max_bars=None):
+    """辅助函数：从 .nb 文件加载数据并创建观察者."""
+    cfg = chanlun.缠论配置()
+    obs = chanlun.观察者("btcusd", 300, cfg)
+    bars = read_nb_bars(NB_PATH, max_bars=max_bars)
+    for i, (ts, o, h, l, c, v) in enumerate(bars):
+        k = chanlun.K线.创建普K(f"k{i}", ts, o, h, l, c, v, i, 300)
+        obs.增加原始K线(k)
+    return obs
+
+
+def test_rc_same_seq_index():
+    """同一序列内 list.index 基于 Rc 指针身份正常工作."""
+    obs = _load_observer()
+
+    # 分型序列
+    fx_list = obs.分型序列
+    if len(fx_list) >= 2:
+        assert fx_list.index(fx_list[0]) == 0
+        assert fx_list.index(fx_list[1]) == 1
+
+    # 缠论K线序列
+    ck_list = obs.缠论K线序列
+    if len(ck_list) >= 2:
+        assert ck_list.index(ck_list[0]) == 0
+        assert ck_list.index(ck_list[-1]) == len(ck_list) - 1
+
+    # 笔序列
+    bi_list = obs.笔序列
+    if len(bi_list) >= 2:
+        assert bi_list.index(bi_list[0]) == 0
+        assert bi_list.index(bi_list[-1]) == len(bi_list) - 1
+
+    # 线段中的笔序列
+    if len(obs.线段序列) > 0:
+        for 段 in obs.线段序列:
+            笔列表 = 段.笔序列
+            if len(笔列表) >= 2:
+                assert 笔列表.index(笔列表[0]) == 0
+                assert 笔列表.index(笔列表[-1]) == len(笔列表) - 1
+                break
+
+    # 中枢序列
+    zs_list = obs.中枢序列
+    if len(zs_list) >= 2:
+        assert zs_list.index(zs_list[0]) == 0
+        assert zs_list.index(zs_list[-1]) == len(zs_list) - 1
+
+    print("  ✓ test_rc_same_seq_index")
+
+
+def test_rc_cross_seq_index():
+    """跨序列 list.index：段.笔序列 中查找 中枢.基础序列 元素."""
+    obs = _load_observer()
+
+    n_checked = 0
+    for 段 in obs.线段序列:
+        zs_list = 段.合_中枢序列
+        if len(zs_list) == 0:
+            continue
+        zs = zs_list[-1]
+        笔列表 = 段.笔序列
+        for j, elem in enumerate(zs.基础序列):
+            idx = 笔列表.index(elem)
+            assert idx >= 0
+            assert 笔列表[idx] == elem
+            n_checked += 1
+        break  # 只测第一个有中枢的段
+
+    assert n_checked >= 3, f"应至少检查3个中枢元素，实际 {n_checked}"
+    print(f"  ✓ test_rc_cross_seq_index (检查 {n_checked} 个元素)")
+
+
+def test_rc_zhaofenxing_cross_ref():
+    """分型序列与笔之间的跨序列引用."""
+    obs = _load_observer()
+
+    fx_list = obs.分型序列
+    if len(fx_list) >= 2 and len(obs.笔序列) > 0:
+        # 笔.文 (起始分型) 应能在分型序列中找到
+        bi = obs.笔序列[-1]
+        try:
+            idx = fx_list.index(bi.文)
+            assert idx >= 0
+        except ValueError:
+            # 可能因为分型过滤导致不在序列中，但不应 panic
+            pass
+
+    print("  ✓ test_rc_zhaofenxing_cross_ref")
+
+
+def test_rc_user_pattern():
+    """复现用户报告的原始代码模式：在中枢基础序列第一个笔之前找同向笔."""
+    obs = _load_observer()
+
+    n_segments_with_zs = 0
+    for 段 in obs.线段序列:
+        zs_list = 段.合_中枢序列
+        if len(zs_list) == 0:
+            continue
+        n_segments_with_zs += 1
+        zs = zs_list[-1]
+        笔列表 = 段.笔序列
+
+        # 用户原始代码模式
+        try:
+            idx = 笔列表.index(zs.基础序列[0])
+        except ValueError as e:
+            raise AssertionError(f"段[{段.序号}] 笔列表中找不到中枢基础序列[0]: {e}")
+
+        # 向前查找同向笔
+        found = False
+        for bi in reversed(笔列表[:idx]):
+            if bi.方向 == zs.基础序列[0].方向:
+                found = True
+                break
+        # found 可以为 True 或 False（取决于是否有前向笔）
+
+    assert n_segments_with_zs > 0, "应至少有一个段包含中枢"
+    print(f"  ✓ test_rc_user_pattern ({n_segments_with_zs} 个有中枢的段)")
+
+
+def test_tongji_macd_behavior_types():
+    """统计MACD行为返回值类型正确: int和list(tuple)，非str."""
+    obs = _load_observer(max_bars=5000)
+    if len(obs.笔序列) == 0:
+        print("  - test_tongji_macd_behavior_types SKIP (无笔)")
+        return
+    笔 = obs.笔序列[-1]
+    普K序列 = 笔.获取普K序列(obs)
+    if len(普K序列) < 2:
+        print("  - test_tongji_macd_behavior_types SKIP (K线不够)")
+        return
+    result = chanlun.虚线.统计MACD行为(普K序列, 8, 3)
+    for key in ["DIF上穿0", "DIF下穿0", "DEA上穿0", "DEA下穿0", "金叉次数", "死叉次数"]:
+        assert isinstance(result[key], int), f"{key} 应为 int, 实际 {type(result[key])}"
+    assert isinstance(result["密集交叉区域"], list), f"密集交叉区域 应为 list"
+    for item in result["密集交叉区域"]:
+        assert isinstance(item, tuple), f"密集交叉区域元素 应为 tuple"
+        assert len(item) == 3
+        assert all(isinstance(v, int) for v in item)
+    # 验证比较操作可用
+    _ = result["DEA上穿0"] > 0 and result["DEA下穿0"] > 0
+    print("  ✓ test_tongji_macd_behavior_types")
+
+
+def test_xiangduifangxiang_methods():
+    """相对方向.是否向上/是否向下 等必须是方法（需要括号调用），不能是 property."""
+    fx = chanlun.相对方向.分析(2.0, 0.5, 1.0, 0.8)
+    # 验证是可调用的方法
+    assert callable(fx.是否向上), "是否向上 必须是方法"
+    assert callable(fx.是否向下), "是否向下 必须是方法"
+    assert callable(fx.是否包含), "是否包含 必须是方法"
+    assert callable(fx.是否缺口), "是否缺口 必须是方法"
+    assert callable(fx.是否衔接), "是否衔接 必须是方法"
+    # 验证返回值类型
+    assert isinstance(fx.是否向上(), bool)
+    assert isinstance(fx.是否向下(), bool)
+
+    print("  ✓ test_xiangduifangxiang_methods")
+
+
+def run_rc_identity_tests():
+    print("=== Rc 身份 / list.index 测试 ===")
+    tests = [
+        test_tongji_macd_behavior_types,
+        test_xiangduifangxiang_methods,
+        test_rc_same_seq_index,
+        test_rc_cross_seq_index,
+        test_rc_zhaofenxing_cross_ref,
+        test_rc_user_pattern,
+    ]
+    for test in tests:
+        try:
+            test()
+        except Exception as e:
+            print(f"  ✗ {test.__name__} FAILED: {e}")
+            import traceback
+
+            traceback.print_exc()
+            return 1
+    print("  ✓ 全部通过")
+    return 0
+
+
 def main():
     import argparse
 
     parser = argparse.ArgumentParser(description="chanlun PyO3 集成测试")
-    parser.add_argument("test", nargs="?", default="all", choices=["all", "subclass", "integration"], help="运行哪组测试 (默认: all)")
+    parser.add_argument("test", nargs="?", default="all", choices=["all", "subclass", "integration", "jiequ", "rc"], help="运行哪组测试 (默认: all)")
     args = parser.parse_args()
 
     exit_code = 0
@@ -412,6 +1174,14 @@ def main():
         if run_integration_test() != 0:
             exit_code = 1
 
+    if args.test in ("all", "jiequ"):
+        if run_jiequ_tests() != 0:
+            exit_code = 1
+
+    if args.test in ("all", "rc"):
+        if run_rc_identity_tests() != 0:
+            exit_code = 1
+
     if exit_code == 0:
         print("\n✓ 所有测试通过")
 

chanlun-py/tests/test_identity.py

@@ -0,0 +1,267 @@
+#!/usr/bin/env python3
+"""
+对象标识测试：验证同一 Rc 底层数据通过不同路径访问时，
+Python 侧始终返回相同的 PyObject（`is` 比较为 True）。
+
+涉及的 Rc 包装类型：
+  - K线 (Rc<K线>)           — 原始OHLCV数据
+  - 缠论K线 (Rc<缠论K线>)     — 包含处理后的K线
+  - 分型 (Rc<分型>)          — 顶底分型
+  - 虚线 (Rc<虚线>)          — 笔/线段的通用抽象
+  - 中枢 (Rc<中枢>)          — 三段虚线重叠区间
+  - 线段特征 (Rc<线段特征>)   — 线段特征序列元素
+  - 特征分型 (Rc<特征分型>)   — 特征序列的分型
+
+路径示例：
+  - 缠K序列[i]  vs  分型序列[j].中  (同一根缠K)
+  - 分型序列[i]  vs  笔序列[j].文    (同一个分型)
+  - 笔序列[i]    vs  中枢[k].基础序列[m]  (同一条虚线)
+"""
+
+import chanlun
+import math
+
+
+def create_observer(symbol="btcusd", period=14400, n_bars=500):
+    """创建观察者并喂入模拟K线数据。"""
+    cfg = chanlun.缠论配置()
+    obs = chanlun.观察者(symbol, period, cfg)
+
+    for i in range(n_bars):
+        trend = i * 3
+        wave = math.sin(i * 0.05) * 2000
+        mid = 68000.0 + trend + wave
+        high = mid + abs(math.cos(i * 0.3)) * 400 + 100
+        low = mid - abs(math.sin(i * 0.5)) * 400 - 100
+        k = chanlun.K线(
+            标识=symbol,
+            周期=period,
+            时间戳=1771675200 + i * period,
+            开盘价=mid - 50,
+            高=high,
+            低=low,
+            收盘价=mid + 50,
+            成交量=abs(math.sin(i)) * 1000,
+        )
+        obs.增加原始K线(k)
+
+    return obs
+
+
+class Test缠K身份:
+    """缠论K线: 从序列、分型、笔端点、中枢等不同路径访问。"""
+
+    def test_序列重复获取(self):
+        """同一序列获取两次，元素应相同。"""
+        obs = create_observer()
+        seq1 = obs.缠论K线序列
+        seq2 = obs.缠论K线序列
+        for i in range(min(len(seq1), 10)):
+            assert seq1[i] is seq2[i], f"缠K序列[{i}] 身份不一致"
+
+    def test_分型中K(self):
+        """分型.中 与 缠K序列 对应元素应相同。"""
+        obs = create_observer()
+        seq = obs.缠论K线序列
+        分序 = obs.分型序列
+        for fx in 分序[:10]:
+            中 = fx.中
+            for ck in seq:
+                if ck.时间戳 == 中.时间戳:
+                    assert ck is 中, f"分型.中 (ts={中.时间戳}) 与序列中元素不匹配"
+                    break
+
+    def test_笔端点钟K(self):
+        """笔的端点分型的中间K线应与序列元素相同。"""
+        obs = create_observer()
+        seq = obs.缠论K线序列
+        for bi in obs.笔序列:
+            for nm, getter in [("文", lambda b=bi: b.文), ("武", lambda b=bi: b.武)]:
+                ep = getter()
+                if ep is None:
+                    continue
+                中 = ep.中
+                for ck in seq:
+                    if ck.时间戳 == 中.时间戳:
+                        assert ck is 中, f"笔.{nm}.中 (ts={中.时间戳}) 与序列中元素不匹配"
+                        break
+
+    def test_getter重复调用(self):
+        """同一getter调用两次返回同一对象。"""
+        obs = create_observer()
+        for fx in obs.分型序列[:5]:
+            中1 = fx.中
+            中2 = fx.中
+            assert 中1 is 中2, "分型.中 两次调用返回不同对象"
+
+
+class Test分型身份:
+    """分型: 从分型序列、笔/线段端点、买卖点等不同路径访问。"""
+
+    def test_序列重复获取(self):
+        """同一序列获取两次，元素应相同。"""
+        obs = create_observer()
+        seq1 = obs.分型序列
+        seq2 = obs.分型序列
+        for i in range(min(len(seq1), 9)):
+            assert seq1[i] is seq2[i], f"分型序列[{i}] 身份不一致"
+
+    def test_笔端点与序列(self):
+        """笔.文 / 笔.武 应与分型序列中对应元素相同。"""
+        obs = create_observer()
+        分序 = obs.分型序列
+        for bi in obs.笔序列:
+            for nm in ["文", "武"]:
+                ep = getattr(bi, nm)
+                if ep is None:
+                    continue
+                matched = False
+                for fx in 分序:
+                    if fx.时间戳 == ep.时间戳 and fx.结构 == ep.结构:
+                        assert fx is ep, f"笔.{nm} (ts={ep.时间戳}) 与分型序列中元素不匹配"
+                        matched = True
+                        break
+                assert matched, f"笔.{nm} (ts={ep.时间戳}) 在分型序列中未找到"
+
+    def test_段端点与序列(self):
+        """段.文 / 段.武 应与分型序列中对应元素相同。"""
+        obs = create_observer()
+        分序 = obs.分型序列
+        for duan in obs.线段序列:
+            for nm in ["文", "武"]:
+                ep = getattr(duan, nm)
+                if ep is None:
+                    continue
+                matched = False
+                for fx in 分序:
+                    if fx.时间戳 == ep.时间戳 and fx.结构 == ep.结构:
+                        assert fx is ep, f"段.{nm} (ts={ep.时间戳}) 与分型序列中元素不匹配"
+                        matched = True
+                        break
+                assert matched, f"段.{nm} (ts={ep.时间戳}) 在分型序列中未找到"
+
+    def test_getter重复调用(self):
+        """同一getter调用两次返回同一对象。"""
+        obs = create_observer()
+        for bi in obs.笔序列:
+            文1 = bi.文
+            文2 = bi.文
+            assert 文1 is 文2, "笔.文 两次调用返回不同对象"
+            武1 = bi.武
+            武2 = bi.武
+            assert 武1 is 武2, "笔.武 两次调用返回不同对象"
+            break  # 只测第一笔
+
+
+class Test虚线身份:
+    """虚线(笔/线段): 从笔序列、线段序列、中枢内部序列等不同路径访问。"""
+
+    def test_笔序列重复获取(self):
+        obs = create_observer()
+        seq1 = obs.笔序列
+        seq2 = obs.笔序列
+        for i in range(min(len(seq1), 8)):
+            assert seq1[i] is seq2[i], f"笔序列[{i}] 身份不一致"
+
+    def test_线段序列重复获取(self):
+        obs = create_observer()
+        seq1 = obs.线段序列
+        seq2 = obs.线段序列
+        for i in range(min(len(seq1), 5)):
+            assert seq1[i] is seq2[i], f"线段序列[{i}] 身份不一致"
+
+    def test_多个扩展序列(self):
+        """扩展线段的不同序列获取同一虚线应相同。"""
+        obs = create_observer()
+        s1 = obs.扩展线段序列
+        s2 = obs.扩展线段序列_线段
+        s3 = obs.扩展线段序列_扩展线段
+        # 这些序列可能包含不同的虚线，但如果同一个 Rc 出现在两个序列中应该相同
+        for d1 in s1:
+            for d2 in s2:
+                if d1.序号 == d2.序号:
+                    assert d1 is d2, f"扩展线段序列[{d1.序号}] 跨序列身份不一致"
+                    break
+
+
+class TestK线身份:
+    """原始K线: 从序列、买卖点、缠K标的等不同路径访问。"""
+
+    def test_序列重复获取(self):
+        obs = create_observer()
+        seq1 = obs.普通K线序列
+        seq2 = obs.普通K线序列
+        for i in range(min(len(seq1), 10)):
+            assert seq1[i] is seq2[i], f"普K序列[{i}] 身份不一致"
+
+
+class Test中枢身份:
+    """中枢: 从中枢序列、分型关联、笔中枢/线段中枢等不同路径访问。"""
+
+    def test_序列重复获取(self):
+        obs = create_observer(period=3600, n_bars=800)
+        seq1 = obs.中枢序列
+        seq2 = obs.中枢序列
+        for i in range(min(len(seq1), 5)):
+            assert seq1[i] is seq2[i], f"中枢序列[{i}] 身份不一致"
+
+    def test_笔中枢与线段中枢(self):
+        obs = create_observer(period=3600, n_bars=800)
+        笔中 = obs.笔_中枢序列
+        段中 = obs.线段_中枢序列
+        扩展中 = obs.扩展中枢序列
+        # 验证同一次获取内的身份
+        for zs in 笔中:
+            文1 = zs.文
+            文2 = zs.文
+            assert 文1 is 文2, f"笔中枢.文 两次调用不同"
+            break
+        for zs in 段中:
+            文1 = zs.文
+            文2 = zs.文
+            assert 文1 is 文2, f"段中枢.文 两次调用不同"
+            break
+
+
+class Test整体身份:
+    """跨类型综合身份测试。"""
+
+    def test_买卖点分型(self):
+        """验证买卖点的关联分型身份。"""
+        obs = create_observer(period=3600, n_bars=800)
+        # 尝试访问可用的结构
+        分序 = obs.分型序列
+        笔序 = obs.笔序列
+        assert len(分序) >= 0 and len(笔序) >= 0  # 至少不崩溃
+
+    def test_全链路一致性(self):
+        """缠K → 分型 → 笔 → 段 链路中所有对象身份一致。"""
+        obs = create_observer()
+        seq = obs.缠论K线序列
+
+        for bi in obs.笔序列:
+            # 笔的端点分型
+            for nm, getter in [("文", lambda b=bi: b.文), ("武", lambda b=bi: b.武)]:
+                ep = getter()
+                if ep is None:
+                    continue
+                # ep 中的 中 是一根缠K，应能在序列中找到相同对象
+                中 = ep.中
+                for ck in seq:
+                    if ck.时间戳 == 中.时间戳:
+                        assert ck is 中
+                        break
+                # 左也应该是可访问的
+                左 = ep.左
+                if 左 is not None:
+                    for ck in seq:
+                        if ck.时间戳 == 左.时间戳:
+                            assert ck is 左
+                            break
+                # 右也应该是可访问的
+                右 = ep.右
+                if 右 is not None:
+                    for ck in seq:
+                        if ck.时间戳 == 右.时间戳:
+                            assert ck is 右
+                            break

chanlun/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "chanlun"
-version = "26.5.1"
+version = "26.5.3"
 edition = "2021"
 rust-version = "1.70"
 license = "MIT"

chanlun/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 YuYuKunKun
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

chanlun/src/algorithm/bi.rs

@@ -29,7 +29,8 @@ use crate::kline::chan_kline::缠论K线;
 use crate::structure::dash_line::虚线;
 use crate::structure::fractal_obj::分型;
 use crate::types::{分型结构, 相对方向};
-use std::rc::Rc;
+use std::sync::atomic::Ordering;
+use std::sync::Arc;
 
 /// 笔 — 从分型生成笔的算法集合（静态方法命名空间）
 pub struct 笔;
@@ -37,8 +38,8 @@ pub struct 笔;
 impl 笔 {
     /// 获取可成笔的缠K数量（考虑弱化模式）
     pub fn 获取缠K数量(
-        缠K序列: &[Rc<缠论K线>],
-        笔序列: &[Rc<虚线>],
+        缠K序列: &[Arc<缠论K线>],
+        笔序列: &[Arc<虚线>],
         配置: &缠论配置,
     ) -> usize {
         let 实际数量 = 缠K序列.len();
@@ -51,7 +52,9 @@ impl 笔 {
             let 实际低点 = Self::实际低点(缠K序列, 配置.笔内相同终点取舍);
 
             if let (Some(ref 高点), Some(ref 低点)) = (&实际高点, &实际低点) {
-                let 原始数量 = 1 + (低点.标的K线.序号 - 高点.标的K线.序号).unsigned_abs() as usize;
+                let 原始数量 = 1
+                    + (低点.标的K线.read().unwrap().序号 - 高点.标的K线.read().unwrap().序号)
+                        .unsigned_abs() as usize;
                 if 原始数量 >= 配置.笔内元素数量 as usize {
                     return 配置.笔内元素数量 as usize;
                 }
@@ -70,16 +73,18 @@ impl 笔 {
 
                 if let Some(ref 筆) = 筆 {
                     if let (Some(ref 高_k), Some(ref 低_k)) = (&实际高点, &实际低点) {
-                        let 原始数量 =
-                            1 + (低_k.标的K线.序号 - 高_k.标的K线.序号).unsigned_abs() as usize;
+                        let 原始数量 = 1
+                            + (低_k.标的K线.read().unwrap().序号
+                                - 高_k.标的K线.read().unwrap().序号)
+                                .unsigned_abs() as usize;
                         // 向上笔
-                        if 筆.方向().是否向上() && 低_k.低 < 筆.低() {
+                        if 筆.方向().是否向上() && 低_k.低.get() < 筆.低() {
                             if 原始数量 >= 配置.笔弱化_原始数量 as usize {
                                 return 配置.笔内元素数量 as usize;
                             }
                         }
                         // 向下笔
-                        if 筆.方向().是否向下() && 低_k.低 > 筆.高() {
+                        if 筆.方向().是否向下() && 低_k.低.get() > 筆.高() {
                             if 原始数量 >= 配置.笔弱化_原始数量 as usize {
                                 return 配置.笔内元素数量 as usize;
                             }
@@ -92,147 +97,182 @@ impl 笔 {
     }
 
     /// 次高 — 排除最高值后的次高点
-    pub fn 次高(缠K序列: &[Rc<缠论K线>], 取舍: bool) -> Option<Rc<缠论K线>> {
+    pub fn 次高(缠K序列: &[Arc<缠论K线>], 取舍: bool) -> Option<Arc<缠论K线>> {
         if 缠K序列.len() < 2 {
             return 缠K序列.first().cloned();
         }
         let max_高 = 缠K序列
             .iter()
-            .map(|k| k.高)
+            .map(|k| k.高.get())
             .fold(f64::NEG_INFINITY, f64::max);
         // 排除最高值
-        let filtered: Vec<&Rc<缠论K线>> = 缠K序列.iter().filter(|k| k.高 != max_高).collect();
+        let filtered: Vec<&Arc<缠论K线>> =
+            缠K序列.iter().filter(|k| k.高.get() != max_高).collect();
         if filtered.is_empty() {
             return 缠K序列.first().cloned();
         }
         // 筛选次高值
         let second_高 = filtered
             .iter()
-            .map(|k| k.高)
+            .map(|k| k.高.get())
             .fold(f64::NEG_INFINITY, f64::max);
-        let mut candidates: Vec<&Rc<缠论K线>> = filtered
+        let mut candidates: Vec<&Arc<缠论K线>> = filtered
             .iter()
-            .filter(|k| k.高 == second_高)
+            .filter(|k| k.高.get() == second_高)
             .copied()
             .collect();
         // 按时间戳排序
-        candidates.sort_by(|a, b| a.时间戳.cmp(&b.时间戳));
+        candidates.sort_by(|a, b| {
+            a.时间戳
+                .load(Ordering::Relaxed)
+                .cmp(&b.时间戳.load(Ordering::Relaxed))
+        });
         if 取舍 {
-            Some(Rc::clone(candidates[candidates.len() - 1]))
+            Some(Arc::clone(candidates[candidates.len() - 1]))
         } else {
-            Some(Rc::clone(candidates[0]))
+            Some(Arc::clone(candidates[0]))
         }
     }
 
     /// 次低 — 排除最低值后的次低点
-    pub fn 次低(缠K序列: &[Rc<缠论K线>], 取舍: bool) -> Option<Rc<缠论K线>> {
+    pub fn 次低(缠K序列: &[Arc<缠论K线>], 取舍: bool) -> Option<Arc<缠论K线>> {
         if 缠K序列.len() < 2 {
             return 缠K序列.first().cloned();
         }
-        let min_低 = 缠K序列.iter().map(|k| k.低).fold(f64::INFINITY, f64::min);
+        let min_低 = 缠K序列
+            .iter()
+            .map(|k| k.低.get())
+            .fold(f64::INFINITY, f64::min);
         // 排除最低值
-        let filtered: Vec<&Rc<缠论K线>> = 缠K序列.iter().filter(|k| k.低 != min_低).collect();
+        let filtered: Vec<&Arc<缠论K线>> =
+            缠K序列.iter().filter(|k| k.低.get() != min_低).collect();
         if filtered.is_empty() {
             return 缠K序列.first().cloned();
         }
         // 筛选次低值
-        let second_低 = filtered.iter().map(|k| k.低).fold(f64::INFINITY, f64::min);
-        let mut candidates: Vec<&Rc<缠论K线>> = filtered
+        let second_低 = filtered
             .iter()
-            .filter(|k| k.低 == second_低)
+            .map(|k| k.低.get())
+            .fold(f64::INFINITY, f64::min);
+        let mut candidates: Vec<&Arc<缠论K线>> = filtered
+            .iter()
+            .filter(|k| k.低.get() == second_低)
             .copied()
             .collect();
         // 按时间戳排序
-        candidates.sort_by(|a, b| a.时间戳.cmp(&b.时间戳));
+        candidates.sort_by(|a, b| {
+            a.时间戳
+                .load(Ordering::Relaxed)
+                .cmp(&b.时间戳.load(Ordering::Relaxed))
+        });
         if 取舍 {
-            Some(Rc::clone(candidates[candidates.len() - 1]))
+            Some(Arc::clone(candidates[candidates.len() - 1]))
         } else {
-            Some(Rc::clone(candidates[0]))
+            Some(Arc::clone(candidates[0]))
         }
     }
 
     /// 实际高点
-    pub fn 实际高点(缠K序列: &[Rc<缠论K线>], 取舍: bool) -> Option<Rc<缠论K线>> {
+    pub fn 实际高点(缠K序列: &[Arc<缠论K线>], 取舍: bool) -> Option<Arc<缠论K线>> {
         if 缠K序列.is_empty() {
             return None;
         }
         let max_高 = 缠K序列
             .iter()
-            .map(|k| k.高)
+            .map(|k| k.高.get())
             .fold(f64::NEG_INFINITY, f64::max);
-        let mut candidates: Vec<&Rc<缠论K线>> = 缠K序列.iter().filter(|k| k.高 == max_高).collect();
+        let mut candidates: Vec<&Arc<缠论K线>> =
+            缠K序列.iter().filter(|k| k.高.get() == max_高).collect();
         if candidates.is_empty() {
-            return Some(Rc::clone(&缠K序列[0]));
+            return Some(Arc::clone(&缠K序列[0]));
         }
         // 按时间戳排序
-        candidates.sort_by(|a, b| a.时间戳.cmp(&b.时间戳));
+        candidates.sort_by(|a, b| {
+            a.时间戳
+                .load(Ordering::Relaxed)
+                .cmp(&b.时间戳.load(Ordering::Relaxed))
+        });
         if 取舍 {
-            Some(Rc::clone(candidates[candidates.len() - 1]))
+            Some(Arc::clone(candidates[candidates.len() - 1]))
         } else {
-            Some(Rc::clone(candidates[0]))
+            Some(Arc::clone(candidates[0]))
         }
     }
 
     /// 实际低点
-    pub fn 实际低点(缠K序列: &[Rc<缠论K线>], 取舍: bool) -> Option<Rc<缠论K线>> {
+    pub fn 实际低点(缠K序列: &[Arc<缠论K线>], 取舍: bool) -> Option<Arc<缠论K线>> {
         if 缠K序列.is_empty() {
             return None;
         }
-        let min_低 = 缠K序列.iter().map(|k| k.低).fold(f64::INFINITY, f64::min);
-        let mut candidates: Vec<&Rc<缠论K线>> = 缠K序列.iter().filter(|k| k.低 == min_低).collect();
+        let min_低 = 缠K序列
+            .iter()
+            .map(|k| k.低.get())
+            .fold(f64::INFINITY, f64::min);
+        let mut candidates: Vec<&Arc<缠论K线>> =
+            缠K序列.iter().filter(|k| k.低.get() == min_低).collect();
         if candidates.is_empty() {
-            return Some(Rc::clone(&缠K序列[0]));
+            return Some(Arc::clone(&缠K序列[0]));
         }
         // 按时间戳排序
-        candidates.sort_by(|a, b| a.时间戳.cmp(&b.时间戳));
+        candidates.sort_by(|a, b| {
+            a.时间戳
+                .load(Ordering::Relaxed)
+                .cmp(&b.时间戳.load(Ordering::Relaxed))
+        });
         if 取舍 {
-            Some(Rc::clone(candidates[candidates.len() - 1]))
+            Some(Arc::clone(candidates[candidates.len() - 1]))
         } else {
-            Some(Rc::clone(candidates[0]))
+            Some(Arc::clone(candidates[0]))
         }
     }
 
     /// 判断笔的相对关系是否合理
     pub fn 相对关系(筆: &虚线, 配置: &缠论配置) -> bool {
         let 文分型 = &筆.文;
-        let 武分型 = &筆.武;
+        let 武分型 = 筆.武.read().unwrap();
 
         let 相对关系 = if 配置.笔内起始分型包含整笔 {
-            let 文中_rc = Rc::clone(&文分型.中);
-            let 武中_rc = Rc::clone(&武分型.中);
-            let 文_元素: [Option<&Rc<缠论K线>>; 3] =
+            let 文中_rc = Arc::clone(&文分型.中);
+            let 武中_rc = Arc::clone(&武分型.中);
+            let 文_元素: [Option<&Arc<缠论K线>>; 3] =
                 [文分型.左.as_ref(), Some(&文中_rc), 文分型.右.as_ref()];
-            let 有效序列: Vec<&Rc<缠论K线>> = 文_元素.iter().filter_map(|x| *x).collect();
+            let 有效序列: Vec<&Arc<缠论K线>> = 文_元素.iter().filter_map(|x| *x).collect();
             let 文高 = 有效序列
                 .iter()
-                .map(|k| k.高)
+                .map(|k| k.高.get())
                 .fold(f64::NEG_INFINITY, f64::max);
-            let 文低 = 有效序列.iter().map(|k| k.低).fold(f64::INFINITY, f64::min);
+            let 文低 = 有效序列
+                .iter()
+                .map(|k| k.低.get())
+                .fold(f64::INFINITY, f64::min);
 
-            let 武_右: Option<&Rc<缠论K线>> = if 配置.笔内起始分型包含整笔_包括右 {
+            let 武_右: Option<&Arc<缠论K线>> = if 配置.笔内起始分型包含整笔_包括右 {
                 武分型.右.as_ref()
             } else {
                 None
             };
-            let 武_元素: [Option<&Rc<缠论K线>>; 3] = [武分型.左.as_ref(), Some(&武中_rc), 武_右];
-            let 有效序列: Vec<&Rc<缠论K线>> = 武_元素.iter().filter_map(|x| *x).collect();
+            let 武_元素: [Option<&Arc<缠论K线>>; 3] = [武分型.左.as_ref(), Some(&武中_rc), 武_右];
+            let 有效序列: Vec<&Arc<缠论K线>> = 武_元素.iter().filter_map(|x| *x).collect();
             let 武高 = 有效序列
                 .iter()
-                .map(|k| k.高)
+                .map(|k| k.高.get())
                 .fold(f64::NEG_INFINITY, f64::max);
-            let 武低 = 有效序列.iter().map(|k| k.低).fold(f64::INFINITY, f64::min);
+            let 武低 = 有效序列
+                .iter()
+                .map(|k| k.低.get())
+                .fold(f64::INFINITY, f64::min);
 
             crate::types::相对方向::分析(文高, 文低, 武高, 武低)
         } else {
             let 相对关系 = crate::types::相对方向::分析(
-                文分型.中.高,
-                文分型.中.低,
-                武分型.中.高,
-                武分型.中.低,
+                文分型.中.高.get(),
+                文分型.中.低.get(),
+                武分型.中.高.get(),
+                武分型.中.低.get(),
             );
             if 配置.笔内原始K线包含整笔 {
-                let 文标的 = &文分型.中.标的K线;
-                let 武标的 = &武分型.中.标的K线;
+                let 文标的 = 文分型.中.标的K线.read().unwrap();
+                let 武标的 = 武分型.中.标的K线.read().unwrap();
                 if crate::types::相对方向::分析(文标的.高, 文标的.低, 武标的.高, 武标的.低)
                     .是否包含()
                 {
@@ -249,43 +289,46 @@ impl 笔 {
     }
 
     /// 以文会友 — 根据起点分型找笔
-    pub fn 以文会友(笔序列: &[Rc<虚线>], 文: &Rc<分型>) -> Option<Rc<虚线>> {
+    pub fn 以文会友(笔序列: &[Arc<虚线>], 文: &Arc<分型>) -> Option<Arc<虚线>> {
         笔序列
             .iter()
-            .find(|b| Rc::as_ptr(&b.文) == Rc::as_ptr(文))
+            .find(|b| Arc::as_ptr(&b.文) == Arc::as_ptr(文))
             .cloned()
     }
 
     /// 以武会友 — 根据终点分型找笔
-    pub fn 以武会友(笔序列: &[Rc<虚线>], 武: &Rc<分型>) -> Option<Rc<虚线>> {
+    pub fn 以武会友(笔序列: &[Arc<虚线>], 武: &Arc<分型>) -> Option<Arc<虚线>> {
         笔序列
             .iter()
             .rev()
-            .find(|b| Rc::as_ptr(&b.武) == Rc::as_ptr(武))
+            .find(|b| Arc::as_ptr(&*b.武.read().unwrap()) == Arc::as_ptr(武))
             .cloned()
     }
 
     /// 根据缠K找对应的笔
     pub fn 根据缠K找笔(
-        笔序列: &[Rc<虚线>],
-        缠K: &Rc<缠论K线>,
+        笔序列: &[Arc<虚线>],
+        缠K: &Arc<缠论K线>,
         偏移: i64,
-    ) -> Option<Rc<虚线>> {
+    ) -> Option<Arc<虚线>> {
         // Python iterates in reverse: for 筆 in 笔序列[::-1]
         for b in 笔序列.iter().rev() {
-            // Python: 筆.文.中.序号 - 偏移 <= 缠K.序号 <= 筆.武.中.序号
-            if b.文.中.序号 - 偏移 <= 缠K.序号 && 缠K.序号 <= b.武.中.序号 {
-                return Some(Rc::clone(b));
+            // Python: 筆.文.中.序号 - 偏移 <= 缠K.序号.load(Ordering::Relaxed) <= 筆.武.read().unwrap().中.序号
+            if b.文.中.序号.load(Ordering::Relaxed) - 偏移 <= 缠K.序号.load(Ordering::Relaxed)
+                && 缠K.序号.load(Ordering::Relaxed)
+                    <= b.武.read().unwrap().中.序号.load(Ordering::Relaxed)
+            {
+                return Some(Arc::clone(b));
             }
         }
         None
     }
 
     /// 从分型序列中弹出最后一个分型和对应的笔
-    fn 弹出旧笔(分型序列: &mut Vec<Rc<分型>>, 笔序列: &mut Vec<Rc<虚线>>) {
+    fn 弹出旧笔(分型序列: &mut Vec<Arc<分型>>, 笔序列: &mut Vec<Arc<虚线>>) {
         分型序列.pop();
         if !笔序列.is_empty() {
-            // Python sets旧笔.有效性 = False; with Rc we just drop the笔
+            // Python sets旧笔.有效性.store(False, Ordering::Relaxed); with Rc we just drop the笔
             笔序列.pop();
         }
     }
@@ -294,19 +337,19 @@ impl 笔 {
     ///
     /// 返回: 递归层次数
     pub fn 分析(
-        初始分型: Rc<分型>,
-        分型序列: &mut Vec<Rc<分型>>,
-        笔序列: &mut Vec<Rc<虚线>>,
-        缠K序列: &[Rc<缠论K线>],
-        _普K序列: &[Rc<K线>],
+        初始分型: Arc<分型>,
+        分型序列: &mut Vec<Arc<分型>>,
+        笔序列: &mut Vec<Arc<虚线>>,
+        缠K序列: &[Arc<缠论K线>],
+        _普K序列: &[Arc<K线>],
         配置: &缠论配置,
     ) -> i64 {
         enum 栈项 {
-            分型(Rc<分型>, i64),
+            分型(Arc<分型>, i64),
             /// 修复错过笔哨兵: 若临时分型被接受为最后一个元素，则扫描武将之后的所有分型
             修复错过笔 {
-                临时分型: Rc<分型>,
-                武将缠K: Rc<缠论K线>,
+                临时分型: Arc<分型>,
+                武将缠K: Arc<缠论K线>,
                 层次: i64,
             },
         }
@@ -325,20 +368,20 @@ impl 笔 {
                     // Python line 2406: only scan if临时分型 was accepted as last element
                     if !分型序列.is_empty() {
                         if let Some(last_fx) = 分型序列.last() {
-                            if Rc::as_ptr(last_fx) == Rc::as_ptr(&临时分型) {
+                            if Arc::as_ptr(last_fx) == Arc::as_ptr(&临时分型) {
                                 if let Some(武_idx) = 缠K序列
                                     .iter()
-                                    .position(|k| Rc::as_ptr(k) == Rc::as_ptr(&武将缠K))
+                                    .position(|k| Arc::as_ptr(k) == Arc::as_ptr(&武将缠K))
                                 {
-                                    let mut 错过: Vec<Rc<分型>> = Vec::new();
+                                    let mut 错过: Vec<Arc<分型>> = Vec::new();
                                     for ck in &缠K序列[武_idx..] {
-                                        if ck.分型 == Some(分型结构::底)
-                                            || ck.分型 == Some(分型结构::顶)
+                                        if *ck.分型.read().unwrap() == Some(分型结构::底)
+                                            || *ck.分型.read().unwrap() == Some(分型结构::顶)
                                         {
                                             if let Some(fx) =
                                                 分型::从缠K序列中获取分型(缠K序列, ck)
                                             {
-                                                错过.push(Rc::new(fx));
+                                                错过.push(Arc::new(fx));
                                             }
                                         }
                                     }
@@ -369,7 +412,7 @@ impl 笔 {
                 continue;
             }
 
-            let 之前分型 = Rc::clone(分型序列.last().unwrap());
+            let 之前分型 = Arc::clone(分型序列.last().unwrap());
 
             // Python line 2330-2335: 清理无效数据
             if 之前分型.时间戳 == 当前分型.时间戳
@@ -384,10 +427,13 @@ impl 笔 {
                 }
             }
 
-            let 之前分型 = Rc::clone(分型序列.last().unwrap());
+            let 之前分型 = Arc::clone(分型序列.last().unwrap());
 
             // Python line 2338: 时序检查 — skip out-of-order fractals
-            if 之前分型.时间戳 > 当前分型.时间戳 && 之前分型.中.序号 - 当前分型.中.序号 > 1
+            if 之前分型.时间戳 > 当前分型.时间戳
+                && 之前分型.中.序号.load(Ordering::Relaxed)
+                    - 当前分型.中.序号.load(Ordering::Relaxed)
+                    > 1
             {
                 continue;
             }
@@ -395,7 +441,9 @@ impl 笔 {
             // Python line 2343-2348: 笔弱化模式
             if 配置.笔弱化 && !笔序列.is_empty() {
                 let 前一笔 = 笔序列.last().unwrap();
-                let 前一笔缠K数 = 前一笔.武.中.序号 - 前一笔.文.中.序号 + 1;
+                let 前一笔缠K数 = 前一笔.武.read().unwrap().中.序号.load(Ordering::Relaxed)
+                    - 前一笔.文.中.序号.load(Ordering::Relaxed)
+                    + 1;
                 if 前一笔缠K数 == 3 {
                     let 破位 = (前一笔.方向().是否向上()
                         && 前一笔.低() > 当前分型.分型特征值
@@ -412,16 +460,16 @@ impl 笔 {
             }
 
             // Re-read之前分型 again after笔弱化 pop
-            let 之前分型 = Rc::clone(分型序列.last().unwrap());
+            let 之前分型 = Arc::clone(分型序列.last().unwrap());
 
             // Python line 2350: 分型结构相反 → 可能成笔
             if 之前分型.结构 != 当前分型.结构 {
                 let 文_idx = 缠K序列
                     .iter()
-                    .position(|k| Rc::as_ptr(k) == Rc::as_ptr(&之前分型.中));
+                    .position(|k| Arc::as_ptr(k) == Arc::as_ptr(&之前分型.中));
                 let 武_idx = 缠K序列
                     .iter()
-                    .position(|k| Rc::as_ptr(k) == Rc::as_ptr(&当前分型.中));
+                    .position(|k| Arc::as_ptr(k) == Arc::as_ptr(&当前分型.中));
 
                 if let (Some(文_idx), Some(武_idx)) = (文_idx, 武_idx) {
                     let 基础序列 = &缠K序列[文_idx..=武_idx];
@@ -436,12 +484,12 @@ impl 笔 {
 
                         // Python line 2359-2367: 文官 != 之前分型.中 → adjust
                         if let Some(ref 文官_k) = 文官 {
-                            if Rc::as_ptr(文官_k) != Rc::as_ptr(&之前分型.中) {
+                            if Arc::as_ptr(文官_k) != Arc::as_ptr(&之前分型.中) {
                                 if let Some(临时分型) =
                                     分型::从缠K序列中获取分型(缠K序列, 文官_k)
                                 {
                                     栈.push(栈项::分型(当前分型, 递归层次));
-                                    栈.push(栈项::分型(Rc::new(临时分型), 递归层次 + 1));
+                                    栈.push(栈项::分型(Arc::new(临时分型), 递归层次 + 1));
                                     continue;
                                 }
                             }
@@ -455,16 +503,16 @@ impl 笔 {
                             _ => Self::实际高点(基础序列, 配置.笔内相同终点取舍),
                         };
 
-                        let 新笔 = Rc::new(虚线::创建笔(
-                            Rc::clone(&之前分型),
-                            Rc::clone(&当前分型),
+                        let 新笔 = Arc::new(虚线::创建笔(
+                            Arc::clone(&之前分型),
+                            Arc::clone(&当前分型),
                             true,
                         ));
 
                         // Python line 2374-2376: 相对关系 and武将 matches
                         if Self::相对关系(&新笔, 配置) {
                             if let Some(ref 武将_k) = 武将 {
-                                if Rc::as_ptr(武将_k) == Rc::as_ptr(&当前分型.中) {
+                                if Arc::as_ptr(武将_k) == Arc::as_ptr(&当前分型.中) {
                                     Self::_添加新笔递归(分型序列, 笔序列, 当前分型, 新笔);
                                     continue;
                                 }
@@ -478,7 +526,7 @@ impl 笔 {
                                 _ => Self::次高(基础序列, 配置.笔内相同终点取舍),
                             };
                             if let Some(ref 武将_k) = 武将 {
-                                if Rc::as_ptr(武将_k) == Rc::as_ptr(&当前分型.中)
+                                if Arc::as_ptr(武将_k) == Arc::as_ptr(&当前分型.中)
                                     && Self::相对关系(&新笔, 配置)
                                 {
                                     Self::_添加新笔递归(分型序列, 笔序列, 当前分型, 新笔);
@@ -492,7 +540,7 @@ impl 笔 {
                             if let Some(临时分型) =
                                 分型::从缠K序列中获取分型(缠K序列, 右)
                             {
-                                栈.push(栈项::分型(Rc::new(临时分型), 递归层次 + 1));
+                                栈.push(栈项::分型(Arc::new(临时分型), 递归层次 + 1));
                                 continue;
                             }
                         }
@@ -509,7 +557,7 @@ impl 笔 {
                 };
 
                 if 更强 {
-                    let 被替换分型 = Rc::clone(&之前分型);
+                    let 被替换分型 = Arc::clone(&之前分型);
                     Self::弹出旧笔(分型序列, 笔序列);
 
                     if let Some(k线序列) = 缠论K线::截取(缠K序列, &被替换分型.中, &当前分型.中)
@@ -525,14 +573,14 @@ impl 笔 {
                             if let Some(临时分型) =
                                 分型::从缠K序列中获取分型(缠K序列, 武将_k)
                             {
-                                let 临时分型_rc = Rc::new(临时分型);
+                                let 临时分型_rc = Arc::new(临时分型);
 
                                 if !分型序列.is_empty() {
                                     // Push in reverse processing order (LIFO):
-                                    栈.push(栈项::分型(Rc::clone(&当前分型), 递归层次 + 2));
+                                    栈.push(栈项::分型(Arc::clone(&当前分型), 递归层次 + 2));
                                     栈.push(栈项::修复错过笔 {
-                                        临时分型: Rc::clone(&临时分型_rc),
-                                        武将缠K: Rc::clone(武将_k),
+                                        临时分型: Arc::clone(&临时分型_rc),
+                                        武将缠K: Arc::clone(武将_k),
                                         层次: 递归层次 + 1,
                                     });
                                     栈.push(栈项::分型(临时分型_rc, 递归层次 + 1));
@@ -561,11 +609,11 @@ impl 笔 {
     ///
     /// 返回: 递归层次数
     pub fn 分析递归(
-        当前分型: Rc<分型>,
-        分型序列: &mut Vec<Rc<分型>>,
-        笔序列: &mut Vec<Rc<虚线>>,
-        缠K序列: &[Rc<缠论K线>],
-        _普K序列: &[Rc<K线>],
+        当前分型: Arc<分型>,
+        分型序列: &mut Vec<Arc<分型>>,
+        笔序列: &mut Vec<Arc<虚线>>,
+        缠K序列: &[Arc<缠论K线>],
+        _普K序列: &[Arc<K线>],
         递归层次: i64,
         配置: &缠论配置,
     ) -> i64 {
@@ -588,7 +636,7 @@ impl 笔 {
         }
 
         // Python line 2329-2335: 清理无效数据
-        let 之前分型 = Rc::clone(分型序列.last().unwrap());
+        let 之前分型 = Arc::clone(分型序列.last().unwrap());
         if 之前分型.时间戳 == 当前分型.时间戳
             || matches!(之前分型.结构, 分型结构::上 | 分型结构::下)
         {
@@ -602,8 +650,10 @@ impl 笔 {
         }
 
         // Python line 2337-2341: 时序检查
-        let 之前分型 = Rc::clone(分型序列.last().unwrap());
-        if 之前分型.时间戳 > 当前分型.时间戳 && 之前分型.中.序号 - 当前分型.中.序号 > 1
+        let 之前分型 = Arc::clone(分型序列.last().unwrap());
+        if 之前分型.时间戳 > 当前分型.时间戳
+            && 之前分型.中.序号.load(Ordering::Relaxed) - 当前分型.中.序号.load(Ordering::Relaxed)
+                > 1
         {
             println!("时序错误-{}, {}, {}", 递归层次, 之前分型, 当前分型);
             return 递归层次;
@@ -612,7 +662,9 @@ impl 笔 {
         // Python line 2343-2348: 笔弱化模式
         if 配置.笔弱化 && !笔序列.is_empty() {
             let 前一笔 = 笔序列.last().unwrap();
-            let 前一笔缠K数 = 前一笔.武.中.序号 - 前一笔.文.中.序号 + 1;
+            let 前一笔缠K数 = 前一笔.武.read().unwrap().中.序号.load(Ordering::Relaxed)
+                - 前一笔.文.中.序号.load(Ordering::Relaxed)
+                + 1;
             if 前一笔缠K数 == 3 {
                 let 破位 = (前一笔.方向().是否向上()
                     && 前一笔.低() > 当前分型.分型特征值
@@ -636,13 +688,13 @@ impl 笔 {
         }
 
         // Python line 2350: 分型结构相反 → 可能成笔
-        let 之前分型 = Rc::clone(分型序列.last().unwrap());
+        let 之前分型 = Arc::clone(分型序列.last().unwrap());
         if 之前分型.结构 != 当前分型.结构 {
             if let Some(基础序列) = 缠论K线::截取(缠K序列, &之前分型.中, &当前分型.中)
             {
-                let 当前笔 = Rc::new(虚线::创建笔(
-                    Rc::clone(&之前分型),
-                    Rc::clone(&当前分型),
+                let 当前笔 = Arc::new(虚线::创建笔(
+                    Arc::clone(&之前分型),
+                    Arc::clone(&当前分型),
                     true,
                 ));
 
@@ -656,12 +708,12 @@ impl 笔 {
 
                     // Python line 2359-2367: 文官调整
                     if let Some(ref 文官_k) = 文官 {
-                        if Rc::as_ptr(文官_k) != Rc::as_ptr(&之前分型.中) {
+                        if Arc::as_ptr(文官_k) != Arc::as_ptr(&之前分型.中) {
                             if let Some(临时分型) =
                                 分型::从缠K序列中获取分型(缠K序列, 文官_k)
                             {
                                 let 递归层次 = Self::分析递归(
-                                    Rc::new(临时分型),
+                                    Arc::new(临时分型),
                                     分型序列,
                                     笔序列,
                                     缠K序列,
@@ -690,7 +742,7 @@ impl 笔 {
 
                     if Self::相对关系(&当前笔, 配置) {
                         if let Some(ref 武将_k) = 武将 {
-                            if Rc::as_ptr(武将_k) == Rc::as_ptr(&当前分型.中) {
+                            if Arc::as_ptr(武将_k) == Arc::as_ptr(&当前分型.中) {
                                 // 直接添加（对照 Python _添加新笔：直接 append）
                                 Self::_添加新笔递归(分型序列, 笔序列, 当前分型, 当前笔);
                                 return 递归层次;
@@ -705,7 +757,7 @@ impl 笔 {
                             _ => Self::次高(&基础序列, 配置.笔内相同终点取舍),
                         };
                         if let Some(ref 武将_k) = 武将 {
-                            if Rc::as_ptr(武将_k) == Rc::as_ptr(&当前分型.中)
+                            if Arc::as_ptr(武将_k) == Arc::as_ptr(&当前分型.中)
                                 && Self::相对关系(&当前笔, 配置)
                             {
                                 Self::_添加新笔递归(分型序列, 笔序列, 当前分型, 当前笔);
@@ -719,7 +771,7 @@ impl 笔 {
                         if let Some(临时分型) = 分型::从缠K序列中获取分型(缠K序列, 右)
                         {
                             return Self::分析递归(
-                                Rc::new(临时分型),
+                                Arc::new(临时分型),
                                 分型序列,
                                 笔序列,
                                 缠K序列,
@@ -743,7 +795,7 @@ impl 笔 {
 
             if 更强 {
                 // 保存被弹出的之前分型（用于修复错过笔的范围计算）
-                let 被替换分型 = Rc::clone(&之前分型);
+                let 被替换分型 = Arc::clone(&之前分型);
                 Self::弹出旧笔(分型序列, 笔序列);
 
                 if let Some(k线序列) = 缠论K线::截取(缠K序列, &被替换分型.中, &当前分型.中)
@@ -757,11 +809,11 @@ impl 笔 {
                         if let Some(临时分型) =
                             分型::从缠K序列中获取分型(缠K序列, 武将_k)
                         {
-                            let 临时分型_rc = Rc::new(临时分型);
+                            let 临时分型_rc = Arc::new(临时分型);
 
                             if !分型序列.is_empty() {
                                 let mut 递归层次 = Self::分析递归(
-                                    Rc::clone(&临时分型_rc),
+                                    Arc::clone(&临时分型_rc),
                                     分型序列,
                                     笔序列,
                                     缠K序列,
@@ -772,25 +824,25 @@ impl 笔 {
 
                                 // 修复错过的笔: 扫描武将之后的所有分型
                                 if !分型序列.is_empty()
-                                    && Rc::as_ptr(分型序列.last().unwrap())
-                                        == Rc::as_ptr(&临时分型_rc)
+                                    && Arc::as_ptr(分型序列.last().unwrap())
+                                        == Arc::as_ptr(&临时分型_rc)
                                 {
                                     if let Some(武_idx) = 缠K序列
                                         .iter()
-                                        .position(|k| Rc::as_ptr(k) == Rc::as_ptr(武将_k))
+                                        .position(|k| Arc::as_ptr(k) == Arc::as_ptr(武将_k))
                                     {
                                         for ck in &缠K序列[武_idx..] {
-                                            if ck.分型 == Some(分型结构::底)
-                                                || ck.分型 == Some(分型结构::顶)
+                                            if *ck.分型.read().unwrap() == Some(分型结构::底)
+                                                || *ck.分型.read().unwrap() == Some(分型结构::顶)
                                             {
                                                 if let Some(错过分型) =
                                                     分型::从缠K序列中获取分型(
                                                         缠K序列, ck,
                                                     )
                                                 {
-                                                    let 错过分型_rc = Rc::new(错过分型);
+                                                    let 错过分型_rc = Arc::new(错过分型);
                                                     递归层次 = Self::分析递归(
-                                                        Rc::clone(&错过分型_rc),
+                                                        Arc::clone(&错过分型_rc),
                                                         分型序列,
                                                         笔序列,
                                                         缠K序列,
@@ -839,17 +891,20 @@ impl 笔 {
 
     /// 添加新笔到序列（递归版本 — 直接追加，对应 Python _添加新笔）
     fn _添加新笔递归(
-        分型序列: &mut Vec<Rc<分型>>,
-        笔序列: &mut Vec<Rc<虚线>>,
-        新分型: Rc<分型>,
-        mut 新笔: Rc<虚线>,
+        分型序列: &mut Vec<Arc<分型>>,
+        笔序列: &mut Vec<Arc<虚线>>,
+        新分型: Arc<分型>,
+        mut 新笔: Arc<虚线>,
     ) {
         分型序列.push(新分型);
         if !笔序列.is_empty() {
-            let seg = Rc::make_mut(&mut 新笔);
-            seg.序号 = 笔序列.last().unwrap().序号 + 1;
-            if seg.武.左.is_none() && seg.武.右.is_none() {
-                seg.有效性 = false;
+            let seg = Arc::make_mut(&mut 新笔);
+            seg.序号.store(
+                笔序列.last().unwrap().序号.load(Ordering::Relaxed) + 1,
+                Ordering::Relaxed,
+            );
+            if seg.武.read().unwrap().左.is_none() && seg.武.read().unwrap().右.is_none() {
+                seg.有效性.store(false, Ordering::Relaxed);
             }
         }
         笔序列.push(新笔);
@@ -867,7 +922,8 @@ impl 笔 {
                     Self::实际高点(&基础序列, false),
                     Self::实际低点(&基础序列, 配置.笔内相同终点取舍),
                 ) {
-                    if Rc::ptr_eq(&筆.文.中, &实际高) && Rc::ptr_eq(&筆.武.中, &实际低)
+                    if Arc::ptr_eq(&筆.文.中, &实际高)
+                        && Arc::ptr_eq(&筆.武.read().unwrap().中, &实际低)
                     {
                         return true;
                     }
@@ -878,7 +934,8 @@ impl 笔 {
                     Self::实际低点(&基础序列, false),
                     Self::实际高点(&基础序列, 配置.笔内相同终点取舍),
                 ) {
-                    if Rc::ptr_eq(&筆.文.中, &实际低) && Rc::ptr_eq(&筆.武.中, &实际高)
+                    if Arc::ptr_eq(&筆.文.中, &实际低)
+                        && Arc::ptr_eq(&筆.武.read().unwrap().中, &实际高)
                     {
                         return true;
                     }
@@ -891,7 +948,7 @@ impl 笔 {
     /// 获取所有停顿位置 — 在笔范围内找出所有能成笔的分型组合
     pub fn 获取所有停顿位置(筆: &虚线, 观察员: &观察者) -> Vec<虚线> {
         let mut 笔序列 = Vec::new();
-        let 文 = Rc::clone(&筆.文);
+        let 文 = Arc::clone(&筆.文);
         let 基础序列 = 筆.获取缠K序列(&观察员.缠论K线序列);
 
         if 基础序列.len() < 5 {
@@ -901,23 +958,30 @@ impl 笔 {
         for i in 3..基础序列.len() - 1 {
             let k = &基础序列[i];
 
-            if k.分型 == Some(分型结构::顶) && 筆.方向() == 相对方向::向上 {
-                let 左 = Rc::clone(&基础序列[i - 1]);
-                let 中 = Rc::clone(k);
-                let 右 = Rc::clone(&基础序列[i + 1]);
+            if *k.分型.read().unwrap() == Some(分型结构::顶) && 筆.方向() == 相对方向::向上
+            {
+                let 左 = Arc::clone(&基础序列[i - 1]);
+                let 中 = Arc::clone(k);
+                let 右 = Arc::clone(&基础序列[i + 1]);
                 let 武 = 分型::new(Some(左), 中, Some(右));
-                let mut 当前笔 = 虚线::创建笔(Rc::clone(&文), Rc::new(武), true);
-                当前笔.序号 = 筆.序号;
+                let 当前笔 = 虚线::创建笔(Arc::clone(&文), Arc::new(武), true);
+                当前笔
+                    .序号
+                    .store(筆.序号.load(Ordering::Relaxed), Ordering::Relaxed);
                 if Self::自检(&当前笔, 观察员) {
                     笔序列.push(当前笔);
                 }
-            } else if k.分型 == Some(分型结构::底) && 筆.方向() == 相对方向::向下 {
-                let 左 = Rc::clone(&基础序列[i - 1]);
-                let 中 = Rc::clone(k);
-                let 右 = Rc::clone(&基础序列[i + 1]);
+            } else if *k.分型.read().unwrap() == Some(分型结构::底)
+                && 筆.方向() == 相对方向::向下
+            {
+                let 左 = Arc::clone(&基础序列[i - 1]);
+                let 中 = Arc::clone(k);
+                let 右 = Arc::clone(&基础序列[i + 1]);
                 let 武 = 分型::new(Some(左), 中, Some(右));
-                let mut 当前笔 = 虚线::创建笔(Rc::clone(&文), Rc::new(武), true);
-                当前笔.序号 = 筆.序号;
+                let 当前笔 = 虚线::创建笔(Arc::clone(&文), Arc::new(武), true);
+                当前笔
+                    .序号
+                    .store(筆.序号.load(Ordering::Relaxed), Ordering::Relaxed);
                 if Self::自检(&当前笔, 观察员) {
                     笔序列.push(当前笔);
                 }
@@ -928,19 +992,19 @@ impl 笔 {
     }
 
     /// 是否背驰过 — 判断笔是否在停顿位置出现过MACD趋向背驰
-    pub fn 是否背驰过(当前筆: &虚线, 观察员: &观察者) -> Vec<Rc<分型>> {
+    pub fn 是否背驰过(当前筆: &虚线, 观察员: &观察者) -> Vec<Arc<缠论K线>> {
         let 停顿位置 = Self::获取所有停顿位置(当前筆, 观察员);
         let mut 结果 = Vec::new();
 
         for 筆 in &停顿位置 {
             let k线范围 = K线::截取rc(
                 &观察员.普通K线序列,
-                &当前筆.文.中.标的K线,
-                &当前筆.武.中.标的K线,
+                &当前筆.文.中.标的K线.read().unwrap().clone(),
+                &当前筆.武.read().unwrap().中.标的K线.read().unwrap().clone(),
             );
             let 背驰信号 = 虚线::计算K线序列MACD趋向背驰(&k线范围, 筆.方向());
             if 背驰信号.iter().all(|&x| x) {
-                结果.push(Rc::clone(&筆.武));
+                结果.push(Arc::clone(&筆.武.read().unwrap().中));
             }
         }
 

chanlun/src/algorithm/divergence.rs

@@ -26,7 +26,7 @@ use crate::config::缠论配置;
 use crate::kline::bar::K线;
 use crate::structure::dash_line::虚线;
 use crate::types::相对方向;
-use std::rc::Rc;
+use std::sync::Arc;
 
 /// 背驰分析 — 判断进入段和离开段之间是否存在背驰
 pub struct 背驰分析;
@@ -35,12 +35,18 @@ impl 背驰分析 {
     /// MACD背驰 — MACD柱状线面积背驰
     /// 方式: "总"=阳+|阴|总面积, 其他=按进入段方向选阳或阴
     pub fn MACD背驰(
-        进入段: &虚线, 离开段: &虚线, K线序列: &[Rc<K线>], 方式: &str
+        进入段: &虚线, 离开段: &虚线, K线序列: &[Arc<K线>], 方式: &str
     ) -> bool {
-        let 进入MACD =
-            Self::_获取MACD面积(K线序列, &进入段.文.中.标的K线, &进入段.武.中.标的K线);
-        let 离开MACD =
-            Self::_获取MACD面积(K线序列, &离开段.文.中.标的K线, &离开段.武.中.标的K线);
+        let 进入MACD = Self::_获取MACD面积(
+            K线序列,
+            &*进入段.文.中.标的K线.read().unwrap(),
+            &*进入段.武.read().unwrap().中.标的K线.read().unwrap(),
+        );
+        let 离开MACD = Self::_获取MACD面积(
+            K线序列,
+            &*离开段.文.中.标的K线.read().unwrap(),
+            &*离开段.武.read().unwrap().中.标的K线.read().unwrap(),
+        );
 
         // 计算面积（绝对值求和）
         let 进入面积 = if 方式 == "总" {
@@ -63,18 +69,18 @@ impl 背驰分析 {
 
     /// 斜率背驰 — 价格斜率背驰
     pub fn 斜率背驰(进入段: &虚线, 离开段: &虚线) -> bool {
-        let dx = (进入段.武.时间戳 - 进入段.文.时间戳) as f64;
+        let dx = (进入段.武.read().unwrap().时间戳 - 进入段.文.时间戳) as f64;
         if dx == 0.0 {
             return false;
         }
-        let dy = 进入段.武.分型特征值 - 进入段.文.分型特征值;
+        let dy = 进入段.武.read().unwrap().分型特征值 - 进入段.文.分型特征值;
         let 进入斜率 = dy / dx;
 
-        let dx = (离开段.武.时间戳 - 离开段.文.时间戳) as f64;
+        let dx = (离开段.武.read().unwrap().时间戳 - 离开段.文.时间戳) as f64;
         if dx == 0.0 {
             return false;
         }
-        let dy = 离开段.武.分型特征值 - 离开段.文.分型特征值;
+        let dy = 离开段.武.read().unwrap().分型特征值 - 离开段.文.分型特征值;
         let 离开斜率 = dy / dx;
 
         if 进入段.方向() == 相对方向::向上 {
@@ -86,12 +92,12 @@ impl 背驰分析 {
 
     /// 测度背驰 — 价格时间测度背驰
     pub fn 测度背驰(进入段: &虚线, 离开段: &虚线) -> bool {
-        let dx = (进入段.武.时间戳 - 进入段.文.时间戳) as f64;
-        let dy = 进入段.武.分型特征值 - 进入段.文.分型特征值;
+        let dx = (进入段.武.read().unwrap().时间戳 - 进入段.文.时间戳) as f64;
+        let dy = 进入段.武.read().unwrap().分型特征值 - 进入段.文.分型特征值;
         let 进入测度 = (dx * dx + dy * dy).sqrt();
 
-        let dx = (离开段.武.时间戳 - 离开段.文.时间戳) as f64;
-        let dy = 离开段.武.分型特征值 - 离开段.文.分型特征值;
+        let dx = (离开段.武.read().unwrap().时间戳 - 离开段.文.时间戳) as f64;
+        let dy = 离开段.武.read().unwrap().分型特征值 - 离开段.文.分型特征值;
         let 离开测度 = (dx * dx + dy * dy).sqrt();
 
         if 进入段.方向() == 相对方向::向上 {
@@ -102,14 +108,14 @@ impl 背驰分析 {
     }
 
     /// 全量背驰 — MACD + 斜率 + 测度 三者全满足
-    pub fn 全量背驰(进入段: &虚线, 离开段: &虚线, 普K序列: &[Rc<K线>]) -> bool {
+    pub fn 全量背驰(进入段: &虚线, 离开段: &虚线, 普K序列: &[Arc<K线>]) -> bool {
         Self::MACD背驰(进入段, 离开段, 普K序列, "总")
             && Self::测度背驰(进入段, 离开段)
             && Self::斜率背驰(进入段, 离开段)
     }
 
     /// 任意背驰 — 任一条件满足即可
-    pub fn 任意背驰(进入段: &虚线, 离开段: &虚线, 普K序列: &[Rc<K线>]) -> bool {
+    pub fn 任意背驰(进入段: &虚线, 离开段: &虚线, 普K序列: &[Arc<K线>]) -> bool {
         Self::MACD背驰(进入段, 离开段, 普K序列, "总")
             || Self::测度背驰(进入段, 离开段)
             || Self::斜率背驰(进入段, 离开段)
@@ -119,7 +125,7 @@ impl 背驰分析 {
     pub fn 配置背驰(
         进入段: &虚线,
         离开段: &虚线,
-        普K序列: &[Rc<K线>],
+        普K序列: &[Arc<K线>],
         配置: &缠论配置,
     ) -> bool {
         match (
@@ -152,7 +158,7 @@ impl 背驰分析 {
     }
 
     /// 任选背驰 — 至少两个条件满足（多数投票）
-    pub fn 任选背驰(进入段: &虚线, 离开段: &虚线, 普K序列: &[Rc<K线>]) -> bool {
+    pub fn 任选背驰(进入段: &虚线, 离开段: &虚线, 普K序列: &[Arc<K线>]) -> bool {
         let 混沌槽 = [
             Self::MACD背驰(进入段, 离开段, 普K序列, "总"),
             Self::测度背驰(进入段, 离开段),
@@ -165,7 +171,7 @@ impl 背驰分析 {
     pub fn 背驰模式(
         进入段: &虚线,
         离开段: &虚线,
-        普K序列: &[Rc<K线>],
+        普K序列: &[Arc<K线>],
         配置: &缠论配置,
         模式: &str,
     ) -> bool {
@@ -180,9 +186,13 @@ impl 背驰分析 {
 
     // ---- 内部辅助 ----
 
-    fn _获取MACD面积(K线序列: &[Rc<K线>], 始: &Rc<K线>, 终: &Rc<K线>) -> MACD面积 {
-        let 始_idx = K线序列.iter().position(|k| Rc::as_ptr(k) == Rc::as_ptr(始));
-        let 终_idx = K线序列.iter().position(|k| Rc::as_ptr(k) == Rc::as_ptr(终));
+    fn _获取MACD面积(K线序列: &[Arc<K线>], 始: &Arc<K线>, 终: &Arc<K线>) -> MACD面积 {
+        let 始_idx = K线序列
+            .iter()
+            .position(|k| Arc::as_ptr(k) == Arc::as_ptr(始));
+        let 终_idx = K线序列
+            .iter()
+            .position(|k| Arc::as_ptr(k) == Arc::as_ptr(终));
 
         let mut 阳 = 0.0f64;
         let mut 阴 = 0.0f64;

chanlun/src/algorithm/hub.rs

@@ -25,35 +25,50 @@
 use crate::structure::dash_line::虚线;
 use crate::structure::fractal_obj::分型;
 use crate::types::相对方向;
-use std::rc::Rc;
+use std::sync::atomic::{AtomicI64, Ordering};
+use std::sync::{Arc, RwLock};
 
 /// 中枢 — 三段虚线重叠区间构成的价格中枢
-#[derive(Debug, Clone)]
+/// 可变字段使用 Cell/RefCell 实现内部可变性，确保 Rc 指针身份一致
+#[derive(Debug)]
 pub struct 中枢 {
-    pub 序号: i64,
-    pub 标识: String,
-    pub 级别: i64,
-    pub 基础序列: Vec<Rc<虚线>>,
-    pub 第三买卖线: Option<Rc<虚线>>,
-    pub 本级_第三买卖线: Option<Rc<虚线>>,
+    pub 序号: AtomicI64,
+    pub 标识: RwLock<String>,
+    pub 级别: AtomicI64,
+    pub 基础序列: RwLock<Vec<Arc<虚线>>>,
+    pub 第三买卖线: RwLock<Option<Arc<虚线>>>,
+    pub 本级_第三买卖线: RwLock<Option<Arc<虚线>>>,
+}
+
+impl Clone for 中枢 {
+    fn clone(&self) -> Self {
+        Self {
+            序号: AtomicI64::new(self.序号.load(Ordering::Relaxed)),
+            标识: RwLock::new(self.标识.read().unwrap().clone()),
+            级别: AtomicI64::new(self.级别.load(Ordering::Relaxed)),
+            基础序列: RwLock::new(self.基础序列.read().unwrap().clone()),
+            第三买卖线: RwLock::new(self.第三买卖线.read().unwrap().clone()),
+            本级_第三买卖线: RwLock::new(self.本级_第三买卖线.read().unwrap().clone()),
+        }
+    }
 }
 
 impl 中枢 {
-    pub fn new(序号: i64, 标识: String, 级别: i64, 基础序列: Vec<Rc<虚线>>) -> Self {
+    pub fn new(序号: i64, 标识: String, 级别: i64, 基础序列: Vec<Arc<虚线>>) -> Self {
         Self {
-            序号,
-            标识,
-            级别,
-            基础序列: 基础序列.into_iter().take(3).collect(),
-            第三买卖线: None,
-            本级_第三买卖线: None,
+            序号: AtomicI64::new(序号),
+            标识: RwLock::new(标识),
+            级别: AtomicI64::new(级别),
+            基础序列: RwLock::new(基础序列.into_iter().take(3).collect()),
+            第三买卖线: RwLock::new(None),
+            本级_第三买卖线: RwLock::new(None),
         }
     }
 
-    pub fn 添加虚线(&mut self, 实线: Rc<虚线>) {
-        self.基础序列.push(实线);
-        self.本级_第三买卖线 = None;
-        self.第三买卖线 = None;
+    pub fn 添加虚线(&self, 实线: Arc<虚线>) {
+        self.基础序列.write().unwrap().push(实线);
+        *self.本级_第三买卖线.write().unwrap() = None;
+        *self.第三买卖线.write().unwrap() = None;
     }
 
     pub fn 图表标题(&self) -> String {
@@ -61,21 +76,21 @@ impl 中枢 {
             "{}:{}:{}:{}",
             self.文().中.标识,
             self.文().中.周期,
-            self.标识,
-            self.序号
+            self.标识.read().unwrap(),
+            self.序号.load(Ordering::Relaxed)
         )
     }
 
-    pub fn 离开段(&self) -> Rc<虚线> {
-        Rc::clone(&self.基础序列[self.基础序列.len() - 1])
+    pub fn 离开段(&self) -> Arc<虚线> {
+        Arc::clone(&self.基础序列.read().unwrap()[self.基础序列.read().unwrap().len() - 1])
     }
 
     pub fn 方向(&self) -> 相对方向 {
-        self.基础序列[0].方向().翻转()
+        self.基础序列.read().unwrap()[0].方向().翻转()
     }
 
     pub fn 高(&self) -> f64 {
-        self.基础序列[..3]
+        self.基础序列.read().unwrap()[..3]
             .iter()
             .map(|x| x.高())
             .min_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))
@@ -83,7 +98,7 @@ impl 中枢 {
     }
 
     pub fn 低(&self) -> f64 {
-        self.基础序列[..3]
+        self.基础序列.read().unwrap()[..3]
             .iter()
             .map(|x| x.低())
             .max_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))
@@ -92,6 +107,8 @@ impl 中枢 {
 
     pub fn 高高(&self) -> f64 {
         self.基础序列
+            .read()
+            .unwrap()
             .iter()
             .map(|x| x.高())
             .max_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))
@@ -100,47 +117,54 @@ impl 中枢 {
 
     pub fn 低低(&self) -> f64 {
         self.基础序列
+            .read()
+            .unwrap()
             .iter()
             .map(|x| x.低())
             .min_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))
             .unwrap_or(0.0)
     }
 
-    pub fn 文(&self) -> Rc<分型> {
-        Rc::clone(&self.基础序列[0].文)
+    pub fn 文(&self) -> Arc<分型> {
+        Arc::clone(&self.基础序列.read().unwrap()[0].文)
     }
 
-    pub fn 武(&self) -> Rc<分型> {
-        Rc::clone(&self.基础序列[self.基础序列.len() - 1].武)
+    pub fn 武(&self) -> Arc<分型> {
+        Arc::clone(
+            &*self.基础序列.read().unwrap()[self.基础序列.read().unwrap().len() - 1]
+                .武
+                .read()
+                .unwrap(),
+        )
     }
 
-    pub fn 设置第三买卖线(&mut self, 线: Rc<虚线>) {
-        self.第三买卖线 = Some(线);
+    pub fn 设置第三买卖线(&self, 线: Arc<虚线>) {
+        *self.第三买卖线.write().unwrap() = Some(线);
     }
 
     /// 获取序列 — 基础序列 + 第三买卖线（若有）
-    pub fn 获取序列(&self) -> Vec<Rc<虚线>> {
-        let mut 序列: Vec<Rc<虚线>> = self.基础序列.clone();
-        if let Some(ref 三买) = self.第三买卖线 {
-            序列.push(Rc::clone(三买));
+    pub fn 获取序列(&self) -> Vec<Arc<虚线>> {
+        let mut 序列: Vec<Arc<虚线>> = self.基础序列.read().unwrap().clone();
+        if let Some(ref 三买) = *self.第三买卖线.read().unwrap() {
+            序列.push(Arc::clone(三买));
         }
         序列
     }
 
     pub fn 获取数据文本(&self) -> String {
-        let 第三买卖线_str = match &self.第三买卖线 {
+        let 第三买卖线_str = match &*self.第三买卖线.read().unwrap() {
             Some(x) => format!("{}", x),
             None => "None".to_string(),
         };
-        let 本级_第三买卖线_str = match &self.本级_第三买卖线 {
+        let 本级_第三买卖线_str = match &*self.本级_第三买卖线.read().unwrap() {
             Some(x) => format!("{}", x),
             None => "None".to_string(),
         };
         format!(
             "{}, {}, {}, 文:({},{}), 武:({},{}), {}, {}",
-            self.标识,
-            self.序号,
-            self.级别,
+            self.标识.read().unwrap(),
+            self.序号.load(Ordering::Relaxed),
+            self.级别.load(Ordering::Relaxed),
             self.文().时间戳,
             crate::utils::format_f64_g(self.文().分型特征值),
             self.武().时间戳,
@@ -151,12 +175,12 @@ impl 中枢 {
     }
 
     /// 校验中枢合法性
-    pub fn 校验合法性(&mut self, 序列: &[Rc<虚线>]) -> bool {
-        let mut 有效序列 = self.基础序列.clone();
-        let mut 无效序列: Vec<Rc<虚线>> = Vec::new();
-        for 元素 in &self.基础序列 {
-            if !序列.iter().any(|x| Rc::as_ptr(x) == Rc::as_ptr(元素)) {
-                无效序列.push(Rc::clone(元素));
+    pub fn 校验合法性(&self, 序列: &[Arc<虚线>]) -> bool {
+        let mut 有效序列 = self.基础序列.read().unwrap().clone();
+        let mut 无效序列: Vec<Arc<虚线>> = Vec::new();
+        for 元素 in self.基础序列.read().unwrap().iter() {
+            if !序列.iter().any(|x| Arc::as_ptr(x) == Arc::as_ptr(元素)) {
+                无效序列.push(Arc::clone(元素));
             }
         }
 
@@ -164,50 +188,52 @@ impl 中枢 {
             let 无效 = &无效序列[0];
             if let Some(pos) = self
                 .基础序列
+                .read()
+                .unwrap()
                 .iter()
-                .position(|x| Rc::as_ptr(x) == Rc::as_ptr(无效))
+                .position(|x| Arc::as_ptr(x) == Arc::as_ptr(无效))
             {
-                有效序列 = self.基础序列[..pos].to_vec();
+                有效序列 = self.基础序列.read().unwrap()[..pos].to_vec();
             }
         }
 
         if 有效序列.len() < 3 {
-            self.第三买卖线 = None;
-            self.本级_第三买卖线 = None;
+            *self.第三买卖线.write().unwrap() = None;
+            *self.本级_第三买卖线.write().unwrap() = None;
             return false;
         }
 
-        self.基础序列 = 有效序列;
+        *self.基础序列.write().unwrap() = 有效序列;
 
         let 中枢高 = self.高();
         let 中枢低 = self.低();
         有效序列 = Vec::new();
-        for 元素 in &self.基础序列 {
+        for 元素 in self.基础序列.read().unwrap().iter() {
             if crate::types::相对方向::分析(中枢高, 中枢低, 元素.高(), 元素.低()).是否缺口()
             {
                 break;
             }
-            有效序列.push(Rc::clone(元素));
+            有效序列.push(Arc::clone(元素));
         }
-        self.基础序列 = 有效序列;
+        *self.基础序列.write().unwrap() = 有效序列;
 
-        if self.基础序列.len() < 3 {
+        if self.基础序列.read().unwrap().len() < 3 {
             return false;
         }
 
-        for i in 1..self.基础序列.len() {
-            let 前 = &self.基础序列[i - 1];
-            let 后 = &self.基础序列[i];
+        for i in 1..self.基础序列.read().unwrap().len() {
+            let 前 = &self.基础序列.read().unwrap()[i - 1];
+            let 后 = &self.基础序列.read().unwrap()[i];
             if !前.之后是(后) {
                 return false;
             }
         }
 
         if !crate::types::相对方向::分析(
-            self.基础序列[0].高(),
-            self.基础序列[0].低(),
-            self.基础序列[2].高(),
-            self.基础序列[2].低(),
+            self.基础序列.read().unwrap()[0].高(),
+            self.基础序列.read().unwrap()[0].低(),
+            self.基础序列.read().unwrap()[2].高(),
+            self.基础序列.read().unwrap()[2].低(),
         )
         .是否缺口()
         {
@@ -218,10 +244,11 @@ impl 中枢 {
             }
         }
 
-        if let Some(ref 三买线) = self.第三买卖线.clone() {
-            if 序列.iter().any(|x| Rc::as_ptr(x) == Rc::as_ptr(三买线)) {
-                if !self.基础序列.last().unwrap().之后是(三买线) {
-                    self.第三买卖线 = None;
+        let 三买线_opt = self.第三买卖线.read().unwrap().clone();
+        if let Some(ref 三买线) = 三买线_opt {
+            if 序列.iter().any(|x| Arc::as_ptr(x) == Arc::as_ptr(三买线)) {
+                if !self.基础序列.read().unwrap().last().unwrap().之后是(三买线) {
+                    *self.第三买卖线.write().unwrap() = None;
                 } else if !crate::types::相对方向::分析(
                     self.高(),
                     self.低(),
@@ -230,11 +257,11 @@ impl 中枢 {
                 )
                 .是否缺口()
                 {
-                    self.添加虚线(Rc::clone(三买线));
-                    self.第三买卖线 = None;
+                    self.添加虚线(Arc::clone(三买线));
+                    *self.第三买卖线.write().unwrap() = None;
                 }
             } else {
-                self.第三买卖线 = None;
+                *self.第三买卖线.write().unwrap() = None;
             }
         }
         true
@@ -243,16 +270,18 @@ impl 中枢 {
     /// 完整性 — 详见教你炒股票43：有关背驰的补习课
     /// 不完整时下一个中枢大概率会与当前中枢发生扩展
     pub fn 完整性(&self, 虚实: &str) -> bool {
-        if self.基础序列[0].标识 == "笔" {
-            return self.第三买卖线.is_some();
+        if *self.基础序列.read().unwrap()[0].标识.read().unwrap() == "笔" {
+            return self.第三买卖线.read().unwrap().is_some();
         }
 
-        let 线段内部中枢 = if 虚实 == "合" {
-            &self.基础序列.last().unwrap().合_中枢序列
+        let 基础序列_ref = self.基础序列.read().unwrap();
+        let 最后段 = 基础序列_ref.last().unwrap();
+        let 内部中枢_vec = if 虚实 == "合" {
+            最后段.合_中枢序列.read().unwrap()
         } else {
-            &self.基础序列.last().unwrap().实_中枢序列
+            最后段.实_中枢序列.read().unwrap()
         };
-        for 内部中枢 in 线段内部中枢 {
+        for 内部中枢 in 内部中枢_vec.iter() {
             if crate::types::相对方向::分析(
                 self.高(),
                 self.低(),
@@ -269,16 +298,19 @@ impl 中枢 {
 
     /// 获取扩展中枢 — 当基础序列 >= 9 时生成扩展中枢
     pub fn 获取扩展中枢(
-        &self, 扩展中枢: &mut Vec<Rc<中枢>>, 配置: &crate::config::缠论配置
+        &self,
+        扩展中枢: &mut Vec<Arc<中枢>>,
+        配置: &crate::config::缠论配置,
     ) {
-        if self.基础序列.len() >= 9 {
-            let mut 扩展线段: Vec<Rc<虚线>> = Vec::new();
-            crate::algorithm::segment::线段::扩展分析(&self.基础序列, &mut 扩展线段, 配置);
+        if self.基础序列.read().unwrap().len() >= 9 {
+            let mut 扩展线段: Vec<Arc<虚线>> = Vec::new();
+            let 基础序列_ref = self.基础序列.read().unwrap();
+            crate::algorithm::segment::线段::扩展分析(&基础序列_ref, &mut 扩展线段, 配置);
             中枢::分析(
                 &扩展线段,
                 扩展中枢,
                 false,
-                &format!("{}_扩展中枢_", self.标识),
+                &format!("{}_扩展中枢_", self.标识.read().unwrap()),
                 0,
             );
         }
@@ -287,13 +319,15 @@ impl 中枢 {
     /// 当前状态 — 详见教你炒股票49：利润率最大的操作模式
     /// 返回当前中枢最后一段所处的位置关系：中枢之中/中枢之上/中枢之下
     pub fn 当前状态(&self) -> &str {
-        let 最后 = self.基础序列.last().unwrap();
-        let 尾部_中 = if 最后.标识 == "笔" {
-            &最后.武.中
-        } else {
-            &最后.基础序列.last().unwrap().武.中
-        };
-        let 关系 = crate::types::相对方向::分析(self.高(), self.低(), 尾部_中.高, 尾部_中.低);
+        let 基础序列_ref = self.基础序列.read().unwrap();
+        let 最后 = Arc::clone(基础序列_ref.last().unwrap());
+        let 尾部 = 最后.获取_武();
+        let 关系 = crate::types::相对方向::分析(
+            self.高(),
+            self.低(),
+            尾部.中.高.get(),
+            尾部.中.低.get(),
+        );
         if 关系 == crate::types::相对方向::向上缺口 {
             "中枢之上"
         } else if 关系 == crate::types::相对方向::向下缺口 {
@@ -323,11 +357,11 @@ impl 中枢 {
 
     /// 创建中枢
     pub fn 创建(
-        左: Rc<虚线>, 中: Rc<虚线>, 右: Rc<虚线>, 级别: i64, 标识: &str
+        左: Arc<虚线>, 中: Arc<虚线>, 右: Arc<虚线>, 级别: i64, 标识: &str
     ) -> Self {
         Self::new(
             0,
-            format!("{}中枢<{}>", 标识, 中.标识),
+            format!("{}中枢<{}>", 标识, 中.标识.read().unwrap()),
             级别,
             vec![左, 中, 右],
         )
@@ -335,17 +369,17 @@ impl 中枢 {
 
     /// 从序列中获取中枢
     pub fn 从序列中获取中枢(
-        虚线序列: &[Rc<虚线>],
+        虚线序列: &[Arc<虚线>],
         起始方向: 相对方向,
         标识: &str,
-    ) -> Option<Rc<中枢>> {
+    ) -> Option<Arc<中枢>> {
         for i in 2..虚线序列.len() {
             let 左 = &虚线序列[i - 2];
             let 中 = &虚线序列[i - 1];
             let 右 = &虚线序列[i];
             if Self::基础检查(左, 中, 右) && 左.方向() == 起始方向 {
-                let 中枢 = Self::创建(Rc::clone(左), Rc::clone(中), Rc::clone(右), 0, 标识);
-                return Some(Rc::new(中枢));
+                let 中枢 = Self::创建(Arc::clone(左), Arc::clone(中), Arc::clone(右), 0, 标识);
+                return Some(Arc::new(中枢));
             }
         }
         None
@@ -353,19 +387,22 @@ impl 中枢 {
 
     /// 向中枢序列尾部添加
     pub fn 向中枢序列尾部添加(
-        中枢序列: &mut Vec<Rc<中枢>>, mut 待添加中枢: Rc<中枢>
+        中枢序列: &mut Vec<Arc<中枢>>, mut 待添加中枢: Arc<中枢>
     ) {
         if let Some(前一个) = 中枢序列.last() {
-            let 新 = Rc::make_mut(&mut 待添加中枢);
-            新.序号 = 前一个.序号 + 1;
+            待添加中枢
+                .序号
+                .store(前一个.序号.load(Ordering::Relaxed) + 1, Ordering::Relaxed);
             // Python: assert seq[-1].获取序列()[-1].序号 <= new.获取序列()[-1].序号
             let 前_seq = 前一个.获取序列();
-            let new_seq = 新.获取序列();
+            let new_seq = 待添加中枢.获取序列();
             if let (Some(前_last), Some(new_last)) = (前_seq.last(), new_seq.last()) {
-                if 前_last.序号 > new_last.序号 {
+                if 前_last.序号.load(Ordering::Relaxed) > new_last.序号.load(Ordering::Relaxed)
+                {
                     panic!(
                         "向中枢序列尾部添加 序号错误 前last={} > new_last={}",
-                        前_last.序号, new_last.序号
+                        前_last.序号.load(Ordering::Relaxed),
+                        new_last.序号.load(Ordering::Relaxed)
                     );
                 }
             }
@@ -375,10 +412,10 @@ impl 中枢 {
 
     /// 从中枢序列尾部弹出
     pub fn 从中枢序列尾部弹出(
-        中枢序列: &mut Vec<Rc<中枢>>,
-        待弹出: &Rc<中枢>,
-    ) -> Option<Rc<中枢>> {
-        if 中枢序列.last().map(|x| Rc::as_ptr(x)) == Some(Rc::as_ptr(待弹出)) {
+        中枢序列: &mut Vec<Arc<中枢>>,
+        待弹出: &Arc<中枢>,
+    ) -> Option<Arc<中枢>> {
+        if 中枢序列.last().map(|x| Arc::as_ptr(x)) == Some(Arc::as_ptr(待弹出)) {
             中枢序列.pop()
         } else {
             None
@@ -389,8 +426,8 @@ impl 中枢 {
     ///
     /// 每收到新的虚线序列数据后调用，更新中枢序列
     pub fn 分析(
-        虚线序列: &[Rc<虚线>],
-        中枢序列: &mut Vec<Rc<中枢>>,
+        虚线序列: &[Arc<虚线>],
+        中枢序列: &mut Vec<Arc<中枢>>,
         跳过首部: bool,
         标识: &str,
         层级: i64,
@@ -410,9 +447,9 @@ impl 中枢 {
                     // Python: 序号 = 虚线序列.index(左)
                     let 序号 = 虚线序列
                         .iter()
-                        .position(|x| Rc::as_ptr(x) == Rc::as_ptr(左))
+                        .position(|x| Arc::as_ptr(x) == Arc::as_ptr(左))
                         .unwrap_or(i - 1);
-                    if 跳过首部 && (左.序号 == 0 || 序号 == 0) {
+                    if 跳过首部 && (左.序号.load(Ordering::Relaxed) == 0 || 序号 == 0) {
                         continue;
                     }
                     if 序号 >= 2 {
@@ -426,11 +463,11 @@ impl 中枢 {
                             continue;
                         }
                     }
-                    let 新中枢 = Rc::new(Self::创建(
-                        Rc::clone(左),
-                        Rc::clone(中),
-                        Rc::clone(右),
-                        中.级别,
+                    let 新中枢 = Arc::new(Self::创建(
+                        Arc::clone(左),
+                        Arc::clone(中),
+                        Arc::clone(右),
+                        中.级别.load(Ordering::Relaxed),
                         标识,
                     ));
                     Self::向中枢序列尾部添加(中枢序列, 新中枢);
@@ -445,13 +482,10 @@ impl 中枢 {
         // 增量更新
         let mut 当前中枢_idx = 中枢序列.len() - 1;
 
-        // Validate in-place via Rc::make_mut — avoids full中枢 struct clone
-        let needs_pop = {
-            let cur = Rc::make_mut(&mut 中枢序列[当前中枢_idx]);
-            !cur.校验合法性(虚线序列)
-        };
+        // Validate via shared reference (中枢 uses RwLock internally)
+        let needs_pop = !中枢序列[当前中枢_idx].校验合法性(虚线序列);
         if needs_pop {
-            let 当前中枢 = Rc::clone(&中枢序列[当前中枢_idx]);
+            let 当前中枢 = Arc::clone(&中枢序列[当前中枢_idx]);
             Self::从中枢序列尾部弹出(中枢序列, &当前中枢);
             Self::分析(虚线序列, 中枢序列, 跳过首部, 标识, 层级);
             return;
@@ -460,10 +494,10 @@ impl 中枢 {
         // 找到当前中枢最后一个元素在虚线序列中的位置
         let 起始索引 = {
             let cur = &中枢序列[当前中枢_idx];
-            let 最后元素 = &cur.基础序列[cur.基础序列.len() - 1];
+            let 最后元素 = &cur.基础序列.read().unwrap()[cur.基础序列.read().unwrap().len() - 1];
             match 虚线序列
                 .iter()
-                .position(|x| Rc::as_ptr(x) == Rc::as_ptr(最后元素))
+                .position(|x| Arc::as_ptr(x) == Arc::as_ptr(最后元素))
             {
                 Some(idx) => idx + 1,
                 None => return,
@@ -472,10 +506,10 @@ impl 中枢 {
 
         let mut 中枢高 = 中枢序列[当前中枢_idx].高();
         let mut 中枢低 = 中枢序列[当前中枢_idx].低();
-        let mut 候选序列: Vec<Rc<虚线>> = Vec::new();
+        let mut 候选序列: Vec<Arc<虚线>> = Vec::new();
 
         for i in 起始索引..虚线序列.len() {
-            let 当前虚线 = Rc::clone(&虚线序列[i]);
+            let 当前虚线 = Arc::clone(&虚线序列[i]);
 
             // 检查是否超出中枢范围（缺口）
             if crate::types::相对方向::分析(中枢高, 中枢低, 当前虚线.高(), 当前虚线.低()).是否缺口()
@@ -485,16 +519,20 @@ impl 中枢 {
                 // Python: if 当前中枢.基础序列[-1].之后是(当前虚线):
                 let needs_三买 = {
                     let cur = &中枢序列[当前中枢_idx];
-                    cur.基础序列.last().unwrap().之后是(&当前虚线)
+                    cur.基础序列
+                        .read()
+                        .unwrap()
+                        .last()
+                        .unwrap()
+                        .之后是(&当前虚线)
                 };
                 if needs_三买 {
-                    Rc::make_mut(&mut 中枢序列[当前中枢_idx])
-                        .设置第三买卖线(当前虚线.clone());
+                    中枢序列[当前中枢_idx].设置第三买卖线(当前虚线.clone());
                 }
             } else {
                 if 候选序列.is_empty() {
                     // 仍在范围内：延伸中枢
-                    Rc::make_mut(&mut 中枢序列[当前中枢_idx]).添加虚线(当前虚线);
+                    中枢序列[当前中枢_idx].添加虚线(当前虚线);
                 } else {
                     候选序列.push(当前虚线);
                 }
@@ -504,6 +542,8 @@ impl 中枢 {
             while 候选序列.len() >= 3 {
                 let 起始方向 = 中枢序列[当前中枢_idx]
                     .基础序列
+                    .read()
+                    .unwrap()
                     .last()
                     .unwrap()
                     .方向()
@@ -526,10 +566,317 @@ impl 中枢 {
     }
 }
 
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::kline::bar::K线;
+    use crate::kline::chan_kline::缠论K线;
+    use crate::structure::fractal_obj::分型;
+    use crate::types::分型结构;
+
+    fn 辅助_创建K线(时间戳: i64, 高: f64, 低: f64, 开: f64, 收: f64) -> K线 {
+        let mut k = K线::default();
+        k.时间戳 = 时间戳;
+        k.高 = 高;
+        k.低 = 低;
+        k.开盘价 = 开;
+        k.收盘价 = 收;
+        k
+    }
+
+    fn 辅助_创建缠K(
+        时间戳: i64,
+        高: f64,
+        低: f64,
+        方向: 相对方向,
+        结构: Option<分型结构>,
+        序号: i64,
+    ) -> Arc<缠论K线> {
+        let 普K = Arc::new(辅助_创建K线(时间戳, 高, 低, 低, 高));
+        Arc::new(缠论K线::创建缠K(
+            时间戳, 高, 低, 方向, 结构, 序号, 普K, None,
+        ))
+    }
+
+    fn 辅助_创建顶分型(时间戳: i64, 高: f64, 低: f64, 序号: i64) -> Arc<分型> {
+        let 左 = 辅助_创建缠K(
+            时间戳 - 2,
+            高 - 2.0,
+            低 - 2.0,
+            相对方向::向上,
+            Some(分型结构::上),
+            序号 - 2,
+        );
+        let 中 = 辅助_创建缠K(时间戳, 高, 低, 相对方向::向上, Some(分型结构::顶), 序号);
+        let 右 = 辅助_创建缠K(
+            时间戳 + 2,
+            高 - 1.0,
+            低 - 1.0,
+            相对方向::向下,
+            Some(分型结构::下),
+            序号 + 2,
+        );
+        Arc::new(分型::new(Some(左), 中, Some(右)))
+    }
+
+    fn 辅助_创建底分型(时间戳: i64, 高: f64, 低: f64, 序号: i64) -> Arc<分型> {
+        let 左 = 辅助_创建缠K(
+            时间戳 - 2,
+            高 + 2.0,
+            低 + 2.0,
+            相对方向::向下,
+            Some(分型结构::下),
+            序号 - 2,
+        );
+        let 中 = 缠论K线::创建缠K(
+            时间戳,
+            高,
+            低,
+            相对方向::向下,
+            Some(分型结构::底),
+            序号,
+            Arc::new(辅助_创建K线(时间戳, 高, 低, 低, 高)),
+            None,
+        );
+        中.分型特征值.set(低);
+        let 中 = Arc::new(中);
+        let 右 = 辅助_创建缠K(
+            时间戳 + 2,
+            高 + 1.0,
+            低 + 1.0,
+            相对方向::向上,
+            Some(分型结构::上),
+            序号 + 2,
+        );
+        Arc::new(分型::new(Some(左), 中, Some(右)))
+    }
+
+    fn 辅助_创建笔(
+        文时间戳: i64,
+        文高: f64,
+        文低: f64,
+        武时间戳: i64,
+        武高: f64,
+        武低: f64,
+    ) -> Arc<虚线> {
+        let 顶 = 辅助_创建顶分型(文时间戳, 文高, 文低, 1);
+        let 底 = 辅助_创建底分型(武时间戳, 武高, 武低, 2);
+        Arc::new(虚线::创建笔(顶, 底, true))
+    }
+
+    // ============================================================
+    // 中枢 Cell/RefCell 字段读写
+    // ============================================================
+
+    #[test]
+    fn test_中枢创建后字段初始值正确() {
+        let 笔1 = 辅助_创建笔(100, 50.0, 40.0, 200, 30.0, 20.0);
+        let 笔2 = 辅助_创建笔(200, 30.0, 20.0, 300, 55.0, 45.0);
+        let 笔3 = 辅助_创建笔(300, 55.0, 45.0, 400, 25.0, 15.0);
+
+        let 中枢 = 中枢::new(
+            1,
+            "测试中枢".into(),
+            1,
+            vec![Arc::clone(&笔1), Arc::clone(&笔2), Arc::clone(&笔3)],
+        );
+
+        assert_eq!(中枢.序号.load(Ordering::Relaxed), 1);
+        assert_eq!(*中枢.标识.read().unwrap(), "测试中枢");
+        assert_eq!(中枢.级别.load(Ordering::Relaxed), 1);
+        assert_eq!(中枢.基础序列.read().unwrap().len(), 3);
+        assert!(中枢.第三买卖线.read().unwrap().is_none());
+        assert!(中枢.本级_第三买卖线.read().unwrap().is_none());
+    }
+
+    #[test]
+    fn test_中枢CellRefCell字段读写() {
+        let 笔1 = 辅助_创建笔(100, 50.0, 40.0, 200, 30.0, 20.0);
+        let 笔2 = 辅助_创建笔(200, 30.0, 20.0, 300, 55.0, 45.0);
+        let 笔3 = 辅助_创建笔(300, 55.0, 45.0, 400, 25.0, 15.0);
+
+        let 中枢 = 中枢::new(
+            0,
+            "测试".into(),
+            1,
+            vec![Arc::clone(&笔1), Arc::clone(&笔2), Arc::clone(&笔3)],
+        );
+
+        // Cell 序号读写
+        中枢.序号.store(99, Ordering::Relaxed);
+        assert_eq!(中枢.序号.load(Ordering::Relaxed), 99);
+
+        // RefCell 第三买卖线读写
+        中枢.设置第三买卖线(Arc::clone(&笔1));
+        assert!(中枢.第三买卖线.read().unwrap().is_some());
+        assert_eq!(
+            Arc::as_ptr(&*中枢.第三买卖线.read().unwrap().as_ref().unwrap()),
+            Arc::as_ptr(&笔1)
+        );
+
+        // 本级_第三买卖线
+        assert!(中枢.本级_第三买卖线.read().unwrap().is_none());
+        *中枢.本级_第三买卖线.write().unwrap() = Some(Arc::clone(&笔3));
+        assert!(中枢.本级_第三买卖线.read().unwrap().is_some());
+    }
+
+    // ============================================================
+    // 中枢 添加虚线
+    // ============================================================
+
+    #[test]
+    fn test_中枢添加虚线后基础序列扩展() {
+        let 笔1 = 辅助_创建笔(100, 50.0, 40.0, 200, 30.0, 20.0);
+        let 笔2 = 辅助_创建笔(200, 30.0, 20.0, 300, 55.0, 45.0);
+        let 笔3 = 辅助_创建笔(300, 55.0, 45.0, 400, 25.0, 15.0);
+        let 笔4 = 辅助_创建笔(400, 25.0, 15.0, 500, 60.0, 50.0);
+
+        let 中枢 = 中枢::new(
+            0,
+            "测试".into(),
+            1,
+            vec![Arc::clone(&笔1), Arc::clone(&笔2), Arc::clone(&笔3)],
+        );
+        assert_eq!(中枢.基础序列.read().unwrap().len(), 3);
+
+        中枢.添加虚线(Arc::clone(&笔4));
+        assert_eq!(中枢.基础序列.read().unwrap().len(), 4);
+        assert_eq!(
+            Arc::as_ptr(&中枢.基础序列.read().unwrap()[3]),
+            Arc::as_ptr(&笔4)
+        );
+    }
+
+    #[test]
+    fn test_中枢添加虚线后清除第三买卖线() {
+        let 笔1 = 辅助_创建笔(100, 50.0, 40.0, 200, 30.0, 20.0);
+        let 笔2 = 辅助_创建笔(200, 30.0, 20.0, 300, 55.0, 45.0);
+        let 笔3 = 辅助_创建笔(300, 55.0, 45.0, 400, 25.0, 15.0);
+        let 笔4 = 辅助_创建笔(400, 25.0, 15.0, 500, 60.0, 50.0);
+
+        let 中枢 = 中枢::new(
+            0,
+            "测试".into(),
+            1,
+            vec![Arc::clone(&笔1), Arc::clone(&笔2), Arc::clone(&笔3)],
+        );
+        中枢.设置第三买卖线(Arc::clone(&笔1));
+        *中枢.本级_第三买卖线.write().unwrap() = Some(Arc::clone(&笔2));
+        assert!(中枢.第三买卖线.read().unwrap().is_some());
+        assert!(中枢.本级_第三买卖线.read().unwrap().is_some());
+
+        中枢.添加虚线(Arc::clone(&笔4));
+        // 添加虚线后第三买卖线被清除
+        assert!(中枢.第三买卖线.read().unwrap().is_none());
+        assert!(中枢.本级_第三买卖线.read().unwrap().is_none());
+    }
+
+    // ============================================================
+    // Clone 后 Rc 指针身份一致
+    // ============================================================
+
+    #[test]
+    fn test_中枢Clone后基础序列Rc指针一致() {
+        let 笔1 = 辅助_创建笔(100, 50.0, 40.0, 200, 30.0, 20.0);
+        let 笔2 = 辅助_创建笔(200, 30.0, 20.0, 300, 55.0, 45.0);
+        let 笔3 = 辅助_创建笔(300, 55.0, 45.0, 400, 25.0, 15.0);
+
+        let 中枢 = 中枢::new(
+            0,
+            "测试".into(),
+            1,
+            vec![Arc::clone(&笔1), Arc::clone(&笔2), Arc::clone(&笔3)],
+        );
+        中枢.设置第三买卖线(Arc::clone(&笔1));
+
+        let 克隆 = 中枢.clone();
+
+        // 基础序列中的 Rc 指针应一致
+        for i in 0..3 {
+            assert_eq!(
+                Arc::as_ptr(&中枢.基础序列.read().unwrap()[i]),
+                Arc::as_ptr(&克隆.基础序列.read().unwrap()[i])
+            );
+        }
+
+        // 第三买卖线 Rc 指针应一致
+        assert_eq!(
+            Arc::as_ptr(中枢.第三买卖线.read().unwrap().as_ref().unwrap()),
+            Arc::as_ptr(克隆.第三买卖线.read().unwrap().as_ref().unwrap())
+        );
+    }
+
+    // ============================================================
+    // 中枢 高/低/高高/低低计算
+    // ============================================================
+
+    #[test]
+    fn test_中枢高低计算正确() {
+        // 笔1: 顶(高=50,低=45) →底(高=40,低=30) = 向下笔, 高=50, 低=30
+        let 笔1 = 辅助_创建笔(100, 50.0, 45.0, 200, 40.0, 30.0);
+
+        // 笔2: 底(高=40,低=30) →顶(高=55,低=50) = 向上笔, 高=55, 低=30
+        let 底2 = 辅助_创建底分型(200, 40.0, 30.0, 10);
+        let 顶2 = 辅助_创建顶分型(300, 55.0, 50.0, 15);
+        let 笔2 = Arc::new(虚线::创建笔(底2, 顶2, true));
+
+        // 笔3: 顶(高=55,低=50) →底(高=35,低=25) = 向下笔, 高=55, 低=25
+        let 笔3 = 辅助_创建笔(300, 55.0, 50.0, 400, 35.0, 25.0);
+
+        let 中枢 = 中枢::new(
+            0,
+            "测试".into(),
+            1,
+            vec![Arc::clone(&笔1), Arc::clone(&笔2), Arc::clone(&笔3)],
+        );
+
+        // 高 = min(笔1高, 笔2高, 笔3高) = min(50, 55, 55) = 50
+        assert!((中枢.高() - 50.0).abs() < 0.01, "中枢高={}", 中枢.高());
+        // 低 = max(笔1低, 笔2低, 笔3低) = max(30, 30, 25) = 30
+        assert!((中枢.低() - 30.0).abs() < 0.01, "中枢低={}", 中枢.低());
+    }
+
+    // ============================================================
+    // 多 Rc 共享下修改可见性
+    // ============================================================
+
+    #[test]
+    fn test_多Rc共享中枢修改对所有引用可见() {
+        let 笔1 = 辅助_创建笔(100, 50.0, 40.0, 200, 30.0, 20.0);
+        let 笔2 = 辅助_创建笔(200, 30.0, 20.0, 300, 55.0, 45.0);
+        let 笔3 = 辅助_创建笔(300, 55.0, 45.0, 400, 25.0, 15.0);
+        let 笔4 = 辅助_创建笔(400, 25.0, 15.0, 500, 60.0, 50.0);
+
+        let 中枢1 = Arc::new(中枢::new(
+            0,
+            "测试".into(),
+            1,
+            vec![Arc::clone(&笔1), Arc::clone(&笔2), Arc::clone(&笔3)],
+        ));
+        let 中枢2 = Arc::clone(&中枢1);
+
+        // 通过 rc1 修改序号
+        中枢1.序号.store(88, Ordering::Relaxed);
+        assert_eq!(中枢2.序号.load(Ordering::Relaxed), 88);
+
+        // 通过 rc1 添加虚线
+        中枢1.添加虚线(Arc::clone(&笔4));
+        assert_eq!(中枢2.基础序列.read().unwrap().len(), 4);
+
+        // 验证共享的 Arc<虚线> 指针一致
+        assert_eq!(
+            Arc::as_ptr(&中枢1.基础序列.read().unwrap()[3]),
+            Arc::as_ptr(&中枢2.基础序列.read().unwrap()[3])
+        );
+    }
+}
+
 impl std::fmt::Display for 中枢 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let 序列_str = self
             .基础序列
+            .read()
+            .unwrap()
             .iter()
             .map(|d| format!("{}", d))
             .collect::<Vec<_>>()
@@ -537,10 +884,10 @@ impl std::fmt::Display for 中枢 {
         write!(
             f,
             "{}({}, {}, 元素数量: {}, [{}], {} ===>>> {})",
-            self.标识,
+            self.标识.read().unwrap(),
             crate::utils::format_f64_g(self.高()),
             crate::utils::format_f64_g(self.低()),
-            self.基础序列.len(),
+            self.基础序列.read().unwrap().len(),
             序列_str,
             self.文(),
             self.武(),

chanlun/src/business/bsp.rs

@@ -27,18 +27,19 @@ use crate::kline::chan_kline::缠论K线;
 use crate::structure::fractal_obj::分型;
 use crate::types::bsp_type::买卖点类型;
 use crate::types::分型结构;
-use std::rc::Rc;
+use std::sync::atomic::Ordering;
+use std::sync::Arc;
 
 /// 基础买卖点 — 买卖点的基础数据结构
 #[derive(Debug, Clone)]
 pub struct 基础买卖点 {
     pub 备注: String,
     pub 类型: 买卖点类型,
-    pub 买卖点分型: Rc<分型>,
-    pub 买卖点K线: Rc<缠论K线>,
-    pub 当前K线: Rc<K线>,
-    pub 失效K线: Option<Rc<K线>>,
-    pub 终结K线: Option<Rc<K线>>,
+    pub 买卖点分型: Arc<分型>,
+    pub 买卖点K线: Arc<缠论K线>,
+    pub 当前K线: Arc<K线>,
+    pub 失效K线: Option<Arc<K线>>,
+    pub 终结K线: Option<Arc<K线>>,
     pub 破位值: f64,
     pub 结构: Option<分型结构>,
 }
@@ -46,12 +47,12 @@ pub struct 基础买卖点 {
 impl 基础买卖点 {
     pub fn new(
         类型: 买卖点类型,
-        当前K线: Rc<K线>,
-        买卖点分型: Rc<分型>,
+        当前K线: Arc<K线>,
+        买卖点分型: Arc<分型>,
         备注: String,
         中枢破位值: f64,
     ) -> Self {
-        let 买卖点K线 = Rc::clone(&买卖点分型.中);
+        let 买卖点K线 = Arc::clone(&买卖点分型.中);
         Self {
             备注,
             类型,
@@ -67,13 +68,13 @@ impl 基础买卖点 {
 
     /// 偏移 — 当前K线与买卖点K线的序号差
     pub fn 偏移(&self) -> i64 {
-        self.当前K线.序号 - self.买卖点K线.序号
+        self.当前K线.序号 - self.买卖点K线.序号.load(Ordering::Relaxed)
     }
 
     /// 失效偏移
     pub fn 失效偏移(&self) -> i64 {
         match &self.失效K线 {
-            Some(k) => k.序号 - self.买卖点K线.序号,
+            Some(k) => k.序号 - self.买卖点K线.序号.load(Ordering::Relaxed),
             None => -1,
         }
     }
@@ -112,8 +113,8 @@ pub struct 买卖点;
 
 impl 买卖点 {
     pub fn 一卖点(
-        买卖点分型: Rc<分型>,
-        当前K线: Rc<K线>,
+        买卖点分型: Arc<分型>,
+        当前K线: Arc<K线>,
         _标识: &str,
         备注: String,
         中枢破位值: f64,
@@ -122,8 +123,8 @@ impl 买卖点 {
     }
 
     pub fn 一买点(
-        买卖点分型: Rc<分型>,
-        当前K线: Rc<K线>,
+        买卖点分型: Arc<分型>,
+        当前K线: Arc<K线>,
         _标识: &str,
         备注: String,
         中枢破位值: f64,
@@ -132,8 +133,8 @@ impl 买卖点 {
     }
 
     pub fn 二卖点(
-        买卖点分型: Rc<分型>,
-        当前K线: Rc<K线>,
+        买卖点分型: Arc<分型>,
+        当前K线: Arc<K线>,
         _标识: &str,
         备注: String,
         中枢破位值: f64,
@@ -142,8 +143,8 @@ impl 买卖点 {
     }
 
     pub fn 二买点(
-        买卖点分型: Rc<分型>,
-        当前K线: Rc<K线>,
+        买卖点分型: Arc<分型>,
+        当前K线: Arc<K线>,
         _标识: &str,
         备注: String,
         中枢破位值: f64,
@@ -152,8 +153,8 @@ impl 买卖点 {
     }
 
     pub fn 三卖点(
-        买卖点分型: Rc<分型>,
-        当前K线: Rc<K线>,
+        买卖点分型: Arc<分型>,
+        当前K线: Arc<K线>,
         _标识: &str,
         备注: String,
         中枢破位值: f64,
@@ -162,8 +163,8 @@ impl 买卖点 {
     }
 
     pub fn 三买点(
-        买卖点分型: Rc<分型>,
-        当前K线: Rc<K线>,
+        买卖点分型: Arc<分型>,
+        当前K线: Arc<K线>,
         _标识: &str,
         备注: String,
         中枢破位值: f64,
@@ -176,8 +177,8 @@ impl 买卖点 {
         特征: &str,
         序号: &str,
         级别: &str,
-        买卖点分型: Rc<分型>,
-        当前缠K: Rc<缠论K线>,
+        买卖点分型: Arc<分型>,
+        当前缠K: Arc<缠论K线>,
     ) -> 基础买卖点 {
         let 买卖 = if matches!(买卖点分型.结构, 分型结构::底 | 分型结构::下) {
             "买"
@@ -188,7 +189,7 @@ impl 买卖点 {
         let 破位值 = 买卖点分型.分型特征值;
 
         // 当前K线 — 从缠K获取其标的K线
-        let 当前K线 = Rc::clone(&当前缠K.标的K线);
+        let 当前K线 = Arc::clone(&*当前缠K.标的K线.read().unwrap());
 
         let 类型 = match (序号, 买卖) {
             ("一", "买") => 买卖点类型::一买,

chanlun/src/business/multi_frame.rs

@@ -26,9 +26,9 @@ use crate::business::observer::观察者;
 use crate::business::synthesizer::K线合成器;
 use crate::config::缠论配置;
 use crate::kline::bar::K线;
-use std::cell::RefCell;
 use std::collections::HashMap;
-use std::rc::Rc;
+use std::sync::Arc;
+use std::sync::RwLock;
 
 /// 立体分析器 — 多周期协调器
 ///
@@ -38,7 +38,7 @@ pub struct 立体分析器 {
     pub 周期组: Vec<i64>,
     输入周期: i64,
     K线合成器: K线合成器,
-    单体分析器: HashMap<i64, Rc<RefCell<观察者>>>,
+    单体分析器: HashMap<i64, Arc<RwLock<观察者>>>,
 }
 
 impl 立体分析器 {
@@ -96,13 +96,13 @@ impl 立体分析器 {
         // Dispatch on completion events (matching Python's __K线回调)
         for (周期, 完成K线) in 完成事件 {
             if let Some(观察员) = self.单体分析器.get(&周期) {
-                观察员.borrow_mut().增加原始K线(完成K线);
+                观察员.write().unwrap().增加原始K线(完成K线);
             }
         }
     }
 
     /// 获取指定周期的观察者
-    pub fn 获取观察者(&self, 周期: i64) -> Option<Rc<RefCell<观察者>>> {
+    pub fn 获取观察者(&self, 周期: i64) -> Option<Arc<RwLock<观察者>>> {
         self.单体分析器.get(&周期).cloned()
     }
 
@@ -116,23 +116,23 @@ impl 立体分析器 {
         let 起始时间 = self
             .单体分析器
             .get(&self.输入周期)
-            .and_then(|o| o.borrow().普通K线序列.first().map(|k| k.时间戳))
+            .and_then(|o| o.read().unwrap().普通K线序列.first().map(|k| k.时间戳))
             .unwrap_or(0);
         let 结束时间 = self
             .单体分析器
             .get(&self.输入周期)
-            .and_then(|o| o.borrow().普通K线序列.last().map(|k| k.时间戳))
+            .and_then(|o| o.read().unwrap().普通K线序列.last().map(|k| k.时间戳))
             .unwrap_or(0);
         let 标识 = self
             .单体分析器
             .get(&self.输入周期)
-            .map(|o| o.borrow().符号.clone())
+            .map(|o| o.read().unwrap().符号.clone())
             .unwrap_or_default();
 
         let 周期 = self
             .单体分析器
             .get(&self.输入周期)
-            .map(|o| o.borrow().周期)
+            .map(|o| o.read().unwrap().周期)
             .unwrap_or_default();
 
         let 目录标识 = format!("RustM_{}:{}_{}_{}", 标识, 周期, 起始时间, 结束时间);
@@ -146,7 +146,8 @@ impl 立体分析器 {
         for 周期 in &self.周期组 {
             if let Some(观察员) = self.单体分析器.get(周期) {
                 观察员
-                    .borrow()
+                    .read()
+                    .unwrap()
                     .测试_保存数据(Some(&保存路径.to_string_lossy()));
             }
         }

chanlun/src/business/observer.rs

@@ -32,8 +32,8 @@ use crate::structure::dash_line::虚线;
 use crate::structure::fractal_obj::分型;
 use crate::types::相对方向;
 use crate::utils::datetime;
-use std::cell::RefCell;
-use std::rc::Rc;
+use std::sync::atomic::Ordering;
+use std::sync::{Arc, RwLock};
 
 /// 观察者 — 单周期分析器，持有所有层级序列，接收K线流式输入后逐层计算
 pub struct 观察者 {
@@ -42,40 +42,41 @@ pub struct 观察者 {
     pub 配置: 缠论配置,
 
     // K线序列
-    pub 普通K线序列: Vec<Rc<K线>>,
-    pub 缠论K线序列: Vec<Rc<缠论K线>>,
+    pub 普通K线序列: Vec<Arc<K线>>,
+    pub 基础缠K序列: Vec<Arc<缠论K线>>,
+    pub 缠论K线序列: Vec<Arc<缠论K线>>,
 
     // 分型与笔
-    pub 分型序列: Vec<Rc<分型>>,
-    pub 笔序列: Vec<Rc<虚线>>,
-    pub 笔_中枢序列: Vec<Rc<中枢>>,
+    pub 分型序列: Vec<Arc<分型>>,
+    pub 笔序列: Vec<Arc<虚线>>,
+    pub 笔_中枢序列: Vec<Arc<中枢>>,
 
     // 线段
-    pub 线段序列: Vec<Rc<虚线>>,
-    pub 中枢序列: Vec<Rc<中枢>>,
+    pub 线段序列: Vec<Arc<虚线>>,
+    pub 中枢序列: Vec<Arc<中枢>>,
 
     // 扩展线段（笔级）
-    pub 扩展线段序列: Vec<Rc<虚线>>,
-    pub 扩展中枢序列: Vec<Rc<中枢>>,
+    pub 扩展线段序列: Vec<Arc<虚线>>,
+    pub 扩展中枢序列: Vec<Arc<中枢>>,
 
     // 扩展线段（线段级）
-    pub 扩展线段序列_线段: Vec<Rc<虚线>>,
-    pub 扩展中枢序列_线段: Vec<Rc<中枢>>,
+    pub 扩展线段序列_线段: Vec<Arc<虚线>>,
+    pub 扩展中枢序列_线段: Vec<Arc<中枢>>,
 
     // 线段之线段
-    pub 线段_线段序列: Vec<Rc<虚线>>,
-    pub 线段_中枢序列: Vec<Rc<中枢>>,
+    pub 线段_线段序列: Vec<Arc<虚线>>,
+    pub 线段_中枢序列: Vec<Arc<中枢>>,
 
     // 扩展线段之扩展线段
-    pub 扩展线段序列_扩展线段: Vec<Rc<虚线>>,
-    pub 扩展中枢序列_扩展线段: Vec<Rc<中枢>>,
+    pub 扩展线段序列_扩展线段: Vec<Arc<虚线>>,
+    pub 扩展中枢序列_扩展线段: Vec<Arc<中枢>>,
 
     // 终止时间戳
     终止时间戳: Option<i64>,
 }
 
 impl 观察者 {
-    pub fn new(符号: String, 周期: i64, 配置: 缠论配置) -> Rc<RefCell<Self>> {
+    pub fn new(符号: String, 周期: i64, 配置: 缠论配置) -> Arc<RwLock<Self>> {
         let 终止时间戳 = if 配置.手动终止 != "1970-01-01 00:00:00" && !配置.手动终止.is_empty()
         {
             datetime::转化为时间戳(&配置.手动终止)
@@ -88,6 +89,7 @@ impl 观察者 {
             周期,
             配置,
             普通K线序列: Vec::new(),
+            基础缠K序列: Vec::new(),
             缠论K线序列: Vec::new(),
             分型序列: Vec::new(),
             笔序列: Vec::new(),
@@ -105,7 +107,7 @@ impl 观察者 {
             终止时间戳,
         };
         instance.配置.标识 = 符号;
-        Rc::new(RefCell::new(instance))
+        Arc::new(RwLock::new(instance))
     }
 
     /// 标识
@@ -114,18 +116,19 @@ impl 观察者 {
     }
 
     /// 当前K线
-    pub fn 当前K线(&self) -> Option<&Rc<K线>> {
+    pub fn 当前K线(&self) -> Option<&Arc<K线>> {
         self.普通K线序列.last()
     }
 
     /// 当前缠K
-    pub fn 当前缠K(&self) -> Option<&Rc<缠论K线>> {
+    pub fn 当前缠K(&self) -> Option<&Arc<缠论K线>> {
         self.缠论K线序列.last()
     }
 
     /// 重置基础序列
     pub fn 重置基础序列(&mut self) {
         self.普通K线序列.clear();
+        self.基础缠K序列.clear();
         self.缠论K线序列.clear();
         self.分型序列.clear();
         self.笔序列.clear();
@@ -232,13 +235,7 @@ impl 观察者 {
                 &mut self.线段_线段序列,
                 &self.配置,
                 0,
-                &[
-                    相对方向::向下,
-                    相对方向::向上,
-                    相对方向::顺,
-                    相对方向::逆,
-                    相对方向::同,
-                ],
+                &[相对方向::向上, 相对方向::向下],
             );
         }
         if self.配置.分析线段中枢 {
@@ -282,12 +279,12 @@ impl 观察者 {
 
         for i in 1..self.缠论K线序列.len() - 1 {
             let 当前分型 = 分型::new(
-                Some(Rc::clone(&self.缠论K线序列[i - 1])),
-                Rc::clone(&self.缠论K线序列[i]),
-                Some(Rc::clone(&self.缠论K线序列[i + 1])),
+                Some(Arc::clone(&self.缠论K线序列[i - 1])),
+                Arc::clone(&self.缠论K线序列[i]),
+                Some(Arc::clone(&self.缠论K线序列[i + 1])),
             );
             笔::分析(
-                Rc::new(当前分型),
+                Arc::new(当前分型),
                 &mut self.分型序列,
                 &mut self.笔序列,
                 &self.缠论K线序列,
@@ -339,13 +336,7 @@ impl 观察者 {
                 &mut self.线段_线段序列,
                 &self.配置,
                 0,
-                &[
-                    相对方向::向下,
-                    相对方向::向上,
-                    相对方向::顺,
-                    相对方向::逆,
-                    相对方向::同,
-                ],
+                &[相对方向::向上, 相对方向::向下],
             );
         }
         if self.配置.分析线段中枢 {
@@ -424,14 +415,14 @@ impl 观察者 {
             .map(|ck| {
                 format!(
                     "缠K, {}, {}, {:?}, {}, {}, {}, {}, {}",
-                    ck.序号,
-                    ck.时间戳,
+                    ck.序号.load(Ordering::Relaxed),
+                    ck.时间戳.load(Ordering::Relaxed),
                     ck.分型,
-                    ck.方向,
-                    ck.高,
-                    ck.低,
+                    *ck.方向.read().unwrap(),
+                    ck.高.get(),
+                    ck.低.get(),
                     ck.原始起始序号,
-                    ck.原始结束序号
+                    ck.原始结束序号.load(Ordering::Relaxed)
                 )
             })
             .collect();
@@ -442,7 +433,12 @@ impl 观察者 {
             .map(|(i, fx)| {
                 format!(
                     "分型, {}, {}, {:?}, {}, {}, {}",
-                    i, fx.时间戳, fx.结构, fx.分型特征值, fx.中.时间戳, fx.中.低,
+                    i,
+                    fx.时间戳,
+                    fx.结构,
+                    fx.分型特征值,
+                    fx.中.时间戳.load(Ordering::Relaxed),
+                    fx.中.低.get(),
                 )
             })
             .collect();
@@ -481,11 +477,36 @@ impl 观察者 {
         println!("全部数据拆分保存完成，目录：{}", 保存路径.display());
     }
 
+    /// 解析本地数据文件 — 从 .nb 文件读取并解析所有 K线
+    pub fn 解析本地数据(&self, 文件路径: &str) -> Result<Vec<K线>, String> {
+        let data = std::fs::read(文件路径).map_err(|e| format!("read file: {}", e))?;
+        let mut bars = Vec::new();
+        let size = 48;
+        for i in 0..data.len() / size {
+            let offset = i * size;
+            if let Some(k线) = K线::from_bytes(&data[offset..offset + size], self.周期, &self.符号)
+            {
+                bars.push(k线);
+            }
+        }
+        Ok(bars)
+    }
+
+    /// 加载本地数据 — 从 .nb 文件加载数据到当前观察者（先重置再投喂）
+    pub fn 加载本地数据(&mut self, 文件路径: &str) -> Result<(), String> {
+        self.重置基础序列();
+        let bars = self.解析本地数据(文件路径)?;
+        for k线 in bars {
+            self.增加原始K线(k线);
+        }
+        Ok(())
+    }
+
     /// 读取数据文件 — 从 .nb 文件加载数据
     pub fn 读取数据文件(
         文件路径: &str,
         配置: Option<缠论配置>,
-    ) -> Result<Rc<RefCell<Self>>, String> {
+    ) -> Result<Arc<RwLock<Self>>, String> {
         let 配置 = 配置.unwrap_or_default();
 
         // Parse filename: btcusd-300-1631772074-1632222374.nb
@@ -510,10 +531,535 @@ impl 观察者 {
         for i in 0..data.len() / size {
             let offset = i * size;
             if let Some(k线) = K线::from_bytes(&data[offset..offset + size], 周期, "nb") {
-                实例.borrow_mut().增加原始K线(k线);
+                实例.write().unwrap().增加原始K线(k线);
             }
         }
 
         Ok(实例)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::config::缠论配置;
+
+    const TEST_DATA_PATH: &str = "/home/moscow/chanlun.rs/btcusd-300-1777649100-1778398800.nb";
+
+    #[test]
+    fn test_普k序列指针一致性() {
+        let config = 缠论配置::default();
+        let obs = 观察者::读取数据文件(TEST_DATA_PATH, Some(config)).unwrap();
+        let obs_ref = obs.read().unwrap();
+
+        for (i, bi) in obs_ref.笔序列.iter().enumerate() {
+            let pu_seq = bi.获取普K序列(&obs_ref.普通K线序列);
+            if pu_seq.is_empty() {
+                println!("笔 {}: 获取普K序列 返回空 (fallback failed)", i);
+                println!("  文.中.标的K线 原始起始序号: {}", bi.文.中.原始起始序号);
+                println!(
+                    "  武.中.标的K线 原始结束序号: {}",
+                    bi.武
+                        .read()
+                        .unwrap()
+                        .中
+                        .原始结束序号
+                        .load(Ordering::Relaxed)
+                );
+                println!("  普通K线序列.len: {}", obs_ref.普通K线序列.len());
+            } else {
+                let first_ptr = Arc::as_ptr(&pu_seq[0]);
+                let found = obs_ref
+                    .普通K线序列
+                    .iter()
+                    .any(|k| Arc::as_ptr(k) == first_ptr);
+                if !found {
+                    println!("笔 {}: 获取普K序列[0] 的 Rc 指针不在 普通K线序列 中!", i);
+                    let wen_ptr = Arc::as_ptr(&*bi.文.中.标的K线.read().unwrap());
+                    let wen_found = obs_ref
+                        .普通K线序列
+                        .iter()
+                        .any(|k| Arc::as_ptr(k) == wen_ptr);
+                    println!("  文.中.标的K线 在序列中: {}", wen_found);
+                } else {
+                    println!("笔 {}: OK, 获取普K序列[0] 在序列中找到", i);
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_pyo3_flow_pointer_consistency() {
+        let config = 缠论配置::default();
+        let obs_ref = 观察者::new("btcusd".into(), 300, config);
+
+        let data = std::fs::read(TEST_DATA_PATH).unwrap();
+        let size = 48;
+
+        for i in 0..data.len() / size {
+            let offset = i * size;
+            if let Some(k线) = K线::from_bytes(&data[offset..offset + size], 300, "btcusd") {
+                let _k线_py_inner = Arc::new(k线.clone());
+                obs_ref.write().unwrap().增加原始K线(k线);
+            }
+        }
+
+        let obs = obs_ref.read().unwrap();
+        println!("普通K线序列.len: {}", obs.普通K线序列.len());
+        println!("笔序列.len: {}", obs.笔序列.len());
+
+        for (i, bi) in obs.笔序列.iter().enumerate() {
+            let pu_seq = bi.获取普K序列(&obs.普通K线序列);
+            if pu_seq.is_empty() {
+                println!("笔 {}: 获取普K序列 返回空!", i);
+            } else {
+                let first_ptr = Arc::as_ptr(&pu_seq[0]);
+                let found = obs.普通K线序列.iter().any(|k| Arc::as_ptr(k) == first_ptr);
+                if !found {
+                    println!("笔 {}: 获取普K序列[0] 指针不在序列中!", i);
+                }
+                if i < 5 {
+                    println!("笔 {}: OK, len={}", i, pu_seq.len());
+                }
+            }
+        }
+    }
+
+    // ============================================================
+    // 分型到笔的 Rc 指针一致性
+    // ============================================================
+
+    #[test]
+    fn test_分型到笔的文武Rc指针一致性() {
+        let config = 缠论配置::default();
+        let obs = 观察者::读取数据文件(TEST_DATA_PATH, Some(config)).unwrap();
+        let obs_ref = obs.read().unwrap();
+
+        // 每个笔的文/武 分型 Rc 指针必须在 分型序列 中
+        for (i, bi) in obs_ref.笔序列.iter().enumerate() {
+            let 文_ptr = Arc::as_ptr(&bi.文);
+            let 文_found = obs_ref.分型序列.iter().any(|f| Arc::as_ptr(f) == 文_ptr);
+            if !文_found {
+                println!("笔 {}: 文(时间戳={}) 不在分型序列中!", i, bi.文.时间戳);
+            }
+
+            let 武_ptr = Arc::as_ptr(&*bi.武.read().unwrap());
+            let 武_found = obs_ref.分型序列.iter().any(|f| Arc::as_ptr(f) == 武_ptr);
+            if !武_found {
+                println!(
+                    "笔 {}: 武(时间戳={}) 不在分型序列中!",
+                    i,
+                    bi.武.read().unwrap().时间戳
+                );
+            }
+        }
+    }
+
+    // ============================================================
+    // 笔到线段的 Rc 指针一致性
+    // ============================================================
+
+    #[test]
+    fn test_笔到线段的基础序列Rc指针一致性() {
+        let config = 缠论配置::default();
+        let obs = 观察者::读取数据文件(TEST_DATA_PATH, Some(config)).unwrap();
+        let obs_ref = obs.read().unwrap();
+
+        // 每个线段的基础序列中的笔 Rc 指针必须在 笔序列 中
+        for (i, seg) in obs_ref.线段序列.iter().enumerate() {
+            for (j, bi_in_seg) in seg.基础序列.read().unwrap().iter().enumerate() {
+                let bi_ptr = Arc::as_ptr(bi_in_seg);
+                let found = obs_ref.笔序列.iter().any(|b| Arc::as_ptr(b) == bi_ptr);
+                if !found {
+                    println!("线段 {} 的基础序列[{}] 不在笔序列中!", i, j);
+                }
+            }
+        }
+    }
+
+    // ============================================================
+    // 中枢基础序列与源的 Rc 指针一致性
+    // ============================================================
+
+    #[test]
+    fn test_中枢基础序列与笔序列Rc指针一致() {
+        let config = 缠论配置::default();
+        let obs = 观察者::读取数据文件(TEST_DATA_PATH, Some(config)).unwrap();
+        let obs_ref = obs.read().unwrap();
+
+        for (i, hub) in obs_ref.笔_中枢序列.iter().enumerate() {
+            for (j, bi_in_hub) in hub.基础序列.read().unwrap().iter().enumerate() {
+                let bi_ptr = Arc::as_ptr(bi_in_hub);
+                let found = obs_ref.笔序列.iter().any(|b| Arc::as_ptr(b) == bi_ptr);
+                if !found {
+                    println!("笔中枢 {} 的基础序列[{}] 不在笔序列中!", i, j);
+                }
+            }
+        }
+
+        for (i, hub) in obs_ref.中枢序列.iter().enumerate() {
+            for (j, seg_in_hub) in hub.基础序列.read().unwrap().iter().enumerate() {
+                let seg_ptr = Arc::as_ptr(seg_in_hub);
+                let found = obs_ref.线段序列.iter().any(|s| Arc::as_ptr(s) == seg_ptr);
+                if !found {
+                    println!("线段中枢 {} 的基础序列[{}] 不在线段序列中!", i, j);
+                }
+            }
+        }
+    }
+
+    // ============================================================
+    // 重复计算一致性
+    // ============================================================
+
+    #[test]
+    fn test_重复计算后结果一致() {
+        let data = std::fs::read(TEST_DATA_PATH).unwrap();
+        let size = 48;
+
+        let 计算 = || {
+            let config = 缠论配置::default();
+            let obs_ref = 观察者::new("btcusd".into(), 300, config);
+            for i in 0..data.len() / size {
+                let offset = i * size;
+                if let Some(k线) = K线::from_bytes(&data[offset..offset + size], 300, "btcusd") {
+                    obs_ref.write().unwrap().增加原始K线(k线);
+                }
+            }
+            let obs = obs_ref.read().unwrap();
+            (
+                obs.笔序列.len(),
+                obs.线段序列.len(),
+                obs.中枢序列.len(),
+                obs.笔_中枢序列.len(),
+            )
+        };
+
+        let (笔数1, 段数1, 中枢1, 笔中枢1) = 计算();
+        let (笔数2, 段数2, 中枢2, 笔中枢2) = 计算();
+
+        assert_eq!(笔数1, 笔数2, "重复计算笔数不一致");
+        assert_eq!(段数1, 段数2, "重复计算线段数不一致");
+        assert_eq!(中枢1, 中枢2, "重复计算中枢数不一致");
+        assert_eq!(笔中枢1, 笔中枢2, "重复计算笔中枢数不一致");
+
+        println!(
+            "两次计算结果一致: 笔={}, 线段={}, 中枢={}, 笔中枢={}",
+            笔数1, 段数1, 中枢1, 笔中枢1
+        );
+    }
+
+    // ============================================================
+    // 重置后重新投喂数据一致性
+    // ============================================================
+
+    #[test]
+    fn test_重置后重新投喂数据一致() {
+        let config = 缠论配置::default();
+        let obs_ref = 观察者::new("btcusd".into(), 300, config);
+
+        let data = std::fs::read(TEST_DATA_PATH).unwrap();
+        let size = 48;
+
+        for i in 0..data.len() / size {
+            let offset = i * size;
+            if let Some(k线) = K线::from_bytes(&data[offset..offset + size], 300, "btcusd") {
+                obs_ref.write().unwrap().增加原始K线(k线);
+            }
+        }
+
+        let 第一次笔数 = obs_ref.read().unwrap().笔序列.len();
+        let 第一次段数 = obs_ref.read().unwrap().线段序列.len();
+
+        // 重置
+        obs_ref.write().unwrap().重置基础序列();
+        assert_eq!(obs_ref.read().unwrap().笔序列.len(), 0);
+        assert_eq!(obs_ref.read().unwrap().线段序列.len(), 0);
+
+        // 重新投喂
+        for i in 0..data.len() / size {
+            let offset = i * size;
+            if let Some(k线) = K线::from_bytes(&data[offset..offset + size], 300, "btcusd") {
+                obs_ref.write().unwrap().增加原始K线(k线);
+            }
+        }
+
+        let 第二次笔数 = obs_ref.read().unwrap().笔序列.len();
+        let 第二次段数 = obs_ref.read().unwrap().线段序列.len();
+
+        assert_eq!(第一次笔数, 第二次笔数, "重置后重新投喂笔数不一致");
+        assert_eq!(第一次段数, 第二次段数, "重置后重新投喂线段数不一致");
+        println!("重置后重投一致: 笔={}, 线段={}", 第一次笔数, 第一次段数);
+    }
+
+    // ============================================================
+    // RefCell 借用安全性 — 连续大量操作不应 panic
+    // ============================================================
+
+    #[test]
+    fn test_RefCell借用安全性_连续读取不panic() {
+        let config = 缠论配置::default();
+        let obs = 观察者::读取数据文件(TEST_DATA_PATH, Some(config)).unwrap();
+        let obs_ref = obs.read().unwrap();
+
+        // 连续大量读取所有 RefCell 字段，不应 panic
+        for _ in 0..100 {
+            for bi in &obs_ref.笔序列 {
+                let _标识 = bi.标识.read().unwrap().clone();
+                let _wu = bi.武.read().unwrap().clone();
+                let _基础序列 = bi.基础序列.read().unwrap().len();
+                let _特征序列 = bi.特征序列.read().unwrap().len();
+                let _模式 = bi.模式.read().unwrap().clone();
+                let _实中枢 = bi.实_中枢序列.read().unwrap().len();
+                let _虚中枢 = bi.虚_中枢序列.read().unwrap().len();
+                let _合中枢 = bi.合_中枢序列.read().unwrap().len();
+                let _确认K = bi.确认K线.read().unwrap().is_some();
+                let _序号 = bi.序号.load(Ordering::Relaxed);
+                let _有效性 = bi.有效性.load(Ordering::Relaxed);
+                let _短路 = bi.短路修正.load(Ordering::Relaxed);
+                let _前一缺口 = *bi.前一缺口.read().unwrap();
+            }
+            for seg in &obs_ref.线段序列 {
+                let _ = seg.标识.read().unwrap().clone();
+                let _ = seg.基础序列.read().unwrap().len();
+            }
+        }
+        // 到达这里 = 无 panic
+    }
+
+    #[test]
+    fn test_RefCell借用安全性_交替读写不panic() {
+        let config = 缠论配置::default();
+        let obs = 观察者::读取数据文件(TEST_DATA_PATH, Some(config)).unwrap();
+        let obs_ref = obs.read().unwrap();
+
+        // 交替读写 RefCell 字段 — 先读再写同字段，分离 borrow 作用域
+        if !obs_ref.笔序列.is_empty() {
+            let bi = &obs_ref.笔序列[0];
+            // 读
+            let old_mode = bi.模式.read().unwrap().clone();
+            // Ref 已释放，可以写
+            *bi.模式.write().unwrap() = "测试模式".into();
+            let new_mode = bi.模式.read().unwrap().clone();
+            assert_eq!(new_mode, "测试模式");
+            // 恢复
+            *bi.模式.write().unwrap() = old_mode;
+
+            // 读武
+            let old_wu = bi.武.read().unwrap().clone();
+            // Ref 已释放，可以检查
+            assert!(Arc::as_ptr(&old_wu) == Arc::as_ptr(&old_wu));
+        }
+    }
+
+    // ============================================================
+    // 缠K 到 分型 的 Rc 指针一致性
+    // ============================================================
+
+    #[test]
+    fn test_缠K到分型的Rc指针一致性() {
+        let config = 缠论配置::default();
+        let obs = 观察者::读取数据文件(TEST_DATA_PATH, Some(config)).unwrap();
+        let obs_ref = obs.read().unwrap();
+
+        // 每个分型的左/中/右 缠K 指针必须在 缠论K线序列 中
+        for (i, f) in obs_ref.分型序列.iter().enumerate() {
+            let 中_ptr = Arc::as_ptr(&f.中);
+            let 中_found = obs_ref.缠论K线序列.iter().any(|k| Arc::as_ptr(k) == 中_ptr);
+            if !中_found {
+                println!("分型 {} 的 中(时间戳={}) 不在缠论K线序列中!", i, f.时间戳);
+            }
+
+            if let Some(ref 左) = f.左 {
+                let 左_ptr = Arc::as_ptr(左);
+                let 左_found = obs_ref.缠论K线序列.iter().any(|k| Arc::as_ptr(k) == 左_ptr);
+                if !左_found {
+                    println!("分型 {} 的 左 不在缠论K线序列中!", i);
+                }
+            }
+
+            if let Some(ref 右) = f.右 {
+                let 右_ptr = Arc::as_ptr(右);
+                let 右_found = obs_ref.缠论K线序列.iter().any(|k| Arc::as_ptr(k) == 右_ptr);
+                if !右_found {
+                    println!("分型 {} 的 右 不在缠论K线序列中!", i);
+                }
+            }
+        }
+    }
+
+    // ========== 跨线程安全测试 ==========
+
+    // 编译期断言：核心类型必须实现 Send + Sync
+    #[allow(dead_code)]
+    fn 断言_Send_Sync_编译期检查() {
+        fn _需要_Send<T: Send>() {}
+        fn _需要_Sync<T: Sync>() {}
+        fn _需要_Send_Sync<T: Send + Sync>() {}
+
+        // 核心数据结构
+        _需要_Send::<crate::kline::chan_kline::缠论K线>();
+        _需要_Send::<crate::structure::dash_line::虚线>();
+        _需要_Send::<crate::algorithm::hub::中枢>();
+        _需要_Send_Sync::<crate::kline::chan_kline::缠论K线>();
+        _需要_Send_Sync::<crate::structure::dash_line::虚线>();
+        _需要_Send_Sync::<crate::algorithm::hub::中枢>();
+
+        // Arc 包装后的 Send 检查
+        _需要_Send::<Arc<crate::kline::chan_kline::缠论K线>>();
+        _需要_Send::<Arc<crate::structure::dash_line::虚线>>();
+        _需要_Send::<Arc<crate::algorithm::hub::中枢>>();
+
+        // 观察者
+        _需要_Send::<crate::business::observer::观察者>();
+    }
+
+    /// 测试：Arc<缠论K线> 可跨线程传递
+    #[test]
+    fn test_跨线程_缠论K线_Send() {
+        use crate::kline::bar::K线;
+        use crate::kline::chan_kline::缠论K线;
+
+        let 普k = Arc::new(K线::创建普K(
+            "test", 1000, 100.0, 110.0, 90.0, 95.0, 1000.0, 0, 300,
+        ));
+        let ck = 缠论K线::创建缠K(
+            1000,
+            110.0,
+            90.0,
+            crate::types::相对方向::向上,
+            None,
+            1,
+            普k,
+            None,
+        );
+        let arc_ck = Arc::new(ck);
+        let arc_ck2 = Arc::clone(&arc_ck);
+
+        let handle = std::thread::spawn(move || {
+            let _ = arc_ck2;
+            42
+        });
+        assert_eq!(handle.join().unwrap(), 42);
+        assert!((arc_ck.高.get() - 110.0).abs() < 0.01);
+    }
+
+    /// 测试：Arc<虚线> 可跨线程传递
+    #[test]
+    fn test_跨线程_虚线_Send() {
+        use crate::kline::bar::K线;
+        use crate::kline::chan_kline::缠论K线;
+        use crate::structure::dash_line::虚线;
+        use crate::structure::fractal_obj::分型;
+
+        let 普k = Arc::new(K线::创建普K(
+            "test", 1000, 100.0, 110.0, 90.0, 95.0, 1000.0, 0, 300,
+        ));
+        let ck = Arc::new(缠论K线::创建缠K(
+            1000,
+            110.0,
+            90.0,
+            crate::types::相对方向::向上,
+            None,
+            1,
+            普k,
+            None,
+        ));
+        let frac = Arc::new(分型::new(None, Arc::clone(&ck), None));
+        let frac2 = Arc::new(分型::new(None, ck, None));
+
+        let dash = Arc::new(虚线::创建笔(frac, frac2, true));
+        let dash2 = Arc::clone(&dash);
+
+        let handle = std::thread::spawn(move || {
+            let _ = Arc::as_ptr(&dash2.文);
+            99
+        });
+        assert_eq!(handle.join().unwrap(), 99);
+        assert_eq!(dash.标识.read().unwrap().as_str(), "笔");
+    }
+
+    /// 测试：Arc<中枢> 可跨线程传递
+    #[test]
+    fn test_跨线程_中枢_Send() {
+        let hub = crate::algorithm::hub::中枢::new(1, "test".into(), 1, vec![]);
+        let arc_hub = Arc::new(hub);
+        let arc_hub2 = Arc::clone(&arc_hub);
+
+        let handle = std::thread::spawn(move || {
+            let _ = arc_hub2.序号.load(Ordering::Relaxed);
+            77
+        });
+        assert_eq!(handle.join().unwrap(), 77);
+        assert_eq!(arc_hub.序号.load(Ordering::Relaxed), 1);
+    }
+
+    /// 测试：多线程并发读取 观察者
+    #[test]
+    fn test_跨线程_观察者_多线程读取() {
+        let obs = 观察者::new("btcusd".into(), 86400, Default::default());
+        let obs2 = Arc::clone(&obs);
+        let obs3 = Arc::clone(&obs);
+
+        let h1 = std::thread::spawn(move || {
+            let guard = obs2.read().unwrap();
+            guard.符号.clone()
+        });
+        let h2 = std::thread::spawn(move || {
+            let guard = obs3.read().unwrap();
+            guard.周期
+        });
+
+        assert_eq!(h1.join().unwrap(), "btcusd");
+        assert_eq!(h2.join().unwrap(), 86400);
+    }
+
+    /// 测试：Cell 字段跨线程读写不 panic
+    #[test]
+    fn test_跨线程_Cell字段_并发读写() {
+        use crate::kline::bar::K线;
+        use crate::kline::chan_kline::缠论K线;
+
+        let 普k = Arc::new(K线::创建普K(
+            "test", 1000, 100.0, 110.0, 90.0, 95.0, 1000.0, 0, 300,
+        ));
+        let ck = Arc::new(缠论K线::创建缠K(
+            1000,
+            110.0,
+            90.0,
+            crate::types::相对方向::向上,
+            None,
+            1,
+            普k,
+            None,
+        ));
+        let ck2 = Arc::clone(&ck);
+
+        let handle = std::thread::spawn(move || {
+            let 序号 = ck2.序号.load(Ordering::Relaxed);
+            let 高 = ck2.高.get();
+            (序号, 高)
+        });
+
+        let (序号, 高) = handle.join().unwrap();
+        assert_eq!(序号, 0); // 序号 初始值为 0
+        assert!((高 - 110.0).abs() < 0.01);
+        ck.序号.store(2, Ordering::Relaxed);
+        assert_eq!(ck.序号.load(Ordering::Relaxed), 2);
+    }
+
+    /// 测试：Arc<观察者> 直接跨线程传递
+    #[test]
+    fn test_跨线程_观察者_所有权转移() {
+        let obs = 观察者::new("ethusd".into(), 7200, Default::default());
+
+        let handle = std::thread::spawn(move || {
+            let guard = obs.read().unwrap();
+            (guard.符号.clone(), guard.周期)
+        });
+
+        let (符号, 周期) = handle.join().unwrap();
+        assert_eq!(符号, "ethusd");
+        assert_eq!(周期, 7200);
+    }
+}

chanlun/src/config.rs

@@ -22,7 +22,7 @@
  * SOFTWARE.
  */
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize};
 
 fn is_infinite_f64(v: &f64) -> bool {
     v.is_infinite()
@@ -70,6 +70,7 @@ pub struct 缠论配置 {
 
     // ---- 指标 ----
     pub 计算指标: bool,
+    #[serde(deserialize_with = "deserialize_指标计算方式")]
     pub 指标计算方式: String,
 
     // ---- MACD ----
@@ -115,6 +116,7 @@ pub struct 缠论配置 {
     pub 买卖点激进识别: bool,
     pub 买卖点与MACD柱强相关: bool,
     pub 买卖点错过误差值: f64,
+    #[serde(deserialize_with = "deserialize_买卖点_指标模式")]
     pub 买卖点_指标模式: String,
     pub 买卖点_指标匹配_MACD: bool,
     pub 买卖点_指标匹配_KDJ: bool,
@@ -136,12 +138,66 @@ pub struct 缠论配置 {
     pub 线段内部背驰_MACD: bool,
     pub 线段内部背驰_斜率: bool,
     pub 线段内部背驰_测度: bool,
+    #[serde(deserialize_with = "deserialize_线段内部背驰_模式")]
     pub 线段内部背驰_模式: String,
 
     // ---- 文件 ----
     pub 加载文件路径: String,
 }
 
+fn deserialize_指标计算方式<'de, D>(deserializer: D) -> Result<String, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let s = String::deserialize(deserializer)?;
+    const VALID: &[&str] = &[
+        "开",
+        "高",
+        "低",
+        "收",
+        "高低均值",
+        "高低收均值",
+        "开高低收均值",
+    ];
+    const DEFAULT: &str = "收";
+    if VALID.contains(&s.as_str()) {
+        Ok(s)
+    } else {
+        eprintln!("\x1b[33m[配置警告]\x1b[m 指标计算方式: \"{s}\" 不在有效值 {VALID:?} 内，已使用默认值 \"{DEFAULT}\"");
+        Ok(DEFAULT.to_string())
+    }
+}
+
+fn deserialize_买卖点_指标模式<'de, D>(deserializer: D) -> Result<String, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let s = String::deserialize(deserializer)?;
+    const VALID: &[&str] = &["任意", "配置", "全量", "相对"];
+    const DEFAULT: &str = "配置";
+    if VALID.contains(&s.as_str()) {
+        Ok(s)
+    } else {
+        eprintln!("\x1b[33m[配置警告]\x1b[m 买卖点_指标模式: \"{s}\" 不在有效值 {VALID:?} 内，已使用默认值 \"{DEFAULT}\"");
+        Ok(DEFAULT.to_string())
+    }
+}
+
+fn deserialize_线段内部背驰_模式<'de, D>(deserializer: D) -> Result<String, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let s = String::deserialize(deserializer)?;
+    const VALID: &[&str] = &["任意", "配置", "全量", "相对"];
+    const DEFAULT: &str = "相对";
+    if VALID.contains(&s.as_str()) {
+        Ok(s)
+    } else {
+        eprintln!("\x1b[33m[配置警告]\x1b[m 线段内部背驰_模式: \"{s}\" 不在有效值 {VALID:?} 内，已使用默认值 \"{DEFAULT}\"");
+        Ok(DEFAULT.to_string())
+    }
+}
+
 impl Default for 缠论配置 {
     fn default() -> Self {
         Self {
@@ -353,6 +409,39 @@ mod tests {
         assert_eq!(config.买卖点偏移, 1);
     }
 
+    #[test]
+    fn test_invalid_enum_field_fallback() {
+        // 无效的 指标计算方式 → 回退默认值 "收"
+        let json = r#"{"指标计算方式": "胡写"}"#;
+        let config: 缠论配置 = serde_json::from_str(json).unwrap();
+        assert_eq!(config.指标计算方式, "收");
+
+        // 有效的 指标计算方式 → 正常通过
+        let json = r#"{"指标计算方式": "开"}"#;
+        let config: 缠论配置 = serde_json::from_str(json).unwrap();
+        assert_eq!(config.指标计算方式, "开");
+
+        // 无效的 买卖点_指标模式 → 回退默认值 "配置"
+        let json = r#"{"买卖点_指标模式": "瞎搞"}"#;
+        let config: 缠论配置 = serde_json::from_str(json).unwrap();
+        assert_eq!(config.买卖点_指标模式, "配置");
+
+        // 有效的 买卖点_指标模式 → 正常通过
+        let json = r#"{"买卖点_指标模式": "任意"}"#;
+        let config: 缠论配置 = serde_json::from_str(json).unwrap();
+        assert_eq!(config.买卖点_指标模式, "任意");
+
+        // 无效的 线段内部背驰_模式 → 回退默认值 "相对"
+        let json = r#"{"线段内部背驰_模式": "乱来"}"#;
+        let config: 缠论配置 = serde_json::from_str(json).unwrap();
+        assert_eq!(config.线段内部背驰_模式, "相对");
+
+        // 有效的 线段内部背驰_模式 → 正常通过
+        let json = r#"{"线段内部背驰_模式": "全量"}"#;
+        let config: 缠论配置 = serde_json::from_str(json).unwrap();
+        assert_eq!(config.线段内部背驰_模式, "全量");
+    }
+
     #[test]
     fn test_不推送() {
         let config = 缠论配置::default();

chanlun/src/indicators/macd.rs

@@ -80,7 +80,7 @@ impl 平滑异同移动平均线 {
         let 慢线EMA = 初始收盘价;
         let DIF = 快线EMA - 慢线EMA;
         let DEA_EMA = DIF;
-        let MACD柱 = DIF - DEA_EMA;
+        let MACD柱 = 2.0 * (DIF - DEA_EMA);
 
         Self {
             时间戳: 初始时间,

chanlun/src/kline/bar.rs

@@ -28,7 +28,7 @@ use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::io::Write;
-use std::rc::Rc;
+use std::sync::Arc;
 
 /// 原始K线 (OHLCV + 指标)
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -202,12 +202,12 @@ impl K线 {
         Some(&序列[始_idx..=终_idx])
     }
 
-    /// 截取Rc<K线>序列中从始到终的片段
-    pub fn 截取rc(序列: &[Rc<Self>], 始: &Rc<Self>, 终: &Rc<Self>) -> Vec<Rc<Self>> {
-        let 始_ptr = Rc::as_ptr(始);
-        let 终_ptr = Rc::as_ptr(终);
-        let 始_idx = 序列.iter().position(|k| Rc::as_ptr(k) == 始_ptr);
-        let 终_idx = 序列.iter().position(|k| Rc::as_ptr(k) == 终_ptr);
+    /// 截取Arc<K线>序列中从始到终的片段
+    pub fn 截取rc(序列: &[Arc<Self>], 始: &Arc<Self>, 终: &Arc<Self>) -> Vec<Arc<Self>> {
+        let 始_ptr = Arc::as_ptr(始);
+        let 终_ptr = Arc::as_ptr(终);
+        let 始_idx = 序列.iter().position(|k| Arc::as_ptr(k) == 始_ptr);
+        let 终_idx = 序列.iter().position(|k| Arc::as_ptr(k) == 终_ptr);
         match (始_idx, 终_idx) {
             (Some(s), Some(e)) => 序列[s..=e].to_vec(),
             _ => Vec::new(),

chanlun/src/kline/chan_kline.rs

@@ -30,24 +30,49 @@ use crate::kline::bar::K线;
 use crate::structure::fractal_obj::分型;
 use crate::types::分型结构;
 use crate::types::相对方向;
-use std::rc::Rc;
+use crate::types::SyncF64;
+use std::sync::atomic::{AtomicI64, Ordering};
+use std::sync::{Arc, RwLock};
 
 /// 缠论K线 — 经包含处理过后的K线
-#[derive(Debug, Clone)]
+///
+/// 部分字段使用 Cell/RefCell 实现内部可变性，确保包含处理原地修改时
+/// Rc 指针不变，所有持有该 Rc 的引用（如分型.右）能看到最新数据。
+#[derive(Debug)]
 pub struct 缠论K线 {
-    pub 序号: i64,
-    pub 时间戳: i64,
-    pub 高: f64,
-    pub 低: f64,
-    pub 方向: 相对方向,
-    pub 分型: Option<分型结构>,
+    pub 序号: AtomicI64,
+    pub 时间戳: AtomicI64,
+    pub 高: SyncF64,
+    pub 低: SyncF64,
+    pub 方向: RwLock<相对方向>,
+    pub 分型: RwLock<Option<分型结构>>,
     pub 周期: i64,
     pub 标识: String,
-    pub 分型特征值: f64,
+    pub 分型特征值: SyncF64,
     pub 原始起始序号: i64,
-    pub 原始结束序号: i64,
-    pub 标的K线: Rc<K线>,
-    pub 买卖点信息: Option<()>, // 占位，后续替换为实际类型
+    pub 原始结束序号: AtomicI64,
+    pub 标的K线: RwLock<Arc<K线>>,
+    pub 买卖点信息: RwLock<Vec<String>>,
+}
+
+impl Clone for 缠论K线 {
+    fn clone(&self) -> Self {
+        Self {
+            序号: AtomicI64::new(self.序号.load(Ordering::Relaxed)),
+            时间戳: AtomicI64::new(self.时间戳.load(Ordering::Relaxed)),
+            高: SyncF64::new(self.高.get()),
+            低: SyncF64::new(self.低.get()),
+            方向: RwLock::new(*self.方向.read().unwrap()),
+            分型: RwLock::new(*self.分型.read().unwrap()),
+            周期: self.周期,
+            标识: self.标识.clone(),
+            分型特征值: SyncF64::new(self.分型特征值.get()),
+            原始起始序号: self.原始起始序号,
+            原始结束序号: AtomicI64::new(self.原始结束序号.load(Ordering::Relaxed)),
+            标的K线: RwLock::new(Arc::clone(&self.标的K线.read().unwrap())),
+            买卖点信息: RwLock::new(self.买卖点信息.read().unwrap().clone()),
+        }
+    }
 }
 
 impl std::fmt::Display for 缠论K线 {
@@ -57,13 +82,16 @@ impl std::fmt::Display for 缠论K线 {
             f,
             "{}<{}, {}, {}, {}, {}, {}, {}>",
             self.标识,
-            self.序号,
-            self.分型.map_or("None".to_string(), |fx| fx.to_string()),
+            self.序号.load(Ordering::Relaxed),
+            self.分型
+                .read()
+                .unwrap()
+                .map_or("None".to_string(), |fx| fx.to_string()),
             self.周期,
-            self.方向,
-            self.时间戳,
-            format_f64_g(self.高),
-            format_f64_g(self.低)
+            *self.方向.read().unwrap(),
+            self.时间戳.load(Ordering::Relaxed),
+            format_f64_g(self.高.get()),
+            format_f64_g(self.低.get())
         )
     }
 }
@@ -72,34 +100,34 @@ impl 缠论K线 {
     /// 创建镜像（浅拷贝 Rc 引用）
     pub fn 镜像(&self) -> Self {
         Self {
-            序号: self.序号,
-            时间戳: self.时间戳,
-            高: self.高,
-            低: self.低,
-            方向: self.方向,
-            分型: self.分型,
+            序号: AtomicI64::new(self.序号.load(Ordering::Relaxed)),
+            时间戳: AtomicI64::new(self.时间戳.load(Ordering::Relaxed)),
+            高: SyncF64::new(self.高.get()),
+            低: SyncF64::new(self.低.get()),
+            方向: RwLock::new(*self.方向.read().unwrap()),
+            分型: RwLock::new(*self.分型.read().unwrap()),
             周期: self.周期,
             标识: self.标识.clone(),
-            分型特征值: self.分型特征值,
+            分型特征值: SyncF64::new(self.分型特征值.get()),
             原始起始序号: self.原始起始序号,
-            原始结束序号: self.原始结束序号,
-            标的K线: Rc::clone(&self.标的K线),
-            买卖点信息: None,
+            原始结束序号: AtomicI64::new(self.原始结束序号.load(Ordering::Relaxed)),
+            标的K线: RwLock::new(Arc::clone(&self.标的K线.read().unwrap())),
+            买卖点信息: RwLock::new(self.买卖点信息.read().unwrap().clone()),
         }
     }
 
     /// 与MACD柱子匹配 — 底分型时MACD柱应<0, 顶分型时>0
     pub fn 与MACD柱子匹配(&self) -> bool {
-        match self.分型 {
+        match *self.分型.read().unwrap() {
             Some(分型结构::底) | Some(分型结构::下) => {
-                if let Some(ref macd) = self.标的K线.macd {
+                if let Some(ref macd) = self.标的K线.read().unwrap().macd {
                     macd.MACD柱 < 0.0
                 } else {
                     false
                 }
             }
             Some(分型结构::顶) | Some(分型结构::上) => {
-                if let Some(ref macd) = self.标的K线.macd {
+                if let Some(ref macd) = self.标的K线.read().unwrap().macd {
                     macd.MACD柱 > 0.0
                 } else {
                     false
@@ -111,9 +139,9 @@ impl 缠论K线 {
 
     /// 与RSI匹配 — 底分型时RSI应低于SMA, 顶分型时高于SMA
     pub fn 与RSI匹配(&self) -> bool {
-        match self.分型 {
+        match *self.分型.read().unwrap() {
             Some(分型结构::底) | Some(分型结构::下) => {
-                if let Some(ref rsi) = self.标的K线.rsi {
+                if let Some(ref rsi) = self.标的K线.read().unwrap().rsi {
                     match (rsi.RSI, rsi.RSI_SMA) {
                         (Some(r), Some(sma)) => r < sma,
                         _ => false,
@@ -123,7 +151,7 @@ impl 缠论K线 {
                 }
             }
             Some(分型结构::顶) | Some(分型结构::上) => {
-                if let Some(ref rsi) = self.标的K线.rsi {
+                if let Some(ref rsi) = self.标的K线.read().unwrap().rsi {
                     match (rsi.RSI, rsi.RSI_SMA) {
                         (Some(r), Some(sma)) => r > sma,
                         _ => false,
@@ -138,9 +166,9 @@ impl 缠论K线 {
 
     /// 与KDJ匹配 — 底分型时K应低于D(死叉后), 顶分型时K应高于D(金叉后)
     pub fn 与KDJ匹配(&self) -> bool {
-        match self.分型 {
+        match *self.分型.read().unwrap() {
             Some(分型结构::底) | Some(分型结构::下) => {
-                if let Some(ref kdj) = self.标的K线.kdj {
+                if let Some(ref kdj) = self.标的K线.read().unwrap().kdj {
                     match (kdj.K, kdj.D) {
                         (Some(k), Some(d)) => k < d,
                         _ => false,
@@ -150,7 +178,7 @@ impl 缠论K线 {
                 }
             }
             Some(分型结构::顶) | Some(分型结构::上) => {
-                if let Some(ref kdj) = self.标的K线.kdj {
+                if let Some(ref kdj) = self.标的K线.read().unwrap().kdj {
                     match (kdj.K, kdj.D) {
                         (Some(k), Some(d)) => k > d,
                         _ => false,
@@ -164,25 +192,30 @@ impl 缠论K线 {
     }
 
     /// 时间戳对齐 — 从基线序列中找匹配的时间戳
-    pub fn 时间戳对齐(基线: &[Rc<缠论K线>], k线: &缠论K线) -> i64 {
+    pub fn 时间戳对齐(基线: &[Arc<缠论K线>], k线: &缠论K线) -> i64 {
         if let Some(基) = 基线.first() {
             for k in 基线.iter().rev() {
                 if 基.周期 < k线.周期 {
-                    if k线.时间戳 <= k.时间戳 && k.时间戳 <= k线.时间戳 + k线.周期
+                    if k线.时间戳.load(Ordering::Relaxed) <= k.时间戳.load(Ordering::Relaxed)
+                        && k.时间戳.load(Ordering::Relaxed)
+                            <= k线.时间戳.load(Ordering::Relaxed) + k线.周期
                     {
-                        if (k线.分型特征值 - k.分型特征值).abs() < f64::EPSILON {
-                            return k.时间戳;
+                        if (k线.分型特征值.get() - k.分型特征值.get()).abs() < f64::EPSILON
+                        {
+                            return k.时间戳.load(Ordering::Relaxed);
                         }
                     }
-                } else if k.时间戳 <= k线.时间戳 && k线.时间戳 <= k.时间戳 + k.周期
+                } else if k.时间戳.load(Ordering::Relaxed) <= k线.时间戳.load(Ordering::Relaxed)
+                    && k线.时间戳.load(Ordering::Relaxed)
+                        <= k.时间戳.load(Ordering::Relaxed) + k.周期
                 {
-                    if (k线.分型特征值 - k.分型特征值).abs() < f64::EPSILON {
-                        return k.时间戳;
+                    if (k线.分型特征值.get() - k.分型特征值.get()).abs() < f64::EPSILON {
+                        return k.时间戳.load(Ordering::Relaxed);
                     }
                 }
             }
         }
-        k线.时间戳
+        k线.时间戳.load(Ordering::Relaxed)
     }
 
     /// 创建缠K
@@ -193,7 +226,7 @@ impl 缠论K线 {
         方向: 相对方向,
         结构: Option<分型结构>,
         原始序号: i64,
-        普k: Rc<K线>,
+        普k: Arc<K线>,
         之前: Option<&缠论K线>,
     ) -> Self {
         if 高.is_nan() || 低.is_nan() {
@@ -204,25 +237,28 @@ impl 缠论K线 {
         let 周期 = 普k.周期;
         let 标识 = 普k.标识.clone();
 
-        let mut 当前 = Self {
-            序号: 0,
-            时间戳,
-            高,
-            低,
-            方向,
-            分型: 结构,
+        let 当前 = Self {
+            序号: AtomicI64::new(0),
+            时间戳: AtomicI64::new(时间戳),
+            高: SyncF64::new(高),
+            低: SyncF64::new(低),
+            方向: RwLock::new(方向),
+            分型: RwLock::new(结构),
             周期,
             标识,
-            分型特征值: 高,
+            分型特征值: SyncF64::new(高),
             原始起始序号: 原始序号,
-            原始结束序号: 原始序号,
-            标的K线: 普k,
-            买卖点信息: None,
+            原始结束序号: AtomicI64::new(原始序号),
+            标的K线: RwLock::new(普k),
+            买卖点信息: RwLock::new(Vec::new()),
         };
 
         if let Some(之前) = 之前 {
-            当前.序号 = 之前.序号 + 1;
-            let 关系 = 相对方向::分析(之前.高, 之前.低, 当前.高, 当前.低);
+            当前
+                .序号
+                .store(之前.序号.load(Ordering::Relaxed) + 1, Ordering::Relaxed);
+            let 关系 =
+                相对方向::分析(之前.高.get(), 之前.低.get(), 当前.高.get(), 当前.低.get());
             if 关系.是否包含() {
                 panic!(
                     "创建缠K 包含关系: {:?}\n  之前: {}\n  当前: {}",
@@ -238,11 +274,11 @@ impl 缠论K线 {
     /// 返回 (新缠K, 模式) — 模式: "添加"/"替换"/None
     pub fn 兼并(
         之前缠K: Option<&缠论K线>,
-        当前缠K: &mut 缠论K线,
-        当前普K: &K线,
+        当前缠K: &缠论K线,
+        当前普K: &Arc<K线>,
         配置: &缠论配置,
-    ) -> (Option<Rc<缠论K线>>, Option<String>) {
-        let 关系 = 相对方向::分析(当前缠K.高, 当前缠K.低, 当前普K.高, 当前普K.低);
+    ) -> (Option<Arc<缠论K线>>, Option<String>) {
+        let 关系 = 相对方向::分析(当前缠K.高.get(), 当前缠K.低.get(), 当前普K.高, 当前普K.低);
 
         // 无包含关系 — 创建新元素追加
         if !关系.是否包含() {
@@ -251,37 +287,47 @@ impl 缠论K线 {
             } else {
                 Some(分型结构::上)
             };
-            let mut 新缠K = Self::创建缠K(
+            let 新缠K = Self::创建缠K(
                 当前普K.时间戳,
                 当前普K.高,
                 当前普K.低,
                 当前普K.方向(),
                 结构,
                 当前普K.序号,
-                Rc::new(当前普K.clone()),
+                Arc::clone(当前普K),
                 Some(当前缠K),
             );
-            新缠K.序号 = 当前缠K.序号 + 1;
-            return (Some(Rc::new(新缠K)), Some("添加".into()));
+            新缠K
+                .序号
+                .store(当前缠K.序号.load(Ordering::Relaxed) + 1, Ordering::Relaxed);
+            return (Some(Arc::new(新缠K)), Some("添加".into()));
         }
 
         // 重复提交检测 — 当序号相同时认为是重复提交K线
-        if 当前普K.序号 == 当前缠K.原始结束序号 {
+        if 当前普K.序号 == 当前缠K.原始结束序号.load(Ordering::Relaxed) {
             return (None, None);
         }
 
         // 序号连续性检查
-        if 当前普K.序号 - 1 != 当前缠K.原始结束序号 && 当前普K.序号 != 当前缠K.原始结束序号
+        if 当前普K.序号 - 1 != 当前缠K.原始结束序号.load(Ordering::Relaxed)
+            && 当前普K.序号 != 当前缠K.原始结束序号.load(Ordering::Relaxed)
         {
             panic!(
                 "兼并: 不可追加不连续元素 缠K.原始结束序号: {}, 当前普K.序号: {}",
-                当前缠K.原始结束序号, 当前普K.序号
+                当前缠K.原始结束序号.load(Ordering::Relaxed),
+                当前普K.序号
             );
         }
 
         // 包含关系 — 原地合并到当前缠K
         let 取值函数: fn(f64, f64) -> f64 = if let Some(之前) = 之前缠K {
-            if 相对方向::分析(之前.高, 之前.低, 当前缠K.高, 当前缠K.低).是否向下()
+            if 相对方向::分析(
+                之前.高.get(),
+                之前.低.get(),
+                当前缠K.高.get(),
+                当前缠K.低.get(),
+            )
+            .是否向下()
             {
                 f64::min
             } else {
@@ -293,20 +339,22 @@ impl 缠论K线 {
 
         // 逆序包含时更新时间和标的K线
         if 关系 != 相对方向::顺 {
-            当前缠K.时间戳 = 当前普K.时间戳;
-            当前缠K.标的K线 = Rc::new(当前普K.clone());
+            当前缠K.时间戳.store(当前普K.时间戳, Ordering::Relaxed);
+            *当前缠K.标的K线.write().unwrap() = Arc::clone(当前普K);
         }
-        当前缠K.高 = 取值函数(当前缠K.高, 当前普K.高);
-        当前缠K.低 = 取值函数(当前缠K.低, 当前普K.低);
-        当前缠K.原始结束序号 = 当前普K.序号;
-        当前缠K.方向 = 当前普K.方向();
+        当前缠K.高.set(取值函数(当前缠K.高.get(), 当前普K.高));
+        当前缠K.低.set(取值函数(当前缠K.低.get(), 当前普K.低));
+        当前缠K.原始结束序号.store(当前普K.序号, Ordering::Relaxed);
+        *当前缠K.方向.write().unwrap() = 当前普K.方向();
 
         if let Some(之前) = 之前缠K {
-            当前缠K.序号 = 之前.序号 + 1;
+            当前缠K
+                .序号
+                .store(之前.序号.load(Ordering::Relaxed) + 1, Ordering::Relaxed);
         }
 
         if 配置.缠K合并替换 {
-            (Some(Rc::new(当前缠K.镜像())), Some("替换".into()))
+            (Some(Arc::new(当前缠K.镜像())), Some("替换".into()))
         } else {
             (None, None)
         }
@@ -317,10 +365,10 @@ impl 缠论K线 {
     /// 返回 (状态, 形态)
     pub fn 分析(
         mut 当前K线: K线,
-        缠K序列: &mut Vec<Rc<缠论K线>>,
-        普K序列: &mut Vec<Rc<K线>>,
+        缠K序列: &mut Vec<Arc<缠论K线>>,
+        普K序列: &mut Vec<Arc<K线>>,
         配置: &缠论配置,
-    ) -> (String, Option<Rc<分型>>) {
+    ) -> (String, Option<Arc<分型>>) {
         当前K线.标识 = 配置.标识.clone();
 
         // ---- 阶段1: 普K序列管理 + 指标增量计算 ----
@@ -365,7 +413,7 @@ impl 缠论K线 {
                     配置.随机指标_超卖阈值,
                 ));
             }
-            let 当前K线_rc = Rc::new(当前K线);
+            let 当前K线_rc = Arc::new(当前K线);
             普K序列.push(当前K线_rc);
         } else {
             let 之前普K = 普K序列.last().unwrap();
@@ -412,7 +460,7 @@ impl 缠论K线 {
                     }
                 }
                 普K序列.pop();
-                普K序列.push(Rc::new(当前K线));
+                普K序列.push(Arc::new(当前K线));
             } else {
                 if 之前普K.时间戳 > 当前K线.时间戳 {
                     panic!("时序错误: 之前={}, 当前={}", 之前普K.时间戳, 当前K线.时间戳);
@@ -455,20 +503,20 @@ impl 缠论K线 {
                         ));
                     }
                 }
-                普K序列.push(Rc::new(当前K线));
+                普K序列.push(Arc::new(当前K线));
             }
         }
 
         // ---- 阶段2: 缠K合并 ----
         let 状态: String;
-        let 当前K线_ref: &K线 = &*普K序列.last().unwrap();
+        let 当前K线_ref: &Arc<K线> = 普K序列.last().unwrap();
 
         if !缠K序列.is_empty() {
             let len = 缠K序列.len();
             let (左边, 右边) = 缠K序列.split_at_mut(len - 1);
-            let 之前缠K: Option<&缠论K线> = 左边.last().map(|rc| Rc::as_ref(rc));
-            let 最后一个缠K_mut = Rc::make_mut(&mut 右边[0]);
-            let (新缠K, 模式) = Self::兼并(之前缠K, 最后一个缠K_mut, 当前K线_ref, 配置);
+            let 之前缠K: Option<&缠论K线> = 左边.last().map(|rc| Arc::as_ref(rc));
+            let 最后一个缠K = &*右边[0];
+            let (新缠K, 模式) = Self::兼并(之前缠K, 最后一个缠K, 当前K线_ref, 配置);
 
             if let Some(k) = 新缠K {
                 match 模式.as_deref() {
@@ -477,9 +525,8 @@ impl 缠论K线 {
                         状态 = "创建".into();
                     }
                     Some("替换") => {
-                        缠K序列.pop();
-                        缠K序列.push(k);
-                        状态 = "替换".into();
+                        // Cell::set 已原地更新数据，无需 pop+push 打破 Rc 身份
+                        状态 = "兼并".into();
                     }
                     _ => {
                         状态 = "兼并".into();
@@ -496,10 +543,10 @@ impl 缠论K线 {
                 当前K线_ref.方向(),
                 None,
                 当前K线_ref.序号,
-                Rc::clone(普K序列.last().unwrap()),
+                Arc::clone(普K序列.last().unwrap()),
                 None,
             );
-            缠K序列.push(Rc::new(新缠K));
+            缠K序列.push(Arc::new(新缠K));
             状态 = "新建".into();
         }
 
@@ -509,106 +556,89 @@ impl 缠论K线 {
         }
 
         let idx = 缠K序列.len();
-        let 左 = Rc::clone(&缠K序列[idx - 3]);
-        let 中 = Rc::clone(&缠K序列[idx - 2]);
-        let 右 = Rc::clone(&缠K序列[idx - 1]);
+        let 左 = Arc::clone(&缠K序列[idx - 3]);
+        let 中 = Arc::clone(&缠K序列[idx - 2]);
+        let 右 = Arc::clone(&缠K序列[idx - 1]);
 
         let 结构 = 分型结构::分析(&*左, &*中, &*右, false, false);
 
-        // 需要通过 Rc::get_mut 或 RefCell 修改 中.分型
-        // 由于使用 Rc，中是不可变的。这里采用创建新 Rc 替换的方式。
-        // 但这是在 Vec 内部修改，需要使用 Rc::make_mut 或重新构建
+        // 对齐 Python：无条件设置 中.分型、中.分型特征值、右.分型特征值、右.分型
+        *缠K序列[idx - 2].分型.write().unwrap() = 结构;
+
         if let Some(结构) = 结构 {
-            // 只在分型未设置或需要更新时才修改缠K，以保持 Rc 指针不变
-            let 当前分型标记 = 缠K序列[idx - 2].分型;
-            let 中需要更新 = 当前分型标记.is_none() || 当前分型标记 != Some(结构);
-
-            if 中需要更新 {
-                let 中_mut = Rc::make_mut(&mut 缠K序列[idx - 2]);
-                中_mut.分型 = Some(结构);
-
-                match 结构 {
-                    分型结构::底 => {
-                        中_mut.分型特征值 = 中_mut.低;
-                        let 右标记 = 缠K序列[idx - 1].分型;
-                        if 右标记.is_none() {
-                            let 右_mut = Rc::make_mut(&mut 缠K序列[idx - 1]);
-                            右_mut.分型特征值 = 右_mut.高;
-                            右_mut.分型 = Some(分型结构::顶);
-                        }
-                    }
-                    分型结构::顶 => {
-                        中_mut.分型特征值 = 中_mut.高;
-                        let 右标记 = 缠K序列[idx - 1].分型;
-                        if 右标记.is_none() {
-                            let 右_mut = Rc::make_mut(&mut 缠K序列[idx - 1]);
-                            右_mut.分型特征值 = 右_mut.低;
-                            右_mut.分型 = Some(分型结构::底);
-                        }
-                    }
-                    分型结构::上 => {
-                        中_mut.分型特征值 = 中_mut.高;
-                        let 右标记 = 缠K序列[idx - 1].分型;
-                        if 右标记.is_none() {
-                            let 右_mut = Rc::make_mut(&mut 缠K序列[idx - 1]);
-                            右_mut.分型特征值 = 右_mut.高;
-                            右_mut.分型 = Some(分型结构::顶);
-                        }
-                    }
-                    分型结构::下 => {
-                        中_mut.分型特征值 = 中_mut.低;
-                        let 右标记 = 缠K序列[idx - 1].分型;
-                        if 右标记.is_none() {
-                            let 右_mut = Rc::make_mut(&mut 缠K序列[idx - 1]);
-                            右_mut.分型特征值 = 右_mut.低;
-                            右_mut.分型 = Some(分型结构::底);
-                        }
-                    }
-                    分型结构::散 => {}
+            match 结构 {
+                分型结构::底 => {
+                    缠K序列[idx - 2].分型特征值.set(缠K序列[idx - 2].低.get());
+                    缠K序列[idx - 1].分型特征值.set(缠K序列[idx - 1].高.get());
+                    *缠K序列[idx - 1].分型.write().unwrap() = Some(分型结构::顶);
                 }
+                分型结构::顶 => {
+                    缠K序列[idx - 2].分型特征值.set(缠K序列[idx - 2].高.get());
+                    缠K序列[idx - 1].分型特征值.set(缠K序列[idx - 1].低.get());
+                    *缠K序列[idx - 1].分型.write().unwrap() = Some(分型结构::底);
+                }
+                分型结构::上 => {
+                    缠K序列[idx - 2].分型特征值.set(缠K序列[idx - 2].高.get());
+                    缠K序列[idx - 1].分型特征值.set(缠K序列[idx - 1].高.get());
+                    *缠K序列[idx - 1].分型.write().unwrap() = Some(分型结构::顶);
+                }
+                分型结构::下 => {
+                    缠K序列[idx - 2].分型特征值.set(缠K序列[idx - 2].低.get());
+                    缠K序列[idx - 1].分型特征值.set(缠K序列[idx - 1].低.get());
+                    *缠K序列[idx - 1].分型.write().unwrap() = Some(分型结构::底);
+                }
+                分型结构::散 => {}
             }
 
             let 形态 = if matches!(结构, 分型结构::上 | 分型结构::下) {
                 // Python: 形态 = 分型(中, 右, None) — 左=中K线, 中=右K线, 右=None
-                Rc::new(分型::new(
-                    Some(Rc::clone(&缠K序列[idx - 2])),
-                    Rc::clone(&缠K序列[idx - 1]),
+                Arc::new(分型::new(
+                    Some(Arc::clone(&缠K序列[idx - 2])),
+                    Arc::clone(&缠K序列[idx - 1]),
                     None,
                 ))
             } else {
-                Rc::new(分型::new(
-                    Some(Rc::clone(&缠K序列[idx - 3])),
-                    Rc::clone(&缠K序列[idx - 2]),
-                    Some(Rc::clone(&缠K序列[idx - 1])),
+                Arc::new(分型::new(
+                    Some(Arc::clone(&缠K序列[idx - 3])),
+                    Arc::clone(&缠K序列[idx - 2]),
+                    Some(Arc::clone(&缠K序列[idx - 1])),
                 ))
             };
 
             return (状态, Some(形态));
         }
 
-        (状态, None)
+        // 对齐 Python：结构为 None 时仍创建并返回分型
+        let 形态 = Arc::new(分型::new(
+            Some(Arc::clone(&缠K序列[idx - 3])),
+            Arc::clone(&缠K序列[idx - 2]),
+            Some(Arc::clone(&缠K序列[idx - 1])),
+        ));
+        return (状态, Some(形态));
     }
 
     /// 截取缠K序列从始到终
     pub fn 截取(
-        序列: &[Rc<缠论K线>], 始: &缠论K线, 终: &缠论K线
-    ) -> Option<Vec<Rc<缠论K线>>> {
+        序列: &[Arc<缠论K线>],
+        始: &缠论K线,
+        终: &缠论K线,
+    ) -> Option<Vec<Arc<缠论K线>>> {
         let 始_idx = 序列
             .iter()
-            .position(|k| Rc::as_ptr(k) == (始 as *const _))?;
+            .position(|k| Arc::as_ptr(k) == (始 as *const _))?;
         let 终_idx = 序列
             .iter()
-            .position(|k| Rc::as_ptr(k) == (终 as *const _))?;
+            .position(|k| Arc::as_ptr(k) == (终 as *const _))?;
         Some(序列[始_idx..=终_idx].to_vec())
     }
 }
 
 impl crate::types::fractal::有高低 for 缠论K线 {
     fn 高(&self) -> f64 {
-        self.高
+        self.高.get()
     }
     fn 低(&self) -> f64 {
-        self.低
+        self.低.get()
     }
 }
 
@@ -623,11 +653,11 @@ mod tests {
 
     #[test]
     fn test_创建缠K_basic() {
-        let pk = Rc::new(make_普K(1000, 100.0, 110.0, 95.0, 105.0, 0));
+        let pk = Arc::new(make_普K(1000, 100.0, 110.0, 95.0, 105.0, 0));
         let ck = 缠论K线::创建缠K(1000, 110.0, 95.0, 相对方向::向上, None, 0, pk, None);
-        assert_eq!(ck.高, 110.0);
-        assert_eq!(ck.低, 95.0);
-        assert_eq!(ck.序号, 0);
+        assert_eq!(ck.高.get(), 110.0);
+        assert_eq!(ck.低.get(), 95.0);
+        assert_eq!(ck.序号.load(Ordering::Relaxed), 0);
     }
 
     #[test]

chanlun/src/main.rs

@@ -79,7 +79,7 @@ fn 测试_读取数据(文件路径: &str) {
     let 配置 = 缠论配置::default().不推送();
     match 观察者::读取数据文件(文件路径, Some(配置)) {
         Ok(观察员) => {
-            let 观察员 = 观察员.borrow();
+            let 观察员 = 观察员.read().unwrap();
             let 消耗用时 = 启动时间.elapsed();
             println!(
                 "测试_读取数据 耗时 {:.2?} 普K数量 {}",
@@ -162,7 +162,7 @@ fn 测试_周期合成(文件路径: &str) {
     // Display stats per period
     for &p in &[周期, 周期 * 5, 周期 * 5 * 6] {
         if let Some(观察员) = 多级别分析.获取观察者(p) {
-            let 观察员 = 观察员.borrow();
+            let 观察员 = 观察员.read().unwrap();
             println!(
                 "周期<{}>: 缠K={}, 分型={}, 笔={}, 线段={}, 中枢={}",
                 p,

chanlun/src/structure/dash_line.rs

@@ -29,77 +29,113 @@ use crate::kline::chan_kline::缠论K线;
 use crate::structure::fractal_obj::分型;
 use crate::structure::segment_feat::线段特征;
 use crate::types::{分型结构, 相对方向, 缺口};
-use std::rc::Rc;
+use std::sync::atomic::{AtomicBool, AtomicI64, Ordering};
+use std::sync::{Arc, RwLock};
 
 /// 虚线 — 笔和线段的通用数据结构
 ///
 /// 笔和线段共享此 struct，通过 `标识` 字段区分 ("笔"/"线段"/"扩展线段"等)
-#[derive(Debug, Clone)]
+/// 可变字段使用 Cell/RefCell 实现内部可变性，确保 Rc 指针身份一致
+#[derive(Debug)]
 pub struct 虚线 {
-    pub 标识: String,
-    pub 序号: i64,
-    pub 级别: i64,
-    pub 文: Rc<分型>,
-    pub 武: Rc<分型>,
-    pub 有效性: bool,
-    pub 基础序列: Vec<Rc<虚线>>,
-    pub 特征序列: Vec<Option<Rc<线段特征>>>,
-    pub 实_中枢序列: Vec<Rc<中枢>>,
-    pub 虚_中枢序列: Vec<Rc<中枢>>,
-    pub 合_中枢序列: Vec<Rc<中枢>>,
-    pub 确认K线: Option<Rc<缠论K线>>,
-    pub 模式: String,
-    pub _特征序列_显示: bool,
-    pub 前一缺口: Option<缺口>,
-    pub 前一结束位置: Option<Rc<虚线>>,
-    pub 短路修正: bool,
+    pub 标识: RwLock<String>,
+    pub 序号: AtomicI64,
+    pub 级别: AtomicI64,
+    pub 文: Arc<分型>,
+    pub 武: RwLock<Arc<分型>>,
+    pub 有效性: AtomicBool,
+    pub 基础序列: RwLock<Vec<Arc<虚线>>>,
+    pub 特征序列: RwLock<Vec<Option<Arc<线段特征>>>>,
+    pub 实_中枢序列: RwLock<Vec<Arc<中枢>>>,
+    pub 虚_中枢序列: RwLock<Vec<Arc<中枢>>>,
+    pub 合_中枢序列: RwLock<Vec<Arc<中枢>>>,
+    pub 确认K线: RwLock<Option<Arc<缠论K线>>>,
+    pub 模式: RwLock<String>,
+    pub _特征序列_显示: AtomicBool,
+    pub 前一缺口: RwLock<Option<缺口>>,
+    pub 前一结束位置: RwLock<Option<Arc<虚线>>>,
+    pub 短路修正: AtomicBool,
+}
+
+/// MACD行为统计 — 统计MACD行为 方法的返回类型
+#[derive(Debug, Clone)]
+pub struct MACD行为统计 {
+    pub DIF上穿0: i64,
+    pub DIF下穿0: i64,
+    pub DEA上穿0: i64,
+    pub DEA下穿0: i64,
+    pub 金叉次数: i64,
+    pub 死叉次数: i64,
+    pub 密集交叉区域: Vec<(usize, usize, usize)>,
+}
+
+impl Clone for 虚线 {
+    fn clone(&self) -> Self {
+        Self {
+            标识: RwLock::new(self.标识.read().unwrap().clone()),
+            序号: AtomicI64::new(self.序号.load(Ordering::Relaxed)),
+            级别: AtomicI64::new(self.级别.load(Ordering::Relaxed)),
+            文: Arc::clone(&self.文),
+            武: RwLock::new(Arc::clone(&self.武.read().unwrap())),
+            有效性: AtomicBool::new(self.有效性.load(Ordering::Relaxed)),
+            基础序列: RwLock::new(self.基础序列.read().unwrap().clone()),
+            特征序列: RwLock::new(self.特征序列.read().unwrap().clone()),
+            实_中枢序列: RwLock::new(self.实_中枢序列.read().unwrap().clone()),
+            虚_中枢序列: RwLock::new(self.虚_中枢序列.read().unwrap().clone()),
+            合_中枢序列: RwLock::new(self.合_中枢序列.read().unwrap().clone()),
+            确认K线: RwLock::new(self.确认K线.read().unwrap().clone()),
+            模式: RwLock::new(self.模式.read().unwrap().clone()),
+            _特征序列_显示: AtomicBool::new(self._特征序列_显示.load(Ordering::Relaxed)),
+            前一缺口: RwLock::new(*self.前一缺口.read().unwrap()),
+            前一结束位置: RwLock::new(self.前一结束位置.read().unwrap().clone()),
+            短路修正: AtomicBool::new(self.短路修正.load(Ordering::Relaxed)),
+        }
+    }
 }
 
 impl 虚线 {
     pub fn new(
         序号: i64,
         标识: String,
-        文: Rc<分型>,
-        武: Rc<分型>,
+        文: Arc<分型>,
+        武: Arc<分型>,
         级别: i64,
         有效性: bool,
     ) -> Self {
         Self {
-            序号,
-            标识,
-            级别,
+            序号: AtomicI64::new(序号),
+            标识: RwLock::new(标识),
+            级别: AtomicI64::new(级别),
             文,
-            武,
-            有效性,
-            基础序列: Vec::new(),
-            特征序列: Vec::new(),
-            实_中枢序列: Vec::new(),
-            虚_中枢序列: Vec::new(),
-            合_中枢序列: Vec::new(),
-            确认K线: None,
-            模式: "文武".into(),
-            _特征序列_显示: false,
-            前一缺口: None,
-            前一结束位置: None,
-            短路修正: false,
+            武: RwLock::new(武),
+            有效性: AtomicBool::new(有效性),
+            基础序列: RwLock::new(Vec::new()),
+            特征序列: RwLock::new(Vec::new()),
+            实_中枢序列: RwLock::new(Vec::new()),
+            虚_中枢序列: RwLock::new(Vec::new()),
+            合_中枢序列: RwLock::new(Vec::new()),
+            确认K线: RwLock::new(None),
+            模式: RwLock::new("文武".into()),
+            _特征序列_显示: AtomicBool::new(false),
+            前一缺口: RwLock::new(None),
+            前一结束位置: RwLock::new(None),
+            短路修正: AtomicBool::new(false),
         }
     }
 
-    /// 笔序列（基础序列的别名）
-    pub fn 笔序列(&self) -> &Vec<Rc<虚线>> {
-        &self.基础序列
-    }
-
     pub fn 图表标题(&self) -> String {
         format!(
             "{}:{}:{}:{}",
-            self.文.中.标识, self.文.中.周期, self.标识, self.序号
+            self.文.中.标识,
+            self.文.中.周期,
+            self.标识.read().unwrap(),
+            self.序号.load(Ordering::Relaxed)
         )
     }
 
     /// 方向 — 文到武的方向
     pub fn 方向(&self) -> 相对方向 {
-        match (self.文.结构, self.武.结构) {
+        match (self.文.结构, self.武.read().unwrap().结构) {
             (分型结构::顶, 分型结构::底) => 相对方向::向下,
             (分型结构::顶, 分型结构::下) => 相对方向::向下,
             (分型结构::上, 分型结构::底) => 相对方向::向下,
@@ -111,67 +147,107 @@ impl 虚线 {
     /// 虚线高
     pub fn 高(&self) -> f64 {
         if self.方向() == 相对方向::向下 {
-            self.文.中.高
+            self.文.中.高.get()
         } else {
-            self.武.中.高
+            self.武.read().unwrap().中.高.get()
         }
     }
 
     /// 虚线低
     pub fn 低(&self) -> f64 {
         if self.方向() == 相对方向::向下 {
-            self.武.中.低
+            self.武.read().unwrap().中.低.get()
         } else {
-            self.文.中.低
+            self.文.中.低.get()
         }
     }
 
     /// 判断两个虚线是否首尾相连
     pub fn 之前是(&self, 之前: &虚线) -> bool {
-        if self.标识 != 之前.标识 {
+        if *self.标识.read().unwrap() != *之前.标识.read().unwrap() {
             return false;
         }
-        Rc::as_ptr(&之前.武) == Rc::as_ptr(&self.文)
+        Arc::as_ptr(&*之前.武.read().unwrap()) == Arc::as_ptr(&self.文)
     }
 
     /// 判断两个虚线是否首尾相连
     pub fn 之后是(&self, 之后: &虚线) -> bool {
-        if self.标识 != 之后.标识 {
+        if *self.标识.read().unwrap() != *之后.标识.read().unwrap() {
             return false;
         }
-        Rc::as_ptr(&self.武) == Rc::as_ptr(&之后.文)
+        Arc::as_ptr(&*self.武.read().unwrap()) == Arc::as_ptr(&之后.文)
     }
 
     /// 获取该虚线范围内的普K序列
-    pub fn 获取普K序列(&self, 普K序列: &[Rc<K线>]) -> Vec<Rc<K线>> {
-        let 始 = self.文.中.原始起始序号 as usize;
-        let 终 = self.武.中.原始结束序号 as usize;
-        if 始 < 普K序列.len() && 终 < 普K序列.len() && 始 <= 终 {
-            普K序列[始..=终].to_vec()
-        } else {
-            Vec::new()
+    pub fn 获取普K序列(&self, 普K序列: &[Arc<K线>]) -> Vec<Arc<K线>> {
+        // 使用指针查找（与 Python list.index 身份匹配行为一致），
+        // 而非序号切片——因为序号可能与实际位置不一致。
+        let 始 = 普K序列
+            .iter()
+            .position(|k| Arc::as_ptr(k) == Arc::as_ptr(&*self.文.中.标的K线.read().unwrap()));
+        let 终 = 普K序列.iter().position(|k| {
+            Arc::as_ptr(k) == Arc::as_ptr(&*self.武.read().unwrap().中.标的K线.read().unwrap())
+        });
+        match (始, 终) {
+            (Some(s), Some(e)) if s <= e => 普K序列[s..=e].to_vec(),
+            _ => {
+                // 指针查找失败时回退到序号方式
+                println!("[警告]虚线.获取普K序列 <指针查找失败时回退到序号方式>");
+                let 始 = self.文.中.原始起始序号 as usize;
+                let 终 = self
+                    .武
+                    .read()
+                    .unwrap()
+                    .中
+                    .原始结束序号
+                    .load(Ordering::Relaxed) as usize;
+                if 始 < 普K序列.len() && 终 < 普K序列.len() && 始 <= 终 {
+                    普K序列[始..=终].to_vec()
+                } else {
+                    Vec::new()
+                }
+            }
         }
     }
 
     /// 获取该虚线范围内的缠K序列
-    pub fn 获取缠K序列(&self, 缠K序列: &[Rc<缠论K线>]) -> Vec<Rc<缠论K线>> {
-        缠论K线::截取(缠K序列, &self.文.中, &self.武.中).unwrap_or_default()
+    pub fn 获取缠K序列(&self, 缠K序列: &[Arc<缠论K线>]) -> Vec<Arc<缠论K线>> {
+        缠论K线::截取(缠K序列, &self.文.中, &self.武.read().unwrap().中).unwrap_or_default()
+    }
+
+    /// 获取_武 — 递归获取虚线的终点分型（笔直接返回武，线段递归到底层笔的武）
+    pub fn 获取_武(&self) -> Arc<分型> {
+        if *self.标识.read().unwrap() == "笔" {
+            return self.武.read().unwrap().clone();
+        }
+        let mut current_rc = Arc::clone(self.基础序列.read().unwrap().last().unwrap());
+        loop {
+            if *current_rc.标识.read().unwrap() == "笔" {
+                return current_rc.武.read().unwrap().clone();
+            }
+            let next = Arc::clone(current_rc.基础序列.read().unwrap().last().unwrap());
+            current_rc = next;
+        }
     }
 
     /// 获取数据文本（用于保存/调试）
     pub fn 获取数据文本(&self) -> String {
         use crate::utils::format_f64_g;
-        if self.标识 == "笔" {
+        if *self.标识.read().unwrap() == "笔" {
             return format!(
                 "{}, {}, {}, 文:({},{}), 武:({},{}), {}",
-                self.标识,
-                self.序号,
-                self.级别,
+                self.标识.read().unwrap(),
+                self.序号.load(Ordering::Relaxed),
+                self.级别.load(Ordering::Relaxed),
                 self.文.时间戳,
                 format_f64_g(self.文.分型特征值),
-                self.武.时间戳,
-                format_f64_g(self.武.分型特征值),
-                if self.有效性 { "True" } else { "False" },
+                self.武.read().unwrap().时间戳,
+                format_f64_g(self.武.read().unwrap().分型特征值),
+                if self.有效性.load(Ordering::Relaxed) {
+                    "True"
+                } else {
+                    "False"
+                },
             );
         }
 
@@ -186,11 +262,11 @@ impl 虚线 {
             }
         };
 
-        let 前一缺口_str = match &self.前一缺口 {
+        let 前一缺口_str = match &*self.前一缺口.read().unwrap() {
             Some(g) => format!("{}", g),
             None => "None".to_string(),
         };
-        let 前一结束位置_str = match &self.前一结束位置 {
+        let 前一结束位置_str = match &*self.前一结束位置.read().unwrap() {
             Some(d) => format!("{}", d),
             None => "None".to_string(),
         };
@@ -199,6 +275,8 @@ impl 虚线 {
         let 实_str = format!(
             "[{}]",
             self.实_中枢序列
+                .read()
+                .unwrap()
                 .iter()
                 .map(|h| format!("{}", h))
                 .collect::<Vec<_>>()
@@ -207,6 +285,8 @@ impl 虚线 {
         let 虚_str = format!(
             "[{}]",
             self.虚_中枢序列
+                .read()
+                .unwrap()
                 .iter()
                 .map(|h| format!("{}", h))
                 .collect::<Vec<_>>()
@@ -215,6 +295,8 @@ impl 虚线 {
         let 合_str = format!(
             "[{}]",
             self.合_中枢序列
+                .read()
+                .unwrap()
                 .iter()
                 .map(|h| format!("{}", h))
                 .collect::<Vec<_>>()
@@ -245,15 +327,15 @@ impl 虚线 {
 
         format!(
             "{}, {}, {}, 文:({},{}), 武:({},{}), {}, {}, ({}, {}, {}), (前: {}, 后: {}, 三: {}, 伤: {}), 实: {}, 虚: {}, 合: {}, {}, {}, {}, {}",
-            self.标识,
-            self.序号,
-            self.级别,
+            self.标识.read().unwrap(),
+            self.序号.load(Ordering::Relaxed),
+            self.级别.load(Ordering::Relaxed),
             self.文.时间戳,
             format_f64_g(self.文.分型特征值),
-            self.武.时间戳,
-            format_f64_g(self.武.分型特征值),
-            if self.有效性 { "True" } else { "False" },
-            self.基础序列.len(),
+            self.武.read().unwrap().时间戳,
+            format_f64_g(self.武.read().unwrap().分型特征值),
+            if self.有效性.load(Ordering::Relaxed) { "True" } else { "False" },
+            self.基础序列.read().unwrap().len(),
             特征_bool(特征_a),
             特征_bool(特征_b),
             特征_bool(特征_c),
@@ -264,33 +346,39 @@ impl 虚线 {
             实_str,
             虚_str,
             合_str,
-            self.模式,
+            self.模式.read().unwrap(),
             前一缺口_str,
             前一结束位置_str,
-            if self.短路修正 { "True" } else { "False" },
+            if self.短路修正.load(Ordering::Relaxed) { "True" } else { "False" },
         )
     }
 
     // ---- 关联函数（静态工厂方法） ----
 
     /// 创建笔
-    pub fn 创建笔(文: Rc<分型>, 武: Rc<分型>, 有效性: bool) -> Self {
+    pub fn 创建笔(文: Arc<分型>, 武: Arc<分型>, 有效性: bool) -> Self {
         Self::new(0, "笔".into(), 文, 武, 1, 有效性)
     }
 
     /// 创建线段
-    pub fn 创建线段(虚线序列: &[Rc<虚线>]) -> Self {
-        let 文 = Rc::clone(&虚线序列[0].文);
-        let 武 = Rc::clone(&虚线序列[虚线序列.len() - 1].武);
-        let 标识 = if 虚线序列[0].标识 == "笔" {
+    pub fn 创建线段(虚线序列: &[Arc<虚线>]) -> Self {
+        let 文 = Arc::clone(&虚线序列[0].文);
+        let 武 = Arc::clone(&*虚线序列[虚线序列.len() - 1].武.read().unwrap());
+        assert!(
+            文.结构 != 武.结构,
+            "创建线段: 文.结构 == 武.结构 文={}, 武={}",
+            文,
+            武
+        );
+        let 标识: String = if *虚线序列[0].标识.read().unwrap() == "笔" {
             "线段".into()
         } else {
-            format!("线段<{}>", 虚线序列[0].标识)
+            format!("线段<{}>", 虚线序列[0].标识.read().unwrap())
         };
-        let 级别 = 虚线序列[0].级别 + 1;
-        let mut 段 = Self::new(0, 标识, 文, 武, 级别, true);
-        段.基础序列 = 虚线序列.to_vec();
-        段.模式 = "文武".into();
+        let 级别 = 虚线序列[0].级别.load(Ordering::Relaxed) + 1;
+        let 段 = Self::new(0, 标识, 文, 武, 级别, true);
+        *段.基础序列.write().unwrap() = 虚线序列.to_vec();
+        *段.模式.write().unwrap() = "文武".into();
         段
     }
 
@@ -344,8 +432,12 @@ impl 虚线 {
     // ---- MACD柱子均值计算 ----
 
     /// 计算MACD柱子均值 — 虚线范围内所有MACD柱的绝对值均值
-    pub fn 计算MACD柱子均值(普K序列: &[Rc<K线>], 实线: &虚线) -> f64 {
-        let K线序列 = K线::截取rc(普K序列, &实线.文.中.标的K线, &实线.武.中.标的K线);
+    pub fn 计算MACD柱子均值(普K序列: &[Arc<K线>], 实线: &虚线) -> f64 {
+        let K线序列 = K线::截取rc(
+            普K序列,
+            &*实线.文.中.标的K线.read().unwrap(),
+            &*实线.武.read().unwrap().中.标的K线.read().unwrap(),
+        );
         if K线序列.is_empty() {
             return 0.0;
         }
@@ -358,8 +450,12 @@ impl 虚线 {
     }
 
     /// 计算MACD柱子均值_阴 — 负柱的绝对值均值
-    pub fn 计算MACD柱子均值_阴(普K序列: &[Rc<K线>], 实线: &虚线) -> Option<f64> {
-        let K线序列 = K线::截取rc(普K序列, &实线.文.中.标的K线, &实线.武.中.标的K线);
+    pub fn 计算MACD柱子均值_阴(普K序列: &[Arc<K线>], 实线: &虚线) -> Option<f64> {
+        let K线序列 = K线::截取rc(
+            普K序列,
+            &*实线.文.中.标的K线.read().unwrap(),
+            &*实线.武.read().unwrap().中.标的K线.read().unwrap(),
+        );
         let 总: Vec<f64> = K线序列
             .iter()
             .filter_map(|k| k.macd.as_ref())
@@ -374,8 +470,12 @@ impl 虚线 {
     }
 
     /// 计算MACD柱子均值_阳 — 正柱的绝对值均值
-    pub fn 计算MACD柱子均值_阳(普K序列: &[Rc<K线>], 实线: &虚线) -> Option<f64> {
-        let K线序列 = K线::截取rc(普K序列, &实线.文.中.标的K线, &实线.武.中.标的K线);
+    pub fn 计算MACD柱子均值_阳(普K序列: &[Arc<K线>], 实线: &虚线) -> Option<f64> {
+        let K线序列 = K线::截取rc(
+            普K序列,
+            &*实线.文.中.标的K线.read().unwrap(),
+            &*实线.武.read().unwrap().中.标的K线.read().unwrap(),
+        );
         let 总: Vec<f64> = K线序列
             .iter()
             .filter_map(|k| k.macd.as_ref())
@@ -392,8 +492,10 @@ impl 虚线 {
     // ---- 武之MACD比较 ----
 
     /// 武之全量MACD均值 — 武端MACD柱是否小于均值（背驰）
-    pub fn 武之全量MACD均值(普K序列: &[Rc<K线>], 实线: &虚线) -> bool {
-        let 武_MACD = match &实线.武.中.标的K线.macd {
+    pub fn 武之全量MACD均值(普K序列: &[Arc<K线>], 实线: &虚线) -> bool {
+        let 武_ref = 实线.武.read().unwrap();
+        let 标 = 武_ref.中.标的K线.read().unwrap();
+        let 武_MACD = match 标.macd.as_ref() {
             Some(m) => m.MACD柱.abs(),
             None => return false,
         };
@@ -401,7 +503,7 @@ impl 虚线 {
     }
 
     /// 武之MACD均值 — 按方向选择阴/阳均值比对
-    pub fn 武之MACD均值(普K序列: &[Rc<K线>], 实线: &虚线) -> bool {
+    pub fn 武之MACD均值(普K序列: &[Arc<K线>], 实线: &虚线) -> bool {
         if 实线.方向() == 相对方向::向上 {
             Self::武之MACD均值_阳(普K序列, 实线)
         } else {
@@ -410,8 +512,10 @@ impl 虚线 {
     }
 
     /// 武之MACD均值_阴 — 武端负柱是否小于阴均值
-    pub fn 武之MACD均值_阴(普K序列: &[Rc<K线>], 实线: &虚线) -> bool {
-        let 武_MACD = match &实线.武.中.标的K线.macd {
+    pub fn 武之MACD均值_阴(普K序列: &[Arc<K线>], 实线: &虚线) -> bool {
+        let 武_ref = 实线.武.read().unwrap();
+        let 标 = 武_ref.中.标的K线.read().unwrap();
+        let 武_MACD = match 标.macd.as_ref() {
             Some(m) => m.MACD柱.abs(),
             None => return false,
         };
@@ -422,8 +526,10 @@ impl 虚线 {
     }
 
     /// 武之MACD均值_阳 — 武端正柱是否小于阳均值
-    pub fn 武之MACD均值_阳(普K序列: &[Rc<K线>], 实线: &虚线) -> bool {
-        let 武_MACD = match &实线.武.中.标的K线.macd {
+    pub fn 武之MACD均值_阳(普K序列: &[Arc<K线>], 实线: &虚线) -> bool {
+        let 武_ref = 实线.武.read().unwrap();
+        let 标 = 武_ref.中.标的K线.read().unwrap();
+        let 武_MACD = match 标.macd.as_ref() {
             Some(m) => m.MACD柱.abs(),
             None => return false,
         };
@@ -434,12 +540,18 @@ impl 虚线 {
     }
 
     /// 武之MACD极值 — 武端MACD柱是否为区间极值
-    pub fn 武之MACD极值(普K序列: &[Rc<K线>], 实线: &虚线) -> bool {
-        let 武_MACD = match &实线.武.中.标的K线.macd {
+    pub fn 武之MACD极值(普K序列: &[Arc<K线>], 实线: &虚线) -> bool {
+        let 武_ref = 实线.武.read().unwrap();
+        let 标 = 武_ref.中.标的K线.read().unwrap();
+        let 武_MACD = match 标.macd.as_ref() {
             Some(m) => m.MACD柱,
             None => return false,
         };
-        let K线序列 = K线::截取rc(普K序列, &实线.文.中.标的K线, &实线.武.中.标的K线);
+        let K线序列 = K线::截取rc(
+            普K序列,
+            &*实线.文.中.标的K线.read().unwrap(),
+            &*实线.武.read().unwrap().中.标的K线.read().unwrap(),
+        );
         let 所有柱子: Vec<f64> = K线序列
             .iter()
             .filter_map(|k| k.macd.as_ref())
@@ -461,7 +573,7 @@ impl 虚线 {
 
     /// 计算K线序列MACD趋向背驰 — 分析 MACD柱/DIF/DEA 三项背驰信号
     pub fn 计算K线序列MACD趋向背驰(
-        普K序列: &[Rc<K线>], 方向: 相对方向
+        普K序列: &[Arc<K线>], 方向: 相对方向
     ) -> [bool; 3] {
         if 普K序列.is_empty() {
             return [false, false, false];
@@ -469,7 +581,7 @@ impl 虚线 {
         let 最后 = &普K序列[普K序列.len() - 1];
 
         if 方向 == 相对方向::向上 {
-            let 柱子序列: Vec<&Rc<K线>> = 普K序列
+            let 柱子序列: Vec<&Arc<K线>> = 普K序列
                 .iter()
                 .filter(|k| k.macd.as_ref().map_or(false, |m| m.MACD柱 > 0.0))
                 .collect();
@@ -491,7 +603,7 @@ impl 虚线 {
                         .unwrap_or(std::cmp::Ordering::Equal)
                 })
                 .unwrap();
-            let mut 柱对 = vec![Rc::clone(*最高柱子), Rc::clone(最后)];
+            let mut 柱对 = vec![Arc::clone(*最高柱子), Arc::clone(最后)];
             柱对.sort_by_key(|k| k.时间戳);
             if let (Some(m0), Some(m1)) = (柱对[0].macd.as_ref(), 柱对[1].macd.as_ref()) {
                 if m0.MACD柱 > m1.MACD柱 && 柱对[0].高 < 柱对[1].高 {
@@ -535,7 +647,7 @@ impl 虚线 {
 
             结果
         } else {
-            let 柱子序列: Vec<&Rc<K线>> = 普K序列
+            let 柱子序列: Vec<&Arc<K线>> = 普K序列
                 .iter()
                 .filter(|k| k.macd.as_ref().map_or(false, |m| m.MACD柱 < 0.0))
                 .collect();
@@ -558,7 +670,7 @@ impl 虚线 {
                         .unwrap_or(std::cmp::Ordering::Equal)
                 })
                 .unwrap();
-            let mut 柱对 = vec![Rc::clone(*最高柱子), Rc::clone(最后)];
+            let mut 柱对 = vec![Arc::clone(*最高柱子), Arc::clone(最后)];
             柱对.sort_by_key(|k| k.时间戳);
             if let (Some(m0), Some(m1)) = (柱对[0].macd.as_ref(), 柱对[1].macd.as_ref()) {
                 if m0.MACD柱 < m1.MACD柱 && 柱对[0].低 > 柱对[1].低 {
@@ -607,7 +719,7 @@ impl 虚线 {
     // ---- MACD柱子分段 ----
 
     /// 计算MACD柱子分段 — 按正负号将MACD柱子分段
-    pub fn 计算MACD柱子分段(k线序列: &[Rc<K线>]) -> Vec<Vec<f64>> {
+    pub fn 计算MACD柱子分段(k线序列: &[Arc<K线>]) -> Vec<Vec<f64>> {
         if k线序列.is_empty() {
             return Vec::new();
         }
@@ -690,12 +802,10 @@ impl 虚线 {
 
     /// 统计MACD行为 — 分析DIF/DEA穿零轴和金叉死叉
     pub fn 统计MACD行为(
-        普K序列: &[Rc<K线>],
+        普K序列: &[Arc<K线>],
         最大间隔: usize,
         最少交叉数: usize,
-    ) -> std::collections::HashMap<String, String> {
-        use std::collections::HashMap;
-
+    ) -> MACD行为统计 {
         let mut dif_up = 0;
         let mut dif_down = 0;
         let mut dea_up = 0;
@@ -759,17 +869,17 @@ impl 虚线 {
             }
         }
 
-        let 密集区 = Self::密集区域按间隔(&交叉标记, 最大间隔, 最少交叉数);
+        let 密集交叉区域 = Self::密集区域按间隔(&交叉标记, 最大间隔, 最少交叉数);
 
-        let mut map = HashMap::new();
-        map.insert("DIF上穿0".into(), dif_up.to_string());
-        map.insert("DIF下穿0".into(), dif_down.to_string());
-        map.insert("DEA上穿0".into(), dea_up.to_string());
-        map.insert("DEA下穿0".into(), dea_down.to_string());
-        map.insert("金叉次数".into(), golden.to_string());
-        map.insert("死叉次数".into(), death.to_string());
-        map.insert("密集交叉区域".into(), format!("{:?}", 密集区));
-        map
+        MACD行为统计 {
+            DIF上穿0: dif_up,
+            DIF下穿0: dif_down,
+            DEA上穿0: dea_up,
+            DEA下穿0: dea_down,
+            金叉次数: golden,
+            死叉次数: death,
+            密集交叉区域,
+        }
     }
 
     // ---- 买卖意义 ----
@@ -783,52 +893,61 @@ impl 虚线 {
         let 普K序列 = &观察员.普通K线序列;
         let 配置 = &观察员.配置;
 
-        if 实线.标识 != "笔" && 实线.标识 != "线段" && !实线.标识.starts_with("线段<")
+        if *实线.标识.read().unwrap() != "笔"
+            && *实线.标识.read().unwrap() != "线段"
+            && !实线.标识.read().unwrap().starts_with("线段<")
         {
             return (false, "标识不在范围内".into());
         }
 
         // KDJ指标完整性检查
-        match &实线.武.中.标的K线.kdj {
+        let 武_ref = 实线.武.read().unwrap();
+        let 标 = 武_ref.中.标的K线.read().unwrap();
+        match 标.kdj.as_ref() {
             Some(kdj) if kdj.K.is_some() && kdj.D.is_some() && kdj.J.is_some() => {}
             _ => return (false, "KDJ指标不完整".into()),
         }
 
-        let 意义 = Self::缠K买卖点模式(&配置.买卖点_指标模式, &实线.武.中, 配置);
+        let 意义 =
+            Self::缠K买卖点模式(&配置.买卖点_指标模式, &实线.武.read().unwrap().中, 配置);
         let 结果 = false;
 
-        let 背驰过: Vec<Rc<分型>> = if 实线.标识 == "笔" {
+        let 背驰过: Vec<Arc<缠论K线>> = if *实线.标识.read().unwrap() == "笔" {
             crate::algorithm::bi::笔::是否背驰过(实线, 观察员)
         } else {
             crate::algorithm::segment::线段::是否背驰过(实线, 观察员)
         };
 
         if 意义 {
-            if 实线.标识 == "笔" {
+            if *实线.标识.read().unwrap() == "笔" {
                 if Self::武之MACD均值(普K序列, 实线) {
                     return (true, "武之MACD均值".into());
                 }
                 if Self::武之MACD极值(普K序列, 实线) && !背驰过.is_empty() {
                     return (true, "背驰过且极值".into());
-                } else if 实线.武.与MACD柱子分型匹配() {
+                } else if 实线.武.read().unwrap().与MACD柱子分型匹配() {
                     return (
                         true,
                         format!(
                             "背驰过:{},极值:{},柱子分型匹配",
                             背驰过.len(),
-                            Self::武之MACD极值(普K序列, 实线)
+                            if Self::武之MACD极值(普K序列, 实线) {
+                                "True"
+                            } else {
+                                "False"
+                            }
                         ),
                     );
                 }
             }
-            if 实线.标识 != "笔"
+            if *实线.标识.read().unwrap() != "笔"
                 && crate::algorithm::segment::线段::判断线段内部是否背驰(实线, 观察员)
             {
                 return (true, "线段内部背驰".into());
             }
         }
 
-        if !结果 && 意义 && 实线.武.中.与MACD柱子匹配() {
+        if !结果 && 意义 && 实线.武.read().unwrap().中.与MACD柱子匹配() {
             if Self::武之MACD极值(普K序列, 实线) && 背驰过.len() > 2 {
                 return (true, "没结果, 极值, 柱子分型匹配, 背驰过大于2次".into());
             }
@@ -838,18 +957,300 @@ impl 虚线 {
     }
 }
 
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::kline::bar::K线;
+    use crate::kline::chan_kline::缠论K线;
+    use crate::types::分型结构;
+
+    /// 辅助：创建一根最小化的原始K线
+    fn 辅助_创建K线(时间戳: i64, 高: f64, 低: f64, 开: f64, 收: f64) -> K线 {
+        let mut k = K线::default();
+        k.时间戳 = 时间戳;
+        k.高 = 高;
+        k.低 = 低;
+        k.开盘价 = 开;
+        k.收盘价 = 收;
+        k
+    }
+
+    /// 辅助：创建一根缠论K线
+    fn 辅助_创建缠K(
+        时间戳: i64,
+        高: f64,
+        低: f64,
+        方向: 相对方向,
+        结构: Option<分型结构>,
+        序号: i64,
+    ) -> Arc<缠论K线> {
+        let 普K = Arc::new(辅助_创建K线(时间戳, 高, 低, 低, 高));
+        let 缠K = 缠论K线::创建缠K(时间戳, 高, 低, 方向, 结构, 序号, 普K, None);
+        Arc::new(缠K)
+    }
+
+    /// 辅助：创建顶分型
+    fn 辅助_创建顶分型(时间戳: i64, 高: f64, 低: f64, 序号: i64) -> Arc<分型> {
+        let 左 = 辅助_创建缠K(
+            时间戳 - 2,
+            高 - 2.0,
+            低 - 2.0,
+            相对方向::向上,
+            Some(分型结构::上),
+            序号 - 2,
+        );
+        let 中 = 辅助_创建缠K(时间戳, 高, 低, 相对方向::向上, Some(分型结构::顶), 序号);
+        let 右 = 辅助_创建缠K(
+            时间戳 + 2,
+            高 - 1.0,
+            低 - 1.0,
+            相对方向::向下,
+            Some(分型结构::下),
+            序号 + 2,
+        );
+        Arc::new(分型::new(Some(左), 中, Some(右)))
+    }
+
+    /// 辅助：创建底分型
+    fn 辅助_创建底分型(时间戳: i64, 高: f64, 低: f64, 序号: i64) -> Arc<分型> {
+        let 左 = 辅助_创建缠K(
+            时间戳 - 2,
+            高 + 2.0,
+            低 + 2.0,
+            相对方向::向下,
+            Some(分型结构::下),
+            序号 - 2,
+        );
+        let 中 = 缠论K线::创建缠K(
+            时间戳,
+            高,
+            低,
+            相对方向::向下,
+            Some(分型结构::底),
+            序号,
+            Arc::new(辅助_创建K线(时间戳, 高, 低, 低, 高)),
+            None,
+        );
+        中.分型特征值.set(低);
+        let 中 = Arc::new(中);
+        let 右 = 辅助_创建缠K(
+            时间戳 + 2,
+            高 + 1.0,
+            低 + 1.0,
+            相对方向::向上,
+            Some(分型结构::上),
+            序号 + 2,
+        );
+        Arc::new(分型::new(Some(左), 中, Some(右)))
+    }
+
+    // ============================================================
+    // Cell 字段读写测试
+    // ============================================================
+
+    #[test]
+    fn test_Cell字段读写一致性() {
+        let 顶 = 辅助_创建顶分型(100, 50.0, 40.0, 5);
+        let 底 = 辅助_创建底分型(200, 30.0, 20.0, 10);
+        let 笔 = 虚线::创建笔(顶, 底, true);
+
+        assert_eq!(笔.序号.load(Ordering::Relaxed), 0);
+        assert!(笔.有效性.load(Ordering::Relaxed));
+        assert!(!笔.短路修正.load(Ordering::Relaxed));
+        assert!(笔.前一缺口.read().unwrap().is_none());
+
+        // 修改 Cell 字段
+        笔.序号.store(42, Ordering::Relaxed);
+        笔.有效性.store(false, Ordering::Relaxed);
+        笔.短路修正.store(true, Ordering::Relaxed);
+        *笔.前一缺口.write().unwrap() = Some(缺口::new(200.0, 100.0));
+
+        assert_eq!(笔.序号.load(Ordering::Relaxed), 42);
+        assert!(!笔.有效性.load(Ordering::Relaxed));
+        assert!(笔.短路修正.load(Ordering::Relaxed));
+        let qk = 笔.前一缺口.read().unwrap().unwrap();
+        assert!((qk.高 - 200.0).abs() < 0.01);
+        assert!((qk.低 - 100.0).abs() < 0.01);
+    }
+
+    // ============================================================
+    // RefCell 字段读写测试
+    // ============================================================
+
+    #[test]
+    fn test_RefCell字段读写一致性() {
+        let 顶 = 辅助_创建顶分型(100, 50.0, 40.0, 5);
+        let 底 = 辅助_创建底分型(200, 30.0, 20.0, 10);
+        let 笔 = 虚线::创建笔(顶, 底, true);
+
+        // 标识
+        assert_eq!(*笔.标识.read().unwrap(), "笔");
+        *笔.标识.write().unwrap() = "测试标识".into();
+        assert_eq!(*笔.标识.read().unwrap(), "测试标识");
+
+        // 模式
+        assert_eq!(*笔.模式.read().unwrap(), "文武");
+        *笔.模式.write().unwrap() = "全量".into();
+        assert_eq!(*笔.模式.read().unwrap(), "全量");
+
+        // 基础序列
+        assert!(笔.基础序列.read().unwrap().is_empty());
+        let 另一底 = 辅助_创建底分型(300, 20.0, 10.0, 15);
+        let 笔2 = 虚线::创建笔(Arc::clone(&*笔.武.read().unwrap()), 另一底, true);
+        笔.基础序列.write().unwrap().push(Arc::new(笔2));
+        assert_eq!(笔.基础序列.read().unwrap().len(), 1);
+
+        // 武 - Replace with new 分型
+        let 新底 = 辅助_创建底分型(400, 15.0, 5.0, 20);
+        let 新底_ptr = Arc::as_ptr(&新底);
+        *笔.武.write().unwrap() = Arc::clone(&新底);
+        assert_eq!(Arc::as_ptr(&*笔.武.read().unwrap()), 新底_ptr);
+    }
+
+    // ============================================================
+    // Clone 后 Rc 指针身份一致
+    // ============================================================
+
+    #[test]
+    fn test_虚线Clone后文Rc指针一致() {
+        let 顶 = 辅助_创建顶分型(100, 50.0, 40.0, 5);
+        let 底 = 辅助_创建底分型(200, 30.0, 20.0, 10);
+        let 笔 = 虚线::创建笔(Arc::clone(&顶), Arc::clone(&底), true);
+
+        let 克隆笔 = 笔.clone();
+
+        // 文 Rc 指针应一致
+        assert_eq!(Arc::as_ptr(&笔.文), Arc::as_ptr(&顶));
+        assert_eq!(Arc::as_ptr(&克隆笔.文), Arc::as_ptr(&笔.文));
+
+        // 武 Rc 指针应一致
+        assert_eq!(Arc::as_ptr(&*笔.武.read().unwrap()), Arc::as_ptr(&底));
+        assert_eq!(
+            Arc::as_ptr(&*克隆笔.武.read().unwrap()),
+            Arc::as_ptr(&*笔.武.read().unwrap())
+        );
+    }
+
+    #[test]
+    fn test_虚线Clone是深拷贝Cell值而非共享() {
+        let 顶 = 辅助_创建顶分型(100, 50.0, 40.0, 5);
+        let 底 = 辅助_创建底分型(200, 30.0, 20.0, 10);
+        let 笔 = 虚线::创建笔(顶, 底, true);
+        笔.序号.store(10, Ordering::Relaxed);
+
+        let 克隆笔 = 笔.clone();
+        // Clone 后序号应独立（deep copy for Cell）
+        克隆笔.序号.store(99, Ordering::Relaxed);
+        assert_eq!(笔.序号.load(Ordering::Relaxed), 10);
+        assert_eq!(克隆笔.序号.load(Ordering::Relaxed), 99);
+
+        // Rc 指针仍应一致（文/武 共享）
+        assert_eq!(Arc::as_ptr(&笔.文), Arc::as_ptr(&克隆笔.文));
+    }
+
+    // ============================================================
+    // 多 Rc 共享下 Cell/RefCell 修改可见性
+    // ============================================================
+
+    #[test]
+    fn test_多Rc共享下Cell修改对所有引用可见() {
+        let 顶 = 辅助_创建顶分型(100, 50.0, 40.0, 5);
+        let 底 = 辅助_创建底分型(200, 30.0, 20.0, 10);
+        let 笔_rc1 = Arc::new(虚线::创建笔(顶, 底, true));
+        let 笔_rc2 = Arc::clone(&笔_rc1);
+
+        // 通过 rc1 修改 Cell
+        笔_rc1.序号.store(77, Ordering::Relaxed);
+        // rc2 应能看到
+        assert_eq!(笔_rc2.序号.load(Ordering::Relaxed), 77);
+
+        // 通过 rc1 修改 RefCell
+        *笔_rc1.模式.write().unwrap() = "配置".into();
+        assert_eq!(*笔_rc2.模式.read().unwrap(), "配置");
+
+        // 通过 rc1 修改 武
+        let 新底 = 辅助_创建底分型(400, 15.0, 5.0, 20);
+        let 新底_ptr = Arc::as_ptr(&新底);
+        *笔_rc1.武.write().unwrap() = Arc::clone(&新底);
+        assert_eq!(Arc::as_ptr(&*笔_rc2.武.read().unwrap()), 新底_ptr);
+    }
+
+    // ============================================================
+    // 获取_武 递归正确性
+    // ============================================================
+
+    #[test]
+    fn test_获取武_笔级别直接返回武() {
+        let 顶 = 辅助_创建顶分型(100, 50.0, 40.0, 5);
+        let 底 = 辅助_创建底分型(200, 30.0, 20.0, 10);
+        let 笔 = 虚线::创建笔(Arc::clone(&顶), Arc::clone(&底), true);
+
+        let wu = 笔.获取_武();
+        assert_eq!(Arc::as_ptr(&*笔.武.read().unwrap()), Arc::as_ptr(&wu));
+        assert_eq!(Arc::as_ptr(&wu), Arc::as_ptr(&底));
+    }
+
+    #[test]
+    fn test_获取武_线段级别递归到底层笔() {
+        let 顶1 = 辅助_创建顶分型(100, 50.0, 40.0, 5);
+        let 底1 = 辅助_创建底分型(200, 30.0, 20.0, 10);
+        let 顶2 = 辅助_创建顶分型(300, 55.0, 45.0, 15);
+        let 底2 = 辅助_创建底分型(400, 25.0, 15.0, 20);
+
+        let 笔1 = Arc::new(虚线::创建笔(Arc::clone(&顶1), Arc::clone(&底1), true));
+        let 笔2 = Arc::new(虚线::创建笔(Arc::clone(&底1), Arc::clone(&顶2), true));
+        let 笔3 = Arc::new(虚线::创建笔(Arc::clone(&顶2), Arc::clone(&底2), true));
+
+        let 段 = 虚线::创建线段(&[Arc::clone(&笔1), Arc::clone(&笔2), Arc::clone(&笔3)]);
+
+        // 线段的 获取_武 应返回底层最后一笔的武（底2）
+        let wu = 段.获取_武();
+        assert_eq!(Arc::as_ptr(&wu), Arc::as_ptr(&底2));
+
+        // 笔1 的 获取_武 应返回底1
+        let wu1 = 笔1.获取_武();
+        assert_eq!(Arc::as_ptr(&wu1), Arc::as_ptr(&底1));
+    }
+
+    // ============================================================
+    // 虚线 字段原子性 - 修改不影响文（不可变字段）
+    // ============================================================
+
+    #[test]
+    fn test_修改武不影响文Rc指针() {
+        let 顶 = 辅助_创建顶分型(100, 50.0, 40.0, 5);
+        let 底1 = 辅助_创建底分型(200, 30.0, 20.0, 10);
+        let 底2 = 辅助_创建底分型(300, 25.0, 15.0, 15);
+
+        let 笔 = 虚线::创建笔(Arc::clone(&顶), Arc::clone(&底1), true);
+        let 文_ptr_before = Arc::as_ptr(&笔.文);
+
+        // 修改武
+        *笔.武.write().unwrap() = Arc::clone(&底2);
+
+        // 文指针不变
+        assert_eq!(Arc::as_ptr(&笔.文), 文_ptr_before);
+
+        // 但方向变了（因为武从底1变成底2）
+        let 新武耗时 = 笔.武.read().unwrap().时间戳;
+        assert_eq!(新武耗时, 300);
+    }
+}
+
 impl std::fmt::Display for 虚线 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        if self.标识 == "笔" {
+        if *self.标识.read().unwrap() == "笔" {
             write!(
                 f,
                 "笔({}, {}, {}, {}, 周期: {}, 数量: {})",
-                self.序号,
+                self.序号.load(Ordering::Relaxed),
                 self.方向(),
                 self.文,
-                self.武,
+                self.武.read().unwrap(),
                 self.文.中.周期,
-                self.武.中.序号 - self.文.中.序号 + 1
+                self.武.read().unwrap().中.序号.load(Ordering::Relaxed)
+                    - self.文.中.序号.load(Ordering::Relaxed)
+                    + 1
             )
         } else {
             let 四象 = crate::algorithm::segment::线段::四象(self);
@@ -858,20 +1259,20 @@ impl std::fmt::Display for 虚线 {
                 Some(g) => format!("{}", g),
                 None => "None".to_string(),
             };
-            let 确认K线_str = match &self.确认K线 {
+            let 确认K线_str = match &*self.确认K线.read().unwrap() {
                 Some(k) => format!("{}", k),
                 None => "None".to_string(),
             };
             write!(
                 f,
                 "{}<{}, {}, {}, {}, {}, 数量: {}, 缺口: {}, {}>",
-                self.标识,
-                self.序号,
+                self.标识.read().unwrap(),
+                self.序号.load(Ordering::Relaxed),
                 四象,
                 self.方向(),
                 self.文,
-                self.武,
-                self.基础序列.len(),
+                self.武.read().unwrap(),
+                self.基础序列.read().unwrap().len(),
                 缺口_str,
                 确认K线_str,
             )

chanlun/src/structure/feat_fractal.rs

@@ -24,20 +24,20 @@
 
 use crate::structure::segment_feat::线段特征;
 use crate::types::分型结构;
-use std::rc::Rc;
+use std::sync::Arc;
 
 /// 特征分型 — 由三个线段特征元素构成的分型
 #[derive(Debug, Clone)]
 pub struct 特征分型 {
-    pub 左: Rc<线段特征>,
-    pub 中: Rc<线段特征>,
-    pub 右: Rc<线段特征>,
+    pub 左: Arc<线段特征>,
+    pub 中: Arc<线段特征>,
+    pub 右: Arc<线段特征>,
     pub 结构: 分型结构,
 }
 
 impl 特征分型 {
     pub fn new(
-        左: Rc<线段特征>, 中: Rc<线段特征>, 右: Rc<线段特征>, 结构: 分型结构
+        左: Arc<线段特征>, 中: Arc<线段特征>, 右: Arc<线段特征>, 结构: 分型结构
     ) -> Self {
         Self {
             左, 中, 右, 结构

chanlun/src/structure/fractal_obj.rs

@@ -25,14 +25,15 @@
 use crate::kline::chan_kline::缠论K线;
 use crate::types::分型结构;
 use crate::types::相对方向;
-use std::rc::Rc;
+use std::sync::atomic::Ordering;
+use std::sync::Arc;
 
 /// 分型 — 由三根缠K构成（可能缺左或右）
 #[derive(Debug, Clone)]
 pub struct 分型 {
-    pub 左: Option<Rc<缠论K线>>,
-    pub 中: Rc<缠论K线>,
-    pub 右: Option<Rc<缠论K线>>,
+    pub 左: Option<Arc<缠论K线>>,
+    pub 中: Arc<缠论K线>,
+    pub 右: Option<Arc<缠论K线>>,
     pub 结构: 分型结构,
     pub 时间戳: i64,
     pub 分型特征值: f64,
@@ -40,11 +41,11 @@ pub struct 分型 {
 
 impl 分型 {
     pub fn new(
-        左: Option<Rc<缠论K线>>, 中: Rc<缠论K线>, 右: Option<Rc<缠论K线>>
+        左: Option<Arc<缠论K线>>, 中: Arc<缠论K线>, 右: Option<Arc<缠论K线>>
     ) -> Self {
-        let 结构 = 中.分型.unwrap_or(分型结构::散);
-        let 时间戳 = 中.时间戳;
-        let 分型特征值 = 中.分型特征值;
+        let 结构 = 中.分型.read().unwrap().unwrap_or(分型结构::散);
+        let 时间戳 = 中.时间戳.load(Ordering::Relaxed);
+        let 分型特征值 = 中.分型特征值.get();
         Self {
             左,
             中,
@@ -60,9 +61,9 @@ impl 分型 {
         let 左 = self.左.as_ref()?;
         let 右 = self.右.as_ref()?;
         Some((
-            相对方向::分析(左.高, 左.低, self.中.高, self.中.低),
-            相对方向::分析(self.中.高, self.中.低, 右.高, 右.低),
-            相对方向::分析(左.高, 左.低, 右.高, 右.低),
+            相对方向::分析(左.高.get(), 左.低.get(), self.中.高.get(), self.中.低.get()),
+            相对方向::分析(self.中.高.get(), self.中.低.get(), 右.高.get(), 右.低.get()),
+            相对方向::分析(左.高.get(), 左.低.get(), 右.高.get(), 右.低.get()),
         ))
     }
 
@@ -97,17 +98,19 @@ impl 分型 {
 
         if let (Some(ref 左), Some(ref 右)) = (&self.左, &self.右) {
             if self.结构 == 分型结构::底 {
-                if 右.标的K线.收盘价 > 左.标的K线.高 {
+                if 右.标的K线.read().unwrap().收盘价 > 左.标的K线.read().unwrap().高 {
                     return "强";
-                } else if 右.标的K线.收盘价 > self.中.标的K线.高 {
+                } else if 右.标的K线.read().unwrap().收盘价 > self.中.标的K线.read().unwrap().高
+                {
                     return "中";
                 } else {
                     return "弱";
                 }
             } else if self.结构 == 分型结构::顶 {
-                if 右.标的K线.收盘价 < 左.标的K线.低 {
+                if 右.标的K线.read().unwrap().收盘价 < 左.标的K线.read().unwrap().低 {
                     return "强";
-                } else if 右.标的K线.收盘价 < self.中.标的K线.低 {
+                } else if 右.标的K线.read().unwrap().收盘价 < self.中.标的K线.read().unwrap().低
+                {
                     return "中";
                 } else {
                     return "弱";
@@ -121,15 +124,21 @@ impl 分型 {
     pub fn 与MACD柱子分型匹配(&self) -> bool {
         if let (Some(ref 左), Some(ref 右)) = (&self.左, &self.右) {
             if self.结构 == 分型结构::底 {
+                let 左_k = 左.标的K线.read().unwrap();
+                let 中_k = self.中.标的K线.read().unwrap();
+                let 右_k = 右.标的K线.read().unwrap();
                 if let (Some(ref 左macd), Some(ref 中macd), Some(ref 右macd)) =
-                    (&左.标的K线.macd, &self.中.标的K线.macd, &右.标的K线.macd)
+                    (&左_k.macd, &中_k.macd, &右_k.macd)
                 {
                     return 左macd.MACD柱 > 中macd.MACD柱 && 中macd.MACD柱 < 右macd.MACD柱;
                 }
             }
             if self.结构 == 分型结构::顶 {
+                let 左_k = 左.标的K线.read().unwrap();
+                let 中_k = self.中.标的K线.read().unwrap();
+                let 右_k = 右.标的K线.read().unwrap();
                 if let (Some(ref 左macd), Some(ref 中macd), Some(ref 右macd)) =
-                    (&左.标的K线.macd, &self.中.标的K线.macd, &右.标的K线.macd)
+                    (&左_k.macd, &中_k.macd, &右_k.macd)
                 {
                     return 左macd.MACD柱 < 中macd.MACD柱 && 中macd.MACD柱 > 右macd.MACD柱;
                 }
@@ -139,35 +148,36 @@ impl 分型 {
     }
 
     /// 判断两个分型是否匹配
-    pub fn 判断分型(左: &Rc<分型>, 右: &Rc<分型>, 模式: &str) -> bool {
+    pub fn 判断分型(左: &Arc<分型>, 右: &Arc<分型>, 模式: &str) -> bool {
         match 模式 {
-            "中" => Rc::as_ptr(左) == Rc::as_ptr(右),
+            "中" => Arc::as_ptr(左) == Arc::as_ptr(右),
             _ => false,
         }
     }
 
     /// 从缠K序列中获取以指定缠K为中元素的分型
     pub fn 从缠K序列中获取分型(
-        K线序列: &[Rc<缠论K线>], 中: &Rc<缠论K线>
+        K线序列: &[Arc<缠论K线>],
+        中: &Arc<缠论K线>,
     ) -> Option<Self> {
         let idx = K线序列
             .iter()
-            .position(|k| Rc::as_ptr(k) == Rc::as_ptr(中))?;
+            .position(|k| Arc::as_ptr(k) == Arc::as_ptr(中))?;
         let 左 = if idx > 0 {
-            Some(Rc::clone(&K线序列[idx - 1]))
+            Some(Arc::clone(&K线序列[idx - 1]))
         } else {
             None
         };
         let 右 = if idx + 1 < K线序列.len() {
-            Some(Rc::clone(&K线序列[idx + 1]))
+            Some(Arc::clone(&K线序列[idx + 1]))
         } else {
             None
         };
-        Some(Self::new(左, Rc::clone(中), 右))
+        Some(Self::new(左, Arc::clone(中), 右))
     }
 
     /// 向分型序列中添加新分型
-    pub fn 向序列中添加(分型序列: &mut Vec<Rc<分型>>, 当前分型: Rc<分型>) {
+    pub fn 向序列中添加(分型序列: &mut Vec<Arc<分型>>, 当前分型: Arc<分型>) {
         if 分型序列.is_empty() {
             if 当前分型.结构 != 分型结构::顶 && 当前分型.结构 != 分型结构::底
             {
@@ -188,10 +198,10 @@ impl 分型 {
 
 impl crate::types::fractal::有高低 for 分型 {
     fn 高(&self) -> f64 {
-        self.中.高
+        self.中.高.get()
     }
     fn 低(&self) -> f64 {
-        self.中.低
+        self.中.低.get()
     }
 }
 
@@ -200,7 +210,11 @@ impl std::fmt::Display for 分型 {
         write!(
             f,
             "{}<{}, {}, None: {}, None: {}>",
-            self.中.分型.unwrap_or(crate::types::分型结构::散),
+            self.中
+                .分型
+                .read()
+                .unwrap()
+                .unwrap_or(crate::types::分型结构::散),
             self.时间戳,
             crate::utils::format_f64_g(self.分型特征值),
             if self.左.is_none() { "True" } else { "False" },

chanlun/src/structure/segment_feat.rs

@@ -26,7 +26,8 @@ use crate::structure::dash_line::虚线;
 use crate::structure::feat_fractal::特征分型;
 use crate::structure::fractal_obj::分型;
 use crate::types::{分型结构, 相对方向};
-use std::rc::Rc;
+use std::sync::atomic::Ordering;
+use std::sync::Arc;
 
 /// 线段特征 — 特征序列元素（内部是虚线的集合）
 #[derive(Debug, Clone)]
@@ -34,11 +35,11 @@ pub struct 线段特征 {
     pub 序号: i64,
     pub 标识: String,
     pub 线段方向: 相对方向,
-    pub 元素: Vec<Rc<虚线>>,
+    pub 元素: Vec<Arc<虚线>>,
 }
 
 impl 线段特征 {
-    pub fn new(标识: String, 基础序列: Vec<Rc<虚线>>, 线段方向: 相对方向) -> Self {
+    pub fn new(标识: String, 基础序列: Vec<Arc<虚线>>, 线段方向: 相对方向) -> Self {
         Self {
             序号: 0,
             标识,
@@ -53,7 +54,7 @@ impl 线段特征 {
 
     /// 文 — 取特征序列元素中分型特征值最大/最小的文分型
     /// tiebreaker: later时间戳 wins when特征值 equal (matches Python)
-    pub fn 文(&self) -> Rc<分型> {
+    pub fn 文(&self) -> Arc<分型> {
         if self.线段方向.是否向上() {
             self.元素
                 .iter()
@@ -64,8 +65,8 @@ impl 线段特征 {
                         .unwrap_or(std::cmp::Ordering::Equal)
                         .then_with(|| a.文.时间戳.cmp(&b.文.时间戳))
                 })
-                .map(|x| Rc::clone(&x.文))
-                .unwrap_or_else(|| Rc::clone(&self.元素[0].文))
+                .map(|x| Arc::clone(&x.文))
+                .unwrap_or_else(|| Arc::clone(&self.元素[0].文))
         } else {
             self.元素
                 .iter()
@@ -76,38 +77,54 @@ impl 线段特征 {
                         .unwrap_or(std::cmp::Ordering::Equal)
                         .then_with(|| b.文.时间戳.cmp(&a.文.时间戳))
                 })
-                .map(|x| Rc::clone(&x.文))
-                .unwrap_or_else(|| Rc::clone(&self.元素[0].文))
+                .map(|x| Arc::clone(&x.文))
+                .unwrap_or_else(|| Arc::clone(&self.元素[0].文))
         }
     }
 
     /// 武 — 取特征序列元素中分型特征值最大/最小的武分型
     /// tiebreaker: later时间戳 wins when特征值 equal (matches Python)
-    pub fn 武(&self) -> Rc<分型> {
+    pub fn 武(&self) -> Arc<分型> {
         if self.线段方向.是否向上() {
             self.元素
                 .iter()
                 .max_by(|a, b| {
                     a.武
+                        .read()
+                        .unwrap()
                         .分型特征值
-                        .partial_cmp(&b.武.分型特征值)
+                        .partial_cmp(&b.武.read().unwrap().分型特征值)
                         .unwrap_or(std::cmp::Ordering::Equal)
-                        .then_with(|| a.武.时间戳.cmp(&b.武.时间戳))
+                        .then_with(|| {
+                            a.武
+                                .read()
+                                .unwrap()
+                                .时间戳
+                                .cmp(&b.武.read().unwrap().时间戳)
+                        })
                 })
-                .map(|x| Rc::clone(&x.武))
-                .unwrap_or_else(|| Rc::clone(&self.元素[0].武))
+                .map(|x| x.武.read().unwrap().clone())
+                .unwrap_or_else(|| self.元素[0].武.read().unwrap().clone())
         } else {
             self.元素
                 .iter()
                 .min_by(|a, b| {
                     a.武
+                        .read()
+                        .unwrap()
                         .分型特征值
-                        .partial_cmp(&b.武.分型特征值)
+                        .partial_cmp(&b.武.read().unwrap().分型特征值)
                         .unwrap_or(std::cmp::Ordering::Equal)
-                        .then_with(|| b.武.时间戳.cmp(&a.武.时间戳))
+                        .then_with(|| {
+                            b.武
+                                .read()
+                                .unwrap()
+                                .时间戳
+                                .cmp(&a.武.read().unwrap().时间戳)
+                        })
                 })
-                .map(|x| Rc::clone(&x.武))
-                .unwrap_or_else(|| Rc::clone(&self.元素[0].武))
+                .map(|x| x.武.read().unwrap().clone())
+                .unwrap_or_else(|| self.元素[0].武.read().unwrap().clone())
         }
     }
 
@@ -129,7 +146,7 @@ impl 线段特征 {
     }
 
     /// 向特征序列元素中添加虚线
-    pub fn 添加(&mut self, 待添加虚线: Rc<虚线>) -> Result<(), String> {
+    pub fn 添加(&mut self, 待添加虚线: Arc<虚线>) -> Result<(), String> {
         if 待添加虚线.方向() == self.线段方向 {
             return Err("添加方向与线段方向相同".into());
         }
@@ -138,14 +155,14 @@ impl 线段特征 {
     }
 
     /// 从特征序列元素中删除虚线
-    pub fn 删除(&mut self, 待删除虚线: &Rc<虚线>) -> Result<(), String> {
+    pub fn 删除(&mut self, 待删除虚线: &Arc<虚线>) -> Result<(), String> {
         if 待删除虚线.方向() == self.方向() {
             return Err("删除方向与特征序列方向相同".into());
         }
         if let Some(pos) = self
             .元素
             .iter()
-            .position(|x| Rc::as_ptr(x) == Rc::as_ptr(待删除虚线))
+            .position(|x| Arc::as_ptr(x) == Arc::as_ptr(待删除虚线))
         {
             self.元素.remove(pos);
             Ok(())
@@ -155,19 +172,19 @@ impl 线段特征 {
     }
 
     /// 新建特征序列元素
-    pub fn 新建(虚线序列: Vec<Rc<虚线>>, 线段方向: 相对方向) -> Self {
+    pub fn 新建(虚线序列: Vec<Arc<虚线>>, 线段方向: 相对方向) -> Self {
         let 标识 = format!("特征<虚线>");
         Self::new(标识, 虚线序列, 线段方向)
     }
 
     /// 静态分析 — 从虚线序列生成特征序列元素列表
     pub fn 静态分析(
-        虚线序列: &[Rc<虚线>],
+        虚线序列: &[Arc<虚线>],
         线段方向: 相对方向,
         四象: &str,
         是否忽视: bool,
-    ) -> Vec<Rc<线段特征>> {
-        let mut 结果: Vec<Rc<线段特征>> = Vec::new();
+    ) -> Vec<Arc<线段特征>> {
+        let mut 结果: Vec<Arc<线段特征>> = Vec::new();
 
         // 需要被合并的方向集合
         let 需要合并: Vec<相对方向> = match 四象 {
@@ -179,9 +196,9 @@ impl 线段特征 {
             // 情况1：方向相同（可能触发分型替换）
             if 虚线.方向() == 线段方向 {
                 if 结果.len() >= 3 {
-                    let 左 = Rc::clone(&结果[结果.len() - 3]);
-                    let 中 = Rc::clone(&结果[结果.len() - 2]);
-                    let 右 = Rc::clone(&结果[结果.len() - 1]);
+                    let 左 = Arc::clone(&结果[结果.len() - 3]);
+                    let 中 = Arc::clone(&结果[结果.len() - 2]);
+                    let 右 = Arc::clone(&结果[结果.len() - 1]);
 
                     if let Some(结构) = 分型结构::分析(&*左, &*中, &*右, true, true) {
                         let 应替换 = (线段方向 == 相对方向::向上
@@ -192,16 +209,24 @@ impl 线段特征 {
                                 && 虚线.低() < 中.低());
 
                         if 应替换 {
-                            let 小号虚线 = 中.元素.iter().min_by_key(|o| o.序号).unwrap();
-                            let 大号虚线 = 右.元素.iter().max_by_key(|o| o.序号).unwrap();
+                            let 小号虚线 = 中
+                                .元素
+                                .iter()
+                                .min_by_key(|o| o.序号.load(Ordering::Relaxed))
+                                .unwrap();
+                            let 大号虚线 = 右
+                                .元素
+                                .iter()
+                                .max_by_key(|o| o.序号.load(Ordering::Relaxed))
+                                .unwrap();
                             let fake = 虚线::创建笔(
-                                Rc::clone(&小号虚线.文),
-                                Rc::clone(&大号虚线.武),
+                                Arc::clone(&小号虚线.文),
+                                大号虚线.武.read().unwrap().clone(),
                                 false,
                             );
                             结果.pop();
                             let idx = 结果.len() - 1;
-                            结果[idx] = Rc::new(Self::新建(vec![Rc::new(fake)], 线段方向));
+                            结果[idx] = Arc::new(Self::新建(vec![Arc::new(fake)], 线段方向));
                         }
                     }
                 }
@@ -210,7 +235,7 @@ impl 线段特征 {
 
             // 情况2：方向不同（执行特征序列的合并/添加）
             if 结果.is_empty() {
-                结果.push(Rc::new(Self::新建(vec![Rc::clone(虚线)], 线段方向)));
+                结果.push(Arc::new(Self::新建(vec![Arc::clone(虚线)], 线段方向)));
                 continue;
             }
 
@@ -225,10 +250,10 @@ impl 线段特征 {
             )) {
                 // Clone-modify-replace
                 let mut 新特征 = (*结果[最后_idx]).clone();
-                let _ = 新特征.添加(Rc::clone(虚线));
-                结果[最后_idx] = Rc::new(新特征);
+                let _ = 新特征.添加(Arc::clone(虚线));
+                结果[最后_idx] = Arc::new(新特征);
             } else {
-                结果.push(Rc::new(Self::新建(vec![Rc::clone(虚线)], 线段方向)));
+                结果.push(Arc::new(Self::新建(vec![Arc::clone(虚线)], 线段方向)));
             }
         }
 
@@ -236,15 +261,15 @@ impl 线段特征 {
     }
 
     /// 获取分型序列
-    pub fn 获取分型序列(特征序列: &[Rc<线段特征>]) -> Vec<特征分型> {
+    pub fn 获取分型序列(特征序列: &[Arc<线段特征>]) -> Vec<特征分型> {
         let mut 结果 = Vec::new();
         if 特征序列.len() < 3 {
             return 结果;
         }
         for i in 2..特征序列.len() {
-            let 左 = Rc::clone(&特征序列[i - 2]);
-            let 中 = Rc::clone(&特征序列[i - 1]);
-            let 右 = Rc::clone(&特征序列[i]);
+            let 左 = Arc::clone(&特征序列[i - 2]);
+            let 中 = Arc::clone(&特征序列[i - 1]);
+            let 右 = Arc::clone(&特征序列[i]);
 
             let 结构 = 分型结构::分析_对象(
                 &*左 as &dyn crate::types::fractal::有高低,
@@ -285,3 +310,273 @@ impl std::fmt::Display for 线段特征 {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::kline::bar::K线;
+    use crate::kline::chan_kline::缠论K线;
+    use crate::structure::fractal_obj::分型;
+    use crate::types::分型结构;
+
+    fn 辅助_创建K线(时间戳: i64, 高: f64, 低: f64, 开: f64, 收: f64) -> K线 {
+        let mut k = K线::default();
+        k.时间戳 = 时间戳;
+        k.高 = 高;
+        k.低 = 低;
+        k.开盘价 = 开;
+        k.收盘价 = 收;
+        k
+    }
+
+    fn 辅助_创建缠K(
+        时间戳: i64,
+        高: f64,
+        低: f64,
+        方向: 相对方向,
+        结构: Option<分型结构>,
+        序号: i64,
+    ) -> Arc<缠论K线> {
+        let 普K = Arc::new(辅助_创建K线(时间戳, 高, 低, 低, 高));
+        Arc::new(缠论K线::创建缠K(
+            时间戳, 高, 低, 方向, 结构, 序号, 普K, None,
+        ))
+    }
+
+    fn 辅助_创建顶分型(时间戳: i64, 高: f64, 低: f64, 序号: i64) -> Arc<分型> {
+        let 左 = 辅助_创建缠K(
+            时间戳 - 2,
+            高 - 2.0,
+            低 - 2.0,
+            相对方向::向上,
+            Some(分型结构::上),
+            序号 - 2,
+        );
+        let 中 = 辅助_创建缠K(时间戳, 高, 低, 相对方向::向上, Some(分型结构::顶), 序号);
+        let 右 = 辅助_创建缠K(
+            时间戳 + 2,
+            高 - 1.0,
+            低 - 1.0,
+            相对方向::向下,
+            Some(分型结构::下),
+            序号 + 2,
+        );
+        Arc::new(分型::new(Some(左), 中, Some(右)))
+    }
+
+    fn 辅助_创建底分型(时间戳: i64, 高: f64, 低: f64, 序号: i64) -> Arc<分型> {
+        let 左 = 辅助_创建缠K(
+            时间戳 - 2,
+            高 + 2.0,
+            低 + 2.0,
+            相对方向::向下,
+            Some(分型结构::下),
+            序号 - 2,
+        );
+        let 中 = 缠论K线::创建缠K(
+            时间戳,
+            高,
+            低,
+            相对方向::向下,
+            Some(分型结构::底),
+            序号,
+            Arc::new(辅助_创建K线(时间戳, 高, 低, 低, 高)),
+            None,
+        );
+        中.分型特征值.set(低);
+        let 中 = Arc::new(中);
+        let 右 = 辅助_创建缠K(
+            时间戳 + 2,
+            高 + 1.0,
+            低 + 1.0,
+            相对方向::向上,
+            Some(分型结构::上),
+            序号 + 2,
+        );
+        Arc::new(分型::new(Some(左), 中, Some(右)))
+    }
+
+    fn 辅助_创建笔(
+        文时间戳: i64,
+        文高: f64,
+        文低: f64,
+        武时间戳: i64,
+        武高: f64,
+        武低: f64,
+    ) -> Arc<虚线> {
+        let 顶 = 辅助_创建顶分型(文时间戳, 文高, 文低, 1);
+        let 底 = 辅助_创建底分型(武时间戳, 武高, 武低, 2);
+        Arc::new(虚线::创建笔(顶, 底, true))
+    }
+
+    // ============================================================
+    // 文 — 取特征值最大/最小的分型
+    // 特征序列元素方向与线段方向相反:
+    //   向上线段 → 元素为向下笔(顶→底) → 文=顶分型 → 取max
+    //   向下线段 → 元素为向上笔(底→顶) → 文=底分型 → 取min
+    // ============================================================
+
+    #[test]
+    fn test_文_向上线段取最大特征值分型() {
+        // 向上线段，元素用向下笔(顶→底)，文=顶分型
+        // 笔1: 顶(特征值=100)→底(80), 文=顶(100)
+        let 笔1 = 辅助_创建笔(100, 100.0, 90.0, 200, 90.0, 80.0);
+        // 笔2: 顶(特征值=110)→底(90), 文=顶(110)
+        let 笔2 = 辅助_创建笔(200, 110.0, 100.0, 300, 90.0, 80.0);
+
+        let feat = 线段特征::new(
+            "测试".into(),
+            vec![Arc::clone(&笔1), Arc::clone(&笔2)],
+            相对方向::向上,
+        );
+
+        // 向上取max → 笔2.文=110
+        let 文 = feat.文();
+        assert!((文.分型特征值 - 110.0).abs() < 0.01);
+    }
+
+    #[test]
+    fn test_文_向下线段取最小特征值分型() {
+        // 向下线段，元素用向上笔(底→顶)，文=底分型
+        // 笔1: 底(特征值=80)→顶(100), 文=底(80)
+        let 底1 = 辅助_创建底分型(100, 90.0, 80.0, 5);
+        let 顶1 = 辅助_创建顶分型(200, 100.0, 90.0, 10);
+        let 笔1 = Arc::new(虚线::创建笔(底1, 顶1, true));
+
+        // 笔2: 底(特征值=70)→顶(95), 文=底(70)
+        let 底2 = 辅助_创建底分型(200, 80.0, 70.0, 15);
+        let 顶2 = 辅助_创建顶分型(300, 95.0, 85.0, 20);
+        let 笔2 = Arc::new(虚线::创建笔(底2, 顶2, true));
+
+        let feat = 线段特征::new(
+            "测试".into(),
+            vec![Arc::clone(&笔1), Arc::clone(&笔2)],
+            相对方向::向下,
+        );
+
+        // 向下取min → 笔2.文=70
+        let 文 = feat.文();
+        assert!((文.分型特征值 - 70.0).abs() < 0.01);
+    }
+
+    // ============================================================
+    // 武 — 取特征值最大/最小的分型
+    //   向上线段 → 元素为向下笔 → 武=底分型 → 取max
+    //   向下线段 → 元素为向上笔 → 武=顶分型 → 取min
+    // ============================================================
+
+    #[test]
+    fn test_武_向上线段取最大特征值分型() {
+        // 向上线段，元素用向下笔(顶→底)，武=底分型
+        // 笔1: 顶(100)→底(特征值=80), 武=底(80)
+        let 笔1 = 辅助_创建笔(100, 100.0, 90.0, 200, 90.0, 80.0);
+        // 笔2: 顶(110)→底(特征值=90), 武=底(90)
+        let 笔2 = 辅助_创建笔(200, 110.0, 100.0, 300, 100.0, 90.0);
+
+        let feat = 线段特征::new(
+            "测试".into(),
+            vec![Arc::clone(&笔1), Arc::clone(&笔2)],
+            相对方向::向上,
+        );
+
+        // 向上取max → 笔2.武=90
+        let 武 = feat.武();
+        assert!((武.分型特征值 - 90.0).abs() < 0.01);
+    }
+
+    #[test]
+    fn test_武_向下线段取最小特征值分型() {
+        // 向下线段，元素用向上笔(底→顶)，武=顶分型
+        // 笔1: 底(80)→顶(特征值=100), 武=顶(100)
+        let 底1 = 辅助_创建底分型(100, 90.0, 80.0, 5);
+        let 顶1 = 辅助_创建顶分型(200, 100.0, 90.0, 10);
+        let 笔1 = Arc::new(虚线::创建笔(底1, 顶1, true));
+
+        // 笔2: 底(60)→顶(特征值=85), 武=顶(85)
+        let 底2 = 辅助_创建底分型(200, 70.0, 60.0, 15);
+        let 顶2 = 辅助_创建顶分型(300, 85.0, 75.0, 20);
+        let 笔2 = Arc::new(虚线::创建笔(底2, 顶2, true));
+
+        let feat = 线段特征::new(
+            "测试".into(),
+            vec![Arc::clone(&笔1), Arc::clone(&笔2)],
+            相对方向::向下,
+        );
+
+        // 向下取min → 笔2.武=85
+        let 武 = feat.武();
+        assert!((武.分型特征值 - 85.0).abs() < 0.01);
+    }
+
+    // ============================================================
+    // 文/武 tiebreaker — 同特征值取后时间戳
+    // ============================================================
+
+    #[test]
+    fn test_文_同特征值取后时间戳() {
+        // 两个笔的文特征值相同=100，但时间戳不同
+        let 顶1 = 辅助_创建顶分型(100, 100.0, 90.0, 5);
+        let 底1 = 辅助_创建底分型(200, 90.0, 80.0, 10);
+        let 笔1 = Arc::new(虚线::创建笔(顶1, 底1, true));
+
+        let 顶2 = 辅助_创建顶分型(300, 100.0, 90.0, 15); // 同特征值，后时间戳
+        let 底2 = 辅助_创建底分型(400, 80.0, 70.0, 20);
+        let 笔2 = Arc::new(虚线::创建笔(顶2, 底2, true));
+
+        let feat = 线段特征::new("测试".into(), vec![笔1, 笔2], 相对方向::向上);
+
+        let 文 = feat.文();
+        // 向上取最大特征值：都是100 → tiebreaker取后时间戳 → 笔2.文(300)
+        assert_eq!(文.时间戳, 300);
+    }
+
+    #[test]
+    fn test_武_同特征值取后时间戳_向上() {
+        let 顶1 = 辅助_创建顶分型(100, 100.0, 90.0, 5);
+        let 底1 = 辅助_创建底分型(200, 80.0, 70.0, 10); // 特征值80
+        let 笔1 = Arc::new(虚线::创建笔(顶1, 底1, true));
+
+        let 顶2 = 辅助_创建顶分型(300, 80.0, 70.0, 15); // 特征值80
+        let 底2 = 辅助_创建底分型(400, 80.0, 70.0, 20); // 特征值80
+        let 笔2 = Arc::new(虚线::创建笔(顶2, 底2, true));
+
+        let feat = 线段特征::new("测试".into(), vec![笔1, 笔2], 相对方向::向上);
+
+        let 武 = feat.武();
+        // 向上取最大特征值：都是80 → tiebreaker取后时间戳 → 笔2.武(400)
+        assert_eq!(武.时间戳, 400);
+    }
+
+    // ============================================================
+    // 添加/删除 操作
+    // ============================================================
+
+    #[test]
+    fn test_添加方向与线段方向相反的虚线可成功() {
+        // 向下笔(顶→底,方向=向下) 添加到 向上线段(方向=向上) → 方向不同, 可添加
+        let 笔1 = 辅助_创建笔(100, 100.0, 90.0, 200, 90.0, 80.0);
+        let mut feat = 线段特征::new("测试".into(), vec![], 相对方向::向上);
+
+        let result = feat.添加(Arc::clone(&笔1));
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_添加方向与线段方向相同的虚线应报错() {
+        // 向下笔(顶→底,方向=向下) 添加到 向下线段(方向=向下) → 方向相同, 应报错
+        let 笔1 = 辅助_创建笔(100, 100.0, 90.0, 200, 90.0, 80.0);
+        let mut feat = 线段特征::new("测试".into(), vec![], 相对方向::向下);
+
+        let result = feat.添加(Arc::clone(&笔1));
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_空线段特征文返回第一个元素的文() {
+        let 笔1 = 辅助_创建笔(100, 100.0, 90.0, 200, 90.0, 80.0);
+        let feat = 线段特征::new("测试".into(), vec![Arc::clone(&笔1)], 相对方向::向上);
+
+        let 文 = feat.文();
+        assert_eq!(Arc::as_ptr(&文), Arc::as_ptr(&笔1.文));
+    }
+}

chanlun/src/types/mod.rs

@@ -26,8 +26,10 @@ pub mod bsp_type;
 pub mod direction;
 pub mod fractal;
 pub mod gap;
+pub mod sync_f64;
 
 pub use bsp_type::买卖点类型;
 pub use direction::相对方向;
 pub use fractal::分型结构;
 pub use gap::缺口;
+pub use sync_f64::SyncF64;

chanlun/src/types/sync_f64.rs

@@ -0,0 +1,25 @@
+use std::sync::atomic::{AtomicU64, Ordering};
+
+/// f64 原子类型 — 基于 AtomicU64 + 位转换，API 与 `Cell<f64>` 一致。
+#[derive(Debug, Default)]
+pub struct SyncF64(AtomicU64);
+
+impl SyncF64 {
+    pub fn new(v: f64) -> Self {
+        Self(AtomicU64::new(v.to_bits()))
+    }
+
+    pub fn get(&self) -> f64 {
+        f64::from_bits(self.0.load(Ordering::Relaxed))
+    }
+
+    pub fn set(&self, v: f64) {
+        self.0.store(v.to_bits(), Ordering::Relaxed);
+    }
+}
+
+impl Clone for SyncF64 {
+    fn clone(&self) -> Self {
+        Self(AtomicU64::new(self.0.load(Ordering::Relaxed)))
+    }
+}

chanlun/src/utils/format.rs

@@ -22,6 +22,7 @@
  * SOFTWARE.
  */
 
+/// 将 f64 格式化为与 Python `:g` (6 位有效数字) 兼容的字符串。
 pub fn format_f64_g(value: f64) -> String {
     if value.is_nan() {
         return "nan".to_string();
@@ -33,9 +34,61 @@ pub fn format_f64_g(value: f64) -> String {
             "-inf".to_string()
         };
     }
+    if value == 0.0 {
+        return "0".to_string();
+    }
 
-    // Use high precision then trim trailing zeros
-    let s = format!("{:.15}", value);
-    let s = s.trim_end_matches('0');
-    s.trim_end_matches('.').to_string()
+    let abs = value.abs();
+    let exp = abs.log10().floor() as i32;
+
+    // Python :g 科学计数法边界: exp < -4 或 exp >= p (=6)
+    if exp < -4 || exp >= 6 {
+        let significand = value / 10_f64.powi(exp);
+        let s = format!("{:.5}", significand);
+        let s = s.trim_end_matches('0').trim_end_matches('.');
+        return format!("{}e{:+03}", s, exp);
+    }
+
+    // 定点表示
+    if abs >= 1.0 {
+        let int_digits = exp as usize + 1;
+        if int_digits >= 6 {
+            return format!("{:.0}", value);
+        }
+        let s = format!("{:.prec$}", value, prec = 6 - int_digits);
+        let s = s.trim_end_matches('0');
+        return s.trim_end_matches('.').to_string();
+    } else {
+        let leading_zeros = (-exp) as usize;
+        let s = format!("{:.prec$}", value, prec = leading_zeros + 5);
+        let s = s.trim_end_matches('0');
+        return s.trim_end_matches('.').to_string();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_format_large() {
+        assert_eq!(format_f64_g(82833.0), "82833");
+        assert_eq!(format_f64_g(74192.2), "74192.2");
+        assert_eq!(format_f64_g(100.0), "100");
+        assert_eq!(format_f64_g(0.0), "0");
+        assert_eq!(format_f64_g(12345.6789), "12345.7");
+    }
+
+    #[test]
+    fn test_format_small() {
+        assert_eq!(format_f64_g(0.001234), "0.001234");
+        assert_eq!(format_f64_g(0.1), "0.1");
+        assert_eq!(format_f64_g(0.001), "0.001");
+    }
+
+    #[test]
+    fn test_format_extreme() {
+        assert_eq!(format_f64_g(1e7), "1e+07");
+        assert_eq!(format_f64_g(1e-5), "1e-05");
+    }
 }