C语言中volatile关键字怎么用C语言volatile在多线程中的作用

volatile关键字在c语言中用于防止编译器优化，确保变量的可见性，但不能保证原子性。1. volatile用于声明可能被外部因素修改的变量，如硬件寄存器或中断服务程序中的变量；2. 在多线程环境中，volatile确保一个线程对变量的修改对其他线程可见；3. 由于volatile变量每次访问都从内存读取，影响程序性能，因此应谨慎使用；4. c11引入\_atomic类型和<threads.h>提供更强大的多线程支持，包括原子操作和线程管理函数。

C语言中的volatile关键字主要用于告诉编译器，某个变量的值可能会以编译器无法预料的方式被改变，因此编译器不应对该变量的访问进行优化。在多线程环境中，volatile可以确保变量的可见性，但不能保证原子性。

解决方案

volatile关键字的正确使用是理解其本质的关键。它并非万能的线程安全工具，而是编译器优化的“刹车片”。当一个变量被声明为volatile时，编译器每次遇到对该变量的访问，都会从内存中重新读取，而不是使用可能已经存储在寄存器中的旧值。

立即学习“C语言免费学习笔记（深入）”；

以下是volatile关键字在C语言中的使用方式和在多线程中的作用：

• 基本用法

  volatile int sensor_value; // 声明一个volatile的整型变量
  
  int main() {
      // ...
      while (sensor_value < 100) {
          // 读取sensor_value，每次都从内存读取
          // 进行一些处理
      }
      // ...
      return 0;
  }

  登录后复制

  在这个例子中，sensor_value可能被中断服务程序或者其他线程修改。如果没有volatile，编译器可能会优化循环，认为sensor_value的值在循环内不会改变，从而导致无限循环。

• 防止编译器优化

  考虑以下情况：

  int *ptr = (int*)0x12345678; // 假设这是一个硬件寄存器的地址
  int value = *ptr;
  int value2 = *ptr;

  登录后复制

  如果没有volatile，编译器可能会认为*ptr的值在两次读取之间不会改变，因此会将第一次读取的值存储在寄存器中，第二次直接使用寄存器中的值。如果ptr指向的是一个会变化的硬件寄存器，这就会导致错误。使用volatile可以避免这种优化：

  volatile int *ptr = (volatile int*)0x12345678;
  int value = *ptr;
  int value2 = *ptr;

  登录后复制

  现在，每次读取*ptr都会从内存中重新读取。

• 多线程环境下的可见性

  在多线程环境中，一个线程修改了某个变量的值，其他线程可能无法立即看到这个修改，因为每个线程可能都有自己的缓存。volatile可以确保一个线程对变量的修改对其他线程是可见的。

  #include <stdio.h>
  #include <pthread.h>
  
  volatile int flag = 0;
  
  void *thread_func(void *arg) {
      while (flag == 0) {
          // 等待flag被设置为1
      }
      printf("Thread: flag is now %d\n", flag);
      return NULL;
  }
  
  int main() {
      pthread_t thread;
      pthread_create(&thread, NULL, thread_func, NULL);
  
      // 模拟主线程修改flag
      sleep(2);
      flag = 1;
      printf("Main: flag set to 1\n");
  
      pthread_join(thread, NULL);
      return 0;
  }

  登录后复制

  在这个例子中，如果flag没有被声明为volatile，编译器可能会将flag的值缓存在寄存器中，导致线程永远无法看到flag被设置为1，从而陷入无限循环。

volatile的局限性

虽然volatile可以确保变量的可见性，但它不能保证原子性。原子性指的是一个操作不可被中断，要么全部执行，要么完全不执行。例如，i++操作实际上包含了读取i的值、将i的值加1、将结果写回i三个步骤，这三个步骤不是原子的。在多线程环境下，多个线程同时执行i++可能会导致数据竞争。

• 原子性问题示例

  #include <stdio.h>
  #include <pthread.h>
  
  volatile int counter = 0;
  
  void *thread_func(void *arg) {
      for (int i = 0; i < 100000; i++) {
          counter++; // 非原子操作
      }
      return NULL;
  }
  
  int main() {
      pthread_t thread1, thread2;
      pthread_create(&thread1, NULL, thread_func, NULL);
      pthread_create(&thread2, NULL, thread_func, NULL);
  
      pthread_join(thread1, NULL);
      pthread_join(thread2, NULL);
  
      printf("Counter value: %d\n", counter); // 期望值为200000，但通常不是
      return 0;
  }

  登录后复制

  在这个例子中，即使counter被声明为volatile，由于counter++不是原子操作，仍然可能出现数据竞争，导致最终的counter值小于200000。

• 如何解决原子性问题

  要解决原子性问题，需要使用互斥锁、原子操作等同步机制。

  

  云雀语言模型

  云雀是一款由字节跳动研发的语言模型，通过便捷的自然语言交互，能够高效的完成互动对话

  54

  查看详情

  #include <stdio.h>
  #include <pthread.h>
  
  int counter = 0;
  pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
  
  void *thread_func(void *arg) {
      for (int i = 0; i < 100000; i++) {
          pthread_mutex_lock(&mutex);
          counter++;
          pthread_mutex_unlock(&mutex);
      }
      return NULL;
  }
  
  int main() {
      pthread_t thread1, thread2;
      pthread_create(&thread1, NULL, thread_func, NULL);
      pthread_create(&thread2, NULL, thread_func, NULL);
  
      pthread_join(thread1, NULL);
      pthread_join(thread2, NULL);
  
      printf("Counter value: %d\n", counter); // 期望值为200000
      pthread_mutex_destroy(&mutex);
      return 0;
  }

  登录后复制

  在这个例子中，使用互斥锁mutex保护counter++操作，确保了原子性。

副标题1volatile关键字与const关键字可以同时使用吗？

当然可以。volatile和const可以同时使用，表示一个变量是只读的，但其值可能会以编译器无法预料的方式被改变。例如，一个硬件时钟寄存器，其值由硬件自动更新，程序只能读取，不能修改。

volatile const int hardware_clock;

这告诉编译器，hardware_clock的值可能会在程序不知情的情况下发生变化，因此每次读取都应该从内存中重新读取，同时程序不应该尝试修改它的值。

副标题2volatile关键字在嵌入式系统中的应用场景有哪些？

volatile在嵌入式系统中应用广泛，主要用于以下场景：

1. 硬件寄存器：访问硬件寄存器时，必须使用volatile，因为寄存器的值可能随时被硬件修改。

2. 中断服务程序（ISR）中使用的变量：在ISR中修改的变量，需要在主循环中声明为volatile，以确保主循环能够看到最新的值。

3. 多线程共享变量：虽然volatile不能保证原子性，但在某些简单的情况下，可以用于确保多线程之间的可见性。

4. DMA传输：当使用DMA传输数据时，需要确保CPU能够看到DMA传输的最新数据，因此需要使用volatile。

副标题3volatile关键字会影响程序的性能吗？

是的，volatile关键字会影响程序的性能。由于编译器不对volatile变量的访问进行优化，每次访问都需要从内存中重新读取，这会增加内存访问的次数，从而降低程序的性能。因此，应该谨慎使用volatile关键字，只在必要的时候使用。

副标题4 除了volatile，C11还提供了哪些多线程相关的特性？

C11标准引入了_Atomic类型和相关的原子操作函数，以及线程库<threads.h>，提供了更强大的多线程支持。

• _Atomic类型：_Atomic类型可以确保对变量的访问是原子的，避免数据竞争。

  #include <stdatomic.h>
  
  atomic_int counter = 0;
  
  void *thread_func(void *arg) {
      for (int i = 0; i < 100000; i++) {
          atomic_fetch_add(&counter, 1); // 原子操作
      }
      return NULL;
  }

  登录后复制

  在这个例子中，atomic_fetch_add函数是一个原子操作，可以确保counter++操作的原子性。

• <threads.h>：<threads.h>提供了创建、管理线程的函数，以及互斥锁、条件变量等同步机制。

  #include <threads.h>
  #include <stdio.h>
  
  int counter = 0;
  mtx_t mutex;
  
  void *thread_func(void *arg) {
      for (int i = 0; i < 100000; i++) {
          mtx_lock(&mutex);
          counter++;
          mtx_unlock(&mutex);
      }
      return NULL;
  }
  
  int main() {
      thrd_t thread1, thread2;
      mtx_init(&mutex, mtx_plain);
      thrd_create(&thread1, thread_func, NULL);
      thrd_create(&thread2, thread_func, NULL);
  
      thrd_join(thread1, NULL);
      thrd_join(thread2, NULL);
  
      printf("Counter value: %d\n", counter);
      mtx_destroy(&mutex);
      return 0;
  }

  登录后复制

  这个例子使用了<threads.h>提供的函数来创建线程和互斥锁。

总之，volatile关键字在C语言中主要用于防止编译器优化，确保变量的可见性。在多线程环境中，虽然volatile可以确保可见性，但不能保证原子性，需要结合互斥锁、原子操作等同步机制来解决数据竞争问题。C11标准提供了更强大的多线程支持，包括_Atomic类型和<threads.h>，可以更方便地编写多线程程序。

以上就是C语言中volatile关键字怎么用C语言volatile在多线程中的作用的详细内容，更多请关注php中文网其它相关文章！