Create lock file in java
A token representing a lock on a region of a file. A file-lock object is created each time a lock is acquired on a file via one of the lock or tryLock methods of the FileChannel class, or the lock or tryLock methods of the AsynchronousFileChannel class. A file-lock object is initially valid. It remains valid until the lock is released by invoking the release method, by closing the channel that was used to acquire it, or by the termination of the Java virtual machine, whichever comes first. The validity of a lock may be tested by invoking its isValid method. A file lock is either exclusive or shared. A shared lock prevents other concurrently-running programs from acquiring an overlapping exclusive lock, but does allow them to acquire overlapping shared locks. An exclusive lock prevents other programs from acquiring an overlapping lock of either type. Once it is released, a lock has no further effect on the locks that may be acquired by other programs. Whether a lock is exclusive or shared may be determined by invoking its isShared method. Some platforms do not support shared locks, in which case a request for a shared lock is automatically converted into a request for an exclusive lock. The locks held on a particular file by a single Java virtual machine do not overlap. The overlaps method may be used to test whether a candidate lock range overlaps an existing lock. A file-lock object records the file channel upon whose file the lock is held, the type and validity of the lock, and the position and size of the locked region. Only the validity of a lock is subject to change over time; all other aspects of a lock’s state are immutable. File locks are held on behalf of the entire Java virtual machine. They are not suitable for controlling access to a file by multiple threads within the same virtual machine. File-lock objects are safe for use by multiple concurrent threads.
Platform dependencies
This file-locking API is intended to map directly to the native locking facility of the underlying operating system. Thus the locks held on a file should be visible to all programs that have access to the file, regardless of the language in which those programs are written. Whether or not a lock actually prevents another program from accessing the content of the locked region is system-dependent and therefore unspecified. The native file-locking facilities of some systems are merely advisory, meaning that programs must cooperatively observe a known locking protocol in order to guarantee data integrity. On other systems native file locks are mandatory, meaning that if one program locks a region of a file then other programs are actually prevented from accessing that region in a way that would violate the lock. On yet other systems, whether native file locks are advisory or mandatory is configurable on a per-file basis. To ensure consistent and correct behavior across platforms, it is strongly recommended that the locks provided by this API be used as if they were advisory locks. On some systems, acquiring a mandatory lock on a region of a file prevents that region from being mapped into memory , and vice versa. Programs that combine locking and mapping should be prepared for this combination to fail. On some systems, closing a channel releases all locks held by the Java virtual machine on the underlying file regardless of whether the locks were acquired via that channel or via another channel open on the same file. It is strongly recommended that, within a program, a unique channel be used to acquire all locks on any given file. Some network filesystems permit file locking to be used with memory-mapped files only when the locked regions are page-aligned and a whole multiple of the underlying hardware’s page size. Some network filesystems do not implement file locks on regions that extend past a certain position, often 2 30 or 2 31 . In general, great care should be taken when locking files that reside on network filesystems.
Constructor Summary
Method Summary
Create file lock on file
In order to help you master Java NIO Library, we have compiled a kick-ass guide with all the major Java NIO features and use cases! Besides studying them online you may download the eBook in PDF format!
Thank you!
Do not forget to close the channel after you are done processing the file so as to release operating system resources.
package com.javacodegeeks.snippets.core; import java.io.File; import java.io.IOException; import java.io.RandomAccessFile; import java.nio.channels.FileChannel; import java.nio.channels.FileLock; import java.nio.channels.OverlappingFileLockException; public class CreateFileLockOnFile < public static void main(String[] args) < try < File file = new File("fileToLock.dat"); // Creates a random access file stream to read from, and optionally to write to FileChannel channel = new RandomAccessFile(file, "rw").getChannel(); // Acquire an exclusive lock on this channel's file (blocks until lock can be retrieved) FileLock lock = channel.lock(); // Attempts to acquire an exclusive lock on this channel's file (returns null or throws // an exception if the file is already locked. try < lock = channel.tryLock(); >catch (OverlappingFileLockException e) < // thrown when an attempt is made to acquire a lock on a a file that overlaps // a region already locked by the same JVM or when another thread is already // waiting to lock an overlapping region of the same file System.out.println("Overlapping File Lock Error: " + e.getMessage()); >// release the lock lock.release(); // close the channel channel.close(); > catch (IOException e) < System.out.println("I/O Error: " + e.getMessage()); >> > This was an example of how to create a file lock on a file in Java using FileChannel.
Java NIO — FileLock
As we know that Java NIO supports concurrency and multi threading which enables it to deal with the multiple threads operating on multiple files at same time.But in some cases we require that our file would not get share by any of thread and get non accessible.
For such requirement NIO again provides an API known as FileLock which is used to provide lock over whole file or on a part of file,so that file or its part doesn’t get shared or accessible.
in order to provide or apply such lock we have to use FileChannel or AsynchronousFileChannel,which provides two methods lock() and tryLock()for this purpose.The lock provided may be of two types −
- Exclusive Lock − An exclusive lock prevents other programs from acquiring an overlapping lock of either type.
- Shared Lock − A shared lock prevents other concurrently-running programs from acquiring an overlapping exclusive lock, but does allow them to acquire overlapping shared locks.
Methods used for obtaining lock over file −
- lock() − This method of FileChannel or AsynchronousFileChannel acquires an exclusive lock over a file associated with the given channel.Return type of this method is FileLock which is further used for monitoring the obtained lock.
- lock(long position, long size, boolean shared) − This method again is the overloaded method of lock method and is used to lock a particular part of a file.
- tryLock() − This method return a FileLock or a null if the lock could not be acquired and it attempts to acquire an explicitly exclusive lock on this channel’s file.
- tryLock(long position, long size, boolean shared) − This method attempts to acquires a lock on the given region of this channel’s file which may be an exclusive or of shared type.
Methods of FileLock Class
- acquiredBy() − This method returns the channel on whose file lock was acquired.
- position() − This method returns the position within the file of the first byte of the locked region.A locked region need not be contained within, or even overlap, the actual underlying file, so the value returned by this method may exceed the file’s current size.
- size() − This method returns the size of the locked region in bytes.A locked region need not be contained within, or even overlap, the actual underlying file, so the value returned by this method may exceed the file’s current size.
- isShared() − This method is used to determine that whether lock is shared or not.
- overlaps(long position,long size) − This method tells whether or not this lock overlaps the given lock range.
- isValid() − This method tells whether or not the obtained lock is valid.A lock object remains valid until it is released or the associated file channel is closed, whichever comes first.
- release() − Releases the obtained lock.If the lock object is valid then invoking this method releases the lock and renders the object invalid. If this lock object is invalid then invoking this method has no effect.
- close() − This method invokes the release() method. It was added to the class so that it could be used in conjunction with the automatic resource management block construct.
Example to demonstrate file lock.
Following example create lock over a file and write content to it
package com.java.nio; import java.io.IOException; import java.nio.ByteBuffer; import java.nio.channels.FileChannel; import java.nio.channels.FileLock; import java.nio.file.Path; import java.nio.file.Paths; import java.nio.file.StandardOpenOption; public class FileLockExample < public static void main(String[] args) throws IOException < String input = "Demo text to be written in locked mode."; System.out.println("Input string to the test file is: " + input); ByteBuffer buf = ByteBuffer.wrap(input.getBytes()); String fp = "D:file.txt"; Path pt = Paths.get(fp); FileChannel channel = FileChannel.open(pt, StandardOpenOption.WRITE,StandardOpenOption.APPEND); channel.position(channel.size() - 1); // position of a cursor at the end of file FileLock lock = channel.lock(); System.out.println("The Lock is shared: " + lock.isShared()); channel.write(buf); channel.close(); // Releases the Lock System.out.println("Content Writing is complete. Therefore close the channel and release the lock."); PrintFileCreated.print(fp); >> package com.java.nio; import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; public class PrintFileCreated < public static void print(String path) throws IOException < FileReader filereader = new FileReader(path); BufferedReader bufferedreader = new BufferedReader(filereader); String tr = bufferedreader.readLine(); System.out.println("The Content of testout.txt file is: "); while (tr != null) < System.out.println(" " + tr); tr = bufferedreader.readLine(); >filereader.close(); bufferedreader.close(); > > Output
Input string to the test file is: Demo text to be written in locked mode. The Lock is shared: false Content Writing is complete. Therefore close the channel and release the lock. The Content of testout.txt file is: To be or not to be?Demo text to be written in locked mode.