src/java.base/share/classes/java/nio/channels/spi/AbstractSelectableChannel.java
author alanb
Wed, 18 Apr 2018 10:20:09 +0100
changeset 49802 8ac08fa69f00
parent 48761 74c1fa26435a
child 59146 455612b3161a
permissions -rw-r--r--
8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress Reviewed-by: bpb
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     1
/*
48761
74c1fa26435a 8196956: (ch) More channels cleanup
alanb
parents: 47216
diff changeset
     2
 * Copyright (c) 2000, 2018, Oracle and/or its affiliates. All rights reserved.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
90ce3da70b43 Initial load
duke
parents:
diff changeset
     4
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
90ce3da70b43 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 1639
diff changeset
     7
 * published by the Free Software Foundation.  Oracle designates this
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     8
 * particular file as subject to the "Classpath" exception as provided
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 1639
diff changeset
     9
 * by Oracle in the LICENSE file that accompanied this code.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    10
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    11
 * This code is distributed in the hope that it will be useful, but WITHOUT
90ce3da70b43 Initial load
duke
parents:
diff changeset
    12
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
90ce3da70b43 Initial load
duke
parents:
diff changeset
    13
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
90ce3da70b43 Initial load
duke
parents:
diff changeset
    14
 * version 2 for more details (a copy is included in the LICENSE file that
90ce3da70b43 Initial load
duke
parents:
diff changeset
    15
 * accompanied this code).
90ce3da70b43 Initial load
duke
parents:
diff changeset
    16
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    17
 * You should have received a copy of the GNU General Public License version
90ce3da70b43 Initial load
duke
parents:
diff changeset
    18
 * 2 along with this work; if not, write to the Free Software Foundation,
90ce3da70b43 Initial load
duke
parents:
diff changeset
    19
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    20
 *
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 1639
diff changeset
    21
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 1639
diff changeset
    22
 * or visit www.oracle.com if you need additional information or have any
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 1639
diff changeset
    23
 * questions.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    24
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    25
90ce3da70b43 Initial load
duke
parents:
diff changeset
    26
package java.nio.channels.spi;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    27
90ce3da70b43 Initial load
duke
parents:
diff changeset
    28
import java.io.IOException;
48761
74c1fa26435a 8196956: (ch) More channels cleanup
alanb
parents: 47216
diff changeset
    29
import java.nio.channels.CancelledKeyException;
74c1fa26435a 8196956: (ch) More channels cleanup
alanb
parents: 47216
diff changeset
    30
import java.nio.channels.ClosedChannelException;
74c1fa26435a 8196956: (ch) More channels cleanup
alanb
parents: 47216
diff changeset
    31
import java.nio.channels.ClosedSelectorException;
74c1fa26435a 8196956: (ch) More channels cleanup
alanb
parents: 47216
diff changeset
    32
import java.nio.channels.IllegalBlockingModeException;
74c1fa26435a 8196956: (ch) More channels cleanup
alanb
parents: 47216
diff changeset
    33
import java.nio.channels.IllegalSelectorException;
74c1fa26435a 8196956: (ch) More channels cleanup
alanb
parents: 47216
diff changeset
    34
import java.nio.channels.SelectableChannel;
74c1fa26435a 8196956: (ch) More channels cleanup
alanb
parents: 47216
diff changeset
    35
import java.nio.channels.SelectionKey;
74c1fa26435a 8196956: (ch) More channels cleanup
alanb
parents: 47216
diff changeset
    36
import java.nio.channels.Selector;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    37
90ce3da70b43 Initial load
duke
parents:
diff changeset
    38
90ce3da70b43 Initial load
duke
parents:
diff changeset
    39
/**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    40
 * Base implementation class for selectable channels.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    41
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    42
 * <p> This class defines methods that handle the mechanics of channel
90ce3da70b43 Initial load
duke
parents:
diff changeset
    43
 * registration, deregistration, and closing.  It maintains the current
90ce3da70b43 Initial load
duke
parents:
diff changeset
    44
 * blocking mode of this channel as well as its current set of selection keys.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    45
 * It performs all of the synchronization required to implement the {@link
90ce3da70b43 Initial load
duke
parents:
diff changeset
    46
 * java.nio.channels.SelectableChannel} specification.  Implementations of the
90ce3da70b43 Initial load
duke
parents:
diff changeset
    47
 * abstract protected methods defined in this class need not synchronize
90ce3da70b43 Initial load
duke
parents:
diff changeset
    48
 * against other threads that might be engaged in the same operations.  </p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    49
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    50
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    51
 * @author Mark Reinhold
90ce3da70b43 Initial load
duke
parents:
diff changeset
    52
 * @author Mike McCloskey
90ce3da70b43 Initial load
duke
parents:
diff changeset
    53
 * @author JSR-51 Expert Group
90ce3da70b43 Initial load
duke
parents:
diff changeset
    54
 * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
    55
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    56
90ce3da70b43 Initial load
duke
parents:
diff changeset
    57
public abstract class AbstractSelectableChannel
90ce3da70b43 Initial load
duke
parents:
diff changeset
    58
    extends SelectableChannel
90ce3da70b43 Initial load
duke
parents:
diff changeset
    59
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
    60
90ce3da70b43 Initial load
duke
parents:
diff changeset
    61
    // The provider that created this channel
90ce3da70b43 Initial load
duke
parents:
diff changeset
    62
    private final SelectorProvider provider;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    63
90ce3da70b43 Initial load
duke
parents:
diff changeset
    64
    // Keys that have been created by registering this channel with selectors.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    65
    // They are saved because if this channel is closed the keys must be
90ce3da70b43 Initial load
duke
parents:
diff changeset
    66
    // deregistered.  Protected by keyLock.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    67
    //
90ce3da70b43 Initial load
duke
parents:
diff changeset
    68
    private SelectionKey[] keys = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    69
    private int keyCount = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    70
90ce3da70b43 Initial load
duke
parents:
diff changeset
    71
    // Lock for key set and count
90ce3da70b43 Initial load
duke
parents:
diff changeset
    72
    private final Object keyLock = new Object();
90ce3da70b43 Initial load
duke
parents:
diff changeset
    73
90ce3da70b43 Initial load
duke
parents:
diff changeset
    74
    // Lock for registration and configureBlocking operations
90ce3da70b43 Initial load
duke
parents:
diff changeset
    75
    private final Object regLock = new Object();
90ce3da70b43 Initial load
duke
parents:
diff changeset
    76
48761
74c1fa26435a 8196956: (ch) More channels cleanup
alanb
parents: 47216
diff changeset
    77
    // True when non-blocking, need regLock to change;
74c1fa26435a 8196956: (ch) More channels cleanup
alanb
parents: 47216
diff changeset
    78
    private volatile boolean nonBlocking;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    79
90ce3da70b43 Initial load
duke
parents:
diff changeset
    80
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    81
     * Initializes a new instance of this class.
18574
4aeaeb541678 8019380: doclint warnings in java.nio, java.nio.file.**, java.nio.channels.**
alanb
parents: 14342
diff changeset
    82
     *
4aeaeb541678 8019380: doclint warnings in java.nio, java.nio.file.**, java.nio.channels.**
alanb
parents: 14342
diff changeset
    83
     * @param  provider
4aeaeb541678 8019380: doclint warnings in java.nio, java.nio.file.**, java.nio.channels.**
alanb
parents: 14342
diff changeset
    84
     *         The provider that created this channel
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    85
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    86
    protected AbstractSelectableChannel(SelectorProvider provider) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    87
        this.provider = provider;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    88
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
    89
90ce3da70b43 Initial load
duke
parents:
diff changeset
    90
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    91
     * Returns the provider that created this channel.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    92
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    93
     * @return  The provider that created this channel
90ce3da70b43 Initial load
duke
parents:
diff changeset
    94
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    95
    public final SelectorProvider provider() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    96
        return provider;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    97
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
    98
90ce3da70b43 Initial load
duke
parents:
diff changeset
    99
90ce3da70b43 Initial load
duke
parents:
diff changeset
   100
    // -- Utility methods for the key set --
90ce3da70b43 Initial load
duke
parents:
diff changeset
   101
90ce3da70b43 Initial load
duke
parents:
diff changeset
   102
    private void addKey(SelectionKey k) {
13582
16f0af616ea0 7132889: (se) AbstractSelectableChannel.register and configureBlocking not safe from asynchronous close
alanb
parents: 5506
diff changeset
   103
        assert Thread.holdsLock(keyLock);
16f0af616ea0 7132889: (se) AbstractSelectableChannel.register and configureBlocking not safe from asynchronous close
alanb
parents: 5506
diff changeset
   104
        int i = 0;
16f0af616ea0 7132889: (se) AbstractSelectableChannel.register and configureBlocking not safe from asynchronous close
alanb
parents: 5506
diff changeset
   105
        if ((keys != null) && (keyCount < keys.length)) {
16f0af616ea0 7132889: (se) AbstractSelectableChannel.register and configureBlocking not safe from asynchronous close
alanb
parents: 5506
diff changeset
   106
            // Find empty element of key array
16f0af616ea0 7132889: (se) AbstractSelectableChannel.register and configureBlocking not safe from asynchronous close
alanb
parents: 5506
diff changeset
   107
            for (i = 0; i < keys.length; i++)
16f0af616ea0 7132889: (se) AbstractSelectableChannel.register and configureBlocking not safe from asynchronous close
alanb
parents: 5506
diff changeset
   108
                if (keys[i] == null)
16f0af616ea0 7132889: (se) AbstractSelectableChannel.register and configureBlocking not safe from asynchronous close
alanb
parents: 5506
diff changeset
   109
                    break;
16f0af616ea0 7132889: (se) AbstractSelectableChannel.register and configureBlocking not safe from asynchronous close
alanb
parents: 5506
diff changeset
   110
        } else if (keys == null) {
49802
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   111
            keys = new SelectionKey[2];
13582
16f0af616ea0 7132889: (se) AbstractSelectableChannel.register and configureBlocking not safe from asynchronous close
alanb
parents: 5506
diff changeset
   112
        } else {
16f0af616ea0 7132889: (se) AbstractSelectableChannel.register and configureBlocking not safe from asynchronous close
alanb
parents: 5506
diff changeset
   113
            // Grow key array
16f0af616ea0 7132889: (se) AbstractSelectableChannel.register and configureBlocking not safe from asynchronous close
alanb
parents: 5506
diff changeset
   114
            int n = keys.length * 2;
16f0af616ea0 7132889: (se) AbstractSelectableChannel.register and configureBlocking not safe from asynchronous close
alanb
parents: 5506
diff changeset
   115
            SelectionKey[] ks =  new SelectionKey[n];
16f0af616ea0 7132889: (se) AbstractSelectableChannel.register and configureBlocking not safe from asynchronous close
alanb
parents: 5506
diff changeset
   116
            for (i = 0; i < keys.length; i++)
16f0af616ea0 7132889: (se) AbstractSelectableChannel.register and configureBlocking not safe from asynchronous close
alanb
parents: 5506
diff changeset
   117
                ks[i] = keys[i];
16f0af616ea0 7132889: (se) AbstractSelectableChannel.register and configureBlocking not safe from asynchronous close
alanb
parents: 5506
diff changeset
   118
            keys = ks;
16f0af616ea0 7132889: (se) AbstractSelectableChannel.register and configureBlocking not safe from asynchronous close
alanb
parents: 5506
diff changeset
   119
            i = keyCount;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   120
        }
13582
16f0af616ea0 7132889: (se) AbstractSelectableChannel.register and configureBlocking not safe from asynchronous close
alanb
parents: 5506
diff changeset
   121
        keys[i] = k;
16f0af616ea0 7132889: (se) AbstractSelectableChannel.register and configureBlocking not safe from asynchronous close
alanb
parents: 5506
diff changeset
   122
        keyCount++;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   123
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   124
90ce3da70b43 Initial load
duke
parents:
diff changeset
   125
    private SelectionKey findKey(Selector sel) {
49802
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   126
        assert Thread.holdsLock(keyLock);
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   127
        if (keys == null)
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   128
            return null;
49802
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   129
        for (int i = 0; i < keys.length; i++)
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   130
            if ((keys[i] != null) && (keys[i].selector() == sel))
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   131
                return keys[i];
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   132
        return null;
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   133
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   134
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   135
90ce3da70b43 Initial load
duke
parents:
diff changeset
   136
    void removeKey(SelectionKey k) {                    // package-private
90ce3da70b43 Initial load
duke
parents:
diff changeset
   137
        synchronized (keyLock) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   138
            for (int i = 0; i < keys.length; i++)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   139
                if (keys[i] == k) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   140
                    keys[i] = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   141
                    keyCount--;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   142
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   143
            ((AbstractSelectionKey)k).invalidate();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   144
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   145
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   146
90ce3da70b43 Initial load
duke
parents:
diff changeset
   147
    private boolean haveValidKeys() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   148
        synchronized (keyLock) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   149
            if (keyCount == 0)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   150
                return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   151
            for (int i = 0; i < keys.length; i++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   152
                if ((keys[i] != null) && keys[i].isValid())
90ce3da70b43 Initial load
duke
parents:
diff changeset
   153
                    return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   154
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   155
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   156
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   157
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   158
90ce3da70b43 Initial load
duke
parents:
diff changeset
   159
90ce3da70b43 Initial load
duke
parents:
diff changeset
   160
    // -- Registration --
90ce3da70b43 Initial load
duke
parents:
diff changeset
   161
90ce3da70b43 Initial load
duke
parents:
diff changeset
   162
    public final boolean isRegistered() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   163
        synchronized (keyLock) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   164
            return keyCount != 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   165
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   166
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   167
90ce3da70b43 Initial load
duke
parents:
diff changeset
   168
    public final SelectionKey keyFor(Selector sel) {
49802
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   169
        synchronized (keyLock) {
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   170
            return findKey(sel);
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   171
        }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   172
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   173
90ce3da70b43 Initial load
duke
parents:
diff changeset
   174
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   175
     * Registers this channel with the given selector, returning a selection key.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   176
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   177
     * <p>  This method first verifies that this channel is open and that the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   178
     * given initial interest set is valid.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   179
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   180
     * <p> If this channel is already registered with the given selector then
90ce3da70b43 Initial load
duke
parents:
diff changeset
   181
     * the selection key representing that registration is returned after
90ce3da70b43 Initial load
duke
parents:
diff changeset
   182
     * setting its interest set to the given value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   183
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   184
     * <p> Otherwise this channel has not yet been registered with the given
90ce3da70b43 Initial load
duke
parents:
diff changeset
   185
     * selector, so the {@link AbstractSelector#register register} method of
90ce3da70b43 Initial load
duke
parents:
diff changeset
   186
     * the selector is invoked while holding the appropriate locks.  The
90ce3da70b43 Initial load
duke
parents:
diff changeset
   187
     * resulting key is added to this channel's key set before being returned.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   188
     * </p>
1449
2ed6188288d6 5025260: Register methods should throw ClosedChannelException instead of NPE
sherman
parents: 2
diff changeset
   189
     *
2ed6188288d6 5025260: Register methods should throw ClosedChannelException instead of NPE
sherman
parents: 2
diff changeset
   190
     * @throws  ClosedSelectorException {@inheritDoc}
2ed6188288d6 5025260: Register methods should throw ClosedChannelException instead of NPE
sherman
parents: 2
diff changeset
   191
     *
2ed6188288d6 5025260: Register methods should throw ClosedChannelException instead of NPE
sherman
parents: 2
diff changeset
   192
     * @throws  IllegalBlockingModeException {@inheritDoc}
2ed6188288d6 5025260: Register methods should throw ClosedChannelException instead of NPE
sherman
parents: 2
diff changeset
   193
     *
2ed6188288d6 5025260: Register methods should throw ClosedChannelException instead of NPE
sherman
parents: 2
diff changeset
   194
     * @throws  IllegalSelectorException {@inheritDoc}
2ed6188288d6 5025260: Register methods should throw ClosedChannelException instead of NPE
sherman
parents: 2
diff changeset
   195
     *
2ed6188288d6 5025260: Register methods should throw ClosedChannelException instead of NPE
sherman
parents: 2
diff changeset
   196
     * @throws  CancelledKeyException {@inheritDoc}
2ed6188288d6 5025260: Register methods should throw ClosedChannelException instead of NPE
sherman
parents: 2
diff changeset
   197
     *
2ed6188288d6 5025260: Register methods should throw ClosedChannelException instead of NPE
sherman
parents: 2
diff changeset
   198
     * @throws  IllegalArgumentException {@inheritDoc}
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   199
     */
49802
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   200
    public final SelectionKey register(Selector sel, int ops, Object att)
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   201
        throws ClosedChannelException
90ce3da70b43 Initial load
duke
parents:
diff changeset
   202
    {
49802
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   203
        if ((ops & ~validOps()) != 0)
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   204
            throw new IllegalArgumentException();
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   205
        if (!isOpen())
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   206
            throw new ClosedChannelException();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   207
        synchronized (regLock) {
48761
74c1fa26435a 8196956: (ch) More channels cleanup
alanb
parents: 47216
diff changeset
   208
            if (isBlocking())
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   209
                throw new IllegalBlockingModeException();
49802
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   210
            synchronized (keyLock) {
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   211
                // re-check if channel has been closed
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   212
                if (!isOpen())
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   213
                    throw new ClosedChannelException();
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   214
                SelectionKey k = findKey(sel);
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   215
                if (k != null) {
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   216
                    k.attach(att);
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   217
                    k.interestOps(ops);
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   218
                } else {
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   219
                    // New registration
13582
16f0af616ea0 7132889: (se) AbstractSelectableChannel.register and configureBlocking not safe from asynchronous close
alanb
parents: 5506
diff changeset
   220
                    k = ((AbstractSelector)sel).register(this, ops, att);
16f0af616ea0 7132889: (se) AbstractSelectableChannel.register and configureBlocking not safe from asynchronous close
alanb
parents: 5506
diff changeset
   221
                    addKey(k);
16f0af616ea0 7132889: (se) AbstractSelectableChannel.register and configureBlocking not safe from asynchronous close
alanb
parents: 5506
diff changeset
   222
                }
49802
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   223
                return k;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   224
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   225
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   226
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   227
90ce3da70b43 Initial load
duke
parents:
diff changeset
   228
90ce3da70b43 Initial load
duke
parents:
diff changeset
   229
    // -- Closing --
90ce3da70b43 Initial load
duke
parents:
diff changeset
   230
90ce3da70b43 Initial load
duke
parents:
diff changeset
   231
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   232
     * Closes this channel.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   233
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   234
     * <p> This method, which is specified in the {@link
90ce3da70b43 Initial load
duke
parents:
diff changeset
   235
     * AbstractInterruptibleChannel} class and is invoked by the {@link
90ce3da70b43 Initial load
duke
parents:
diff changeset
   236
     * java.nio.channels.Channel#close close} method, in turn invokes the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   237
     * {@link #implCloseSelectableChannel implCloseSelectableChannel} method in
90ce3da70b43 Initial load
duke
parents:
diff changeset
   238
     * order to perform the actual work of closing this channel.  It then
90ce3da70b43 Initial load
duke
parents:
diff changeset
   239
     * cancels all of this channel's keys.  </p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   240
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   241
    protected final void implCloseChannel() throws IOException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   242
        implCloseSelectableChannel();
49802
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   243
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   244
        // clone keys to avoid calling cancel when holding keyLock
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   245
        SelectionKey[] copyOfKeys = null;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   246
        synchronized (keyLock) {
49802
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   247
            if (keys != null) {
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   248
                copyOfKeys = keys.clone();
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   249
            }
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   250
        }
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   251
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   252
        if (copyOfKeys != null) {
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   253
            for (SelectionKey k : copyOfKeys) {
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   254
                if (k != null) {
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   255
                    k.cancel();   // invalidate and adds key to cancelledKey set
8ac08fa69f00 8201315: (se) Allow SelectableChannel.register to be invoked while selection operation is in progress
alanb
parents: 48761
diff changeset
   256
                }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   257
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   258
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   259
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   260
90ce3da70b43 Initial load
duke
parents:
diff changeset
   261
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   262
     * Closes this selectable channel.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   263
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   264
     * <p> This method is invoked by the {@link java.nio.channels.Channel#close
90ce3da70b43 Initial load
duke
parents:
diff changeset
   265
     * close} method in order to perform the actual work of closing the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   266
     * channel.  This method is only invoked if the channel has not yet been
90ce3da70b43 Initial load
duke
parents:
diff changeset
   267
     * closed, and it is never invoked more than once.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   268
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   269
     * <p> An implementation of this method must arrange for any other thread
90ce3da70b43 Initial load
duke
parents:
diff changeset
   270
     * that is blocked in an I/O operation upon this channel to return
90ce3da70b43 Initial load
duke
parents:
diff changeset
   271
     * immediately, either by throwing an exception or by returning normally.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   272
     * </p>
18574
4aeaeb541678 8019380: doclint warnings in java.nio, java.nio.file.**, java.nio.channels.**
alanb
parents: 14342
diff changeset
   273
     *
4aeaeb541678 8019380: doclint warnings in java.nio, java.nio.file.**, java.nio.channels.**
alanb
parents: 14342
diff changeset
   274
     * @throws  IOException
4aeaeb541678 8019380: doclint warnings in java.nio, java.nio.file.**, java.nio.channels.**
alanb
parents: 14342
diff changeset
   275
     *          If an I/O error occurs
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   276
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   277
    protected abstract void implCloseSelectableChannel() throws IOException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   278
90ce3da70b43 Initial load
duke
parents:
diff changeset
   279
90ce3da70b43 Initial load
duke
parents:
diff changeset
   280
    // -- Blocking --
90ce3da70b43 Initial load
duke
parents:
diff changeset
   281
90ce3da70b43 Initial load
duke
parents:
diff changeset
   282
    public final boolean isBlocking() {
48761
74c1fa26435a 8196956: (ch) More channels cleanup
alanb
parents: 47216
diff changeset
   283
        return !nonBlocking;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   284
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   285
90ce3da70b43 Initial load
duke
parents:
diff changeset
   286
    public final Object blockingLock() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   287
        return regLock;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   288
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   289
90ce3da70b43 Initial load
duke
parents:
diff changeset
   290
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   291
     * Adjusts this channel's blocking mode.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   292
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   293
     * <p> If the given blocking mode is different from the current blocking
90ce3da70b43 Initial load
duke
parents:
diff changeset
   294
     * mode then this method invokes the {@link #implConfigureBlocking
90ce3da70b43 Initial load
duke
parents:
diff changeset
   295
     * implConfigureBlocking} method, while holding the appropriate locks, in
90ce3da70b43 Initial load
duke
parents:
diff changeset
   296
     * order to change the mode.  </p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   297
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   298
    public final SelectableChannel configureBlocking(boolean block)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   299
        throws IOException
90ce3da70b43 Initial load
duke
parents:
diff changeset
   300
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   301
        synchronized (regLock) {
13582
16f0af616ea0 7132889: (se) AbstractSelectableChannel.register and configureBlocking not safe from asynchronous close
alanb
parents: 5506
diff changeset
   302
            if (!isOpen())
16f0af616ea0 7132889: (se) AbstractSelectableChannel.register and configureBlocking not safe from asynchronous close
alanb
parents: 5506
diff changeset
   303
                throw new ClosedChannelException();
48761
74c1fa26435a 8196956: (ch) More channels cleanup
alanb
parents: 47216
diff changeset
   304
            boolean blocking = !nonBlocking;
74c1fa26435a 8196956: (ch) More channels cleanup
alanb
parents: 47216
diff changeset
   305
            if (block != blocking) {
74c1fa26435a 8196956: (ch) More channels cleanup
alanb
parents: 47216
diff changeset
   306
                if (block && haveValidKeys())
74c1fa26435a 8196956: (ch) More channels cleanup
alanb
parents: 47216
diff changeset
   307
                    throw new IllegalBlockingModeException();
74c1fa26435a 8196956: (ch) More channels cleanup
alanb
parents: 47216
diff changeset
   308
                implConfigureBlocking(block);
74c1fa26435a 8196956: (ch) More channels cleanup
alanb
parents: 47216
diff changeset
   309
                nonBlocking = !block;
74c1fa26435a 8196956: (ch) More channels cleanup
alanb
parents: 47216
diff changeset
   310
            }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   311
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   312
        return this;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   313
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   314
90ce3da70b43 Initial load
duke
parents:
diff changeset
   315
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   316
     * Adjusts this channel's blocking mode.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   317
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   318
     * <p> This method is invoked by the {@link #configureBlocking
90ce3da70b43 Initial load
duke
parents:
diff changeset
   319
     * configureBlocking} method in order to perform the actual work of
90ce3da70b43 Initial load
duke
parents:
diff changeset
   320
     * changing the blocking mode.  This method is only invoked if the new mode
90ce3da70b43 Initial load
duke
parents:
diff changeset
   321
     * is different from the current mode.  </p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   322
     *
32143
394ab6a6658d 8133459: replace <tt> tags (obsolete in html5) in java.nio docs
avstepan
parents: 25859
diff changeset
   323
     * @param  block  If {@code true} then this channel will be placed in
394ab6a6658d 8133459: replace <tt> tags (obsolete in html5) in java.nio docs
avstepan
parents: 25859
diff changeset
   324
     *                blocking mode; if {@code false} then it will be placed
18574
4aeaeb541678 8019380: doclint warnings in java.nio, java.nio.file.**, java.nio.channels.**
alanb
parents: 14342
diff changeset
   325
     *                non-blocking mode
4aeaeb541678 8019380: doclint warnings in java.nio, java.nio.file.**, java.nio.channels.**
alanb
parents: 14342
diff changeset
   326
     *
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   327
     * @throws IOException
90ce3da70b43 Initial load
duke
parents:
diff changeset
   328
     *         If an I/O error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   329
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   330
    protected abstract void implConfigureBlocking(boolean block)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   331
        throws IOException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   332
90ce3da70b43 Initial load
duke
parents:
diff changeset
   333
}