Back to index...

	/*
	* Copyright (c) 2008, 2009, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package sun.nio.ch;

	import java.nio.ByteBuffer;
	import java.nio.channels.*;
	import java.util.concurrent.ExecutorService;
	import java.util.concurrent.Future;
	import java.util.concurrent.locks.*;
	import java.io.FileDescriptor;
	import java.io.IOException;

	/**
	* Base implementation of AsynchronousFileChannel.
	*/

	abstract class AsynchronousFileChannelImpl
	extends AsynchronousFileChannel
	{
	// close support
	protected final ReadWriteLock closeLock = new ReentrantReadWriteLock();
	protected volatile boolean closed;

	// file descriptor
	protected final FileDescriptor fdObj;

	// indicates if open for reading/writing
	protected final boolean reading;
	protected final boolean writing;

	// associated Executor
	protected final ExecutorService executor;

	protected AsynchronousFileChannelImpl(FileDescriptor fdObj,
	boolean reading,
	boolean writing,
	ExecutorService executor)
	{
	this.fdObj = fdObj;
	this.reading = reading;
	this.writing = writing;
	this.executor = executor;
	}

	final ExecutorService executor() {
	return executor;
	}

	@Override
	public final boolean isOpen() {
	return !closed;
	}

	/**
	* Marks the beginning of an I/O operation.
	*
	* @throws ClosedChannelException If channel is closed
	*/
	protected final void begin() throws IOException {
	closeLock.readLock().lock();
	if (closed)
	throw new ClosedChannelException();
	}

	/**
	* Marks the end of an I/O operation.
	*/
	protected final void end() {
	closeLock.readLock().unlock();
	}

	/**
	* Marks end of I/O operation
	*/
	protected final void end(boolean completed) throws IOException {
	end();
	if (!completed && !isOpen())
	throw new AsynchronousCloseException();
	}

	// -- file locking --

	abstract <A> Future<FileLock> implLock(long position,
	long size,
	boolean shared,
	A attachment,
	CompletionHandler<FileLock,? super A> handler);

	@Override
	public final Future<FileLock> lock(long position,
	long size,
	boolean shared)

	{
	return implLock(position, size, shared, null, null);
	}

	@Override
	public final <A> void lock(long position,
	long size,
	boolean shared,
	A attachment,
	CompletionHandler<FileLock,? super A> handler)
	{
	if (handler == null)
	throw new NullPointerException("'handler' is null");
	implLock(position, size, shared, attachment, handler);
	}

	private volatile FileLockTable fileLockTable;

	final void ensureFileLockTableInitialized() throws IOException {
	if (fileLockTable == null) {
	synchronized (this) {
	if (fileLockTable == null) {
	fileLockTable = FileLockTable.newSharedFileLockTable(this, fdObj);
	}
	}
	}
	}

	final void invalidateAllLocks() throws IOException {
	if (fileLockTable != null) {
	for (FileLock fl: fileLockTable.removeAll()) {
	synchronized (fl) {
	if (fl.isValid()) {
	FileLockImpl fli = (FileLockImpl)fl;
	implRelease(fli);
	fli.invalidate();
	}
	}
	}
	}
	}

	/**
	* Adds region to lock table
	*/
	protected final FileLockImpl addToFileLockTable(long position, long size, boolean shared) {
	final FileLockImpl fli;
	try {
	// like begin() but returns null instead of exception
	closeLock.readLock().lock();
	if (closed)
	return null;

	try {
	ensureFileLockTableInitialized();
	} catch (IOException x) {
	// should not happen
	throw new AssertionError(x);
	}
	fli = new FileLockImpl(this, position, size, shared);
	// may throw OverlappedFileLockException
	fileLockTable.add(fli);
	} finally {
	end();
	}
	return fli;
	}

	protected final void removeFromFileLockTable(FileLockImpl fli) {
	fileLockTable.remove(fli);
	}

	/**
	* Releases the given file lock.
	*/
	protected abstract void implRelease(FileLockImpl fli) throws IOException;

	/**
	* Invoked by FileLockImpl to release the given file lock and remove it
	* from the lock table.
	*/
	final void release(FileLockImpl fli) throws IOException {
	try {
	begin();
	implRelease(fli);
	removeFromFileLockTable(fli);
	} finally {
	end();
	}
	}


	// -- reading and writing --

	abstract <A> Future<Integer> implRead(ByteBuffer dst,
	long position,
	A attachment,
	CompletionHandler<Integer,? super A> handler);

	@Override
	public final Future<Integer> read(ByteBuffer dst, long position) {
	return implRead(dst, position, null, null);
	}

	@Override
	public final <A> void read(ByteBuffer dst,
	long position,
	A attachment,
	CompletionHandler<Integer,? super A> handler)
	{
	if (handler == null)
	throw new NullPointerException("'handler' is null");
	implRead(dst, position, attachment, handler);
	}

	abstract <A> Future<Integer> implWrite(ByteBuffer src,
	long position,
	A attachment,
	CompletionHandler<Integer,? super A> handler);


	@Override
	public final Future<Integer> write(ByteBuffer src, long position) {
	return implWrite(src, position, null, null);
	}

	@Override
	public final <A> void write(ByteBuffer src,
	long position,
	A attachment,
	CompletionHandler<Integer,? super A> handler)
	{
	if (handler == null)
	throw new NullPointerException("'handler' is null");
	implWrite(src, position, attachment, handler);
	}
	}

Back to index...