PuGong

// Java.SQL.CommonDataSource
/**
        *<p>Sets the maximum time in seconds that this data source will wait
        *while attempting to connect to a database.A value of zero
        *specifies that the timeout is the default system timeout
        *if there is one;otherwise,it specifies that there is no timeout.
        *When a <code>DataSource</code> object is created,the login timeout is
        *initially zero.
        *@param seconds the data source login time limit
        *@exception SQLException if a database access error occurs.
        *@see #getLoginTimeout
    void setloginTimeout(int seconds)throws SQLException;

//className:org.postgresql.core.v3.QueryExecutorlmpl
public synchronized void execute(Query query,@Nullable Parameterlist parameters,
        ResultHandler handler,
        int maxRows,int fetchSize,int flags)throws SQLException{
    waitOnLock0；
    boolean autosave=false;
    try{
        try{
        handler=sendQueryPreamble(handler,flags);
        autosave=sendAutomaticSavepoint(query,flags);
            sendQuery(query,(V3ParameterList)parameters,maxRows,fetchSize,flags,
                handler,null)；
    }catch (IOException e){
        abort0；
        handler.handleError(
            new PSQLException(GT.tr("An l/O error occurred while sending to the backend."),
                PSQLState.CONNECTION FAILURE,e));
        ...
    }
 }

// className org.postgresql.core.PGStream
public void setNetworkTimeout(int milliseconds)throws IOException{
    connection.setSoTimeout(milliseconds);
    pglnput.setTimeoutRequested(milliseconds!=0)；

// className:java.net.Socket
 /**
     *  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</B> is raised, though the
     *  Socket is still valid. The option <B>must</B> 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));
    }