Linux文件锁无卵用？

无形装逼

在Linux下写了一段小代码测试一下文件锁，创建文件并写入文件锁（强制锁，写入锁），结果无论怎么测试其它线程和自身都可以随意写入数据，文件锁丝毫不起作用，将代码贴出来，各位前辈看看什么情况。

1. /*file_lock_set.c*/
   
2. int lock_set(int fd,int type)
   
3. {
   
4.     struct flock old_lock,lock;
   
5.     lock.l_whence=SEEK_SET;
   
6.     lock.l_start=0;
   
7.     lock.l_len=25;
   
8.     lock.l_type=type;
   
9.     lock.l_pid=-1;
   
10. 
    
11. /*judge whether the file has been locked*/
    
12.     fcntl(fd,F_GETLK,&lock);
    
13.         if (lock.l_type!=F_UNLCK)/*there is already a lock*/
    
14.         {
    
15.             if(lock.l_type==F_RDLCK)
    
16.                 printf("read lock is already setted by %d",lock.l_pid);       
    
17.                 else if(lock.l_type==F_WRLCK)
    
18.                     printf("read lock is already setted by %d",lock.l_pid);       
    
19.         }
    
20.     lock.l_type=type;/*l_type may be changed by F_GETLK*/
    
21.    
    
22.     if(fcntl(fd,F_SETLKW,&lock)<0)
    
23.         {
    
24.             printf("lock failed:type = %d\n",lock.l_type);
    
25.         }        
    
26.            
    
27.     else if(fcntl(fd,F_SETLKW,&lock)==0)
    
28.     {
    
29.         switch(lock.l_type)       
    
30.         {
    
31.             case F_RDLCK:
    
32.                 printf("read lock set by %d\n",getpid());break;
    
33.             case F_WRLCK:
    
34.                 printf("write lock set by %d\n",getpid());break;
    
35.             case F_UNLCK:
    
36.                 printf("release lock by %d\n",getpid());       
    
37.         }           
    
38.     }       
    
39. }           
    
40.            
    
41.            
    
42. #include<sys/types.h>
    
43. #include<unistd.h>
    
44. #include<fcntl.h>
    
45. #include<stdio.h>
    
46. #include<string.h>
    
47. #include<stdlib.h>
    
48. #include<signal.h>
    
49. #include<pthread.h>
    
50. #include<semaphore.h>
    
51. #include"file_lock_set.c"
    
52. 
    
53. sem_t mywrite,mylock;
    
54. pthread_t thread[2];
    
55. 
    
56. 
    
57. /*func******************************************************************/
    
58. void func(void)
    
59. {   
    
60.     int fd;
    
61.     printf("thread1 is going to open the locked file\n");
    
62.     fd=open("./datafile",O_RDWR);
    
63.     if (fd<0)
    
64.         perror("open datafile fail");
    
65.     if(fd>0)
    
66.     {
    
67.         while(1)
    
68.             {
    
69.                 if(write(fd,"thread1 has been here \n",22)>0)
    
70.                     printf("thread1 write data sucessfully \n");
    
71.                 else if(write(fd,"thread1 has been here \n",22)<=0)
    
72.                     printf("thread1 failed to write data \n");
    
73.                 sleep(1);
    
74.          }
    
75.     }        
    
76. }
    
77. 
    
78. /*locker***************************************************************/
    
79. void* locker(void* arg)
    
80. {
    
81.     int fd;
    
82.     sem_wait(&mylock);
    
83.     printf("child1 is creating a datafile\n");
    
84.     fd=open("./datafile",O_RDWR|O_CREAT,0666);/*创建数据文件*/
    
85.     if(fd<0)
    
86.         perror("creat datafile fail");
    
87.     lock_set(fd,F_WRLCK);/*文件上锁*/
    
88.     if(write(fd,"thread0 has been here \n",22)>0)
    
89.                     printf("thread0 write data sucessfully \n");
    
90.                 else if(write(fd,"thread1 has been here \n",22)<=0)
    
91.                     printf("thread2 failed to write data \n");
    
92.     sem_post(&mywrite);
    
93.     sleep(3);
    
94.     lock_set(fd,F_UNLCK);
    
95.     sleep(2);
    
96.     pthread_cancel(thread[1]);
    
97. }
    
98. /*writer***************************************************************/
    
99. void* writer(void* arg)
    
100. {
     
101.     sem_wait(&mywrite);
     
102.     func();       
     
103. }
     
104. 
     
105. /*main****************************************************************/
     
106. int main (int argc,char* argv[])
     
107. {
     
108.     int ret;
     
109.    
     
110. /*创建两个线程*/  
     
111.     ret=sem_init(&mylock,0,1);
     
112.     ret+=sem_init(&mywrite,0,0);
     
113.     if(ret!=0)
     
114.         printf("At least one sem init failed");
     
115.     ret=pthread_create(&thread[0],NULL,locker,NULL);
     
116.     ret+=pthread_create(&thread[1],NULL,writer,NULL);
     
117.     if(ret!=0)
     
118.         printf("At least one thread created failed");
     
119.     pthread_join(thread[0],NULL);
     
120.     pthread_join(thread[1],NULL);
     
121.     return 0;
     
122.     exit(0);
     
123. }
     
124. 
     

复制代码

执行结果在附件的图片里，锁完全没起作用啊

hellioncu

一般只是advisory锁吧

yaoyefengyun

这只是建议锁并不是强制锁，也就是说，你每次操作之前，应该先获取一次锁，如果得到锁，即进行操作，否则不操作。强制锁我好像在哪儿看到过，但并没有看内容，你可以网上查查，一般场景建议锁也够用了。

流氓无产者

无形装逼 发表于 2016-05-29 12:25
在Linux下写了一段小代码测试一下文件锁，创建文件并写入文件锁（强制锁，写入锁），结果无论怎么测试其它线 ...

大家都要加锁才有效果啊
可以封装成一个库供使用
但往往出现有不加锁的害群之马
所以，还是希望有内核自动加锁，不知道现在有没有了

lolizeppelin

强制锁要挂载的时候加特别参数才生效吧

只用过协同锁 强制锁没用过