如何防止文件同时操作问题

[wade008]

当对文件A进行写时,如何防止对文件A同时进读操作? 也就是只有当写完成后,才能对文件进行读操作?


这是不是文件同步问题?要如何实现?


请大家给上思路, 谢谢!

[feifanup]

HANDLE WINAPI CreateFile(
__in LPCTSTR lpFileName,
__in DWORD dwDesiredAccess,
__in DWORD dwShareMode,
__in LPSECURITY_ATTRIBUTES lpSecurityAttributes,
__in DWORD dwCreationDisposition,
__in DWORD dwFlagsAndAttributes,
__in HANDLE hTemplateFile
);


__in DWORD dwShareMode:
If this parameter is zero (0) and CreateFile succeeds, the object cannot be shared and cannot be opened again until the handle is closed. For more information, see the Remarks section of this topic.

[kingteng]

用信号量，几句话也说不清楚，google或者看《unix环境高级编程》

[huanmie_09]

我觉得是一个同步问题,
以写方式打开文本，置互斥标志， 不允许其它进程或线程进行读写.
以读方式打开文本，置写互斥标志，允许其它进程或线程进行读，但不允许其它进程或线程写.

[wuyu637]

不用太复杂的话，你要个简单的变量就可以了。

每次操作文件的时候，先访问这个变量的值，如果这个变量的值是1，表示，有一个其他的操作在进行，那么就不可以操作。

等到那个操作结束以后，把这个变量制成0.然后通知别的操作，或者就结束

[xiaowai0219]

就是进程的互斥问题嘛，去学IPC吧

[wade008]

[Quote=引用 3 楼 huanmie_09 的回复:]
我觉得是一个同步问题,
以写方式打开文本，置互斥标志， 不允许其它进程或线程进行读写.
以读方式打开文本，置写互斥标志，允许其它进程或线程进行读，但不允许其它进程或线程写.
[/Quote]

嗯

[wade008]

[Quote=引用 4 楼 wuyu637 的回复:]
不用太复杂的话，你要个简单的变量就可以了。

每次操作文件的时候，先访问这个变量的值，如果这个变量的值是1，表示，有一个其他的操作在进行，那么就不可以操作。

等到那个操作结束以后，把这个变量制成0.然后通知别的操作，或者就结束
[/Quote]

这方法看来不错,实现起来比较简单

[ForestDB]

帮顶。

[cattycat]

线程或进程间同步和互斥问题，可以用Mutex或Semaphore.

[ljyat]

使用信号量

[kevinyujm]

互斥问题（访问是异步的，A和B没有依赖关系，只是要求他们不同时访问）。简单使用#4楼的方法就就可以。
同步的问题，用信号量。（譬如，程序B要等到A写完后，用A的数据，整个流程是顺序的）

[sbdt123]

使用信号量可能行吧

[xiangzideai]

package com.huawei.manager;

/**
 *	线程同步方式：1 代码块同步 2 方法同步 3 对象同步 
 *
 *	同步关键字:synchronized
 */
public class ThreadTest 
{
	private TaskTest taskTest;
	
	ThreadTest()
	{
		taskTest = new TaskTest();
		threadTest();
	}
	
	/**
	 *	线程同步任务 
	 *	
	 *	@return void
	 */
	public void threadTest()
	{
		new Thread(new ThreadC(taskTest, "张三")).start();
		new Thread(new ThreadC(taskTest, "李四")).start();
	}
	
	/**
	 * @param args
	 */
	public static void main(String[] args) 
	{
		// TODO Auto-generated method stub
		new ThreadTest();
	}
}

class ThreadA implements Runnable
{
	private TaskTest taskTest;
	private String name;
	
	ThreadA(TaskTest taskTest, String name)
	{
		this.taskTest = taskTest;
		this.name = name;
	}
	
	public void run() 
	{
		// TODO Auto-generated method stub
		taskTest.taskTestA(name);
	}
}

class ThreadB implements Runnable
{
	private TaskTest taskTest;
	private String name;
	
	ThreadB(TaskTest taskTest, String name)
	{
		this.taskTest = taskTest;
		this.name = name;
	}
	
	public void run() 
	{
		// TODO Auto-generated method stub
		taskTest.taskTestB(name);
	}
}

/**
 *	对象同步
 *	
 *	同步作用域：整个对象同步 
 */
class ThreadC implements Runnable
{
	private TaskTest taskTest;
	private String name;
	
	ThreadC(TaskTest taskTest, String name)
	{
		this.taskTest = taskTest;
		this.name = name;
	}
	
	public void run() 
	{
		// TODO Auto-generated method stub
		synchronized(taskTest)
		{
			taskTest.taskTestA(name);
		}
	}
}

class TaskTest
{
	/**
	 *	方法同步 
	 *	
	 *	同步作用域：整个方法同步
	 */
	public void taskTestA(String name)
	{
		for(int numA = 0; numA < 20; numA++)
		{
			System.out.println(name + "正在操作...");
		}
		System.out.println(name + "退出操作...");
	}
	
	/**
	 *	代码块同步 
	 *
	 *	同步作用域：独立代码块同步
	 */
	public void taskTestB(String name)
	{
		synchronized(this)
		{
			for(int numA = 0; numA < 20; numA++)
			{
				System.out.println(name + "正在操作...");
			}
			System.out.println(name + "退出操作...");
		}
	}
}