History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/java/nio/channels/AsynchronousServerSocketChannel.java (1 of 18352 files). Show all

Unified · Split

java/pkg/java/nio/channels/AsynchronousServerSocketChannel.java+300−0
@@ -0,0 +1,300 @@
1/*
2 * Copyright (c) 2007, 2009, 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
26package java.nio.channels;
27
28import java.nio.channels.spi.*;
29import java.net.SocketOption;
30import java.net.SocketAddress;
31import java.util.concurrent.Future;
32import java.io.IOException;
33
34/**
35 * An asynchronous channel for stream-oriented listening sockets.
36 *
37 * <p> An asynchronous server-socket channel is created by invoking the
38 * {@link #open open} method of this class.
39 * A newly-created asynchronous server-socket channel is open but not yet bound.
40 * It can be bound to a local address and configured to listen for connections
41 * by invoking the {@link #bind(SocketAddress,int) bind} method. Once bound,
42 * the {@link #accept(Object,CompletionHandler) accept} method
43 * is used to initiate the accepting of connections to the channel's socket.
44 * An attempt to invoke the <tt>accept</tt> method on an unbound channel will
45 * cause a {@link NotYetBoundException} to be thrown.
46 *
47 * <p> Channels of this type are safe for use by multiple concurrent threads
48 * though at most one accept operation can be outstanding at any time.
49 * If a thread initiates an accept operation before a previous accept operation
50 * has completed then an {@link AcceptPendingException} will be thrown.
51 *
52 * <p> Socket options are configured using the {@link #setOption(SocketOption,Object)
53 * setOption} method. Channels of this type support the following options:
54 * <blockquote>
55 * <table border>
56 * <tr>
57 * <th>Option Name</th>
58 * <th>Description</th>
59 * </tr>
60 * <tr>
61 * <td> {@link java.net.StandardSocketOptions#SO_RCVBUF SO_RCVBUF} </td>
62 * <td> The size of the socket receive buffer </td>
63 * </tr>
64 * <tr>
65 * <td> {@link java.net.StandardSocketOptions#SO_REUSEADDR SO_REUSEADDR} </td>
66 * <td> Re-use address </td>
67 * </tr>
68 * </table>
69 * </blockquote>
70 * Additional (implementation specific) options may also be supported.
71 *
72 * <p> <b>Usage Example:</b>
73 * <pre>
74 * final AsynchronousServerSocketChannel listener =
75 * AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(5000));
76 *
77 * listener.accept(null, new CompletionHandler&lt;AsynchronousSocketChannel,Void&gt;() {
78 * public void completed(AsynchronousSocketChannel ch, Void att) {
79 * // accept the next connection
80 * listener.accept(null, this);
81 *
82 * // handle this connection
83 * handle(ch);
84 * }
85 * public void failed(Throwable exc, Void att) {
86 * ...
87 * }
88 * });
89 * </pre>
90 *
91 * @since 1.7
92 */
93
94public abstract class AsynchronousServerSocketChannel
95 implements AsynchronousChannel, NetworkChannel
96{
97 private final AsynchronousChannelProvider provider;
98
99 /**
100 * Initializes a new instance of this class.
101 */
102 protected AsynchronousServerSocketChannel(AsynchronousChannelProvider provider) {
103 this.provider = provider;
104 }
105
106 /**
107 * Returns the provider that created this channel.
108 */
109 public final AsynchronousChannelProvider provider() {
110 return provider;
111 }
112
113 /**
114 * Opens an asynchronous server-socket channel.
115 *
116 * <p> The new channel is created by invoking the {@link
117 * java.nio.channels.spi.AsynchronousChannelProvider#openAsynchronousServerSocketChannel
118 * openAsynchronousServerSocketChannel} method on the {@link
119 * java.nio.channels.spi.AsynchronousChannelProvider} object that created
120 * the given group. If the group parameter is <tt>null</tt> then the
121 * resulting channel is created by the system-wide default provider, and
122 * bound to the <em>default group</em>.
123 *
124 * @param group
125 * The group to which the newly constructed channel should be bound,
126 * or <tt>null</tt> for the default group
127 *
128 * @return A new asynchronous server socket channel
129 *
130 * @throws ShutdownChannelGroupException
131 * If the channel group is shutdown
132 * @throws IOException
133 * If an I/O error occurs
134 */
135 public static AsynchronousServerSocketChannel open(AsynchronousChannelGroup group)
136 throws IOException
137 {
138 AsynchronousChannelProvider provider = (group == null) ?
139 AsynchronousChannelProvider.provider() : group.provider();
140 return provider.openAsynchronousServerSocketChannel(group);
141 }
142
143 /**
144 * Opens an asynchronous server-socket channel.
145 *
146 * <p> This method returns an asynchronous server socket channel that is
147 * bound to the <em>default group</em>. This method is equivalent to evaluating
148 * the expression:
149 * <blockquote><pre>
150 * open((AsynchronousChannelGroup)null);
151 * </pre></blockquote>
152 *
153 * @return A new asynchronous server socket channel
154 *
155 * @throws IOException
156 * If an I/O error occurs
157 */
158 public static AsynchronousServerSocketChannel open()
159 throws IOException
160 {
161 return open(null);
162 }
163
164 /**
165 * Binds the channel's socket to a local address and configures the socket to
166 * listen for connections.
167 *
168 * <p> An invocation of this method is equivalent to the following:
169 * <blockquote><pre>
170 * bind(local, 0);
171 * </pre></blockquote>
172 *
173 * @param local
174 * The local address to bind the socket, or <tt>null</tt> to bind
175 * to an automatically assigned socket address
176 *
177 * @return This channel
178 *
179 * @throws AlreadyBoundException {@inheritDoc}
180 * @throws UnsupportedAddressTypeException {@inheritDoc}
181 * @throws SecurityException {@inheritDoc}
182 * @throws ClosedChannelException {@inheritDoc}
183 * @throws IOException {@inheritDoc}
184 */
185 public final AsynchronousServerSocketChannel bind(SocketAddress local)
186 throws IOException
187 {
188 return bind(local, 0);
189 }
190
191 /**
192 * Binds the channel's socket to a local address and configures the socket to
193 * listen for connections.
194 *
195 * <p> This method is used to establish an association between the socket and
196 * a local address. Once an association is established then the socket remains
197 * bound until the associated channel is closed.
198 *
199 * <p> The {@code backlog} parameter is the maximum number of pending
200 * connections on the socket. Its exact semantics are implementation specific.
201 * In particular, an implementation may impose a maximum length or may choose
202 * to ignore the parameter altogther. If the {@code backlog} parameter has
203 * the value {@code 0}, or a negative value, then an implementation specific
204 * default is used.
205 *
206 * @param local
207 * The local address to bind the socket, or {@code null} to bind
208 * to an automatically assigned socket address
209 * @param backlog
210 * The maximum number of pending connections
211 *
212 * @return This channel
213 *
214 * @throws AlreadyBoundException
215 * If the socket is already bound
216 * @throws UnsupportedAddressTypeException
217 * If the type of the given address is not supported
218 * @throws SecurityException
219 * If a security manager has been installed and its {@link
220 * SecurityManager#checkListen checkListen} method denies the operation
221 * @throws ClosedChannelException
222 * If the channel is closed
223 * @throws IOException
224 * If some other I/O error occurs
225 */
226 public abstract AsynchronousServerSocketChannel bind(SocketAddress local, int backlog)
227 throws IOException;
228
229 /**
230 * @throws IllegalArgumentException {@inheritDoc}
231 * @throws ClosedChannelException {@inheritDoc}
232 * @throws IOException {@inheritDoc}
233 */
234 public abstract <T> AsynchronousServerSocketChannel setOption(SocketOption<T> name, T value)
235 throws IOException;
236
237 /**
238 * Accepts a connection.
239 *
240 * <p> This method initiates an asynchronous operation to accept a
241 * connection made to this channel's socket. The {@code handler} parameter is
242 * a completion handler that is invoked when a connection is accepted (or
243 * the operation fails). The result passed to the completion handler is
244 * the {@link AsynchronousSocketChannel} to the new connection.
245 *
246 * <p> When a new connection is accepted then the resulting {@code
247 * AsynchronousSocketChannel} will be bound to the same {@link
248 * AsynchronousChannelGroup} as this channel. If the group is {@link
249 * AsynchronousChannelGroup#isShutdown shutdown} and a connection is accepted,
250 * then the connection is closed, and the operation completes with an {@code
251 * IOException} and cause {@link ShutdownChannelGroupException}.
252 *
253 * <p> To allow for concurrent handling of new connections, the completion
254 * handler is not invoked directly by the initiating thread when a new
255 * connection is accepted immediately (see <a
256 * href="AsynchronousChannelGroup.html#threading">Threading<a>).
257 *
258 * <p> If a security manager has been installed then it verifies that the
259 * address and port number of the connection's remote endpoint are permitted
260 * by the security manager's {@link SecurityManager#checkAccept checkAccept}
261 * method. The permission check is performed with privileges that are restricted
262 * by the calling context of this method. If the permission check fails then
263 * the connection is closed and the operation completes with a {@link
264 * SecurityException}.
265 *
266 * @param attachment
267 * The object to attach to the I/O operation; can be {@code null}
268 * @param handler
269 * The handler for consuming the result
270 *
271 * @throws AcceptPendingException
272 * If an accept operation is already in progress on this channel
273 * @throws NotYetBoundException
274 * If this channel's socket has not yet been bound
275 * @throws ShutdownChannelGroupException
276 * If the channel group has terminated
277 */
278 public abstract <A> void accept(A attachment,
279 CompletionHandler<AsynchronousSocketChannel,? super A> handler);
280
281 /**
282 * Accepts a connection.
283 *
284 * <p> This method initiates an asynchronous operation to accept a
285 * connection made to this channel's socket. The method behaves in exactly
286 * the same manner as the {@link #accept(Object, CompletionHandler)} method
287 * except that instead of specifying a completion handler, this method
288 * returns a {@code Future} representing the pending result. The {@code
289 * Future}'s {@link Future#get() get} method returns the {@link
290 * AsynchronousSocketChannel} to the new connection on successful completion.
291 *
292 * @return a {@code Future} object representing the pending result
293 *
294 * @throws AcceptPendingException
295 * If an accept operation is already in progress on this channel
296 * @throws NotYetBoundException
297 * If this channel's socket has not yet been bound
298 */
299 public abstract Future<AsynchronousSocketChannel> accept();
300}

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t