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

alwaysR9

我做了两个实验：

第一个实验，创建一个本地文件，然后用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. }

复制代码

folklore

系统调用都是线程安全的。

bskay

貌似方式错了,多线程应该不是用来做IO的, 而是用于处理器消耗型的任务并发

hellioncu

应该说write是线程安全的，但最终的结果如何取决于“文件”的实现。

write写普通文件，指定偏移量不重叠写，最终结果是肯定的
write写TCP socket，你每次写个几十K，结果很可能就会不一样了

sculida

其实往socket_fd里write也不安全，比如我把你的msg改成thread_%d0123456789001234567890012345678900123456789001234567890
然后每个线程写100遍。你自己执行看看，是不是文字也错乱了。我就得到下面这一段输出
---------------------------------------
thread_1 123456789012345678901234567890123456890
thread_1 123456789012345678901234567890123456890
thread_1 123456789012345678901234567890123456890
thread_1 123456789012345678901234567890123456890
23thread_1 123456789012345678901234567890123456890
thread_1 123456789012345678901234567890123456890
---------------------------------
关于线程与io，可以使用pwrite和pread，参见《unix高级环境编程》的章节：12.10 线程与IO

alwaysR9

回复 5# sculida


    我重新测试了write socket， 5个线程，每个线程每次写2KB数据到socket，写100次。
   服务器收到的数据依然是正确的顺序
   你再看看你改的程序，或者仔细测试一下，会不会你在测试输出时出错了。服务器端n_msg变量的值一定要设对，否则read出客户端发送的消息长度不对，就会造成输出看起来像乱序了一样

cokeboL

回复 6# alwaysR9


    那么点数据和次数，能测出的概率很小。。

cokeboL

只考虑原理，阻塞IO，一次写入成功的数量可能比要写入的数量小，系统调用时陷入内核，多个线程竞争一个fd，A这次写了10个字节系统调用结束后，当前调度到哪个线程的write，如果不是刚才没写完的那个，就可能出错咯

alwaysR9

回复 8# cokeboL


    我去找源码看看，只有源码能说明write有没有加锁

folklore

回复 8# cokeboL


    write是原子的， 系统一定要保证这个语义， 不然这系统没法用了