Android APIs
public abstract class

FileLock

extends Object
implements AutoCloseable
java.lang.Object
   ↳ java.nio.channels.FileLock

Class Overview

A FileLock represents a locked region of a file.

Locks have certain properties that enable collaborating processes to avoid the lost update problem or reading inconsistent data. Logically, a file lock can be exclusive or shared. Multiple processes can hold shared locks on the same region of a file, but only a single process can hold an exclusive lock on a given region of a file and no other process can simultaneously hold a shared lock overlapping the exclusive lock. An application can determine whether a FileLock is shared or exclusive via the isShared() method.

Locks held by a particular process cannot overlap one another. Applications can determine whether a proposed lock will overlap by using the overlaps(long, long)) method. Locks held in other processes may overlap locks held in this process. Locks are shared amongst all threads in the acquiring process, and are therefore unsuitable for intra-process synchronization.

Once a lock is acquired, it is immutable in all its state except isValid(). The lock will initially be valid, but may be rendered invalid by explicit removal of the lock, using release(), or implicitly by closing the channel or exiting the process (terminating the VM).

Platform dependencies

Locks are intended to be true platform operating system file locks, and therefore locks held by the VM will be visible to other operating system processes.

The characteristics of the underlying operating system locks will show through in the Java implementation. For example, some platforms' locks are 'mandatory' -- meaning the operating system enforces the locks on processes that attempt to access locked regions of files; whereas other platforms' locks are only 'advisory' -- meaning that processes are required to collaborate to ensure locks are acquired and there is a potential for processes to not play well. To be on the safe side, it is best to assume that the platform is adopting advisory locks and always acquire shared locks when reading a region of a file.

On some platforms, the presence of a lock will prevent the file from being memory-mapped. On some platforms, closing a channel on a given file handle will release all the locks held on that file -- even if there are other channels open on the same file; their locks will also be released. The safe option here is to ensure that you only acquire locks on a single channel for a particular file and that becomes the synchronization point.

Further care should be exercised when locking files maintained on network file systems, since they often have further limitations.

Summary

Protected Constructors
FileLock(FileChannel channel, long position, long size, boolean shared)
Constructs a new file lock instance for a given channel.
Public Methods
final FileChannel channel()
Returns the lock's FileChannel.
final void close()
Calls release() for AutoCloseable.
final boolean isShared()
Indicates if the file lock is shared with other processes or if it is exclusive.
abstract boolean isValid()
Indicates whether this lock is a valid file lock.
final boolean overlaps(long start, long length)
Indicates if the receiver's lock region overlaps the region described in the parameter list.
final long position()
Returns the lock's starting position in the file.
abstract void release()
Releases this particular lock on the file.
final long size()
Returns the length of the file lock in bytes.
final String toString()
Returns a string that shows the details of the lock suitable for debugging.
[Expand]
Inherited Methods
From class java.lang.Object
From interface java.lang.AutoCloseable

Protected Constructors

protected FileLock (FileChannel channel, long position, long size, boolean shared)

Added in API level 1

Constructs a new file lock instance for a given channel. The constructor enforces the starting position, length and sharing mode of the lock.

Parameters
channel the underlying file channel that holds the lock.
position the starting point for the lock.
size the length of the lock in number of bytes.
shared the lock's sharing mode of lock; true is shared, false is exclusive.

Public Methods

public final FileChannel channel ()

Added in API level 1

Returns the lock's FileChannel.

Returns
  • the channel.

public final void close ()

Added in API level 19

Calls release() for AutoCloseable.

Throws
IOException

public final boolean isShared ()

Added in API level 1

Indicates if the file lock is shared with other processes or if it is exclusive.

Returns
  • true if the lock is a shared lock, false if it is exclusive.

public abstract boolean isValid ()

Added in API level 1

Indicates whether this lock is a valid file lock. The lock is valid unless the underlying channel has been closed or it has been explicitly released.

Returns
  • true if the lock is valid, false otherwise.

public final boolean overlaps (long start, long length)

Added in API level 1

Indicates if the receiver's lock region overlaps the region described in the parameter list.

Parameters
start the starting position for the comparative lock.
length the length of the comparative lock.
Returns
  • true if there is an overlap, false otherwise.

public final long position ()

Added in API level 1

Returns the lock's starting position in the file.

Returns
  • the lock position.

public abstract void release ()

Added in API level 1

Releases this particular lock on the file. If the lock is invalid then this method has no effect. Once released, the lock becomes invalid.

Throws
ClosedChannelException if the channel is already closed when an attempt to release the lock is made.
IOException if another I/O error occurs.

public final long size ()

Added in API level 1

Returns the length of the file lock in bytes.

Returns
  • the size of the file lock in bytes.

public final String toString ()

Added in API level 1

Returns a string that shows the details of the lock suitable for debugging.

Returns
  • a printable representation of this object.