1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193
/* * Copyright 2006 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ /* * @(#)AbstractInterruptibleChannel.java 1.17 05/11/17 */ package java.nio.channels.spi; import java.io.IOException; import java.lang.reflect.Method; import java.lang.reflect.InvocationTargetException; import java.nio.channels.*; import java.security.AccessController; import java.security.PrivilegedAction; import sun.nio.ch.Interruptible; /** * Base implementation class for interruptible channels. * * <p> This class encapsulates the low-level machinery required to implement * the asynchronous closing and interruption of channels. A concrete channel * class must invoke the {@link #begin begin} and {@link #end end} methods * before and after, respectively, invoking an I/O operation that might block * indefinitely. In order to ensure that the {@link #end end} method is always * invoked, these methods should be used within a * <tt>try</tt> ... <tt>finally</tt> block: <a name="be"> * * <blockquote><pre> * boolean completed = false; * try { * begin(); * completed = ...; // Perform blocking I/O operation * return ...; // Return result * } finally { * end(completed); * }</pre></blockquote> * * <p> The <tt>completed</tt> argument to the {@link #end end} method tells * whether or not the I/O operation actually completed, that is, whether it had * any effect that would be visible to the invoker. In the case of an * operation that reads bytes, for example, this argument should be * <tt>true</tt> if, and only if, some bytes were actually transferred into the * invoker's target buffer. * * <p> A concrete channel class must also implement the {@link * #implCloseChannel implCloseChannel} method in such a way that if it is * invoked while another thread is blocked in a native I/O operation upon the * channel then that operation will immediately return, either by throwing an * exception or by returning normally. If a thread is interrupted or the * channel upon which it is blocked is asynchronously closed then the channel's * {@link #end end} method will throw the appropriate exception. * * <p> This class performs the synchronization required to implement the {@link * java.nio.channels.Channel} specification. Implementations of the {@link * #implCloseChannel implCloseChannel} method need not synchronize against * other threads that might be attempting to close the channel. </p> * * * @author Mark Reinhold * @author JSR-51 Expert Group * @version 1.17, 05/11/17 * @since 1.4 */ public abstract class AbstractInterruptibleChannel implements Channel, InterruptibleChannel { private Object closeLock = new Object(); private volatile boolean open = true; /** * Initializes a new instance of this class. */ protected AbstractInterruptibleChannel() { } /** * Closes this channel. * * <p> If the channel has already been closed then this method returns * immediately. Otherwise it marks the channel as closed and then invokes * the {@link #implCloseChannel implCloseChannel} method in order to * complete the close operation. </p> * * @throws IOException * If an I/O error occurs */ public final void close() throws IOException { synchronized (closeLock) { if (!open) return; open = false; implCloseChannel(); } } /** * Closes this channel. * * <p> This method is invoked by the {@link #close close} method in order * to perform the actual work of closing the channel. This method is only * invoked if the channel has not yet been closed, and it is never invoked * more than once. * * <p> An implementation of this method must arrange for any other thread * that is blocked in an I/O operation upon this channel to return * immediately, either by throwing an exception or by returning normally. * </p> * * @throws IOException * If an I/O error occurs while closing the channel */ protected abstract void implCloseChannel() throws IOException; public final boolean isOpen() { return open; } // -- Interruption machinery -- private Interruptible interruptor; private volatile boolean interrupted = false; /** * Marks the beginning of an I/O operation that might block indefinitely. * * <p> This method should be invoked in tandem with the {@link #end end} * method, using a <tt>try</tt> ... <tt>finally</tt> block as * shown <a href="#be">above</a>, in order to implement asynchronous * closing and interruption for this channel. </p> */ protected final void begin() { if (interruptor == null) { interruptor = new Interruptible() { public void interrupt() { synchronized (closeLock) { if (!open) return; interrupted = true; open = false; try { AbstractInterruptibleChannel.this.implCloseChannel(); } catch (IOException x) { } } }}; } blockedOn(interruptor); if (Thread.currentThread().isInterrupted()) interruptor.interrupt(); } /** * Marks the end of an I/O operation that might block indefinitely. * * <p> This method should be invoked in tandem with the {@link #begin * begin} method, using a <tt>try</tt> ... <tt>finally</tt> block * as shown <a href="#be">above</a>, in order to implement asynchronous * closing and interruption for this channel. </p> * * @param completed * <tt>true</tt> if, and only if, the I/O operation completed * successfully, that is, had some effect that would be visible to * the operation's invoker * * @throws AsynchronousCloseException * If the channel was asynchronously closed * * @throws ClosedByInterruptException * If the thread blocked in the I/O operation was interrupted */ protected final void end(boolean completed) throws AsynchronousCloseException { blockedOn(null); if (completed) { interrupted = false; return; } if (interrupted) throw new ClosedByInterruptException(); if (!open) throw new AsynchronousCloseException(); } // -- sun.misc.SharedSecrets -- static void blockedOn(Interruptible intr) { // package-private sun.misc.SharedSecrets.getJavaLangAccess().blockedOn(Thread.currentThread(), intr); } }