在关键的计算机应用程序的生存期中，日志记录是一件非常重要的活动，特别是当故障的症状并不十分明显时。日志记录提供了故障前应用程序状态的详细信息，如变量的值、函数的返回值等等。在一段时间的运行过程中，将不断地产生大量的跟踪数据，并持续地将其写入到磁盘上的文本文件中。要进行有效的日志记录，需要使用大量的磁盘空间，并且在多线程环境中，所需的磁盘空间会成倍地增加，因为大量的线程都在记录它们的跟踪信息。

使用常规文件进行日志记录的两个主要问题是：硬盘空间的可用性，以及在对一个文件写入数据时磁盘 I/O 的速度较慢。持续地对磁盘进行写入操作可能会极大地降低程序的性能，导致其运行速度缓慢。通常，可以通过使用日志轮换策略来解决空间问题，将日志保存在几个文件中，当这些文件大小达到某个预定义的字节数时，对它们进行截断和覆盖。

要克服空间问题并实现磁盘 I/O 的最小化，某些程序可以将它们的跟踪数据记录在内存中，仅当请求时才转储些数据。这个循环的、内存中的缓冲区称为循环缓冲区。本文讨论了循环缓冲区的一些常见实现，并对多线程程序中循环缓冲区的启用机制提出了一些观点。

循环缓冲区是一种用于应用程序的日志记录技术，它可以将相关的数据保存在内存中，而不是每次都将其写入到磁盘上的文件中。在需要的时候（比如当用户请求将内存数据转储到文件中时、程序检测到一个错误时，或者由于非法的操作或者接收到的信号而引起程序崩溃时）可以将内存中的数据转储到磁盘。循环缓冲区日志记录由一个固定大小的内存缓冲区构成，进程使用这个内存缓冲区进行日志记录。顾名思义，该缓冲区采用循环的方式进行实现。当该缓冲区填满了数据时，无需为新的数据分配更多的内存，而是从缓冲区开始的位置对其进行写操作，因此将覆盖以前的内容。请参见下图的示例。

上图显示了将两个条目写入到循环缓冲区后该缓冲区的状态。在写入了第一个日志条目（用蓝色表示）之后，当该进程尝试写入第二个条目（用红色表示）时，该缓冲区中已经没有足够的剩余空间。该进程写入数据，一直到达缓冲区的末尾，然后将剩余的数据复制到缓冲区的开始位置，覆盖以前的日志条目。

通过保存一个读指针，可以实现对循环缓冲区的读操作；相应地移动读指针和写指针，以确保在进行读操作期间，读指针不会越过写指针。为了提高效率，一些应用程序可以将原始数据（而不是经过格式化的数据）保存到该缓冲区。在这种情况下需要一个解析器，该解析器可以根据这些内存转储生成有意义的日志消息。

当您可以简单地对一个文件进行写入操作时，为什么要使用循环缓冲区呢？因为您覆盖了循环缓冲区中以前的内容，所以在完成该操作后，您将丢失以前的数据。与传统的文件日志记录机制相比，循环缓冲区提供了下列优势。

• 速度快。与磁盘的 I/O 操作相比，内存的写操作要快得多。仅当需要的时候才刷新数据。
• 持续的日志记录可能会填满系统中的空间，从而导致其他程序也耗尽空间并且执行失败。在这样的情况下，您有两种选择，要么手动地删除日志信息，要么实现日志轮换策略。
• 一旦您启用了日志记录，无论您是否需要它，该进程都将持续地填充硬盘上的空间。
• 有时，您仅仅需要程序崩溃之前的相关数据，而不是该进程完整的历史数据。
• 有一些常见的调试函数，如 printf、write 等，可能会在多线程应用程序的情况下更改一个程序的行为，使得它们难以调试。使用这些函数会导致应用程序隐藏某些平时可能表现出来的错误。这些函数都是可撤销点，并且可能导致在线程环境中产生一个该程序并不期望的挂起信号。

网上找的一个实现多线程环境下循环缓冲区的实现代码：

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <errno.h>
4. #include <pthread.h>
5. #include <string.h>
6. /*
7. * The program reads from a text file, each of the threads takes that message
8. * and writes it to the Ring Buffer after attaching its thread-id to it. Finally,
9. * the Ring Buffer is dumped to the file out.txt. The command line argument is the name of
10. * the input message file.
11. */
12. struct ring_buffer
13. {
14. char * write_pointer;
15. char * buff_start;
16. int wrapped;
17. unsigned long size;
18. };
19. /** Function Prototypes **/
20. void init_buffer(unsigned long);
21. int load_data(void*, unsigned int*);
22. void print_buffer_state();
23. char* mem_allocate(unsigned long);
24. int dump_buffer(const char*);
25. /** Global Variables **/
26. struct ring_buffer global_ring;
27. pthread_mutex_t mutex;
28. char file_contents[300000];
29. /** Fucntions **/
30. char* mem_allocate(unsigned long mem_size)
31. {
32. char* data;
33. data = (char*)calloc(mem_size, sizeof(unsigned char));
34. if(data == NULL)
35. {
36. perror( "calloc" );
37. exit(1);
38. }
39. return data;
40. }
41. void init_buffer(unsigned long mem_size)
42. {
43. if(pthread_mutex_init(&mutex, 0) != 0)
44. {
45. perror("pthread_mutex_init");
46. exit(1);
47. }
48. global_ring.size = mem_size;
49. global_ring.buff_start = mem_allocate(mem_size);
50. global_ring.write_pointer = global_ring.buff_start;
51. global_ring.wrapped = 0;
52. }
53. int load_data(void* data, unsigned int* len)
54. {
55. int temp = 0;
56. if(len == NULL || *len == 0)
57. {
58. return -1;
59. }
60. if(*len > global_ring.size)
61. {
62. *len = global_ring.size;
63. }
64. if(pthread_mutex_lock(&mutex) != 0)
65. {
66. perror("pthread_mutex_lock");
67. exit(1);
68. }
69. temp = (global_ring.buff_start + global_ring.size) - global_ring.write_pointer;
70. if(*len > temp)
71. {
72. memcpy(global_ring.write_pointer, data, temp);
73. memcpy(global_ring.buff_start, (char*)data+temp, *len-temp);
74. global_ring.write_pointer = global_ring.buff_start + *len-temp;
75. global_ring.wrapped = 1;
76. }
77. else
78. {
79. memcpy(global_ring.write_pointer, data, *len);
80. global_ring.write_pointer += *len;
81. }
82. if(pthread_mutex_unlock(&mutex) != 0)
83. {
84. perror("pthread_mutex_lock");
85. exit(1);
86. }
87. return 0;
88. }
89. int dump_buffer(const char* file_to_dump)
90. {
91. FILE* fp ;
92. int temp = 0;
93. int len;
94. if ((fp = fopen(file_to_dump, "a")) == NULL)
95. return -1;
96. pthread_mutex_lock(&mutex);
97. if(global_ring.wrapped == 1)
98. {
99. fwrite( global_ring.buff_start, sizeof(unsigned char), global_ring.size, fp);
100. }
101. else
102. {
103. len = global_ring.write_pointer - global_ring.buff_start + 1;
104. fwrite(global_ring.buff_start, sizeof(unsigned char), len, fp);
105. }
106. fclose(fp);
107. pthread_mutex_unlock(&mutex);
108. return 0;
109. }
110. void print_buffer_state()
111. {
112. printf("\n/***** Printing the buffer before dump****/\n");
113. printf("Buffer data from Start pointer:\n%s\n", global_ring.buff_start);
114. printf("/******************************/\n\n");
115. }
116. int read_input(char* filename)
117. {
118. FILE *inputFilePtr;
119. char *iReturn;
120. inputFilePtr = fopen(filename, "r");
121. if(inputFilePtr == NULL)
122. {
123. printf("ERROR: File Not Found\n");
124. return -1;
125. }
126. iReturn = fgets(file_contents, 209600, inputFilePtr);
127. if (iReturn == NULL) /* End of file reached */
128. return -1;
129. return 0;
130. }
131. void* loader_function(void* a)
132. {
133. unsigned int len, current_thread, old_state = 0;
134. char* local_msg;
135. current_thread = pthread_self();//得到当前的线程
136. local_msg = (char*)calloc(sizeof(file_contents)+32 , sizeof(unsigned char));
137. if(sprintf(local_msg, "%s:%d", file_contents, current_thread) <0)
138. {
139. printf(":(\n");
140. }
141. printf("Message loaded by thread %d to the buffer = \"%s\"\n", pthread_self(), local_msg);
142. len = strlen(local_msg);
143. load_data(local_msg, &len);
144. pthread_exit(0);
145. }
146. void threaded_test(char* filename)
147. {
148. pthread_t threads[2];
149. int i,j, ret,toDump = 0;
150. int data_read = read_input(filename);
151. if(data_read < 0)
152. exit(1);
153. printf("FILE_CONTENTS = %s\n", file_contents);
154. if(pthread_mutex_init(&mutex, 0) != 0)
155. {
156. perror("pthread_mutex_init");
157. exit(1);
158. }
159. init_buffer(20);
160. /***** Threads Created for to load the data *****/
161. for(j = 0; j<2; j++)
162. {
163. pthread_create (&threads[j], NULL, &loader_function, NULL);
164. }
165. for(j = 0; j<2; j++)
166. {
167. pthread_join(threads[j], NULL);
168. }
169. print_buffer_state();
170. dump_buffer("out.txt");
171. printf("Buffer dumped to file \"out.txt\"\n\n");
172. }
173. int main(int argc, char** argv)
174. {
175. if(argc!=2)
176. {
177. printf("Usage: ./test <input-file>\n");
178. exit(1);
179. }
180. else
181. {
182. threaded_test(argv[1]);
183. }
184. }