New Select Module



There is now select support in the [ jython distribution], as of version 2.2rc1.

The new module presents an API which is as close as possible to the [ cpython select module], Jython supports both the

  1. function
  2. [ select.poll objects].

When using the select module, you should be guided by the cpython documentation: any deviation from the behaviour described in that documentation, except for the the considerations mentioned below, should be considered a bug and [ reported] as such.

If you are starting a new project, it is recommended that you use select.poll objects, because

  1. Poll objects are the most efficient mechanism to multiplex sockets on jython, being fairly much a direct mapping to [ objects].

  2. The function is implemented using a poll object, which means that sockets are de/registered every single time, which is slightly less efficient.

Usage notes

Always close poll objects

When a socket has been registered with a select.poll object, it remains registered until explicitly deregistered. This has the following implications

  1. Sockets cannot be placed in blocking mode while they are still registered with poll objects
  2. The reference from the poll object to the socket might interfere with garbage collection

Therefore, it is recommended that you always explicitly close poll objects, using an idiom such as

def my_polling_func(sockets):
    poll_object = select.poll()
        for s in sockets:

Closing a poll object cancels all registrations of sockets.

Differences between cpython and jython

Due to fundamental differences in the behaviour of java and C on various platforms, there are differences between the cpython and jython select modules which are not possible to code around. Those differences will be listed here.

Only sockets in non-blocking mode can be multiplexed

On cpython, when a socket is passed to or select.poll, it can either be in blocking or non-blocking mode.

However, [,%20int) java will only permit multiplex operations on sockets that are in non-blocking mode]. Because jython must respect this java restriction, any attempt in jython to pass a socket in blocking mode to either or select.poll().register will fail with an exception.

To summarise

  1. You must set a socket in non-blocking mode before passing it to the select function or registering it with a poll object
  2. Any attempt to register a blocking socket for multiplex will raise a select.error exception, with an error code of errno.ESOCKISBLOCKING
  3. If a socket is currently registered with a select.poll object, an attempt to change it to blocking mode will give rise to the same exception.
  4. A socket can only be placed in blocking mode if it is not registered with a select.poll object.

This issue could be problematic if you want to use a cpython module which relies on select. Such cpython modules do not set their sockets in non-blocking mode before passing them to In order to support such cpython modules, the following workaround is available.

The cpython-compatible select function

A special version of the select function is provided, to provide cpython compatible select functionality. This function works by

  1. Recording the blocking mode of all sockets that are passed to the function
  2. Setting non-blocking mode on all sockets
  3. Calling the normal jython function (which requires non-blocking sockets)
  4. Restoring the previously-saved blocking mode for all sockets
  5. Returning the results of the wrapped select function

This function should only be used when you are working with code that has been written for cpython select, i.e. when the code is passing blocking-sockets to the select function.

How to enable cpython compatible select processing

Here is a code sample which shows how to use the cpython-compatible select function as a replacement for the standard jython select function

from select import cpython_compatible_select as select

# Make use of the select function here


  1. If using the cpython_compatible_select function, you must be aware that the function will modify the blocking mode of your sockets for the duration of the call. If you are carrying out socket operations on that socket in another thread, then those socket operations may fail or raise exceptions.
  2. This function will still not cover all possible uses of by cpython modules. If a cpython module tries to multiplex the sys.stdin or sys.stdout streams, then registration of the channels will fail, because the InputStream and OutputStream representing sys.stdin and sys.stdout are not SelectableChannels.