C++11多线程：atomic头文件

最新推荐文章于 2024-08-10 21:33:28 发布
最新推荐文章于 2024-08-10 21:33:28 发布
阅读量8k 收藏 15
点赞数 2
分类专栏： C++11多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014673282/article/details/89789139
版权

原子类型是对数据的一种封装，可以防止数据竞争，同步多线程间的内存访问。<atomic>头文件中主要包含两个类：atomic和atomic_flag，可以在自包含类中实现原子类型的所有特性。同时头文件还声明了一组与C语言原子支持兼容的C风格类型和函数。

1. atomic

在这里插入图片描述
包含特定类型(T)的原子类型对象。原子对象的主要特点是：多个线程访问对象所包含的值不会引起数据竞争。此外，原子对象能够通过指定不同的内存顺序来同步对线程中其他非原子对象的访问。
在这里插入图片描述
内存顺序（memory_order)：

typedef enum memory_order {
    memory_order_relaxed,   // relaxed
    memory_order_consume,   // consume
    memory_order_acquire,   // acquire
    memory_order_release,   // release
    memory_order_acq_rel,   // acquire/release
    memory_order_seq_cst    // sequentially consistent
} memory_order;

用作原子性函数的参数，以指定如何同步不同线程上的其他操作。在一个原子操作完成之前其他线程无法访问该原子对象。但是每个线程可能在原子对象本身之外的内存位置执行操作：这些其他操作可能对其他线程产生副作用。memory_order允许指定操作的内存顺序，以确定线程之间如何同步这些(可能是非原子的)副作用，使用原子操作作为同步点：

  • memory_order_relaxed
    在某个时间点执行该原子操作。这是最松散的内存顺序，不能保证不同线程中的内存访问是按照原子操作的顺序进行的。
  • memory_order_consume
    一旦释放线程中所有对内存的访问(这些访问依赖于释放操作(并且对加载线程有副作用))都发生了，则命令执行该操作。
  • memory_order_acquire
    一旦释放线程中的所有内存访问(这些访问对加载线程有副作用)都发生了，则命令执行该操作。
  • memory_order_release
    该操作在消耗或获取操作之前执行，作为对内存的其他访问的同步点，这些访问可能对加载线程产生副作用。
  • memory_order_acq_rel
    该操作加载获取和存储释放(如上面的memory_order_acquisition和memory_order_release所定义)。
  • memory_order_seq_cst
    该操作以顺序一致的方式进行排序：使用该内存顺序的所有操作都是在所有可能对涉及的其他线程产生副作用的内存访问都已经发生之后才执行的。
    这是最严格的内存顺序，通过非原子内存访问确保线程交互之间的意外副作用最小。
    对于消耗和获取负载，顺序一致的存储操作被认为是释放操作。

1.1 std::atomic::atomic

在这里插入图片描述
(1). 默认构造
构造一个未初始化的原子对象。（后面可通过调用atomic_init进行初始化）
(2). 初始化构造
构造一个用val初始化的原子对象。
(3). 复制构造 [禁用]
禁用复制构造函数，原子对象不可复制/移动。

示例：

// constructing atomics
#include <iostream>       // std::cout
#include <atomic>         // std::atomic, std::atomic_flag, ATOMIC_FLAG_INIT
#include <thread>         // std::thread, std::this_thread::yield
#include <vector>         // std::vector

std::atomic<bool> ready (false);
std::atomic_flag winner = ATOMIC_FLAG_INIT;

void count1m (int id) {
  while (!ready) { std::this_thread::yield(); }      // wait for the ready signal
  for (volatile int i=0; i<1000000; ++i) {}          // go!, count to 1 million
  if (!winner.test_and_set()) { std::cout << "thread #" << id << " won!\n"; }
};

int main ()
{
  std::vector<std::thread> threads;
  std::cout << "spawning 10 threads that count to 1 million...\n";
  for (int i=1; i<=10; ++i) threads.push_back(std::thread(count1m,i));
  ready = true;
  for (auto& th : threads) th.join();

  return 0;
}

输出：

spawning 10 threads that count to 1 million...
thread #7 won!

1.2 std::atomic::operator=

在这里插入图片描述
(1). 给原子对象赋值（val）。这个操作是原子性的，并且使用顺序一致性(memory_order_seq_cst)
(2). 原子对象不可复制赋值，但是可以隐式转换。

示例：

// atomic::operator=/operator T example:
#include <iostream>       // std::cout
#include <atomic>         // std::atomic
#include <thread>         // std::thread, std::this_thread::yield

std::atomic<int> foo = 0;

void set_foo(int x) {
  foo = x;
}

void print_foo() {
  while (foo==0) {             // wait while foo=0
    std::this_thread::yield();
  }
  std::cout << "foo: " << foo << '\n';
}

int main ()
{
  std::thread first (print_foo);
  std::thread second (set_foo,10);
  first.join();
  second.join();
  return 0;
}

输出：

foo: 10

1.3 std::atomic::is_lock_free

在这里插入图片描述
判断原子对象是否 lock-free 状态。无锁状态的原子对象不会导致其他线程在访问时被阻塞(可能使用某种类型的事务内存)。

1.4 std::atomic::store

在这里插入图片描述
用 val 替换原子对象中的值。该操作是原子性的，通过 sync 指定内存顺序。

sync的可选项：memory_order_relaxed、memory_order_release 、memory_order_seq_cst

示例：

// atomic::load/store example
#include <iostream>       // std::cout
#include <atomic>         // std::atomic, std::memory_order_relaxed
#include <thread>         // std::thread

std::atomic<int> foo (0);

void set_foo(int x) {
  foo.store(x,std::memory_order_relaxed);     // set value atomically
}

void print_foo() {
  int x;
  do {
    x = foo.load(std::memory_order_relaxed);  // get value atomically
  } while (x==0);
  std::cout << "foo: " << x << '\n';
}

int main ()
{
  std::thread first (print_foo);
  std::thread second (set_foo,10);
  first.join();
  second.join();
  return 0;
}

输出：

foo: 10

1.5 std::atomic::load

在这里插入图片描述
返回原子对象中的值。该操作是原子性的，通过 sync 指定内存顺序。

sync的可选项：memory_order_relaxed、memory_order_consume、memory_order_acquire、memory_order_seq_cst

1.6 std::atomic::operator T

在这里插入图片描述
返回原子对象中的值。这是一个类型转换符，取出原子对象中类型为 T 的值。这个操作是原子性的，并且使用顺序一致性(memory_order_seq_cst)

示例：

// atomic::operator=/operator T example:
#include <iostream>       // std::cout
#include <atomic>         // std::atomic
#include <thread>         // std::thread, std::this_thread::yield

std::atomic<int> foo = 0;
std::atomic<int> bar = 0;

void set_foo(int x) {
  foo = x;
}
void copy_foo_to_bar () {
  while (foo==0) std::this_thread::yield();
  bar = static_cast<int>(foo);
}
void print_bar() {
  while (bar==0) std::this_thread::yield();
  std::cout << "bar: " << bar << '\n';
}

int main ()
{
  std::thread first (print_bar);
  std::thread second (set_foo,10);
  std::thread third (copy_foo_to_bar);
  first.join();
  second.join();
  third.join();
  return 0;
}

输出：

bar: 10

1.7 std::atomic::exchange

在这里插入图片描述
用 val 替换原子对象中的值，并返回原来存储的值。操作是原子性的，整个（读-修改-写）操作完成之前其他线程无法访问。

sync的可选项：所有6个

示例：

// atomic::exchange example
#include <iostream>       // std::cout
#include <atomic>         // std::atomic
#include <thread>         // std::thread
#include <vector>         // std::vector

std::atomic<bool> ready (false);
std::atomic<bool> winner (false);

void count1m (int id) {
  while (!ready) {}                  // wait for the ready signal
  for (int i=0; i<1000000; ++i) {}   // go!, count to 1 million
  if (!winner.exchange(true)) { std::cout << "thread #" << id << " won!\n"; }
};

int main ()
{
  std::vector<std::thread> threads;
  std::cout << "spawning 10 threads that count to 1 million...\n";
  for (int i=1; i<=10; ++i) threads.push_back(std::thread(count1m,i));
  ready = true;
  for (auto& th : threads) th.join();

  return 0;
}

输出（结果可能不同）：

spawning 10 threads that count to 1 million...
thread #7 won!

1.8 std::atomic::compare_exchange_weak

在这里插入图片描述
将原子对象存储的值与预期值比较：

  • 如果为true，用 val 替换原子对象的值（像store）。
  • 如果为false，它用包含的值替换预期值。

函数总是读取原子对象存储的值，如果比较结果是“true”，就替换存储值。整个过程是原子性的。

(2)中使用的内存顺序取决于比较结果：true->sucess; flase->failure。

注意该函数比较的是原子对象和预期值中的物理内容（physical contents），这可能导致使用操作符==比较相等的值的在这里比较失败（如果基础类型具有相同值的填充位、陷阱值或替代表示形式）。

与compare_exchange_strong不同，该week版本允许错误的返回false，即使原子对象存储值与预期值相等（operator==）。对于某些循环算法，这可能是可接受的行为，并且可能在某些平台上显著提高性能。对于这些虚假的失败（spurious failures），函数返回false，但不修改预期的值。对于非循环算法，通常首选compare_exchange_strong。

sync可选项：所有6个

示例：

// atomic::compare_exchange_weak example:
#include <iostream>       // std::cout
#include <atomic>         // std::atomic
#include <thread>         // std::thread
#include <vector>         // std::vector

// a simple global linked list:
struct Node { int value; Node* next; };
std::atomic<Node*> list_head (nullptr);

void append (int val) {     // append an element to the list
  Node* oldHead = list_head;
  Node* newNode = new Node {val,oldHead};

  // what follows is equivalent to: list_head = newNode, but in a thread-safe way:
  while (!list_head.compare_exchange_weak(oldHead,newNode))
    newNode->next = oldHead;
}

int main ()
{
  // spawn 10 threads to fill the linked list:
  std::vector<std::thread> threads;
  for (int i=0; i<10; ++i) threads.push_back(std::thread(append,i));
  for (auto& th : threads) th.join();

  // print contents:
  for (Node* it = list_head; it!=nullptr; it=it->next)
    std::cout << ' ' << it->value;
  std::cout << '\n';

  // cleanup:
  Node* it; while (it=list_head) {list_head=it->next; delete it;}

  return 0;
}

输出（顺序可能不同）：

 9 8 7 6 5 4 3 2 1 0

1.9 std::atomic::compare_exchange_strong

在这里插入图片描述
将原子对象存储的值与预期值比较：

  • 如果为true，用 val 替换原子对象的值（像store）。
  • 如果为false，它用包含的值替换预期值。

函数总是读取原子对象存储的值，如果比较结果是“true”，就替换存储值。整个过程是原子性的。

(2)中使用的内存顺序取决于比较结果：true->sucess; flase->failure。

注意该函数比较的是原子对象和预期值中的物理内容（physical contents），这可能导致使用操作符==比较相等的值的在这里比较失败（如果基础类型具有相同值的填充位、陷阱值或替代表示形式）。

与compare_exchange_week不同，当期望值与对象存储的值相等时，这个强版本必须始终返回true，不允许虚假的失败。但是，在某些机器上，对于某些在循环中检查这个的算法，compare_exchange_weak可能有更高的性能表现。

sync的可选项：所有6个

1.10 专门化计算操作

  • std::atomic::fetch_add
    在这里插入图片描述
    存储的值加上 val 并返回之前的值，整个操作是原子性的。如果第二个参数使用默认值，那么这个函数相当于atomic::operator+=。
  • std::atomic::fetch_sub
    在这里插入图片描述
    存储的值减去 val 并返回之前的值，整个操作是原子性的。如果第二个参数使用默认值，那么这个函数相当于atomic::operator-=。
  • std::atomic::fetch_and
    在这里插入图片描述
    存储的值与 val 进行 “与操作” 并返回之前的值，整个操作是原子性的。如果第二个参数使用默认值，那么这个函数相当于atomic::operator&=。
  • std::atomic::fetch_or
    在这里插入图片描述
    存储的值与 val 进行 “或操作” 并返回之前的值，整个操作是原子性的。如果第二个参数使用默认值，那么这个函数相当于atomic::operator|=。
  • std::atomic::fetch_xor
    在这里插入图片描述
    存储的值与 val 进行 “异或操作” 并返回之前的值，整个操作是原子性的。如果第二个参数使用默认值，那么这个函数相当于atomic::operator^=。
  • std::atomic::operator++
    在这里插入图片描述
    递增所包含值的值，并返回生成的值(1)或之前的值(2)，整个操作是原子性的。
  • std::atomic::operator–
    在这里插入图片描述
    递减所包含值的值，并返回生成的值(1)或之前的值(2)，整个操作是原子性的。
  • std::atomic::operator (comp. assign.)
    在这里插入图片描述
    整数(1)和指针(2)类型的专门化原子复合赋值:
    应用对应的复合赋值操作符到相应的原子对象并返回操作之前的值，所有的操作都是原子性的。

2 std::atomic_flag

在这里插入图片描述
原子标志（atomic_flag）是bool型的原子对象，只支持两种操作：test-and-set和clear。原子标志是无锁的(这是惟一一种在所有库实现上保证无锁的类型)。

在这里插入图片描述
示例：

// using atomic_flag as a lock
#include <iostream>       // std::cout
#include <atomic>         // std::atomic_flag
#include <thread>         // std::thread
#include <vector>         // std::vector
#include <sstream>        // std::stringstream

std::atomic_flag lock_stream = ATOMIC_FLAG_INIT;
std::stringstream stream;

void append_number(int x) {
  while (lock_stream.test_and_set()) {}
  stream << "thread #" << x << '\n';
  lock_stream.clear();
}

int main ()
{
  std::vector<std::thread> threads;
  for (int i=1; i<=10; ++i) threads.push_back(std::thread(append_number,i));
  for (auto& th : threads) th.join();

  std::cout << stream.str();
  return 0;
}

输出（结果可能不同）：

thread #1
thread #2
thread #3
thread #4
thread #5
thread #6
thread #7
thread #8
thread #9
thread #10

2.1 std::atomic_flag::atomic_flag

在这里插入图片描述
构建一个原子标志对象。除非显式用 ATOMIC_FLAG_INIT初始化，否则该对象在构造时处于未指定的状态（既不是 set 也不是 clear）。这个显式初始化是在默认构造时实现还是后期调用取决于具体的库实现。原子标志对象不可复制也不可转移。

示例：

// constructing atomics: atomic<bool> vs atomic_flag
#include <iostream>       // std::cout
#include <atomic>         // std::atomic, std::atomic_flag, ATOMIC_FLAG_INIT
#include <thread>         // std::thread, std::this_thread::yield
#include <vector>         // std::vector

std::atomic<bool> ready (false);               // can be checked without being set
std::atomic_flag winner = ATOMIC_FLAG_INIT;    // always set when checked

void count1m (int id) {
  while (!ready) { std::this_thread::yield(); }      // wait for the ready signal
  for (int i=0; i<1000000; ++i) {}                   // go!, count to 1 million
  if (!winner.test_and_set()) { std::cout << "thread #" << id << " won!\n"; }
};

int main ()
{
  std::vector<std::thread> threads;
  std::cout << "spawning 10 threads that count to 1 million...\n";
  for (int i=1; i<=10; ++i) threads.push_back(std::thread(count1m,i));
  ready = true;
  for (auto& th : threads) th.join();

  return 0;
}

输出（可能不同）：

spawning 10 threads that count to 1 million...
thread #6 won!

2.2 std::atomic_flag::test_and_set

在这里插入图片描述
设置原子标志（设为true），并返回它是否在调用之前已被设置，若已被设置返回true，否则false。操作是原子性的。

sync的可选项：全部6个

示例：

// atomic_flag as a spinning lock
#include <iostream>       // std::cout
#include <atomic>         // std::atomic_flag
#include <thread>         // std::thread
#include <vector>         // std::vector
#include <sstream>        // std::stringstream

std::atomic_flag lock_stream = ATOMIC_FLAG_INIT;
std::stringstream stream;

void append_number(int x) {
  while (lock_stream.test_and_set()) {}
  stream << "thread #" << x << '\n';
  lock_stream.clear();
}

int main ()
{
  std::vector<std::thread> threads;
  for (int i=1; i<=10; ++i) threads.push_back(std::thread(append_number,i));
  for (auto& th : threads) th.join();

  std::cout << stream.str();
  return 0;
}

输出（可能不同）：

thread #1
thread #2
thread #3
thread #4
thread #5
thread #6
thread #7
thread #8
thread #9
thread #10

2.3 std::atomic_flag::clear

在这里插入图片描述
清除原子标志（设为false）。下一次调用 atomic_flag::test_and_set会返回false。该操作是原子性的。

sync的可选项：memory_order_relaxed、memory_order_consume、memory_order_acquire、memory_order_release、memory_order_seq_cst

参考

[1]. http://www.cplusplus.com/reference/atomic/

jiang_yu_hao
关注
专栏目录
std::atomic 相关接口(来自cppreference.com)
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
06-17 1139
https://en.cppreference.com/w/cpp/atomic/atomic
C++11 atomic
konglongdanfo的博客
02-05 3028
atomic是在多线程编程中经常使用的一个类。使用的时候需要包含&lt;atomic&gt;文件。 atomic atomic内部封装一个值，并保证对该值的访问的互斥性。可以用来进行线程同步。使用非常方便。说白了就是atomic内部保存的值是线程安全的，不用担心多线程访问时的同步问题。也就是说保证对内部值的读取和保存的操作的原子性。 atomic是个模板类，可以保存的常用的值的类型（这些类型在at...
C++ 原子类型（atomic）
最新发布
Echo_HY的博客
08-10 559
原子类型是多线程编程中重要的工具，能够有效地避免数据竞争问题，提高程序的安全性和性能。通过合理使用原子类型和理解内存序，可以编写出高效的并发代码。
atomic头文件编译_C++11 并发指南六(atomic 类型详解一 atomic_flag 介绍)
weixin_39954487的博客
12-20 135
C++11 并发指南已经写了 5 章，前五章重点介绍了多线程编程方面的内容，但大部分内容只涉及多线程、互斥量、条件变量和异步编程相关的 API，C++11 程序员完全可以不必知道这些 API 在底层是如何实现的，只需要清楚 C++11 多线程和异步编程相关 API 的语义，然后熟加练习即可应付大部分多线程编码需求。但是在很多极端的场合下为了性能和效率，我们需要开发一些 lock-free 的算法和...
atomic头文件编译_C++11并发编程：原子操作atomic
weixin_29783407的博客
02-06 197
一：概述项目中经常用遇到多线程操作共享数据问题，常用的处理方式是对共享数据进行加锁，如果多线程操作共享变量也同样采用这种方式。为什么要对共享变量加锁或使用原子操作？如两个线程操作同一变量过程中，一个线程执行过程中可能被内核临时挂起，这就是线程切换，当内核再次切换到该线程时，之前的数据可能已被修改，不能保证原子操作。C++11提供了个原子的类和方法atomic，保证了多线程对变量原子性操作，相比加锁...
标准库头文件：atomic
zhuikefeng的博客
03-11 3978
1.常用变量 atomic //原子类模板及其布尔型，整型和指针类型的特化 atomic_ref //提供对非原子对象的原子操作 atomic_flag //锁的布尔原子类型 std::atomic_bool //std::atomic<bool> std::atomic_char //std::atomic<char> std::atomic_sch......
vs2019 c++20规范 STL 库中头文件 ＜atomic＞ 源码注释及探讨几个知识点
zhangzhangkeji的博客
06-13 409
(2 探讨二 ) 可见 atomic 的 fetch_xx 函数，返回的都是 atomic 中存储的旧值。
C++并发之原子操作(std::atomic)
flysnow010的博客
06-17 1089
原子类型是封装一个值的类型，该值的访问保证不会导致数据争用，并且可以用于同步不同线程之间的内存访问。这个头文件(atomic)声明了两个C++类，atomic和atomic_flag，它们在自包含类中实现原子类型的所有特性。头文件(atomic)还声明了一整套与C中的原子支持兼容的C样式类型和函数。
atomic头文件编译_c++11 多线程（3）atomic 总结
weixin_35578211的博客
12-30 2019
一、头文件结构头文件：原子类型是封装了一个值的类型，它的访问保证不会导致数据的竞争，并且可以用于在不同的线程之间同步内存访问。这个头声明了两个c++类，原子和atomic_flag，它实现了自包含类中的原子类型的所有特性。header还声明了整个C样式类型和函数与C中的原子支持兼容。头文件中结构定义查看。头文件的结构：class用于bool、整数和指针类型的原子类模板和特殊化 (类模板)无锁布尔原...
std::atomic头文件
04-07
std::atomic头文件是C++11中的一个头文件，用于支持原子操作。 原子操作是指不可分割的单个操作，可以保证在多线程环境下的正确性。std::atomic提供了一系列的类型和函数，可以实现原子操作。 std::atomic支持的...
std::atomic的头文件
07-29
- *2* [C++11多线程：atomic头文件](https://blog.csdn.net/u014673282/article/details/89789139)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_...
安全栈表实现，C++11实现，使用atomic特性
02-19
安全栈表实现，C++11实现，使用atomic特性，可以多线程进行操作
C++11多线程（三）：atomic与atomic_flag的使用与原理分析
琅嬛福地
02-21 3957
C++11提供了线程的原子操作，这些在boost库中也有，在多个线程时原子操作保证了数据的安全性。C++11的原子操作主要是atomic和atomic_flag，使用时需要包含如下头文件： #include<atomic> 一.atmoic类的使用 template<>struct atomic<_ITYPE> ,...
atomic头文件编译_c++11新特性之atomic
weixin_39631899的博客
12-20 227
std::atomic_flagstd::atomic_flag是一个原子的布尔类型，可支持两种原子操作：test_and_set, 如果atomic_flag对象被设置，则返回true; 如果atomic_flag对象未被设置，则设置之，返回falseclear. 清楚atomic_flag对象std::atomic_flag可用于多线程之间的同步操作，类似于linux中的信号量。使用atomi...
atomic 内存序_C++11 - atomic类型和内存模型
weixin_32159633的博客
01-17 694
概述：本文是两本书的读书笔记，一本是《深入理解C++11 - C++11新特性解析与应用》(下文简称书1)，另外一本是《C++ Concurrency In Action》(英文版)(下文简称书2)。作者在Windows平台下使用多线程技术进行工业自动化领域开发工作，深知多线程程序开发、测试和调试及调优，是件痛苦的事情——深夜调试/失眠、抓狂……2000年之后，依靠CPU频率提升加速软件运行速度的...
C++11 multithreading
Augusdi的专栏
09-01 692
C++11 并发指南七(C++11 内存模型一：介绍)Haippy 2013-11-14 16:38 阅读: 32835 评论: 4 推荐: 5 C++11 并发指南三(Lock 详解)Haippy 2013-10-02 11:38 阅读: 64782 评论: 6 推荐: 5 C++11 并发指南六(atomic 类型详解四 C 风格原子操作介绍)Haippy 2013-09-07 11:18 阅读: 20676 评论: 1 推荐: 0 C++11 并发指南六(atomic 类型详解...
C++11: atomic 头文件
weixin_34122548的博客
04-25 336
利用CAS实现自旋锁 class spin_mutex { private: std::atomic<bool> flag = ATOMIC_VAR_INIT(false); public: spin_mutex() = default; spin_mutex(const spin_mutex&) = de...
C++11 atomic及其内存序列和CAS
qq_44875284的博客
04-19 8334
简单介绍atomic的一些用法
c++ 11 atomic
SWELER的博客
12-12 257
举个例子，int64_t类型，在32位机器上为非原子操作。更新时该类型的值时，需要进行两步操作（高32位、低32位）。如果多线程操作该类型的变量，且在操作时未加锁，可能会出现读脏数据的情况。C++11起提供了atomic，可以使用它定义一个原子类型。解决该问题的话，加锁，或者提供一种定义原子类型的方法。为什么要定义一个原子类型？
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值