Java example source code file (Socket.java)
The Socket.java Java example source code
/*
* Copyright (c) 1995, 2013, 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 java.net;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;
import java.nio.channels.SocketChannel;
import java.security.AccessController;
import java.security.PrivilegedExceptionAction;
import java.security.PrivilegedAction;
/**
* This class implements client sockets (also called just
* "sockets"). A socket is an endpoint for communication
* between two machines.
* <p>
* The actual work of the socket is performed by an instance of the
* {@code SocketImpl} class. An application, by changing
* the socket factory that creates the socket implementation,
* can configure itself to create sockets appropriate to the local
* firewall.
*
* @author unascribed
* @see java.net.Socket#setSocketImplFactory(java.net.SocketImplFactory)
* @see java.net.SocketImpl
* @see java.nio.channels.SocketChannel
* @since JDK1.0
*/
public
class Socket implements java.io.Closeable {
/**
* Various states of this socket.
*/
private boolean created = false;
private boolean bound = false;
private boolean connected = false;
private boolean closed = false;
private Object closeLock = new Object();
private boolean shutIn = false;
private boolean shutOut = false;
/**
* The implementation of this Socket.
*/
SocketImpl impl;
/**
* Are we using an older SocketImpl?
*/
private boolean oldImpl = false;
/**
* Creates an unconnected socket, with the
* system-default type of SocketImpl.
*
* @since JDK1.1
* @revised 1.4
*/
public Socket() {
setImpl();
}
/**
* Creates an unconnected socket, specifying the type of proxy, if any,
* that should be used regardless of any other settings.
* <P>
* If there is a security manager, its {@code checkConnect} method
* is called with the proxy host address and port number
* as its arguments. This could result in a SecurityException.
* <P>
* Examples:
* <UL> The network software may discard bytes that are buffered * by the socket. Bytes that aren't discarded by the network * software can be read using {@link java.io.InputStream#read read}. * * <li> If there are no bytes buffered on the socket, or all * buffered bytes have been consumed by * {@link java.io.InputStream#read read}, then all subsequent * calls to {@link java.io.InputStream#read read} will throw an * {@link java.io.IOException IOException}. * * <li> If there are no bytes buffered on the socket, and the * socket has not been closed using {@link #close close}, then * {@link java.io.InputStream#available available} will * return {@code 0}. * * </ul> * * <p> Closing the returned {@link java.io.InputStream InputStream} * will close the associated socket. * * @return an input stream for reading bytes from this socket. * @exception IOException if an I/O error occurs when creating the * input stream, the socket is closed, the socket is * not connected, or the socket input has been shutdown * using {@link #shutdownInput()} * * @revised 1.4 * @spec JSR-51 */ public InputStream getInputStream() throws IOException { if (isClosed()) throw new SocketException("Socket is closed"); if (!isConnected()) throw new SocketException("Socket is not connected"); if (isInputShutdown()) throw new SocketException("Socket input is shutdown"); final Socket s = this; InputStream is = null; try { is = AccessController.doPrivileged( new PrivilegedExceptionAction<InputStream>() { public InputStream run() throws IOException { return impl.getInputStream(); } }); } catch (java.security.PrivilegedActionException e) { throw (IOException) e.getException(); } return is; } /** * Returns an output stream for this socket. * * <p> If this socket has an associated channel then the resulting output * stream delegates all of its operations to the channel. If the channel * is in non-blocking mode then the output stream's {@code write} * operations will throw an {@link * java.nio.channels.IllegalBlockingModeException}. * * <p> Closing the returned {@link java.io.OutputStream OutputStream} * will close the associated socket. * * @return an output stream for writing bytes to this socket. * @exception IOException if an I/O error occurs when creating the * output stream or if the socket is not connected. * @revised 1.4 * @spec JSR-51 */ public OutputStream getOutputStream() throws IOException { if (isClosed()) throw new SocketException("Socket is closed"); if (!isConnected()) throw new SocketException("Socket is not connected"); if (isOutputShutdown()) throw new SocketException("Socket output is shutdown"); final Socket s = this; OutputStream os = null; try { os = AccessController.doPrivileged( new PrivilegedExceptionAction<OutputStream>() { public OutputStream run() throws IOException { return impl.getOutputStream(); } }); } catch (java.security.PrivilegedActionException e) { throw (IOException) e.getException(); } return os; } /** * Enable/disable {@link SocketOptions#TCP_NODELAY TCP_NODELAY} * (disable/enable Nagle's algorithm). * * @param on {@code true} to enable TCP_NODELAY, * {@code false} to disable. * * @exception SocketException if there is an error * in the underlying protocol, such as a TCP error. * * @since JDK1.1 * * @see #getTcpNoDelay() */ public void setTcpNoDelay(boolean on) throws SocketException { if (isClosed()) throw new SocketException("Socket is closed"); getImpl().setOption(SocketOptions.TCP_NODELAY, Boolean.valueOf(on)); } /** * Tests if {@link SocketOptions#TCP_NODELAY TCP_NODELAY} is enabled. * * @return a {@code boolean} indicating whether or not * {@link SocketOptions#TCP_NODELAY TCP_NODELAY} is enabled. * @exception SocketException if there is an error * in the underlying protocol, such as a TCP error. * @since JDK1.1 * @see #setTcpNoDelay(boolean) */ public boolean getTcpNoDelay() throws SocketException { if (isClosed()) throw new SocketException("Socket is closed"); return ((Boolean) getImpl().getOption(SocketOptions.TCP_NODELAY)).booleanValue(); } /** * Enable/disable {@link SocketOptions#SO_LINGER SO_LINGER} with the * specified linger time in seconds. The maximum timeout value is platform * specific. * * The setting only affects socket close. * * @param on whether or not to linger on. * @param linger how long to linger for, if on is true. * @exception SocketException if there is an error * in the underlying protocol, such as a TCP error. * @exception IllegalArgumentException if the linger value is negative. * @since JDK1.1 * @see #getSoLinger() */ public void setSoLinger(boolean on, int linger) throws SocketException { if (isClosed()) throw new SocketException("Socket is closed"); if (!on) { getImpl().setOption(SocketOptions.SO_LINGER, new Boolean(on)); } else { if (linger < 0) { throw new IllegalArgumentException("invalid value for SO_LINGER"); } if (linger > 65535) linger = 65535; getImpl().setOption(SocketOptions.SO_LINGER, new Integer(linger)); } } /** * Returns setting for {@link SocketOptions#SO_LINGER SO_LINGER}. * -1 returns implies that the * option is disabled. * * The setting only affects socket close. * * @return the setting for {@link SocketOptions#SO_LINGER SO_LINGER}. * @exception SocketException if there is an error * in the underlying protocol, such as a TCP error. * @since JDK1.1 * @see #setSoLinger(boolean, int) */ public int getSoLinger() throws SocketException { if (isClosed()) throw new SocketException("Socket is closed"); Object o = getImpl().getOption(SocketOptions.SO_LINGER); if (o instanceof Integer) { return ((Integer) o).intValue(); } else { return -1; } } /** * Send one byte of urgent data on the socket. The byte to be sent is the lowest eight * bits of the data parameter. The urgent byte is * sent after any preceding writes to the socket OutputStream * and before any future writes to the OutputStream. * @param data The byte of data to send * @exception IOException if there is an error * sending the data. * @since 1.4 */ public void sendUrgentData (int data) throws IOException { if (!getImpl().supportsUrgentData ()) { throw new SocketException ("Urgent data not supported"); } getImpl().sendUrgentData (data); } /** * Enable/disable {@link SocketOptions#SO_OOBINLINE SO_OOBINLINE} * (receipt of TCP urgent data) * * By default, this option is disabled and TCP urgent data received on a * socket is silently discarded. If the user wishes to receive urgent data, then * this option must be enabled. When enabled, urgent data is received * inline with normal data. * <p> * Note, only limited support is provided for handling incoming urgent * data. In particular, no notification of incoming urgent data is provided * and there is no capability to distinguish between normal data and urgent * data unless provided by a higher level protocol. * * @param on {@code true} to enable * {@link SocketOptions#SO_OOBINLINE SO_OOBINLINE}, * {@code false} to disable. * * @exception SocketException if there is an error * in the underlying protocol, such as a TCP error. * * @since 1.4 * * @see #getOOBInline() */ public void setOOBInline(boolean on) throws SocketException { if (isClosed()) throw new SocketException("Socket is closed"); getImpl().setOption(SocketOptions.SO_OOBINLINE, Boolean.valueOf(on)); } /** * Tests if {@link SocketOptions#SO_OOBINLINE SO_OOBINLINE} is enabled. * * @return a {@code boolean} indicating whether or not * {@link SocketOptions#SO_OOBINLINE SO_OOBINLINE}is enabled. * * @exception SocketException if there is an error * in the underlying protocol, such as a TCP error. * @since 1.4 * @see #setOOBInline(boolean) */ public boolean getOOBInline() throws SocketException { if (isClosed()) throw new SocketException("Socket is closed"); return ((Boolean) getImpl().getOption(SocketOptions.SO_OOBINLINE)).booleanValue(); } /** * Enable/disable {@link SocketOptions#SO_TIMEOUT SO_TIMEOUT} * with the specified timeout, in milliseconds. With this option set * to a non-zero timeout, a read() call on the InputStream associated with * this Socket will block for only this amount of time. If the timeout * expires, a <B>java.net.SocketTimeoutException is raised, though the * Socket is still valid. The option <B>must be enabled * prior to entering the blocking operation to have effect. The * timeout must be {@code > 0}. * A timeout of zero is interpreted as an infinite timeout. * * @param timeout the specified timeout, in milliseconds. * @exception SocketException if there is an error * in the underlying protocol, such as a TCP error. * @since JDK 1.1 * @see #getSoTimeout() */ public synchronized void setSoTimeout(int timeout) throws SocketException { if (isClosed()) throw new SocketException("Socket is closed"); if (timeout < 0) throw new IllegalArgumentException("timeout can't be negative"); getImpl().setOption(SocketOptions.SO_TIMEOUT, new Integer(timeout)); } /** * Returns setting for {@link SocketOptions#SO_TIMEOUT SO_TIMEOUT}. * 0 returns implies that the option is disabled (i.e., timeout of infinity). * * @return the setting for {@link SocketOptions#SO_TIMEOUT SO_TIMEOUT} * @exception SocketException if there is an error * in the underlying protocol, such as a TCP error. * * @since JDK1.1 * @see #setSoTimeout(int) */ public synchronized int getSoTimeout() throws SocketException { if (isClosed()) throw new SocketException("Socket is closed"); Object o = getImpl().getOption(SocketOptions.SO_TIMEOUT); /* extra type safety */ if (o instanceof Integer) { return ((Integer) o).intValue(); } else { return 0; } } /** * Sets the {@link SocketOptions#SO_SNDBUF SO_SNDBUF} option to the * specified value for this {@code Socket}. * The {@link SocketOptions#SO_SNDBUF SO_SNDBUF} option is used by the * platform's networking code as a hint for the size to set the underlying * network I/O buffers. * * <p>Because {@link SocketOptions#SO_SNDBUF SO_SNDBUF} is a hint, * applications that want to verify what size the buffers were set to * should call {@link #getSendBufferSize()}. * * @exception SocketException if there is an error * in the underlying protocol, such as a TCP error. * * @param size the size to which to set the send buffer * size. This value must be greater than 0. * * @exception IllegalArgumentException if the * value is 0 or is negative. * * @see #getSendBufferSize() * @since 1.2 */ public synchronized void setSendBufferSize(int size) throws SocketException{ if (!(size > 0)) { throw new IllegalArgumentException("negative send size"); } if (isClosed()) throw new SocketException("Socket is closed"); getImpl().setOption(SocketOptions.SO_SNDBUF, new Integer(size)); } /** * Get value of the {@link SocketOptions#SO_SNDBUF SO_SNDBUF} option * for this {@code Socket}, that is the buffer size used by the platform * for output on this {@code Socket}. * @return the value of the {@link SocketOptions#SO_SNDBUF SO_SNDBUF} * option for this {@code Socket}. * * @exception SocketException if there is an error * in the underlying protocol, such as a TCP error. * * @see #setSendBufferSize(int) * @since 1.2 */ public synchronized int getSendBufferSize() throws SocketException { if (isClosed()) throw new SocketException("Socket is closed"); int result = 0; Object o = getImpl().getOption(SocketOptions.SO_SNDBUF); if (o instanceof Integer) { result = ((Integer)o).intValue(); } return result; } /** * Sets the {@link SocketOptions#SO_RCVBUF SO_RCVBUF} option to the * specified value for this {@code Socket}. The * {@link SocketOptions#SO_RCVBUF SO_RCVBUF} option is * used by the platform's networking code as a hint for the size to set * the underlying network I/O buffers. * * <p>Increasing the receive buffer size can increase the performance of * network I/O for high-volume connection, while decreasing it can * help reduce the backlog of incoming data. * * <p>Because {@link SocketOptions#SO_RCVBUF SO_RCVBUF} is a hint, * applications that want to verify what size the buffers were set to * should call {@link #getReceiveBufferSize()}. * * <p>The value of {@link SocketOptions#SO_RCVBUF SO_RCVBUF} is also used * to set the TCP receive window that is advertized to the remote peer. * Generally, the window size can be modified at any time when a socket is * connected. However, if a receive window larger than 64K is required then * this must be requested <B>before the socket is connected to the * remote peer. There are two cases to be aware of: * <ol> * <li>For sockets accepted from a ServerSocket, this must be done by calling * {@link ServerSocket#setReceiveBufferSize(int)} before the ServerSocket * is bound to a local address.<p> IPTOS_LOWCOST (0x02)
* <LI>IPTOS_RELIABILITY (0x04)
* <LI>IPTOS_THROUGHPUT (0x08)
* <LI>IPTOS_LOWDELAY (0x10)
* </UL>
* The last low order bit is always ignored as this
* corresponds to the MBZ (must be zero) bit.
* <p>
* Setting bits in the precedence field may result in a
* SocketException indicating that the operation is not
* permitted.
* <p>
* As RFC 1122 section 4.2.4.2 indicates, a compliant TCP
* implementation should, but is not required to, let application
* change the TOS field during the lifetime of a connection.
* So whether the type-of-service field can be changed after the
* TCP connection has been established depends on the implementation
* in the underlying platform. Applications should not assume that
* they can change the TOS field after the connection.
* <p>
* For Internet Protocol v6 {@code tc} is the value that
* would be placed into the sin6_flowinfo field of the IP header.
*
* @param tc an {@code int} value for the bitset.
* @throws SocketException if there is an error setting the
* traffic class or type-of-service
* @since 1.4
* @see #getTrafficClass
* @see SocketOptions#IP_TOS
*/
public void setTrafficClass(int tc) throws SocketException {
if (tc < 0 || tc > 255)
throw new IllegalArgumentException("tc is not in range 0 -- 255");
if (isClosed())
throw new SocketException("Socket is closed");
getImpl().setOption(SocketOptions.IP_TOS, new Integer(tc));
}
/**
* Gets traffic class or type-of-service in the IP header
* for packets sent from this Socket
* <p>
* As the underlying network implementation may ignore the
* traffic class or type-of-service set using {@link #setTrafficClass(int)}
* this method may return a different value than was previously
* set using the {@link #setTrafficClass(int)} method on this Socket.
*
* @return the traffic class or type-of-service already set
* @throws SocketException if there is an error obtaining the
* traffic class or type-of-service value.
* @since 1.4
* @see #setTrafficClass(int)
* @see SocketOptions#IP_TOS
*/
public int getTrafficClass() throws SocketException {
return ((Integer) (getImpl().getOption(SocketOptions.IP_TOS))).intValue();
}
/**
* Enable/disable the {@link SocketOptions#SO_REUSEADDR SO_REUSEADDR}
* socket option.
* <p>
* When a TCP connection is closed the connection may remain
* in a timeout state for a period of time after the connection
* is closed (typically known as the {@code TIME_WAIT} state
* or {@code 2MSL} wait state).
* For applications using a well known socket address or port
* it may not be possible to bind a socket to the required
* {@code SocketAddress} if there is a connection in the
* timeout state involving the socket address or port.
* <p>
* Enabling {@link SocketOptions#SO_REUSEADDR SO_REUSEADDR}
* prior to binding the socket using {@link #bind(SocketAddress)} allows
* the socket to be bound even though a previous connection is in a timeout
* state.
* <p>
* When a {@code Socket} is created the initial setting
* of {@link SocketOptions#SO_REUSEADDR SO_REUSEADDR} is disabled.
* <p>
* The behaviour when {@link SocketOptions#SO_REUSEADDR SO_REUSEADDR} is
* enabled or disabled after a socket is bound (See {@link #isBound()})
* is not defined.
*
* @param on whether to enable or disable the socket option
* @exception SocketException if an error occurs enabling or
* disabling the {@link SocketOptions#SO_REUSEADDR SO_REUSEADDR}
* socket option, or the socket is closed.
* @since 1.4
* @see #getReuseAddress()
* @see #bind(SocketAddress)
* @see #isClosed()
* @see #isBound()
*/
public void setReuseAddress(boolean on) throws SocketException {
if (isClosed())
throw new SocketException("Socket is closed");
getImpl().setOption(SocketOptions.SO_REUSEADDR, Boolean.valueOf(on));
}
/**
* Tests if {@link SocketOptions#SO_REUSEADDR SO_REUSEADDR} is enabled.
*
* @return a {@code boolean} indicating whether or not
* {@link SocketOptions#SO_REUSEADDR SO_REUSEADDR} is enabled.
* @exception SocketException if there is an error
* in the underlying protocol, such as a TCP error.
* @since 1.4
* @see #setReuseAddress(boolean)
*/
public boolean getReuseAddress() throws SocketException {
if (isClosed())
throw new SocketException("Socket is closed");
return ((Boolean) (getImpl().getOption(SocketOptions.SO_REUSEADDR))).booleanValue();
}
/**
* Closes this socket.
* <p>
* Any thread currently blocked in an I/O operation upon this socket
* will throw a {@link SocketException}.
* <p>
* Once a socket has been closed, it is not available for further networking
* use (i.e. can't be reconnected or rebound). A new socket needs to be
* created.
*
* <p> Closing this socket will also close the socket's
* {@link java.io.InputStream InputStream} and
* {@link java.io.OutputStream OutputStream}.
*
* <p> If this socket has an associated channel then the channel is closed
* as well.
*
* @exception IOException if an I/O error occurs when closing this socket.
* @revised 1.4
* @spec JSR-51
* @see #isClosed
*/
public synchronized void close() throws IOException {
synchronized(closeLock) {
if (isClosed())
return;
if (created)
impl.close();
closed = true;
}
}
/**
* Places the input stream for this socket at "end of stream".
* Any data sent to the input stream side of the socket is acknowledged
* and then silently discarded.
* <p>
* If you read from a socket input stream after invoking this method on the
* socket, the stream's {@code available} method will return 0, and its
* {@code read} methods will return {@code -1} (end of stream).
*
* @exception IOException if an I/O error occurs when shutting down this
* socket.
*
* @since 1.3
* @see java.net.Socket#shutdownOutput()
* @see java.net.Socket#close()
* @see java.net.Socket#setSoLinger(boolean, int)
* @see #isInputShutdown
*/
public void shutdownInput() throws IOException
{
if (isClosed())
throw new SocketException("Socket is closed");
if (!isConnected())
throw new SocketException("Socket is not connected");
if (isInputShutdown())
throw new SocketException("Socket input is already shutdown");
getImpl().shutdownInput();
shutIn = true;
}
/**
* Disables the output stream for this socket.
* For a TCP socket, any previously written data will be sent
* followed by TCP's normal connection termination sequence.
*
* If you write to a socket output stream after invoking
* shutdownOutput() on the socket, the stream will throw
* an IOException.
*
* @exception IOException if an I/O error occurs when shutting down this
* socket.
*
* @since 1.3
* @see java.net.Socket#shutdownInput()
* @see java.net.Socket#close()
* @see java.net.Socket#setSoLinger(boolean, int)
* @see #isOutputShutdown
*/
public void shutdownOutput() throws IOException
{
if (isClosed())
throw new SocketException("Socket is closed");
if (!isConnected())
throw new SocketException("Socket is not connected");
if (isOutputShutdown())
throw new SocketException("Socket output is already shutdown");
getImpl().shutdownOutput();
shutOut = true;
}
/**
* Converts this socket to a {@code String}.
*
* @return a string representation of this socket.
*/
public String toString() {
try {
if (isConnected())
return "Socket[addr=" + getImpl().getInetAddress() +
",port=" + getImpl().getPort() +
",localport=" + getImpl().getLocalPort() + "]";
} catch (SocketException e) {
}
return "Socket[unconnected]";
}
/**
* Returns the connection state of the socket.
* <p>
* Note: Closing a socket doesn't clear its connection state, which means
* this method will return {@code true} for a closed socket
* (see {@link #isClosed()}) if it was successfuly connected prior
* to being closed.
*
* @return true if the socket was successfuly connected to a server
* @since 1.4
*/
public boolean isConnected() {
// Before 1.3 Sockets were always connected during creation
return connected || oldImpl;
}
/**
* Returns the binding state of the socket.
* <p>
* Note: Closing a socket doesn't clear its binding state, which means
* this method will return {@code true} for a closed socket
* (see {@link #isClosed()}) if it was successfuly bound prior
* to being closed.
*
* @return true if the socket was successfuly bound to an address
* @since 1.4
* @see #bind
*/
public boolean isBound() {
// Before 1.3 Sockets were always bound during creation
return bound || oldImpl;
}
/**
* Returns the closed state of the socket.
*
* @return true if the socket has been closed
* @since 1.4
* @see #close
*/
public boolean isClosed() {
synchronized(closeLock) {
return closed;
}
}
/**
* Returns whether the read-half of the socket connection is closed.
*
* @return true if the input of the socket has been shutdown
* @since 1.4
* @see #shutdownInput
*/
public boolean isInputShutdown() {
return shutIn;
}
/**
* Returns whether the write-half of the socket connection is closed.
*
* @return true if the output of the socket has been shutdown
* @since 1.4
* @see #shutdownOutput
*/
public boolean isOutputShutdown() {
return shutOut;
}
/**
* The factory for all client sockets.
*/
private static SocketImplFactory factory = null;
/**
* Sets the client socket implementation factory for the
* application. The factory can be specified only once.
* <p>
* When an application creates a new client socket, the socket
* implementation factory's {@code createSocketImpl} method is
* called to create the actual socket implementation.
* <p>
* Passing {@code null} to the method is a no-op unless the factory
* was already set.
* <p>If there is a security manager, this method first calls
* the security manager's {@code checkSetFactory} method
* to ensure the operation is allowed.
* This could result in a SecurityException.
*
* @param fac the desired factory.
* @exception IOException if an I/O error occurs when setting the
* socket factory.
* @exception SocketException if the factory is already defined.
* @exception SecurityException if a security manager exists and its
* {@code checkSetFactory} method doesn't allow the operation.
* @see java.net.SocketImplFactory#createSocketImpl()
* @see SecurityManager#checkSetFactory
*/
public static synchronized void setSocketImplFactory(SocketImplFactory fac)
throws IOException
{
if (factory != null) {
throw new SocketException("factory already defined");
}
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkSetFactory();
}
factory = fac;
}
/**
* Sets performance preferences for this socket.
*
* <p> Sockets use the TCP/IP protocol by default. Some implementations
* may offer alternative protocols which have different performance
* characteristics than TCP/IP. This method allows the application to
* express its own preferences as to how these tradeoffs should be made
* when the implementation chooses from the available protocols.
*
* <p> Performance preferences are described by three integers
* whose values indicate the relative importance of short connection time,
* low latency, and high bandwidth. The absolute values of the integers
* are irrelevant; in order to choose a protocol the values are simply
* compared, with larger values indicating stronger preferences. Negative
* values represent a lower priority than positive values. If the
* application prefers short connection time over both low latency and high
* bandwidth, for example, then it could invoke this method with the values
* {@code (1, 0, 0)}. If the application prefers high bandwidth above low
* latency, and low latency above short connection time, then it could
* invoke this method with the values {@code (0, 1, 2)}.
*
* <p> Invoking this method after this socket has been connected
* will have no effect.
*
* @param connectionTime
* An {@code int} expressing the relative importance of a short
* connection time
*
* @param latency
* An {@code int} expressing the relative importance of low
* latency
*
* @param bandwidth
* An {@code int} expressing the relative importance of high
* bandwidth
*
* @since 1.5
*/
public void setPerformancePreferences(int connectionTime,
int latency,
int bandwidth)
{
/* Not implemented yet */
}
}
Other Java examples (source code examples)Here is a short list of links related to this Java Socket.java source code file: |
The search page
Other Java source code examples at this package level
Click here to learn more about this project
