C# thread file lock

ReaderWriterLockSlim is similar to ReaderWriterLock , but it has simplified rules for recursion and for upgrading and downgrading lock state. ReaderWriterLockSlim avoids many cases of potential deadlock. ReaderWriterLock is used to synchronize access to a resource.

At any given time, it allows either concurrent read access for multiple threads, or write access for a single thread. In a situation where a resource is changed infrequently, a ReaderWriterLock provides better throughput than a simple one-at-a-time lock, such as Monitor. ReaderWriterLock works best where most accesses are reads, while writes are infrequent and of short duration. Multiple readers alternate with single writers, so that neither readers nor writers are blocked for long periods.

Holding reader locks or writer locks for long periods will starve other threads. For best performance, consider restructuring your application to minimize the duration of writes. A thread can hold a reader lock or a writer lock, but not both at the same time. Readers and writers are queued separately.

When a thread releases the writer lock, all threads waiting in the reader queue at that instant are granted reader locks; when all of those reader locks have been released, the next thread waiting in the writer queue, if any, is granted the writer lock, and so on. In other words, ReaderWriterLock alternates between a collection of readers, and one writer. While a thread in the writer queue is waiting for active reader locks to be released, threads requesting new reader locks accumulate in the reader queue.

Their requests are not granted, even though they could share concurrent access with existing reader-lock holders; this helps protect writers against indefinite blockage by readers. Most methods for acquiring locks on a ReaderWriterLock accept time-out values. Use time-outs to avoid deadlocks in your application. For example, a thread might acquire the writer lock on one resource and then request a reader lock on a second resource; in the meantime, another thread might acquire the writer lock on the second resource, and request a reader lock on the first.

Unless time-outs are used, the threads deadlock. Active Oldest Votes. Unless you have a good reason for write to the file asynchronously, this is wasted effort.

You can then get away with something like this: using System; using System. IO; using System. Text; using System. Threading; using System. Improve this answer. David Crowell David Crowell 2 2 silver badges 6 6 bronze badges. If you have two instances of Writer pointing at the same file, the locking will do nothing unless you use the static lock.

Sign up or log in Sign up using Google. Sign up using Facebook. Sign up using Email and Password. Post as a guest Name. Email Required, but never shown. It deals with requests from asynchronous operations, which may come in at any time. The FilePath is set per class instance so the lock Object is per instance , but there is potential for conflict since these classes may share FilePaths. That sort of conflict, as well as all other types from outside the class instance, would be dealt with retries.

Is this code suitable for its purpose? Is there a better way to handle this that means less or no reliance on the catch and retry mechanic? How you approach this is going to depend a lot on how frequently you're writing.

If you're writing a relatively small amount of text fairly infrequently, then just use a static lock and be done with it. That might be your best bet in any case because the disk drive can only satisfy one request at a time. Assuming that all of your output files are on the same drive perhaps not a fair assumption, but bear with me , there's not going to be much difference between locking at the application level and the lock that's done at the OS level.

If you want this thing to be bulletproof or at least reasonably so , you can't get away from catching exceptions. Bad things can happen. You must handle exceptions in some way. What you do in the face of error is something else entirely. You'll probably want to retry a few times if the file is locked. If you get a bad path or filename error or disk full or any of a number of other errors, you probably want to kill the program.

Again, that's up to you. But you can't avoid exception handling unless you're okay with the program crashing on error. Assuming you're using. NET 4. See File. One other way you could handle this is to have the threads write their messages to a queue, and have a dedicated thread that services that queue. You'd have a BlockingCollection of messages and associated file paths. For example:. Your potential risk here is that threads create messages too fast, causing the queue to grow without bound because the consumer can't keep up.

Whether that's a real risk in your application is something only you can say. Then an object that defined a lock is created. Then a method called display is created in which the lock is used to make any other threads trying to access the method wait or block until the thread that is already executing completes its execution.

Then the keyword lock is used to lock the object that was created earlier. Then the output is displayed synchronously in a row by one thread followed by another thread because we have used lock on display method. The output is shown in the snapshot above. In this tutorial, we understand the concept of lock-in C through definition, syntax, and working of the lock through programming examples and their outputs.

This is a guide to Lock in C.