linux write 函数 是否是 线程安全的？

http://bbs.chinaunix.net/thread-4187636-1-1.html

我做了两个实验：

第一个实验，创建一个本地文件，然后用5个线程对这个文件进行写入，结果前面的写入内容被后面的写入内容覆盖；对write函数加锁之后结果就正常了，就似乎验证了write函数是非线程安全的。

第二个实验，创建一个客户端的TCP socket，然后用5个线程对这个socket进行写入；服务器端把内容读取出来并打印，发现打印结果与客户端发送内容一致，没有出现异常，似乎说明write TCP socket是线程安全的。

我的问题是：
如果write不是线程安全的，为什么写TCP socket却正常，是否因为系统为socket操作加锁了？

实验代码如下

1. #include        <unistd.h>
   
2. #include        <errno.h>
   
3. #include        <pthread.h>
   
4. 
   
5. #include        <sys/socket.h>
   
6. #include        <netinet/in.h>
   
7. #include        <sys/types.h>
   
8. #include        <sys/select.h>
   
9. #include        <sys/stat.h>
   
10. #include        <arpa/inet.h>
    
11. #include        <fcntl.h>
    
12. 
    
13. #include        <stdio.h>
    
14. #include        <stdlib.h>
    
15. #include        <string.h>
    
16. 
    
17. #define BUFF_SIZE 1024
    
18. 
    
19. pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
    
20. 
    
21. struct ThreadArg
    
22. {
    
23.         int id;
    
24.         int fd;
    
25. };
    
26. 
    
27. void* 
    
28. proc(void* arg)
    
29. {
    
30.         struct ThreadArg* p_arg = (struct ThreadArg*) arg;
    
31. 
    
32.         char msg[BUFF_SIZE];
    
33.         int  n_msg;
    
34.         n_msg = snprintf(msg, BUFF_SIZE, "thread_%d\n", p_arg->id);
    
35. 
    
36.         int i;
    
37.         for (i = 0; i < 5; ++ i)
    
38.         {
    
39.                 //pthread_mutex_lock(& mutex);
    
40.                 if (write(p_arg->fd, msg, n_msg) < 0)
    
41.                         perror("thread %d write fail");
    
42.                 //pthread_mutex_unlock(& mutex);
    
43.         }
    
44. }
    
45. 
    
46. int 
    
47. open_socket(char* ip)
    
48. {
    
49.         int                                 connfd;
    
50.         struct sockaddr_in         serv_addr;
    
51. 
    
52.         if ( (connfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    
53.                 return -1;
    
54. 
    
55.         memset(&serv_addr, 0, sizeof(serv_addr));
    
56.         serv_addr.sin_family = AF_INET;
    
57.         serv_addr.sin_port         = htons(9999);
    
58.         inet_pton(AF_INET, ip, &serv_addr.sin_addr);
    
59. 
    
60.         if ( connect(connfd, (struct sockaddr*) &serv_addr, sizeof(serv_addr)) == -1)
    
61.                 return -1;
    
62. 
    
63.         return connfd;
    
64. }
    
65. 
    
66. int 
    
67. open_file(char* file_name)
    
68. {
    
69.         return open(file_name, O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
    
70. }
    
71. 
    
72. int 
    
73. main(int argc, char** argv)
    
74. {
    
75.         int  fd;
    
76. 
    
77.         pthread_t tids[5];
    
78.         struct ThreadArg targ[5];
    
79. 
    
80.         //if ( (fd = open_socket("127.0.0.1")) < 0) // 实验二
    
81.         //        exit(1);
    
82. 
    
83.         if ( (fd = open_file("data")) < 0) // 实验一
    
84.                 exit(1);
    
85. 
    
86.         /* start child threads */
    
87.         int i;
    
88.         for (i = 0; i < 5; ++ i)
    
89.         {
    
90.                 targ[i].id = i;
    
91.                 targ[i].fd = fd;
    
92.                 pthread_create(tids+i, NULL, proc, targ+i);
    
93.         }
    
94. 
    
95.         for (i = 0; i < 5; ++ i)
    
96.                 pthread_join(tids[i], NULL);
    
97. 
    
98.         close(fd);
    
99.         exit(0);
    
100. }

复制代码

实验二 需要的服务器程序代码如下：

1. #include        <stdio.h>
   
2. #include        <stdlib.h>
   
3. #include        <string.h>
   
4. 
   
5. #include        <sys/types.h>
   
6. #include        <sys/socket.h>
   
7. #include        <netinet/in.h>
   
8. #include        <sys/epoll.h>
   
9. #include        <fcntl.h>
   
10. 
    
11. #include        <errno.h>
    
12. 
    
13. const int MAX_EVENTS = 1024;
    
14. const int BUFF_SIZE = 1024;
    
15. 
    
16. void err_quit(const char* msg) {
    
17.         printf("%s, error code = %d\n", msg, errno);
    
18.         exit(1);
    
19. }
    
20. 
    
21. void err_sys(const char* msg) {
    
22.         printf("%s, error code = %d\n", msg, errno);
    
23. }
    
24. 
    
25. int create_and_bind(int port_no) {
    
26.         int listen_fd;
    
27.         struct sockaddr_in serv_addr;
    
28. 
    
29.         if ( (listen_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    
30.                 return -1;
    
31. 
    
32.         memset(&serv_addr, 0, sizeof(serv_addr));
    
33.         serv_addr.sin_family      = AF_INET;
    
34.         serv_addr.sin_addr.s_addr = INADDR_ANY;
    
35.         serv_addr.sin_port        = htons(port_no);
    
36. 
    
37.         if ( bind(listen_fd, (struct sockaddr*) &serv_addr, sizeof(serv_addr)) < 0)
    
38.                 return -1;
    
39. 
    
40.         return listen_fd;
    
41. }
    
42. 
    
43. int communicate(const int fd)
    
44. {
    
45.         int  n_msg = 9;
    
46.         char msg[BUFF_SIZE];
    
47. 
    
48.         int count = 0;
    
49.         int n_read;
    
50.         while ( (n_read = read(fd, msg, n_msg)) > 0)
    
51.         {
    
52.                 msg[n_msg] = 0;
    
53.                 printf("%s", msg);
    
54.                 ++ count;
    
55.         }
    
56. 
    
57.         printf("msg number = %d\n", count);
    
58. 
    
59.         if (n_read < 0)
    
60.                 return -1;
    
61.         return 0;
    
62. }
    
63. 
    
64. int main(int argc, char** argv) {
    
65. 
    
66.         int listen_fd;
    
67.         int conn_fd;
    
68. 
    
69.         /* create and bind listening socket */
    
70.         listen_fd = create_and_bind(9999);
    
71.         if (listen_fd < 0)
    
72.                 err_quit("create and bind listening socket failed!");
    
73. 
    
74.         /* listening */
    
75.         listen(listen_fd, 100);
    
76. 
    
77.         while (1) {
    
78.                 if ( (conn_fd = accept(listen_fd, NULL, NULL)) < 0)
    
79.                         err_sys("accept connection socket failed!");
    
80.                 else 
    
81.                         if (communicate(conn_fd) < 0)
    
82.                                 perror("read socket fail");
    
83.                         else
    
84.                                 close(conn_fd);
    
85.         }
    
86. 
    
87.         close(listen_fd);
    
88.         exit(0);
    
89. }

系统调用都是线程安全的。 write是原子的， 系统一定要保证这个语义， 不然这系统没法用了,但是下面这三个都不是线程安全的。

printf（）----stdout()

malloc-------内存分配表

free()--------内存分配表