<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
    <id>https://lonetrail.vercel.app/</id>
    <title>Chayv</title>
    <updated>2026-06-18T00:00:00.000Z</updated>
    <generator>Astro - Feed Library</generator>
    <author>
        <name>Lonetrail 演示</name>
        <email>qwq@chongxi.us</email>
        <uri>https://lonetrail.vercel.app/</uri>
    </author>
    <link rel="alternate" href="https://lonetrail.vercel.app/"/>
    <link rel="self" href="https://lonetrail.vercel.app/atom.xml"/>
    <subtitle>循此苦旅，以达星辰</subtitle>
    <icon>https://lonetrail.vercel.app/favicon.ico</icon>
    <rights>All rights reserved 2026, Chayv</rights>
    <entry>
        <title type="html"><![CDATA[Golang 的 GMP 原理]]></title>
        <id>https://lonetrail.vercel.app/posts/Golang%E7%9A%84GMP%E5%8E%9F%E7%90%86/</id>
        <link href="https://lonetrail.vercel.app/posts/Golang%E7%9A%84GMP%E5%8E%9F%E7%90%86/"/>
        <updated>2026-06-18T00:00:00.000Z</updated>
        <summary type="html"><![CDATA[深入剖析 Go 语言的协程调度 GMP 模型，理解其进程、线程、协程与 Goroutine 的关系和调度原理。]]></summary>
        <content type="html"><![CDATA[<h2>概念梳理</h2>
<h2>进程</h2>
<p>进程是计算机中已运行的程序示例，拥有独立的内存空间、资源和系统信息。每个进程都是互相独立的，进程间通信需要通过特定的机制（如管道、消息队列、共享内存、信号、套接字、信号量、内存映射文件、远程过程调用（RPC）等），核心点如下：</p>
<p>（1）独立的内存空间</p>
<p>（2）进程之间相互隔离</p>
<p>（3）创建和销毁开销较大</p>
<p>（4）通常用于操作系统调度的基本单位</p>
<h2>线程</h2>
<p>通常语义中的线程，指的是内核级线程，核心点如下：</p>
<p>（1）是操作系统最小调度单元</p>
<p>（2）创建、销毁、调度交由内核完成，cpu需要完成用户态与内核态的切换</p>
<p>（3）可充分利用多核，实现并行</p>
<h2>协程</h2>
<p>协程，又称为用户级线程，核心点如下：</p>
<p>（1）与线程存在映射关系，为M：1</p>
<p>（2）创建、销毁、调度在用户态完成，对内核透明，所以更轻</p>
<p>（3）从属同一个内核级线程，无法并行；一个协程阻塞会导致从属同一下称的所有协程无法执行</p>
<h2>Goroutine</h2>
<p>Goroutine，经Golang优化后的特殊”协程“，核心点如下：</p>
<p>（1）与线程存在映射关系，为M:N;</p>
<p>（2）创建、销毁、调度都在用户态完成，对内核透明，足够轻便</p>
<p>（3）可以利用多线程、实现并行</p>
<p>（4）通过调度器的斡旋，实现和线程间的动态绑定和灵活调度</p>
<p>（5）栈空间大小可动态扩缩，因地制宜</p>
<h1>GMP模型</h1>
<h2>g</h2>
<ul>
<li>g，即goroutine，是golang中对协程的抽象</li>
<li>g有自己的运行栈、生命周期状态、以及执行的任务函数（用户通过go func指定）；</li>
<li>g需要绑定在m上执行，在g视角中，可以将m理解为它的cpu</li>
</ul>
<h2>m</h2>
<ul>
<li>m即machine，是golang中对线程的抽象</li>
<li>m需要和p进行结合，从而进入gmp调度体系之中</li>
<li>m的运行目标始终在g0和g之间切换-当运行g0是执行的是m的调度流程，负责寻找合适的”任务“，也就是g；当运行g时，执行的时m获取到的”任务“，也就是用户通过go func启动的goroutine</li>
</ul>
<h2>p</h2>
<ul>
<li>p即processor，是golang中的调度器</li>
<li>p可以理解为m的执行代理，m需要与p绑定后，才会进入到gmp调度模式中；因此p的数量决定了g最大并行数量（可由用户通过**GOMAXPROCS**进行设定，超过CPU核数时无意义）</li>
<li>p是g的存储容器，其自带一个本地g队列（local run queue，简称lrq），承载着一系列等待被调度的g</li>
</ul>
<h2>gmp</h2>
<p>（1）M是线程的抽象；G是goroutine；P是承上启下的调度器</p>
<p>（2）M调度G前，需要和P绑定</p>
<p>（3）全局有多个M和多个P，但同时并行的G的最大数量等于P的数量</p>
<p>（4）G的存放队列有三类：P的本地队列、全局队列和wait队列</p>
<p>（5）M调度G时，优先取P本地队列，其次取全局队列，后取wait队列，这样的好处是，取本地队列时，可以接近于无锁化，减少全局锁竞争</p>
<p>（6）为防止不同P的闲忙差异过大，设立work-stealing机制，本地队列为空的P可以尝试从其他P本地队列偷取一半G补充到自身队列中</p>
]]></content>
        <author>
            <name>Lonetrail 演示</name>
            <email>qwq@chongxi.us</email>
            <uri>https://lonetrail.vercel.app/</uri>
        </author>
        <category label="Go"/>
        <category label="GMP"/>
        <category label="Concurrency"/>
        <published>2026-06-18T00:00:00.000Z</published>
    </entry>
    <entry>
        <title type="html"><![CDATA[Go 中的垃圾回收]]></title>
        <id>https://lonetrail.vercel.app/posts/Go%E4%B8%AD%E7%9A%84%E5%9E%83%E5%9C%BE%E5%9B%9E%E6%94%B6/</id>
        <link href="https://lonetrail.vercel.app/posts/Go%E4%B8%AD%E7%9A%84%E5%9E%83%E5%9C%BE%E5%9B%9E%E6%94%B6/"/>
        <updated>2026-06-18T00:00:00.000Z</updated>
        <summary type="html"><![CDATA[详细介绍垃圾回收（GC）算法背景、三色标记法、并发回收机制以及屏障机制的工作原理。]]></summary>
        <content type="html"><![CDATA[<h2>垃圾回收算法</h2>
<h2>背景介绍</h2>
<p>垃圾回收（Garbage Collection，简称 GC）是一种内存管理策略，由垃圾收集器以及守护协程的方式在后台运作，按照既定的策略为用户回收那些不在被使用的对象，释放对应的内存空间。</p>
<p>（1） GC带来的优势：</p>
<ul>
<li>屏蔽内存回收细节，为用户屏蔽复杂的内存管理工作。</li>
<li>以全局视野执行任务。</li>
</ul>
<p>（2） GC带来的劣势：</p>
<ul>
<li>将释放内存的工作委托给垃圾回收模块，研发人员得到了减负，也失去了控制主权。</li>
<li>增加了额外的成本，需要额外的状态信息用以存储全局的内存使用情况，且部分时间需要中断整个程序用以支持垃圾回收工作的执行。</li>
</ul>
<h2>标记清扫</h2>
<p>标记清扫（Mark-Sweep）算法，分两步走：</p>
<ul>
<li>标记：标记出当前还存活的对象</li>
<li>清扫：清扫掉未被标记到的垃圾对象</li>
</ul>
<p>不足：会产生内存碎片，如果由大对象需要分配内存，可能会因为内存空间无法化零而导致分配失败。</p>
<h2>标记压缩</h2>
<p>标记压缩（Mark-Compact）算法，是在标记清扫算法的基础上做了升级，在第二步“清扫“的同时还会对存活对象进行压缩整合，使整体空间更为紧凑，从而解决内存碎片问题。</p>
<p>不足：实现会有很高的复杂度</p>
<h2>半空间复制</h2>
<p>半空间复制（Semispace Copy）核心点：</p>
<ul>
<li>分配两片相等大小的空间，称为fromspace和tospace</li>
<li>每轮只使用formspace空间，以GC作为分水岭划分轮次</li>
<li>GC时，将fromspace存活对象转移到tospace中，并以此为契机对空间进行压缩整合</li>
<li>GC后，交换fromspace和tospace，开启新的轮次</li>
</ul>
<p>半空间复制算法应用了以空间换取时间的优化策略，解决了内存碎片的问题，降低了压缩空间的复杂度。</p>
<p>不足：比较浪费空间</p>
<h2>引用计数</h2>
<p>引用计数（Reference Counting）算法核心点：</p>
<ul>
<li>对象每被引用一次，计数器加1</li>
<li>对象每被删除引用一次，计数器减1</li>
<li>GC时，把计数器等于0的对象删除</li>
</ul>
<p>不足：无法解决循环引用和自引用问题</p>
<h1>Golang中垃圾回收</h1>
<p>Golang在1.8版本之后，GC策略矿建已经奠定，就是并发三色标记法+混合写屏障机制。</p>
<h2>三色标记法</h2>
<p>Golang GC用到的三色标记法属于标记清扫-算法的一种实现，核心点有：</p>
<ul>
<li>对象分为三种颜色标记：黑、灰、白</li>
<li>黑对象代表，对象自身存活，且其指向对象都已标记完成</li>
<li>灰对象代表，对象自身存活，但其指向对象还未标记完成</li>
<li>白对象代表，对象尚未被标记到，可能是垃圾对象</li>
<li>标记开始前，将根对象（全局对象、栈上的局部变量等）置黑，将其所指向的对象置灰</li>
<li>标记规则是，从灰对象触发，将其所指向的对象都置灰。所有指向对象都置灰后，当前灰对象置黑</li>
<li>标记结束后，白色对象就是不可达对象，进行垃圾清扫</li>
</ul>
<h2>并发垃圾回收</h2>
<p>Golang1.5版本是个分水岭，在此之前，GC时需要停止全局的用户协程，专注完成GC工作后，再恢复用户协程。</p>
<p>在1.5版本之后，Golang引入了并发垃圾回收机制，允许用户协程和后台的GC协程并发运行。</p>
<p>（1）Golang并发垃圾回收可能存在漏标问题</p>
<p>漏标问题是指用户协程与GC协程并发执行的场景下，部分存活对象未被标记从而被误删的情况。</p>
<ul>
<li>初始时刻，对象B持有对象C的引用</li>
<li>GC协程下，对象A被扫描完成，置黑；此时对象B是灰色，还未完成扫描</li>
<li>用户协程下，对象A建立指向对象C的引用</li>
<li>用户协程下，对象B删除指向对象C的引用</li>
<li>GC协程下，开始指向对对象B的扫描</li>
</ul>
<p>由于GC协程在B删除C的引用后才开始扫描B，因此无法到达C，因为A已经被置黑，不会再重复扫描，因此从扫描结果看，C是不可达的。</p>
<p>事实上C应该是被A引用的，而GC结束后因为C仍为白色，因此被GC误删</p>
<p>（2）Golang并发垃圾回收可能存在多标问题</p>
<p>多标问题指的是在用户协程与GC协程并发执行的场景下，部分垃圾对象被误标记从而导致GC未按时将其回收的问题</p>
<ul>
<li>初始时刻，对象A持有对象B的引用</li>
<li>GC协程下，对象A被扫描完成，置黑；对象B被对象A引用，因此被置灰</li>
<li>用户协程下，对象A删除执行对象B的引用</li>
</ul>
<p>在事实上，B在被A删除引用后，已经称为垃圾对象，但由于其事先已被置灰，因此最终灰更新为黑色，不会被GC删除。</p>
<h1>屏障机制</h1>
<h2>强弱三色不变式</h2>
<ul>
<li>强三色不变式：白色对象不能被黑色对象直接引用（直接破坏）</li>
<li>弱三色不变式：白色对象可以被黑色对象引用，但要从某一个灰色对象出发仍然可以到达该白色对象</li>
</ul>
<h2>插入写屏障</h2>
<p>屏障机制类似于一个回调保护机制，指的是在完成某个特定动作之前，会先完成屏障设置的内容。</p>
<p>插入写屏障的目标是实现强三色不变式，保证当一个黑色对象指向一个白色对象前，会触发屏障将白色对象置为灰色，再建立引用。</p>
<h2>删除写屏障</h2>
<p>删除写屏障的目标是实现弱三色不变式，保证当一个白色对象即将被上游删除引用前，会触发屏障将其置灰，之后再删除上有指向其的引用。</p>
<h2>混合写屏障</h2>
<p>屏障机制无法作用于栈对象</p>
<p>这是因为栈对象可能涉及频繁的轻量操作，倘若这些高频操作都需要-触发写屏障机制，那么所带来的成本将无法接收。</p>
<p>在这一背景下，单独看插入写屏障或删除写屏障，都无法真正解决漏标问题，除非我们引入额外的Stop the wrold（STW）阶段，对栈对象的额处理进行兜底。</p>
<p>为了消除这个额外的STW成本，Golang1.8引入了混合写屏障机制，可以视为糅合了插入写屏障和删除屏障的加强版，要点如下：</p>
<ul>
<li>GC开始前，以栈为单位分批扫描，将栈中所有对象置黑</li>
<li>GC期间，栈上新创建对象直接置黑</li>
<li>堆对象正常启用插入写屏障</li>
<li>堆对象正常启用删除写屏障</li>
</ul>
]]></content>
        <author>
            <name>Lonetrail 演示</name>
            <email>qwq@chongxi.us</email>
            <uri>https://lonetrail.vercel.app/</uri>
        </author>
        <category label="Go"/>
        <category label="GC"/>
        <category label="Memory Management"/>
        <published>2026-06-18T00:00:00.000Z</published>
    </entry>
    <entry>
        <title type="html"><![CDATA[Go 的接口型函数]]></title>
        <id>https://lonetrail.vercel.app/posts/Go%E7%9A%84%E6%8E%A5%E5%8F%A3%E5%9E%8B%E5%87%BD%E6%95%B0/</id>
        <link href="https://lonetrail.vercel.app/posts/Go%E7%9A%84%E6%8E%A5%E5%8F%A3%E5%9E%8B%E5%87%BD%E6%95%B0/"/>
        <updated>2026-06-18T00:00:00.000Z</updated>
        <summary type="html"><![CDATA[探讨 Go 语言中经典的接口型函数设计模式，分析其工作原理、使用场景与优雅之处。]]></summary>
        <content type="html"><![CDATA[<p>在net/http包中，HandlerFunc为函数，实现了Handler接口。</p>
<pre><code class="language-go">type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
}

type HandlerFunc func(ResponseWriter, *Request)

func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
    f(w, r)
}
</code></pre>
<p>这样实现后，只要你的函数签名为：</p>
<pre><code class="language-go">func (ResponseWriter, *Request)
</code></pre>
<p>拥有<strong>http.HandlerFunc()<strong>一致的函数签名，就可以将该函数进行类型转换，转换为http.HandlerFunc函数类型。且</strong>http.HandlerFunc</strong>函数类型实现了<strong>Handle</strong>r接口，则你命名的函数转换后也相当于实现了<strong>Handler</strong>接口。</p>
<p>我们可以 <code>&lt;font style="color:rgb(36, 41, 46);"&gt;http.Handle&lt;/font&gt;</code> 来映射请求路径和处理函数，Handle 的定义如下：</p>
<pre><code class="language-go">func Handle(pattern string, handler Handler)
</code></pre>
<p>第二个参数是即接口类型 Handler，我们可以这么用。</p>
<pre><code class="language-go">func home(w http.ResponseWriter, r *http.Request) {
	w.WriteHeader(http.StatusOK)
	_, _ = w.Write([]byte("hello, index page"))
}

func main() {
	http.Handle("/home", http.HandlerFunc(home))
	_ = http.ListenAndServe("localhost:8000", nil)
}
</code></pre>
<p>通常，我们还会使用另外一个函数 <code>&lt;font style="color:rgb(36, 41, 46);"&gt;http.HandleFunc&lt;/font&gt;</code>，HandleFunc 的定义如下：</p>
<pre><code class="language-go">func HandleFunc(pattern string, handler func(ResponseWriter, *Request))
</code></pre>
<p>第二个参数是一个普通的函数类型，那可以直接将 home 传递给 HandleFunc：</p>
<pre><code class="language-go">func main() {
	http.HandleFunc("/home", home)
	_ = http.ListenAndServe("localhost:8000", nil)
}
</code></pre>
<p>那如果我们看过 HandleFunc 的内部实现的话，就会知道两种写法是完全等价的，内部将第二种写法转换为了第一种写法。</p>
<pre><code class="language-go">func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
	if handler == nil {
		panic("http: nil handler")
	}
	mux.Handle(pattern, HandlerFunc(handler))
}
</code></pre>
]]></content>
        <author>
            <name>Lonetrail 演示</name>
            <email>qwq@chongxi.us</email>
            <uri>https://lonetrail.vercel.app/</uri>
        </author>
        <category label="Go"/>
        <category label="Interface"/>
        <category label="Design Pattern"/>
        <published>2026-06-18T00:00:00.000Z</published>
    </entry>
    <entry>
        <title type="html"><![CDATA[Lonetrail Markdown 编写规范]]></title>
        <id>https://lonetrail.vercel.app/posts/markdown-guide/</id>
        <link href="https://lonetrail.vercel.app/posts/markdown-guide/"/>
        <updated>2026-06-18T00:00:00.000Z</updated>
        <summary type="html"><![CDATA[基于 Lonetrail 博客主题特点整理的 Markdown 文档编写规范，包含 Frontmatter 字段定义、排版风格、代码高亮、数学公式及自定义组件的使用说明。]]></summary>
        <content type="html"><![CDATA[<p>本文档旨在为 Lonetrail 博客平台的文章撰写制定统一的 Markdown 编写规范。通过遵循本规范，可以确保文章在主题渲染、排版美观度、功能可用性（如代码高亮、数学公式、自定义组件）以及检索优化（SEO）上达到最佳效果。</p>
<hr />
<h2>一、 Frontmatter 元数据规范</h2>
<p>每篇博客文章的开头必须包含 YAML 格式的 Frontmatter 区域，用以定义文章的元数据。</p>
<h3>1. 标准模板</h3>
<pre><code class="language-yaml">---
title: "文章标题"
published: 2026-06-18
description: "这是一段关于文章核心内容的简短摘要，用于文章列表展示及 SEO Meta 描述。"
tags: ["标签一", "标签二"]
category: "Tech"
image: "/images/covers/demo-cover.webp"
---
</code></pre>
<h3>2. 字段详细说明</h3>
<table>
<thead>
<tr>
<th>字段名称</th>
<th>类型</th>
<th>是否必填</th>
<th>说明</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>title</code></td>
<td>String</td>
<td><strong>是</strong></td>
<td>文章标题。应尽量简炼且表达主题，两端使用双引号包裹。</td>
</tr>
<tr>
<td><code>published</code></td>
<td>Date</td>
<td><strong>是</strong></td>
<td>发布日期。格式为 <code>YYYY-MM-DD</code>，无需加引号。</td>
</tr>
<tr>
<td><code>description</code></td>
<td>String</td>
<td><strong>是</strong></td>
<td>文章简介/摘要。建议在 100-150 字之间，有利于列表卡片美观及 SEO 抓取。</td>
</tr>
<tr>
<td><code>tags</code></td>
<td>Array</td>
<td><strong>是</strong></td>
<td>标签列表。用以进行标签页面的分类聚合。例如：<code>["Go", "Concurrency"]</code>。</td>
</tr>
<tr>
<td><code>category</code></td>
<td>String</td>
<td><strong>是</strong></td>
<td>分类。全站主要的大分类之一，例如 <code>Tech</code>（技术）或 <code>Journal</code>（日志）。</td>
</tr>
<tr>
<td><code>image</code></td>
<td>String</td>
<td>否</td>
<td>文章封面图路径。若无，请留空字符串 <code>""</code>。</td>
</tr>
</tbody>
</table>
<blockquote>
<p>[!WARNING]
<strong>注意</strong>：禁止在正文中遗漏 Frontmatter。未包含 Frontmatter 的历史文档（如部分旧技术笔记）应及时补充此元数据，否则可能导致 Astro 渲染引擎读取属性失败或无法在归档/系列列表中正常展示。</p>
</blockquote>
<hr />
<h2>二、 页面标题与结构规范</h2>
<h3>1. 标题层级</h3>
<ul>
<li><strong>禁止在正文中使用一级标题 (<code>#</code>)</strong>。
Astro 渲染器会自动将 Frontmatter 中的 <code>title</code> 解析并渲染为页面的 <code>&lt;h1&gt;</code> 标签。因此，文章正文的最高级标题<strong>必须从二级标题 (<code>##</code>) 开始</strong>。</li>
<li>合理使用三级标题 (<code>###</code>) 和四级标题 (<code>####</code>) 进行内容细分，避免标题层级过深（一般不超过四级）。</li>
</ul>
<h3>2. 空行与间距</h3>
<ul>
<li>每个标题、段落、列表、代码块、引用块之间，<strong>必须保留且仅保留一个空行</strong>。</li>
<li>这样可以保证 Markdown 源码的可读性，并使得渲染后的排版间距符合视觉比例。</li>
</ul>
<h3>3. 中英文混排与排版细节</h3>
<p>为了排版的美观性与专业性，建议在正文撰写中遵循以下细节：</p>
<ul>
<li><strong>空格使用</strong>：中文与英文、中文与数字之间建议保留一个半角空格。
<ul>
<li><em>推荐</em>：我们在 Go 语言中经常使用 Goroutine 来处理并发。</li>
<li><em>不推荐</em>：我们在Go语言中经常使用Goroutine来处理并发。</li>
</ul>
</li>
<li><strong>避免无用样式</strong>：严禁直接从 Notion 或其它富文本编辑器复制带有多余 HTML 标签的内容（例如带有 <code>&lt;font style="color:..."&gt;</code> 的文本），应尽量保持纯净的 Markdown 语法。</li>
</ul>
<hr />
<h2>三、 代码块与高亮规范</h2>
<p>Lonetrail 集成了功能强大的 <code>astro-expressive-code</code> 插件，支持多语言语法高亮、代码框标题、行号、折叠、高亮行等高级功能。</p>
<h3>1. 语言标识符</h3>
<p>编写代码块时，<strong>必须明确指定语言标识符</strong>，以便代码高亮引擎正确解析。</p>
<pre><code class="language-markdown"># 推荐写法
```go
func main() {
    fmt.Println("Hello, Lonetrail")
}
</code></pre>
<pre><code>
常用标识符参考：`typescript`, `javascript`, `python`, `rust`, `go`, `yaml`, `bash`, `json`, `markdown`。

### 2. 行内代码

对于正文中提及的变量、函数名、文件名、配置项或终端命令，应使用反引号包裹：
* 示例：调用 `calculateTrajectory(origin, destination)` 方法来计算轨道。

---

## 四、 数学公式规范 (KaTeX)

Lonetrail 支持通过 KaTeX 渲染数学公式。

### 1. 块级公式

单独成行的公式使用双美元符号 `$$` 包裹：

$$
E = mc^2
$$

$$
v = \sqrt{\frac{2GM}{r}}
$$

### 2. 行内公式

行内嵌入的数学公式使用单美元符号 `$` 包裹。例如：质能方程 $E=mc^2$ 描述了质量与能量的等价关系。

---

## 五、 自定义提示框与组件规范

基于 `rehype-components` 插件，Lonetrail 支持在 Markdown 中直接使用 HTML 自定义标签来渲染精美的提示框（Callout/Admonition）。

### 1. 提示框类型

根据 `astro.config.mjs` 中的配置，系统目前支持以下提示框标签：

| 标签对 | 别名标签（颜色） | 适用场景 | 渲染效果 |
| :--- | :--- | :--- | :--- |
| `&lt;note&gt;` | `&lt;blue&gt;` | 一般信息、补充说明 | 蓝色背景提示框 |
| `&lt;tip&gt;` | `&lt;green&gt;` | 实用技巧、最佳实践建议 | 绿色背景提示框 |
| `&lt;important&gt;`| `&lt;cyan&gt;` | 关键步骤、核心要点 | 青色背景提示框 |
| `&lt;warning&gt;` | `&lt;yellow&gt;` | 潜在风险、兼容性警告 | 黄色背景提示框 |
| `&lt;caution&gt;` | `&lt;red&gt;` | 高危操作、可能导致失败的细节 | 红色背景提示框 |

### 2. 使用方法示例

在 Markdown 正文中直接使用闭合标签包裹内容即可：

```html
&lt;note&gt;
这是一条蓝色的补充说明信息，用于提示读者某些不显眼但有用的细节。
&lt;/note&gt;

&lt;tip&gt;
**提示**：在执行 `pnpm dev` 之前，确保已运行过 `pnpm install` 完整下载所有依赖。
&lt;/tip&gt;

&lt;caution&gt;
**警告**：修改 `src/site.yml` 配置时，请保持正确的 YAML 缩进，否则可能导致构建报错。
&lt;/caution&gt;
</code></pre>
<hr />
<h2>六、 引用与列表规范</h2>
<h3>1. 引用块</h3>
<p>引用块使用 <code>&gt;</code> 引导，通常用于引用名言、参考资料说明等。如需换行，需要在行末加上两个空格或直接使用空行：</p>
<blockquote>
<p>Ad Astra Per Aspera.<br />
<em>Through hardships to the stars.</em></p>
</blockquote>
<h3>2. 列表</h3>
<ul>
<li><strong>无序列表</strong>：使用 <code>-</code> 或 <code>*</code> 作为引导符。</li>
<li><strong>有序列表</strong>：使用数字加英文句点 <code>1.</code>，后面保留一个空格。</li>
<li><strong>嵌套列表</strong>：子列表的引导符相比上级列表需要缩进 2 或 4 个空格。</li>
</ul>
]]></content>
        <author>
            <name>Lonetrail 演示</name>
            <email>qwq@chongxi.us</email>
            <uri>https://lonetrail.vercel.app/</uri>
        </author>
        <category label="Lonetrail"/>
        <category label="Markdown"/>
        <category label="Writing Guide"/>
        <category label="Specification"/>
        <published>2026-06-18T00:00:00.000Z</published>
    </entry>
</feed>