rust
/
rust-course
mirror of https://github.com/sunface/rust-course
5
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '12108c0325'
${ noResults }
rust-course/advance/concurrency-with-threads/sync2.html

483 lines
72 KiB
Raw Normal View History Unescape

deploy
1 month ago
<!DOCTYPE HTML>
<html lang="zh-CN" class="light" dir="ltr">
<head>
<!-- Book generated using mdBook -->
<meta charset="UTF-8">
<title>线程同步：Atomic 原子操作与内存顺序 - Rust语言圣经(Rust Course)</title>
<!-- Custom HTML head -->
<meta name="description" content="">
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta name="theme-color" content="#ffffff">
<link rel="icon" href="../../favicon.svg">
<link rel="shortcut icon" href="../../favicon.png">
<link rel="stylesheet" href="../../css/variables.css">
<link rel="stylesheet" href="../../css/general.css">
<link rel="stylesheet" href="../../css/chrome.css">
<link rel="stylesheet" href="../../css/print.css" media="print">
<!-- Fonts -->
<link rel="stylesheet" href="../../FontAwesome/css/font-awesome.css">
<link rel="stylesheet" href="../../fonts/fonts.css">
<!-- Highlight.js Stylesheets -->
<link rel="stylesheet" href="../../highlight.css">
<link rel="stylesheet" href="../../tomorrow-night.css">
<link rel="stylesheet" href="../../ayu-highlight.css">
<!-- Custom theme stylesheets -->
<link rel="stylesheet" href="../../theme/style.css">
</head>
<body class="sidebar-visible no-js">
<div id="body-container">
<!-- Provide site root to javascript -->
<script>
var path_to_root = "../../";
var default_theme = window.matchMedia("(prefers-color-scheme: dark)").matches ? "navy" : "light";
</script>
<!-- Work around some values being stored in localStorage wrapped in quotes -->
<script>
try {
var theme = localStorage.getItem('mdbook-theme');
var sidebar = localStorage.getItem('mdbook-sidebar');
if (theme.startsWith('"') && theme.endsWith('"')) {
localStorage.setItem('mdbook-theme', theme.slice(1, theme.length - 1));
}
if (sidebar.startsWith('"') && sidebar.endsWith('"')) {
localStorage.setItem('mdbook-sidebar', sidebar.slice(1, sidebar.length - 1));
}
} catch (e) { }
</script>
<!-- Set the theme before any content is loaded, prevents flash -->
<script>
var theme;
try { theme = localStorage.getItem('mdbook-theme'); } catch(e) { }
if (theme === null || theme === undefined) { theme = default_theme; }
var html = document.querySelector('html');
html.classList.remove('light')
html.classList.add(theme);
var body = document.querySelector('body');
body.classList.remove('no-js')
body.classList.add('js');
</script>
<input type="checkbox" id="sidebar-toggle-anchor" class="hidden">
<!-- Hide / unhide sidebar before it is displayed -->
<script>
var body = document.querySelector('body');
var sidebar = null;
var sidebar_toggle = document.getElementById("sidebar-toggle-anchor");
if (document.body.clientWidth >= 1080) {
try { sidebar = localStorage.getItem('mdbook-sidebar'); } catch(e) { }
sidebar = sidebar || 'visible';
} else {
sidebar = 'hidden';
}
sidebar_toggle.checked = sidebar === 'visible';
body.classList.remove('sidebar-visible');
body.classList.add("sidebar-" + sidebar);
</script>
<nav id="sidebar" class="sidebar" aria-label="Table of contents">
<div class="sidebar-scrollbox">
<ol class="chapter"><li class="chapter-item affix "><a href="../../about-book.html">关于本书</a></li><li class="chapter-item affix "><a href="../../into-rust.html">进入 Rust 编程世界</a></li><li class="chapter-item affix "><a href="../../first-try/sth-you-should-not-do.html">避免从入门到放弃</a></li><li class="chapter-item affix "><a href="../../community.html">社区和锈书</a></li><li class="spacer"></li><li class="chapter-item affix "><a href="../../some-thoughts.html">Xobserve: 一切皆可观测</a></li><li class="chapter-item affix "><a href="../../beat-ai.html">BeatAI: 工程师 AI 入门圣经</a></li><li class="chapter-item affix "><li class="part-title">Rust 语言基础学习</li><li class="spacer"></li><li class="chapter-item "><a href="../../first-try/intro.html"><strong aria-hidden="true">1.</strong> 寻找牛刀，以便小试</a><a class="toggle"><div>❱</div></a></li><li><ol class="section"><li class="chapter-item "><a href="../../first-try/installation.html"><strong aria-hidden="true">1.1.</strong> 安装 Rust 环境</a></li><li class="chapter-item "><a href="../../first-try/editor.html"><strong aria-hidden="true">1.2.</strong> 墙推 VSCode!</a></li><li class="chapter-item "><a href="../../first-try/cargo.html"><strong aria-hidden="true">1.3.</strong> 认识 Cargo</a></li><li class="chapter-item "><a href="../../first-try/hello-world.html"><strong aria-hidden="true">1.4.</strong> 不仅仅是 Hello world</a></li><li class="chapter-item "><a href="../../first-try/slowly-downloading.html"><strong aria-hidden="true">1.5.</strong> 下载依赖太慢了？</a></li></ol></li><li class="chapter-item "><a href="../../basic/intro.html"><strong aria-hidden="true">2.</strong> Rust 基础入门</a><a class="toggle"><div>❱</div></a></li><li><ol class="section"><li class="chapter-item "><a href="../../basic/variable.html"><strong aria-hidden="true">2.1.</strong> 变量绑定与解构</a></li><li class="chapter-item "><a href="../../basic/base-type/index.html"><strong aria-hidden="true">2.2.</strong> 基本类型</a><a class="toggle"><div>❱</div></a></li><li><ol class="section"><li class="chapter-item "><a href="../../basic/base-type/numbers.html"><strong aria-hidden="true">2.2.1.</strong> 数值类型</a></li><li class="chapter-item "><a href="../../basic/base-type/char-bool.html"><strong aria-hidden="true">2.2.2.</strong> 字符、布尔、单元类型</a></li><li class="chapter-item "><a href="../../basic/base-type/statement-expression.html"><strong aria-hidden="true">2.2.3.</strong> 语句与表达式</a></li><li class="chapter-item "><a href="../../basic/base-type/function.html"><strong aria-hidden="true">2.2.4.</strong> 函数</a></li></ol></li><li class="chapter-item "><a href="../../basic/ownership/index.html"><strong aria-hidden="true">2.3.</strong> 所有权和借用</a><a class="toggle"><div>❱</div></a></li><li><ol class="section"><li class="chapter-item "><a href="../../basic/ownership/ownership.html"><strong aria-hidden="true">2.3.1.</strong> 所有权</a></li><li class="chapter-item "><a href="../../basic/ownership/borrowing.html"><strong aria-hidden="true">2.3.2.</strong> 引用与借用</a></li></ol></li><li class="chapter-item "><a href="../../basic/compound-type/intro.html"><strong aria-hidden="true">2.4.</strong> 复合类型</a><a class="toggle"><div>❱</div></a></li><li><ol class="section"><li class="chapter-item "><a href="../../basic/compound-type/string-slice.html"><strong aria-hidden="true">2.4.1.</strong> 字符串与切片</a></li><li class="chapter-item "><a href="../../basic/compound-type/tuple.html"><strong aria-hidden="true">2.4.2.</strong> 元组</a></li><li class="chapter-item "><a href="../../basic/compound-type/struct.html"><strong aria-hidden="true">2.4.3.</strong> 结构体</a></li><li class="chapter-item "><a href="../../basic/compound-type/enum.html"><strong aria-hidden="true">2.4.4.</strong> 枚举</a></li><li class="chapter-item "><a href="../../basic/compound-type/array.html"><strong aria-hidden="true">2.4.5.</strong> 数组</a></l
</div>
<div id="sidebar-resize-handle" class="sidebar-resize-handle">
<div class="sidebar-resize-indicator"></div>
</div>
</nav>
<!-- Track and set sidebar scroll position -->
<script>
var sidebarScrollbox = document.querySelector('#sidebar .sidebar-scrollbox');
sidebarScrollbox.addEventListener('click', function(e) {
if (e.target.tagName === 'A') {
sessionStorage.setItem('sidebar-scroll', sidebarScrollbox.scrollTop);
}
}, { passive: true });
var sidebarScrollTop = sessionStorage.getItem('sidebar-scroll');
sessionStorage.removeItem('sidebar-scroll');
if (sidebarScrollTop) {
// preserve sidebar scroll position when navigating via links within sidebar
sidebarScrollbox.scrollTop = sidebarScrollTop;
} else {
// scroll sidebar to current active section when navigating via "next/previous chapter" buttons
var activeSection = document.querySelector('#sidebar .active');
if (activeSection) {
activeSection.scrollIntoView({ block: 'center' });
}
}
</script>
<div id="page-wrapper" class="page-wrapper">
<div class="page">
<div id="menu-bar-hover-placeholder"></div>
<div id="menu-bar" class="menu-bar sticky">
<div class="left-buttons">
<label id="sidebar-toggle" class="icon-button" for="sidebar-toggle-anchor" title="Toggle Table of Contents" aria-label="Toggle Table of Contents" aria-controls="sidebar">
<i class="fa fa-bars"></i>
</label>
<button id="theme-toggle" class="icon-button" type="button" title="Change theme" aria-label="Change theme" aria-haspopup="true" aria-expanded="false" aria-controls="theme-list">
<i class="fa fa-paint-brush"></i>
</button>
<ul id="theme-list" class="theme-popup" aria-label="Themes" role="menu">
<li role="none"><button role="menuitem" class="theme" id="light">Light</button></li>
<li role="none"><button role="menuitem" class="theme" id="rust">Rust</button></li>
<li role="none"><button role="menuitem" class="theme" id="coal">Coal</button></li>
<li role="none"><button role="menuitem" class="theme" id="navy">Navy</button></li>
<li role="none"><button role="menuitem" class="theme" id="ayu">Ayu</button></li>
</ul>
<button id="search-toggle" class="icon-button" type="button" title="Search. (Shortkey: s)" aria-label="Toggle Searchbar" aria-expanded="false" aria-keyshortcuts="S" aria-controls="searchbar">
<i class="fa fa-search"></i>
</button>
</div>
<h1 class="menu-title">Rust语言圣经(Rust Course)</h1>
<div class="right-buttons">
<a href="../../print.html" title="Print this book" aria-label="Print this book">
<i id="print-button" class="fa fa-print"></i>
</a>
<a href="https://github.com/sunface/rust-course" title="Git repository" aria-label="Git repository">
<i id="git-repository-button" class="fa fa-github"></i>
</a>
<a href="https://github.com/sunface/rust-course/edit/main/src/advance/concurrency-with-threads/sync2.md" title="Suggest an edit" aria-label="Suggest an edit">
<i id="git-edit-button" class="fa fa-edit"></i>
</a>
</div>
</div>
<div id="search-wrapper" class="hidden">
<form id="searchbar-outer" class="searchbar-outer">
<input type="search" id="searchbar" name="searchbar" placeholder="Search this book ..." aria-controls="searchresults-outer" aria-describedby="searchresults-header">
</form>
<div id="searchresults-outer" class="searchresults-outer hidden">
<div id="searchresults-header" class="searchresults-header"></div>
<ul id="searchresults">
</ul>
</div>
</div>
<!-- Apply ARIA attributes after the sidebar and the sidebar toggle button are added to the DOM -->
<script>
document.getElementById('sidebar-toggle').setAttribute('aria-expanded', sidebar === 'visible');
document.getElementById('sidebar').setAttribute('aria-hidden', sidebar !== 'visible');
Array.from(document.querySelectorAll('#sidebar a')).forEach(function(link) {
link.setAttribute('tabIndex', sidebar === 'visible' ? 0 : -1);
});
</script>
<div id="content" class="content">
<!-- Page table of contents -->
<div class="sidetoc"><nav class="pagetoc"></nav></div>
<main>
<h1 id="线程同步atomic-原子类型与内存顺序"><a class="header" href="#线程同步atomic-原子类型与内存顺序">线程同步：Atomic 原子类型与内存顺序</a></h1>
<p><code>Mutex</code>用起来简单，但是无法并发读，<code>RwLock</code>可以并发读，但是使用场景较为受限且性能不够，那么有没有一种全能性选手呢？ 欢迎我们的<code>Atomic</code>闪亮登场。</p>
<p>从 Rust1.34 版本后，就正式支持原子类型。原子指的是一系列不可被 CPU 上下文交换的机器指令，这些指令组合在一起就形成了原子操作。在多核 CPU 下，当某个 CPU 核心开始运行原子操作时，会先暂停其它 CPU 内核对内存的操作，以保证原子操作不会被其它 CPU 内核所干扰。</p>
<p>由于原子操作是通过指令提供的支持，因此它的性能相比锁和消息传递会好很多。相比较于锁而言，原子类型不需要开发者处理加锁和释放锁的问题，同时支持修改，读取等操作，还具备较高的并发性能，几乎所有的语言都支持原子类型。</p>
<p>可以看出原子类型是无锁类型，但是无锁不代表无需等待，因为原子类型内部使用了<code>CAS</code>循环，当大量的冲突发生时，该等待还是得<a href="https://course.rs/advance/concurrency-with-threads/thread.html#%E5%A4%9A%E7%BA%BF%E7%A8%8B%E7%9A%84%E5%BC%80%E9%94%80">等待</a>！但是总归比锁要好。</p>
<blockquote>
<p>CAS 全称是 Compare and swap, 它通过一条指令读取指定的内存地址，然后判断其中的值是否等于给定的前置值，如果相等，则将其修改为新的值</p>
</blockquote>
<h2 id="使用-atomic-作为全局变量"><a class="header" href="#使用-atomic-作为全局变量">使用 Atomic 作为全局变量</a></h2>
<p>原子类型的一个常用场景，就是作为全局变量来使用:</p>
<pre><pre class="playground"><code class="language-rust edition2021">use std::ops::Sub;
use std::sync::atomic::{AtomicU64, Ordering};
use std::thread::{self, JoinHandle};
use std::time::Instant;
const N_TIMES: u64 = 10000000;
const N_THREADS: usize = 10;
static R: AtomicU64 = AtomicU64::new(0);
fn add_n_times(n: u64) -&gt; JoinHandle&lt;()&gt; {
thread::spawn(move || {
for _ in 0..n {
R.fetch_add(1, Ordering::Relaxed);
}
})
}
fn main() {
let s = Instant::now();
let mut threads = Vec::with_capacity(N_THREADS);
for _ in 0..N_THREADS {
threads.push(add_n_times(N_TIMES));
}
for thread in threads {
thread.join().unwrap();
}
assert_eq!(N_TIMES * N_THREADS as u64, R.load(Ordering::Relaxed));
println!(&quot;{:?}&quot;,Instant::now().sub(s));
}</code></pre></pre>
<p>以上代码启动了数个线程，每个线程都在疯狂对全局变量进行加 1 操作, 最后将它与<code>线程数 * 加1次数</code>进行比较，如果发生了因为多个线程同时修改导致了脏数据，那么这两个必将不相等。好在，它没有让我们失望，不仅快速的完成了任务，而且保证了 100%的并发安全性。</p>
<p>当然以上代码的功能其实也可以通过<code>Mutex</code>来实现，但是后者的强大功能是建立在额外的性能损耗基础上的，因此性能会逊色不少:</p>
<pre><code class="language-console">Atomic实现：673ms
Mutex实现: 1136ms
</code></pre>
<p>可以看到<code>Atomic</code>实现会比<code>Mutex</code>快<strong>41%</strong>，实际上在复杂场景下还能更快(甚至达到 4 倍的性能差距)！</p>
<p>还有一点值得注意: <strong>和<code>Mutex</code>一样，<code>Atomic</code>的值具有内部可变性</strong>，你无需将其声明为<code>mut</code>：</p>
<pre><pre class="playground"><code class="language-rust edition2021">use std::sync::Mutex;
use std::sync::atomic::{Ordering, AtomicU64};
struct Counter {
count: u64
}
fn main() {
let n = Mutex::new(Counter {
count: 0
});
n.lock().unwrap().count += 1;
let n = AtomicU64::new(0);
n.fetch_add(0, Ordering::Relaxed);
}</code></pre></pre>
<p>这里有一个奇怪的枚举成员<code>Ordering::Relaxed</code>, 看上去很像是排序作用，但是我们并没有做排序操作啊？实际上它用于控制原子操作使用的<strong>内存顺序</strong>。</p>
<h2 id="内存顺序"><a class="header" href="#内存顺序">内存顺序</a></h2>
<p>内存顺序是指 CPU 在访问内存时的顺序，该顺序可能受以下因素的影响：</p>
<ul>
<li>代码中的先后顺序</li>
<li>编译器优化导致在编译阶段发生改变(内存重排序 reordering)</li>
<li>运行阶段因 CPU 的缓存机制导致顺序被打乱</li>
</ul>
<h4 id="编译器优化导致内存顺序的改变"><a class="header" href="#编译器优化导致内存顺序的改变">编译器优化导致内存顺序的改变</a></h4>
<p>对于第二点，我们举个例子：</p>
<pre><pre class="playground"><code class="language-rust edition2021">static mut X: u64 = 0;
static mut Y: u64 = 1;
fn main() {
... // A
unsafe {
... // B
X = 1;
... // C
Y = 3;
... // D
X = 2;
... // E
}
}</code></pre></pre>
<p>假如在<code>C</code>和<code>D</code>代码片段中，根本没有用到<code>X = 1</code>，那么编译器很可能会将<code>X = 1</code>和<code>X = 2</code>进行合并:</p>
<pre><pre class="playground"><code class="language-rust edition2021"><span class="boring">#![allow(unused)]
</span><span class="boring">fn main() {
</span> ... // A
unsafe {
... // B
X = 2;
... // C
Y = 3;
... // D
... // E
}
<span class="boring">}</span></code></pre></pre>
<p>若代码<code>A</code>中创建了一个新的线程用于读取全局静态变量<code>X</code>，则该线程将无法读取到<code>X = 1</code>的结果，因为在编译阶段就已经被优化掉。</p>
<h4 id="cpu-缓存导致的内存顺序的改变"><a class="header" href="#cpu-缓存导致的内存顺序的改变">CPU 缓存导致的内存顺序的改变</a></h4>
<p>假设之前的<code>X = 1</code>没有被优化掉，并且在代码片段<code>A</code>中有一个新的线程:</p>
<pre><code class="language-console">initial state: X = 0, Y = 1
THREAD Main THREAD A
X = 1; if X == 1 {
Y = 3; Y *= 2;
X = 2; }
</code></pre>
<p>我们来讨论下以上线程状态，<code>Y</code>最终的可能值(可能性依次降低):</p>
<ul>
<li><code>Y = 3</code>: 线程<code>Main</code>运行完后才运行线程<code>A</code>，或者线程<code>A</code>运行完后再运行线程<code>Main</code></li>
<li><code>Y = 6</code>: 线程<code>Main</code>的<code>Y = 3</code>运行完，但<code>X = 2</code>还没被运行， 此时线程 A 开始运行<code>Y *= 2</code>, 最后才运行<code>Main</code>线程的<code>X = 2</code></li>
<li><code>Y = 2</code>: 线程<code>Main</code>正在运行<code>Y = 3</code>还没结束，此时线程<code>A</code>正在运行<code>Y *= 2</code>, 因此<code>Y</code>取到了值 1，然后<code>Main</code>的线程将<code>Y</code>设置为 3， 紧接着就被线程<code>A</code>的<code>Y = 2</code>所覆盖</li>
<li><code>Y = 2</code>: 上面的还只是一般的数据竞争，这里虽然产生了相同的结果<code>2</code>，但是背后的原理大相径庭: 线程<code>Main</code>运行完<code>Y = 3</code>，但是 CPU 缓存中的<code>Y = 3</code>还没有被同步到其它 CPU 缓存中，此时线程<code>A</code>中的<code>Y *= 2</code>就开始读取<code>Y</code>，结果读到了值<code>1</code>，最终计算出结果<code>2</code></li>
</ul>
<p>甚至更改成:</p>
<pre><code class="language-console">initial state: X = 0, Y = 1
THREAD Main THREAD A
X = 1; if X == 2 {
Y = 3; Y *= 2;
X = 2; }
</code></pre>
<p>还是可能出现<code>Y = 2</code>，因为<code>Main</code>线程中的<code>X</code>和<code>Y</code>被同步到其它 CPU 缓存中的顺序未必一致。</p>
<h4 id="限定内存顺序的-5-个规则"><a class="header" href="#限定内存顺序的-5-个规则">限定内存顺序的 5 个规则</a></h4>
<p>在理解了内存顺序可能存在的改变后，你就可以明白为什么 Rust 提供了<code>Ordering::Relaxed</code>用于限定内存顺序了，事实上，该枚举有 5 个成员:</p>
<ul>
<li><strong>Relaxed</strong>， 这是最宽松的规则，它对编译器和 CPU 不做任何限制，可以乱序</li>
<li><strong>Release 释放</strong>，设定内存屏障(Memory barrier)，保证它之前的操作永远在它之前，但是它后面的操作可能被重排到它前面</li>
<li><strong>Acquire 获取</strong>, 设定内存屏障，保证在它之后的访问永远在它之后，但是它之前的操作却有可能被重排到它后面，往往和<code>Release</code>在不同线程中联合使用</li>
<li><strong>AcqRel</strong>, 是 <em>Acquire</em> 和 <em>Release</em> 的结合，同时拥有它们俩提供的保证。比如你要对一个 <code>atomic</code> 自增 1，同时希望该操作之前和之后的读取或写入操作不会被重新排序</li>
<li><strong>SeqCst 顺序一致性</strong>， <code>SeqCst</code>就像是<code>AcqRel</code>的加强版，它不管原子操作是属于读取还是写入的操作，只要某个线程有用到<code>SeqCst</code>的原子操作，线程中该<code>SeqCst</code>操作前的数据操作绝对不会被重新排在该<code>SeqCst</code>操作之后，且该<code>SeqCst</code>操作后的数据操作也绝对不会被重新排在<code>SeqCst</code>操作前。</li>
</ul>
<p>这些规则由于是系统提供的，因此其它语言提供的相应规则也大同小异，大家如果不明白可以看看其它语言的相关解释。</p>
<h4 id="内存屏障的例子"><a class="header" href="#内存屏障的例子">内存屏障的例子</a></h4>
<p>下面我们以<code>Release</code>和<code>Acquire</code>为例，使用它们构筑出一对内存屏障，防止编译器和 CPU 将屏障前(Release)和屏障后(Acquire)中的数据操作重新排在屏障围成的范围之外:</p>
<pre><pre class="playground"><code class="language-rust edition2021">use std::thread::{self, JoinHandle};
use std::sync::atomic::{Ordering, AtomicBool};
static mut DATA: u64 = 0;
static READY: AtomicBool = AtomicBool::new(false);
fn reset() {
unsafe {
DATA = 0;
}
READY.store(false, Ordering::Relaxed);
}
fn producer() -&gt; JoinHandle&lt;()&gt; {
thread::spawn(move || {
unsafe {
DATA = 100; // A
}
READY.store(true, Ordering::Release); // B: 内存屏障 ↑
})
}
fn consumer() -&gt; JoinHandle&lt;()&gt; {
thread::spawn(move || {
while !READY.load(Ordering::Acquire) {} // C: 内存屏障 ↓
assert_eq!(100, unsafe { DATA }); // D
})
}
fn main() {
loop {
reset();
let t_producer = producer();
let t_consumer = consumer();
t_producer.join().unwrap();
t_consumer.join().unwrap();
}
}</code></pre></pre>
<p>原则上，<code>Acquire</code>用于读取，而<code>Release</code>用于写入。但是由于有些原子操作同时拥有读取和写入的功能，此时就需要使用<code>AcqRel</code>来设置内存顺序了。在内存屏障中被写入的数据，都可以被其它线程读取到，不会有 CPU 缓存的问题。</p>
<p><strong>内存顺序的选择</strong></p>
<ol>
<li>不知道怎么选择时，优先使用<code>SeqCst</code>，虽然会稍微减慢速度，但是慢一点也比出现错误好</li>
<li>多线程只计数<code>fetch_add</code>而不使用该值触发其他逻辑分支的简单使用场景，可以使用<code>Relaxed</code><br />
参考 <a href="https://stackoverflow.com/questions/30407121/which-stdsyncatomicordering-to-use">Which std::sync::atomic::Ordering to use?</a></li>
</ol>
<h2 id="多线程中使用-atomic"><a class="header" href="#多线程中使用-atomic">多线程中使用 Atomic</a></h2>
<p>在多线程环境中要使用<code>Atomic</code>需要配合<code>Arc</code>：</p>
<pre><pre class="playground"><code class="language-rust edition2021">use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::{hint, thread};
fn main() {
let spinlock = Arc::new(AtomicUsize::new(1));
let spinlock_clone = Arc::clone(&amp;spinlock);
let thread = thread::spawn(move|| {
spinlock_clone.store(0, Ordering::SeqCst);
});
// 等待其它线程释放锁
while spinlock.load(Ordering::SeqCst) != 0 {
hint::spin_loop();
}
if let Err(panic) = thread.join() {
println!(&quot;Thread had an error: {:?}&quot;, panic);
}
}</code></pre></pre>
<h2 id="atomic-能替代锁吗"><a class="header" href="#atomic-能替代锁吗">Atomic 能替代锁吗</a></h2>
<p>那么原子类型既然这么全能，它可以替代锁吗？答案是不行：</p>
<ul>
<li>对于复杂的场景下，锁的使用简单粗暴，不容易有坑</li>
<li><code>std::sync::atomic</code>包中仅提供了数值类型的原子操作：<code>AtomicBool</code>, <code>AtomicIsize</code>, <code>AtomicUsize</code>, <code>AtomicI8</code>, <code>AtomicU16</code>等，而锁可以应用于各种类型</li>
<li>在有些情况下，必须使用锁来配合，例如上一章节中使用<code>Mutex</code>配合<code>Condvar</code></li>
</ul>
<h2 id="atomic-的应用场景"><a class="header" href="#atomic-的应用场景">Atomic 的应用场景</a></h2>
<p>事实上，<code>Atomic</code>虽然对于用户不太常用，但是对于高性能库的开发者、标准库开发者都非常常用，它是并发原语的基石，除此之外，还有一些场景适用：</p>
<ul>
<li>无锁(lock free)数据结构</li>
<li>全局变量，例如全局自增 ID, 在后续章节会介绍</li>
<li>跨线程计数器，例如可以用于统计指标</li>
</ul>
<p>以上列出的只是<code>Atomic</code>适用的部分场景，具体场景需要大家未来根据自己的需求进行权衡选择。</p>
<div id="giscus-container"></div>
</main>
<nav class="nav-wrapper" aria-label="Page navigation">
<!-- Mobile navigation buttons -->
<a rel="prev" href="../../advance/concurrency-with-threads/sync1.html" class="mobile-nav-chapters previous" title="Previous chapter" aria-label="Previous chapter" aria-keyshortcuts="Left">
<i class="fa fa-angle-left"></i>
</a>
<a rel="next prefetch" href="../../advance/concurrency-with-threads/send-sync.html" class="mobile-nav-chapters next" title="Next chapter" aria-label="Next chapter" aria-keyshortcuts="Right">
<i class="fa fa-angle-right"></i>
</a>
<div style="clear: both"></div>
</nav>
</div>
</div>
<nav class="nav-wide-wrapper" aria-label="Page navigation">
<a rel="prev" href="../../advance/concurrency-with-threads/sync1.html" class="nav-chapters previous" title="Previous chapter" aria-label="Previous chapter" aria-keyshortcuts="Left">
<i class="fa fa-angle-left"></i>
</a>
<a rel="next prefetch" href="../../advance/concurrency-with-threads/send-sync.html" class="nav-chapters next" title="Next chapter" aria-label="Next chapter" aria-keyshortcuts="Right">
<i class="fa fa-angle-right"></i>
</a>
</nav>
</div>
<script>
window.playground_copyable = true;
</script>
<script src="../../ace.js"></script>
<script src="../../editor.js"></script>
<script src="../../mode-rust.js"></script>
<script src="../../theme-dawn.js"></script>
<script src="../../theme-tomorrow_night.js"></script>
<script src="../../elasticlunr.min.js"></script>
<script src="../../mark.min.js"></script>
<script src="../../searcher.js"></script>
<script src="../../clipboard.min.js"></script>
<script src="../../highlight.js"></script>
<script src="../../book.js"></script>
<script type="text/javascript" charset="utf-8">
var pagePath = "advance/concurrency-with-threads/sync2.md"
</script>
<!-- Custom JS scripts -->
<script src="../../assets/custom.js"></script>
<script src="../../assets/bigPicture.js"></script>
</div>
</body>
</html>