为什么使用`printf（）`不会引起溢出？

Question

我正在对printf（）进行一些实验，我的代码如下：

#include <iostream>       // std::cout
#include <thread>         // std::thread
 
void foo() 
{
    while(1) printf("a");
}

void bar()
{
  while(1) printf("b");
}

int main() 
{
  std::thread first (foo);     // spawn new thread that calls foo()
  std::thread second (bar);  // spawn new thread that calls bar(0)
  first.join();                // pauses until first finishes
  second.join();               // pauses until second finishes
  return 0;
}

大量AB会输出。但是我在这里有一个问题：据我所知，printf有一个缓冲区，那么为什么buffer [pos ++]不会导致溢出？我想使用了一个圆缓冲区，但我不确定。

因此，当缓冲区不完整时，两个线程会同时写入缓冲区，我也编写另一个版本

#include <iostream>       // std::cout
#include <thread>         // std::thread
 
void foo() 
{
    while(1) printf("aaaaaa");
}

void bar()
{
  while(1) printf("bbbbbb");
}

int main() 
{
  std::thread first (foo);     // spawn new thread that calls foo()
  std::thread second (bar);  // spawn new thread that calls bar(0)
  first.join();                // pauses until first finishes
  second.join();               // pauses until second finishes
  return 0;
}

，但是输出不会像ababab一样，我想知道Printf如何同时处理写作？

Answer 1

为什么缓冲区[POS ++]不会导致溢出？

printf的实现要注意，如果使用缓冲区，它从未在缓冲区之外写下。

我想使用了一个圆缓冲区

实现可能会选择这样做。

我想知道printf如何同时处理写作？

C标准说：

每个流都有一个关联的锁定，用于在多个执行访问流并限制多个线程执行的流操作的相互作用时，用于防止数据种族。一次只有一个线程可以容纳此锁。锁定是重入的：一个线程可能在给定时间将锁多次固定。