1 /*

     2  * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package java.nio.channels.spi;

    27 

    28 import java.io.IOException;

    29 import java.nio.channels.*;

    30 

    31 

    32 /**

    33  * Base implementation class for selectable channels.

    34  *

    35  * <p> This class defines methods that handle the mechanics of channel

    36  * registration, deregistration, and closing.  It maintains the current

    37  * blocking mode of this channel as well as its current set of selection keys.

    38  * It performs all of the synchronization required to implement the {@link

    39  * java.nio.channels.SelectableChannel} specification.  Implementations of the

    40  * abstract protected methods defined in this class need not synchronize

    41  * against other threads that might be engaged in the same operations.  </p>

    42  *

    43  *

    44  * @author Mark Reinhold

    45  * @author Mike McCloskey

    46  * @author JSR-51 Expert Group

    47  * @since 1.4

    48  */

    49 

    50 public abstract class AbstractSelectableChannel

    51     extends SelectableChannel

    52 {

    53 

    54     // The provider that created this channel

    55     private final SelectorProvider provider;

    56 

    57     // Keys that have been created by registering this channel with selectors.

    58     // They are saved because if this channel is closed the keys must be

    59     // deregistered.  Protected by keyLock.

    60     //

    61     private SelectionKey[] keys = null;

    62     private int keyCount = 0;

    63 

    64     // Lock for key set and count

    65     private final Object keyLock = new Object();

    66 

    67     // Lock for registration and configureBlocking operations

    68     private final Object regLock = new Object();

    69 

    70     // Blocking mode, protected by regLock

    71     boolean blocking = true;

    72 

    73     /**

    74      * Initializes a new instance of this class.

    75      *

    76      * @param  provider

    77      *         The provider that created this channel

    78      */

    79     protected AbstractSelectableChannel(SelectorProvider provider) {

    80         this.provider = provider;

    81     }

    82 

    83     /**

    84      * Returns the provider that created this channel.

    85      *

    86      * @return  The provider that created this channel

    87      */

    88     public final SelectorProvider provider() {

    89         return provider;

    90     }

    91 

    92 

    93     // -- Utility methods for the key set --

    94 

    95     private void addKey(SelectionKey k) {

    96         assert Thread.holdsLock(keyLock);

    97         int i = 0;

    98         if ((keys != null) && (keyCount < keys.length)) {

    99             // Find empty element of key array

   100             for (i = 0; i < keys.length; i++)

   101                 if (keys[i] == null)

   102                     break;

   103         } else if (keys == null) {

   104             keys =  new SelectionKey[3];

   105         } else {

   106             // Grow key array

   107             int n = keys.length * 2;

   108             SelectionKey[] ks =  new SelectionKey[n];

   109             for (i = 0; i < keys.length; i++)

   110                 ks[i] = keys[i];

   111             keys = ks;

   112             i = keyCount;

   113         }

   114         keys[i] = k;

   115         keyCount++;

   116     }

   117 

   118     private SelectionKey findKey(Selector sel) {

   119         synchronized (keyLock) {

   120             if (keys == null)

   121                 return null;

   122             for (int i = 0; i < keys.length; i++)

   123                 if ((keys[i] != null) && (keys[i].selector() == sel))

   124                     return keys[i];

   125             return null;

   126         }

   127     }

   128 

   129     void removeKey(SelectionKey k) {                    // package-private

   130         synchronized (keyLock) {

   131             for (int i = 0; i < keys.length; i++)

   132                 if (keys[i] == k) {

   133                     keys[i] = null;

   134                     keyCount--;

   135                 }

   136             ((AbstractSelectionKey)k).invalidate();

   137         }

   138     }

   139 

   140     private boolean haveValidKeys() {

   141         synchronized (keyLock) {

   142             if (keyCount == 0)

   143                 return false;

   144             for (int i = 0; i < keys.length; i++) {

   145                 if ((keys[i] != null) && keys[i].isValid())

   146                     return true;

   147             }

   148             return false;

   149         }

   150     }

   151 

   152 

   153     // -- Registration --

   154 

   155     public final boolean isRegistered() {

   156         synchronized (keyLock) {

   157             return keyCount != 0;

   158         }

   159     }

   160 

   161     public final SelectionKey keyFor(Selector sel) {

   162         return findKey(sel);

   163     }

   164 

   165     /**

   166      * Registers this channel with the given selector, returning a selection key.

   167      *

   168      * <p>  This method first verifies that this channel is open and that the

   169      * given initial interest set is valid.

   170      *

   171      * <p> If this channel is already registered with the given selector then

   172      * the selection key representing that registration is returned after

   173      * setting its interest set to the given value.

   174      *

   175      * <p> Otherwise this channel has not yet been registered with the given

   176      * selector, so the {@link AbstractSelector#register register} method of

   177      * the selector is invoked while holding the appropriate locks.  The

   178      * resulting key is added to this channel's key set before being returned.

   179      * </p>

   180      *

   181      * @throws  ClosedSelectorException {@inheritDoc}

   182      *

   183      * @throws  IllegalBlockingModeException {@inheritDoc}

   184      *

   185      * @throws  IllegalSelectorException {@inheritDoc}

   186      *

   187      * @throws  CancelledKeyException {@inheritDoc}

   188      *

   189      * @throws  IllegalArgumentException {@inheritDoc}

   190      */

   191     public final SelectionKey register(Selector sel, int ops,

   192                                        Object att)

   193         throws ClosedChannelException

   194     {

   195         synchronized (regLock) {

   196             if (!isOpen())

   197                 throw new ClosedChannelException();

   198             if ((ops & ~validOps()) != 0)

   199                 throw new IllegalArgumentException();

   200             if (blocking)

   201                 throw new IllegalBlockingModeException();

   202             SelectionKey k = findKey(sel);

   203             if (k != null) {

   204                 k.interestOps(ops);

   205                 k.attach(att);

   206             }

   207             if (k == null) {

   208                 // New registration

   209                 synchronized (keyLock) {

   210                     if (!isOpen())

   211                         throw new ClosedChannelException();

   212                     k = ((AbstractSelector)sel).register(this, ops, att);

   213                     addKey(k);

   214                 }

   215             }

   216             return k;

   217         }

   218     }

   219 

   220 

   221     // -- Closing --

   222 

   223     /**

   224      * Closes this channel.

   225      *

   226      * <p> This method, which is specified in the {@link

   227      * AbstractInterruptibleChannel} class and is invoked by the {@link

   228      * java.nio.channels.Channel#close close} method, in turn invokes the

   229      * {@link #implCloseSelectableChannel implCloseSelectableChannel} method in

   230      * order to perform the actual work of closing this channel.  It then

   231      * cancels all of this channel's keys.  </p>

   232      */

   233     protected final void implCloseChannel() throws IOException {

   234         implCloseSelectableChannel();

   235         synchronized (keyLock) {

   236             int count = (keys == null) ? 0 : keys.length;

   237             for (int i = 0; i < count; i++) {

   238                 SelectionKey k = keys[i];

   239                 if (k != null)

   240                     k.cancel();

   241             }

   242         }

   243     }

   244 

   245     /**

   246      * Closes this selectable channel.

   247      *

   248      * <p> This method is invoked by the {@link java.nio.channels.Channel#close

   249      * close} method in order to perform the actual work of closing the

   250      * channel.  This method is only invoked if the channel has not yet been

   251      * closed, and it is never invoked more than once.

   252      *

   253      * <p> An implementation of this method must arrange for any other thread

   254      * that is blocked in an I/O operation upon this channel to return

   255      * immediately, either by throwing an exception or by returning normally.

   256      * </p>

   257      *

   258      * @throws  IOException

   259      *          If an I/O error occurs

   260      */

   261     protected abstract void implCloseSelectableChannel() throws IOException;

   262 

   263 

   264     // -- Blocking --

   265 

   266     public final boolean isBlocking() {

   267         synchronized (regLock) {

   268             return blocking;

   269         }

   270     }

   271 

   272     public final Object blockingLock() {

   273         return regLock;

   274     }

   275 

   276     /**

   277      * Adjusts this channel's blocking mode.

   278      *

   279      * <p> If the given blocking mode is different from the current blocking

   280      * mode then this method invokes the {@link #implConfigureBlocking

   281      * implConfigureBlocking} method, while holding the appropriate locks, in

   282      * order to change the mode.  </p>

   283      */

   284     public final SelectableChannel configureBlocking(boolean block)

   285         throws IOException

   286     {

   287         synchronized (regLock) {

   288             if (!isOpen())

   289                 throw new ClosedChannelException();

   290             if (blocking == block)

   291                 return this;

   292             if (block && haveValidKeys())

   293                 throw new IllegalBlockingModeException();

   294             implConfigureBlocking(block);

   295             blocking = block;

   296         }

   297         return this;

   298     }

   299 

   300     /**

   301      * Adjusts this channel's blocking mode.

   302      *

   303      * <p> This method is invoked by the {@link #configureBlocking

   304      * configureBlocking} method in order to perform the actual work of

   305      * changing the blocking mode.  This method is only invoked if the new mode

   306      * is different from the current mode.  </p>

   307      *

   308      * @param  block  If {@code true} then this channel will be placed in

   309      *                blocking mode; if {@code false} then it will be placed

   310      *                non-blocking mode

   311      *

   312      * @throws IOException

   313      *         If an I/O error occurs

   314      */

   315     protected abstract void implConfigureBlocking(boolean block)

   316         throws IOException;

   317 

   318 }