NoThreadSocketExecuter (litesockets 4.14 API)

java.lang.Object
- org.threadly.util.AbstractService
- - org.threadly.litesockets.NoThreadSocketExecuter

All Implemented Interfaces:

SocketExecuter, org.threadly.util.Service

Direct Known Subclasses:

SingleThreadSocketExecuter
```
public class NoThreadSocketExecuter
extends org.threadly.util.AbstractService
```
The NoThreadSocketExecuter is a simpler implementation of a SocketExecuter that does not create any threads. Since there are no threads operations happen on whatever thread calls .select(), and only 1 thread at a time should ever call it at a time. Other then that it should be completely thread safe.

This is generally the implementation used by clients. It can be used for servers but only when not servicing many connections at once. How many connections is hardware and OS defendant. For an average multi-core x86 linux server I a connections not to much more then 1000 connections would be its limit, though alot depends on how active those connections are.

It should also be noted that all client read/close callbacks happen on the thread that calls select().

Field Summary

Fields
Modifier and Type Field and Description

static int SELECT_TIME_MS

Fields
Modifier and Type	Field and Description
`static int`	`SELECT_TIME_MS`

Constructor Summary

Constructors
Constructor and Description
`NoThreadSocketExecuter()` Constructs a NoThreadSocketExecuter.
`NoThreadSocketExecuter(org.threadly.concurrent.NoThreadScheduler scheduler)` Constructs a NoThreadSocketExecuter.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`TCPClient`	`createTCPClient(java.nio.channels.SocketChannel sc)` This will create a `TCPClient` on the specified `SocketExecuter` with an already created `SocketChannel`.
`TCPClient`	`createTCPClient(java.lang.String host, int port)` This will create a `TCPClient` on the specified `SocketExecuter`.
`TCPServer`	`createTCPServer(java.nio.channels.ServerSocketChannel ssc)` This will crate a `TCPServer` from a given `ServerSocketChannel` object.
`TCPServer`	`createTCPServer(java.lang.String host, int port)` This will create a `TCPServer` on the specified `SocketExecuter`.
`UDPServer`	`createUDPServer(java.lang.String host, int port)` This will create a UDPServer on the specified `SocketExecuter`.
`int`	`getClientCount()` Get the count of `Client` on this SocketExecuter.
`org.threadly.concurrent.SubmitterExecutor`	`getExecutorFor(java.lang.Object obj)` This allows you to get the `SubmitterExecutor` for a specified object.
`int`	`getServerCount()` Get the count of `Server` from the SocketExecuter.
`SimpleByteStats`	`getStats()` This will give you read and write stats for the SocketExecuter.
`org.threadly.concurrent.SubmitterScheduler`	`getThreadScheduler()` This returns the current `SubmitterScheduler` for this SocketExecuter.
`long`	`getTotalPendingReadBytes()` Check the total amount of pending reads across all associated clients.
`long`	`getTotalPendingWriteBytes()` Check the total number of bytes pending to be sent by clients.
`void`	`select()` This will run all ExecuterTasks, check for pending network operations, then run those operations.
`void`	`select(int delay)` This is the same as the `select()` but it allows you to set a delay.
`void`	`setClientOperations(Client client)` This is called when the a clients state needs to be rechecked.
`void`	`setPerConnectionStatsEnabled(boolean enabled)` By default per-connection stats will be enabled.
`void`	`setUDPServerOperations(UDPServer udpServer, boolean enable)`
`void`	`startListening(Server server)` This is used by `Server` to tell the SocketExecuter to start allowing new clients to be accepted.
`void`	`stopListening(Server server)` This will stop tell the executer to stop listening for new connections on the specified `Server`.
`void`	`wakeup()` This is used to wakeup the `Selector` assuming it was called with a timeout on it.
`void`	`watchFuture(org.threadly.concurrent.future.ListenableFuture<?> lf, long delay)` This allows you to put a timer on a `ListenableFuture`.

Methods inherited from class org.threadly.util.AbstractService
hasStopped, isRunning, start, startIfNotStarted, stop, stopIfRunning

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.threadly.util.Service
hasStopped, isRunning, start, startIfNotStarted, stop, stopIfRunning

- Field Detail
  - SELECT_TIME_MS
```
public static final int SELECT_TIME_MS
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - NoThreadSocketExecuter
```
public NoThreadSocketExecuter()
```
    Constructs a NoThreadSocketExecuter. AbstractService.start() must still be called before using it.
  - NoThreadSocketExecuter
```
public NoThreadSocketExecuter(org.threadly.concurrent.NoThreadScheduler scheduler)
```
    Constructs a NoThreadSocketExecuter. AbstractService.start() must still be called before using it.
- Method Detail
  - wakeup
```
public void wakeup()
```
    This is used to wakeup the Selector assuming it was called with a timeout on it. Most all methods in this class that need to do a wakeup do it automatically, but there are situations where you might want to wake up the thread we are blocked on manually.
  - setClientOperations
```
public void setClientOperations(Client client)
```
    Description copied from interface: SocketExecuter
    
    This is called when the a clients state needs to be rechecked. It will cause the SocketExecuter to start checking the client for any state changes that are currently allowed. The Client must have been created using this SocketExecuter or from a Server that was created with it.
    
    Parameters:
    
    client - The Client object to check the state of.
  - setUDPServerOperations
```
public void setUDPServerOperations(UDPServer udpServer,
                                   boolean enable)
```
  - select
```
public void select()
```
    This will run all ExecuterTasks, check for pending network operations, then run those operations. There can be a lot of I/O operations so this could take some time to run. In general it should not be called from things like GUI threads.
  - select
```
public void select(int delay)
```
    This is the same as the select() but it allows you to set a delay. This delay is the time to wait for socket operations to happen. It will block the calling thread for up to this amount of time, but it could be less if any network operation happens (including another thread adding a client/server).
    
    Parameters:
    
    delay - Max time in milliseconds to block for.
  - getExecutorFor
```
public org.threadly.concurrent.SubmitterExecutor getExecutorFor(java.lang.Object obj)
```
    Description copied from interface: SocketExecuter
    
    This allows you to get the SubmitterExecutor for a specified object.
    
    Parameters:
    
    obj - The Object whose SubmitterExecutor you are looking for
    
    Returns:
    
    the SubmitterExecutor for that object.
  - getTotalPendingWriteBytes
```
public long getTotalPendingWriteBytes()
```
    Description copied from interface: SocketExecuter
    
    Check the total number of bytes pending to be sent by clients. This is data which has been provided to the client to write, but is waiting on the network and kernel to accept the write.
    
    Specified by:
    
    getTotalPendingWriteBytes in interface SocketExecuter
    
    Returns:
    
    The total number of bytes pending to write by clients
  - getTotalPendingReadBytes
```
public long getTotalPendingReadBytes()
```
    Description copied from interface: SocketExecuter
    
    Check the total amount of pending reads across all associated clients. Bytes here indicate that the client has been notified a read is available but has not consumed it.
    
    Specified by:
    
    getTotalPendingReadBytes in interface SocketExecuter
    
    Returns:
    
    The total number of bytes pending to read by clients
  - setPerConnectionStatsEnabled
```
public void setPerConnectionStatsEnabled(boolean enabled)
```
    Description copied from interface: SocketExecuter
    
    By default per-connection stats will be enabled. Stats can always be disabled on a per-Client basis, but this allows the default state of the stats to be enabled / disabled.
    
    Specified by:
    
    setPerConnectionStatsEnabled in interface SocketExecuter
    
    Parameters:
    
    enabled - false if stats should not be collected per-connection by default
  - createTCPClient
```
public TCPClient createTCPClient(java.lang.String host,
                                 int port)
                          throws java.io.IOException
```
    Description copied from interface: SocketExecuter
    
    This will create a TCPClient on the specified SocketExecuter.
    
    Specified by:
    
    createTCPClient in interface SocketExecuter
    
    Parameters:
    
    host - This is the remote host or IP to connect this client too.
    
    port - This is the remote port to connect this client too.
    
    Returns:
    
    a TCPClient object.
    
    Throws:
    
    java.io.IOException - This is thrown if we can not make the socket or can not connect to the remote host.
  - createTCPClient
```
public TCPClient createTCPClient(java.nio.channels.SocketChannel sc)
                          throws java.io.IOException
```
    Description copied from interface: SocketExecuter
    
    This will create a TCPClient on the specified SocketExecuter with an already created SocketChannel. This is generally how a TCPServer will create its TCPClients.
    
    Specified by:
    
    createTCPClient in interface SocketExecuter
    
    Parameters:
    
    sc - the SocketChannel to be used for this TCPClient.
    
    Returns:
    
    a TCPClient
    
    Throws:
    
    java.io.IOException - This is thrown if there is a problem with the passed in SocketChannel.
  - createTCPServer
```
public TCPServer createTCPServer(java.lang.String host,
                                 int port)
                          throws java.io.IOException
```
    Description copied from interface: SocketExecuter
    
    This will create a TCPServer on the specified SocketExecuter.
    
    Specified by:
    
    createTCPServer in interface SocketExecuter
    
    Parameters:
    
    host - The local host or IP the TCPServer should listen on.
    
    port - The local port the TCPServer should listen on.
    
    Returns:
    
    a TCPServer.
    
    Throws:
    
    java.io.IOException - This is only thrown if we can not create the TCPServers socket.
  - createTCPServer
```
public TCPServer createTCPServer(java.nio.channels.ServerSocketChannel ssc)
                          throws java.io.IOException
```
    Description copied from interface: SocketExecuter
    
    This will crate a TCPServer from a given ServerSocketChannel object.
    
    Specified by:
    
    createTCPServer in interface SocketExecuter
    
    Parameters:
    
    ssc - The ServerSocketChannel object to use for this TCPServer.
    
    Returns:
    
    a TCPServer.
    
    Throws:
    
    java.io.IOException - This is thrown if there is a problem with the ServerSocketChannel.
  - createUDPServer
```
public UDPServer createUDPServer(java.lang.String host,
                                 int port)
                          throws java.io.IOException
```
    Description copied from interface: SocketExecuter
    
    This will create a UDPServer on the specified SocketExecuter. Please note that UDPClients are made from UDPServers not directly on the SocketExecuter
    
    Specified by:
    
    createUDPServer in interface SocketExecuter
    
    Parameters:
    
    host - The local host or IP the UDPServer should listen on.
    
    port - The local port the UDPServer should listen on.
    
    Returns:
    
    A UDPServer.
    
    Throws:
    
    java.io.IOException - This is only thrown if we can not create the UDPServers socket.
  - startListening
```
public void startListening(Server server)
```
    Description copied from interface: SocketExecuter
    
    This is used by Server to tell the SocketExecuter to start allowing new clients to be accepted. The Server must have been created with this SocketExecuter.
    
    Specified by:
    
    startListening in interface SocketExecuter
    
    Parameters:
    
    server - The Server to start listening on.
  - stopListening
```
public void stopListening(Server server)
```
    Description copied from interface: SocketExecuter
    
    This will stop tell the executer to stop listening for new connections on the specified Server. The Server will not be closed, but will no longer accept or call back in new connections till startListening is called for it.
    
    Specified by:
    
    stopListening in interface SocketExecuter
    
    Parameters:
    
    server - The Server to stop listening with.
  - getClientCount
```
public int getClientCount()
```
    Description copied from interface: SocketExecuter
    
    Get the count of Client on this SocketExecuter.
    
    Specified by:
    
    getClientCount in interface SocketExecuter
    
    Returns:
    
    the number of clients.
  - getServerCount
```
public int getServerCount()
```
    Description copied from interface: SocketExecuter
    
    Get the count of Server from the SocketExecuter.
    
    Specified by:
    
    getServerCount in interface SocketExecuter
    
    Returns:
    
    the number of Servers.
  - getThreadScheduler
```
public org.threadly.concurrent.SubmitterScheduler getThreadScheduler()
```
    Description copied from interface: SocketExecuter
    
    This returns the current SubmitterScheduler for this SocketExecuter. Every SocketExecuter must have some kind of a SubmitterScheduler for it to execute client/server operations on.
    
    Specified by:
    
    getThreadScheduler in interface SocketExecuter
    
    Returns:
    
    returns the SubmitterScheduler the SocketExecuter is using.
  - getStats
```
public SimpleByteStats getStats()
```
    Description copied from interface: SocketExecuter
    
    This will give you read and write stats for the SocketExecuter. This will tell you information about the number of bytes sent/received by this SocketExecuter.
    
    Specified by:
    
    getStats in interface SocketExecuter
    
    Returns:
    
    a SimpleByteStats object to allow you to get the stats for this SocketExecuter.
  - watchFuture
```
public void watchFuture(org.threadly.concurrent.future.ListenableFuture<?> lf,
                        long delay)
```
    Description copied from interface: SocketExecuter
    
    This allows you to put a timer on a ListenableFuture. If the timer triggers before the ListenableFuture is done it will cancel the ListenableFuture
    
    Specified by:
    
    watchFuture in interface SocketExecuter
    
    Parameters:
    
    lf - The ListenableFuture to watch.
    
    delay - The delay time in Millis to wait for the ListenableFuture to finish.

Class NoThreadSocketExecuter

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.threadly.util.AbstractService

Methods inherited from class java.lang.Object

Methods inherited from interface org.threadly.util.Service

Field Detail

SELECT_TIME_MS

Constructor Detail

NoThreadSocketExecuter

NoThreadSocketExecuter

Method Detail

wakeup

setClientOperations

setUDPServerOperations

select

select

getExecutorFor

getTotalPendingWriteBytes

getTotalPendingReadBytes

setPerConnectionStatsEnabled

createTCPClient

createTCPClient

createTCPServer

createTCPServer

createUDPServer

startListening

stopListening

getClientCount

getServerCount

getThreadScheduler

getStats

watchFuture