Programming

Hi,
Can anyone give me any idea when multiple processes access a file (like opening it, modifying it etc.) how can the synchronization can be done if they can access the same file at any time? How can this scenario is different from when multiple threads access a same file, modifying it etc- in this case how can this synchronization can be done?

It will be great help to me if you could give me some test programs in c/c++/linux/unix or some good links to follow.

Thanks in advance for your support.
sk

In case of threads mutex can hold the write access ( which means only one thread writes at any time and all threads can read simultaneously ) . When some thread wants to write to file he should obtain the mutex first .

In linux ( ubuntu ) :
sudo apt-get install libpth-dev
man pth ( look for mutex )

Thread synchronization is a big topic due to the various complexities involved. I agree with rr about where to look first. If you're coding on Linux, there is also the futex library which is worth looking at if the performance of the mutex is an issue.

Thanks for the above replies guys, but I want a simple dummy example coe in linux for both scenarios. If you can provide it wud a gr8 help.

I would suggest to go to :
Open Source Code Search Engine - Black Duck Koders
and search for mutex & futex there .
You will get as much example code as you can handle

Hello
you can also do simple file locking using the fcntl.h
You would want to have a look at this.
fcntl(2): change file descriptor - Linux man page for a simple example.
Regards

This is a complex topic.

Are your I/O operations synchronous or asynchronous? Are you using the O_NONBLOCK interface or the AIO interface? Are you going to use the buffer cache or using the O_DIRECT interface?

Synchronous I/O
Lets start with one process, one file descriptor, and multiple threads
You must use a muxtex like interface to protect the usage of the file descriptor since a file descriptor is an object of the process and not a thread.

If you duplicate the file descriptor, you need to protect the duplicated file descriptor using the same mutex because the duplicated file descriptor is a new number but points to the same file object (ie it is the same seek location)

File locking does nothing for you if you have one file descriptor since you already own the lock.

What happens if you open the file a second time within your process? File locking will work for you because you have another file structure.

What happens if a thread dies(crashes) that was using the second open file descriptor? The file descriptor is still open since the file descriptor is an object of the process. If there was a file lock on second file descriptor, then that file region becomes not accessible if you are using file locks.

What happens if you add a second process? First file locking is advisory and mandatory. This means another process can open your file unless you protect the file using file permissions.

File locking is the only OS interface for protecting against overlapping I/O operations but for cooperating processes you can build your own interface.

Asynchronous I/O interfaces have a different set of conventions and if you want answer here, you need to define your environment better because there are multiple solutions with different implementations.