Secondary non-blocking window

I am maintaining a several year old AppleScript application and I want to add a secondary window to the application that will have some simple controls. The user will be able to open and close the secondary window at will. The secondary window should not block the main window, i.e., when the secondary window is open, all of the controls in the main window should still be available.
I can create a Panel object in Interface Builder and open it like so:
display panel window "myPanel"
But the panel blocks the main window until it's closed.
If I create a Window object in Interface Builder and attempt to open it like so:
display window "myWindow"
I get an error dialog that says 'window "myWindow" doesn't understand the <<event panSdisP>> message.'
I can't find any attributes to change on the Panel such that it doesn't block my application's main window and I can't figure out what the error is when trying to open a standard Window.
This has got to be easy to do! Can anyone help?
Thanks...

The "finished" message is a close_notify alert. If you examine section 7.2.1 of [rfc 2246|http://www.rfc-editor.org/rfc/rfc2246.txt] and its successors , you'll see the following text:
"...each party is required to send a close_notify alert before closing the write side of the connection. The other party MUST respond with a close_notify alert of its own and close down the connection immediately, discarding any pending writes."
To do what you want, you'll have to implement your own protocol with an end-of-protocol scheme on top of SSL. For example, if you know a priori how many bytes you'll be sending you can start out by sending the byte count. Or, if it is a character protocol then you can bracket the data with XML tags like <message>....</message>.
If at all possible you should avoid writing your own protocol. I'm not an HTTP expert but I'd guess that HTTP over SSL would give you the level of control you need.

Similar Messages

Non-blocking and terminating processes

Can someone give me an example of using the host.nonblocking to terminate a process or a window that is opened using a webutil_file_Transfer.DB_To_Client when finished using the opened document.
I am using oracle 10g developer:
Thanks

"non-blocking port" and "1:1 oversubscription" are the same. It's also the same when you are saying "line rate".

Using OCIBindDynamic with non-blocking connections

I need to use an OCI array interface for execute statements more than once per one request to server.
When I have called stored procedure or function in the non-blocking connection context using OCIBindDynamic for parameter binding, application have been crashed at random time.
I don't have any problems using default (blocking) mode.
Environment:
Oracle 8.1.7 release 3 for Windows
MS Visual C++ 6.0 compiler
Could anybody help me ?

It's always possible in any read that the number of bytes read is less than the number of bytes requested. You need to keep reading until you have got everything you expected, and cope with every possible error condition on each iteration.
EJP

Broken Pipe with Non-blocking Socket

Hello,
I write a Unix Agent who connect on a Windows Server with socket...
Working well on Linux but on Solaris my problem is:
-When my agent is running before server at connection all seems OK: Connect, Select and Getsockopt but when I try to send data I have always EPIPE Signal but I can receive datas from server !
- When my agent is strarting after the server all it's Ok
I don't unserstand this appears on Solaris SPARC 8 and Solaris 9 Intel ...
Please Help is there something special with non-blocking sockets on Solaris ?
Thanks

Can't help you much but what I would recommend is that you
insure that your pipes are opened for both read/write, even
though you are only going to read or write from it. This insures
that the pipe does not close down when you hit EOF.

LV 8.20 crashes on opening non-existent window

With LV 8.20 and Mac OS X 10.4.8
Open LV, and by default it opens a blank window.
(preferences
IsFirstLaunch: False
showNoNavDialog: True
skipNavigatorDialog: True
Close the blank window titled "Untitled 1 Front Panel" using the "close button"
Note that in the Window menu, "Untitled 1 Front Panel" and "Untitled 1 Block Diagram" both still exist.
Select "Untitled 1 Front Panel" in the window menu.
LV will crash as it tries to display a non-existent window
Crash at VirtualInstrument.cpp 2345
Reported to NI SRQ 7137659

Just to update, CAR #43RAJ3C5 has been issued for this.

Non-blocking file behaviour for Reader

Hi!
It will be really nice if Reader will not block files for writing. Assume someone is using TeX to create PDF and he need to
a) examine the results;
b) edit the source.
It becomes a nightmare with Reader. Compile TeX, open Reader, examine results, close Reader. And then from the beginning.
Auto reloading of a PDF file is also a nice feature!
So far I can see only one solution: one should use another viewer to get non-blocking behaviour.
Thanks!

OK, let us see. I use Windows XP Professional SP3, Reader version is 9.3.0. I made a simple test: openned a file in Reader, then openned this file in my favourite text editor and tried to change "%PDF-1.4" to "%PDF-1.3" and save. I received a "File sharing violation error". I can also try to do it in Ubuntu.
As for the open source viewers. That is what I am currently doing: I use additional viewer to view the files I create and I use Adobe Reader to view all other files. One can leave with such solution, but it is not the best.

Non blocking jDialog & return values

Hi,
I have (at the center of this problem) 3 classes. A controller class, and two jDialog windows.
The controller initiates the first jDialog window (a main menu window). When the use clicks on a button the second jDialog window opens (a search window).
How do I start the jDialog windows without the controller blocking on the show() calls?

solved the non-blocking problem now have another lol!
the method in the controller now does not block and the search dialog is displayed fine.
It displays a list of results and the use double clicks on a result to display the details. I am using a jTable to display the results. The table has a mouse click listener that detects the double click. How do i notify the my controller class that the use has selected a result?
If this is an easy problem, accept my apologies, I am relatively new to java...

Non-Blocking Multicast Sockets in JDK 1.4?

Hi,
I've been trying to create non-blocking multicast sockets in JDK1.4, which essentially seems (at this stage) to boil down to the simpler problem of creating a DatagramChannel that uses MulticastSockets, or at least DatagramSockets that can join a Multicast group. Not having found any obvious way to do it, I created this extraordinary hack:
package java.net; // Wicked, wicked!
import java.io.*;
public class MyDatagramSocket {
public static void join(java.net.DatagramSocket socket, InetAddress addr)
throws IOExceptio DatagramSocket ds = new DatagramSocket(port);
ds.setReuseAddress(true);
MyDatagramSocket.join(ds, InetAddress.getByName("224.0.0.104"));
DatagramPacket dp = new DatagramPacket(array, 5000);
ds.receive(dp);          /* READS FINE */
n
socket.impl.join(addr); // Uses knowledge of DatagramSocket culled from examining source to access DatagramSocketImpl
Now I compile this, and drop the class file into my rt.jar files (in the JDK and the JRE), so that I can use MyDatagramSocket.join (DatagramSocket, InetAddress), which looks like it should work from code like this:
try {
int port = 58501;
DatagramChannel dc = DatagramChannel.open();
dc.socket().setReuseAddress(true);
dc.socket().bind(new InetSocketAddress(port));
MyDatagramSocket.join(dc.socket(), InetAddress.getByName("224.0.0.104"));
byte [] array = new byte[5000];
ByteBuffer bb = ByteBuffer.wrap(array);
dc.receive(bb);
System.out.println("Read from dc");
} catch (Exception x) {
x.printStackTrace();
But it doesn't work - it just doesn't read. A simpler example is this:
DatagramSocket ds = new DatagramSocket(port);
ds.setReuseAddress(true);
MyDatagramSocket.join(ds, InetAddress.getByName("224.0.0.104"));
DatagramPacket dp = new DatagramPacket(array, 5000);
ds.receive(dp);          /* READS FINE */
So I know that my hack is working, but this fails:
DatagramChannel dc = DatagramChannel.open();
dc.socket().bind(new InetSocketAddress(port));
dc.socket().setReuseAddress(true);
MyDatagramSocket.join(dc.socket(), InetAddress.getByName("224.0.0.104"));
DatagramPacket dp = new DatagramPacket(array, 5000);
dc.socket().receive(dp);     /* NEVER READS */
I've reduced the problem to one of the difference between a java.net.DatagramSocket - the standard DatagramSocket, and a sun.nio.ch.DatagramSocketAdaptor, which is what DatagramChannels seem to use.
My questions are:
a) Is there a proper way to do this, without my adding my own classes to java.net?
b) If NO is the answer to a), any ideas what I'm doing wrong in my code?
Many thanks for any assistance,
Craig

I've encountered the same problem in my code. The datagramChannel never receives incoming data. Doesn't matter the rate at which you send it or anything else. I don't see any way around this problem at the moment. If i find something i'll post it. Interesting enough, my friend who programs with C++ got non-blocking I/O with datagrams to work in windows. So this might just be java.

NIO Non-Blocking Server not Reading from Key

I have created a NIO non blocking server (below) and it will not pick up any input from the client.... My log doesnt even show that it enters the readKey() method, so it must be something before. Any help would be appreciated.
Scott
package jamb.server;
import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.channels.spi.SelectorProvider;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.util.Iterator;
import java.util.Set;
import java.util.logging.Logger;
import java.util.prefs.Preferences;
import jamb.server.client.Client;
public class Server {
        private Selector selector;
        private ServerSocketChannel serverChannel;
        private static Logger logger = Logger.getLogger("jamb.server");
        private static Preferences prefs = Preferences.systemRoot().node("/jamb/server");
        public void init() {
                logger.entering("jamb.server.Server", "init");
                //Get a selector...
                try {
                        selector = SelectorProvider.provider().openSelector();
                        //Open the SocketChannel and make it non-blocking...
                        serverChannel = ServerSocketChannel.open();
                     serverChannel.configureBlocking(false);
                        //Bind the server to the port....
                        int port = prefs.getInt("Port", 4000);
                        logger.config("Server configured on port " + port + " (default: 4000)");
                     InetSocketAddress isa = new InetSocketAddress(
                                InetAddress.getLocalHost(), port);
                     serverChannel.socket().bind(isa);
                } catch (IOException ioe) {
                        logger.severe ("IOException during server initialization!");
                logger.exiting("jamb.server.Server", "init");
        public void run() {
                logger.entering("jamb.server.Server", "run");
                int bufferSize = prefs.getInt("BufferSize", 8);
                logger.config("Buffer size set to " + bufferSize + " (default: 8)");
                SelectionKey acceptKey = null;
                try {
                        acceptKey = serverChannel.register(
                                selector, SelectionKey.OP_ACCEPT);
                } catch (ClosedChannelException cce) {
                try {
                        while (acceptKey.selector().select() > 0) {
                                Set readyKeys = selector.selectedKeys();
                                Iterator i = readyKeys.iterator();
                                while (i.hasNext()) {
                                        //logger.finest("Processing keys...");
                                        //Get the key from the set and remove it
                                        SelectionKey currentKey = (SelectionKey) i.next();
                                        i.remove();
                                        if (currentKey.isAcceptable()) {
                                                logger.finest("Accepting key...");
                                                acceptKey(currentKey);
                                        } else if (currentKey.isReadable()) {
                                                logger.finest("Reading key...");
                                                readKey(currentKey, bufferSize);
                                        } else if (currentKey.isWritable()) {
                                                //logger.finest("Writing key...");
                                                writeKey(currentKey);
                } catch (IOException ioe) {
                        logger.warning("IOException during key handling!");
                logger.exiting("jamb.server.Server", "run");
        public void flushClient (Client client) {
                try {
                        ByteBuffer buf = ByteBuffer.wrap( client.getOutputBuffer().toString().getBytes());
                        client.getChannel().write(buf);
                } catch (IOException ioe) {
                        System.out.println ("Error writing to player");
                client.setOutputBuffer(new StringBuffer());
        private void acceptKey (SelectionKey acceptKey) {
                logger.entering("jamb.server.Server", "acceptKey");
                //Retrieve a SocketChannel for the new client, and register a new selector with
                //read/write interests, and then register
                try {
                        SocketChannel channel = ((ServerSocketChannel) acceptKey.channel()).accept();
                        channel.configureBlocking(false);
                        SelectionKey readKey = channel.register(
                                selector, SelectionKey.OP_READ|SelectionKey.OP_WRITE );
                        readKey.attach(new Client(this, channel));
                } catch (IOException ioe) {
                        System.out.println ("Error accepting key");
                logger.exiting("jamb.server.Server", "acceptKey");
        private void readKey (SelectionKey readKey, int bufSize) {
                logger.entering("jamb.server.Server", "readKey");
                Client client = (Client) readKey.attachment();
                try {
                        ByteBuffer byteBuffer = ByteBuffer.allocate(bufSize);
                        int nbytes = client.getChannel().read( byteBuffer );
                        byteBuffer.flip();
                        Charset charset = Charset.forName( "us-ascii" );
                        CharsetDecoder decoder = charset.newDecoder();
                        CharBuffer charBuffer = decoder.decode(byteBuffer);
                        String text = charBuffer.toString();
                        client.getInputBuffer().append(text);
                        if ( text.indexOf( "\n" ) >= 0 )
                                client.input();
                } catch (IOException ioe) {
                        logger.warning("Unexpected quit...");
                        client.disconnect();
                logger.exiting("jamb.server.Server", "readKey");
        private void writeKey (SelectionKey writeKey) {
                //logger.entering("jamb.server.Server", "writeKey");
                Client client = (Client) writeKey.attachment();
                if (!client.isConnected()) {
                        client.connect();
                //logger.exiting("jamb.server.Server", "writeKey");

From my own expierence with the NIO (Under Windows XP/ jdk1.4.1_01); you can't seem to set READ and WRITE at the same time.
The program flow I usually end up with for a echo server is:
When the selector.isAcceptable(): accept a connection; register for READs
In the read event; write the incoming characters to a buffer; register for a WRITE and add the buffer as an attachment.
In the write event; write the data to the socket If all the data was written; register for a READ; otherwise register for another WRITE so that you can write the rest.
Not sure if that the "proper" way; but it works well for me.
- Chris

Non-blocking socket concurrent limitation?

I have 2 socket program,one is server side used nio package with JDK1.4.1,the other is client used traditional socket,the client will initialize about 50
threads trying to connect with server when starting,but only about 15
can be accepted,these 2 program are runnning in the same computer which
OS is win2000 professional PC.
the followd is these code:
please make a probe with them ,and tell me what's going on?
server:
package nio_select_demo;
import java.io.*;
import java.net.*;
import java.nio.*;
import java.nio.channels.*;
import java.util.*;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
public class Server implements Runnable
// The port we will listen on
private int port;
// A pre-allocated buffer for processing data
private final ByteBuffer buffer = ByteBuffer.allocate( 16384 );
private ByteBuffer resBuf = ByteBuffer.allocate( 128 );
Selector selector;
AddInfo test ;
public Server( int port ) {
this.port = port;
// for (int i=0; i<threadnum; ++i) {
new Thread( this ).start();
test = new AddInfo();
test.start();
public void run() {
try {
// create a ServerSocketChannel
ServerSocketChannel ssc1 = ServerSocketChannel.open();
// ServerSocketChannel ssc2 = ServerSocketChannel.open();
// Set it to non-blocking
ssc1.configureBlocking( false );
// Get the Socket connected to this channel, and bind it
// to the listening port
ServerSocket ss = ssc1.socket();
InetSocketAddress isa = new InetSocketAddress( port );
ss.bind( isa , 60 );
// Create a new Selector for selecting
selector = Selector.open();
// Register the ServerSocketChannel, so we can
// listen for incoming connections
ssc1.register( selector, SelectionKey.OP_ACCEPT );
System.out.println( "Listening on port "+port );
int n = 0;
while (true) {
// See if we've had any activity -- either
// an incoming connection, or incoming data on an
// existing connection
int num = selector.select();
// If we don't have any activity, loop around and wait
// again
if (num == 0) {
continue;
// Get the keys corresponding to the activity
// that has been detected, and process them
// one by one
Set keys = selector.selectedKeys();
Iterator it = keys.iterator();
while (it.hasNext()) {
// Get a key representing one of bits of I/O
// activity
SelectionKey key = (SelectionKey)it.next();
// What kind of activity is it?
if ((key.readyOps() & SelectionKey.OP_ACCEPT) ==
SelectionKey.OP_ACCEPT) {
System.out.println( "accept request" );
// It's an incoming connection.
// Register this socket with the Selector
// so we can listen for input on it
SocketChannel sc = ((ServerSocketChannel)key.channel()).accept();
System.out.println( "Got connection from "+sc.socket());
// Make sure to make it non-blocking, so we can
// use a selector on it.
//SocketChannel sc = s.getChannel();
sc.configureBlocking( false );
// Register it with the selector, for reading
sc.register( selector, SelectionKey.OP_READ| SelectionKey.OP_WRITE);
} else if ((key.readyOps() & SelectionKey.OP_READ) ==
SelectionKey.OP_READ) {
//ssc.register(selector , SelectionKey.OP_READ);
SocketChannel sc = null;
try {
// It's incoming data on a connection, so
// process it
sc = (SocketChannel)key.channel();
Socket s1 = sc.socket();
s1.setTcpNoDelay(true);
System.out.println( "enter processing data" );
boolean ok = processInput( key );
synchronized (selector) {
key.interestOps(key.interestOps() & ~SelectionKey.OP_READ);
// If the connection is dead, then remove it
// from the selector and close it
if (!ok) {
key.cancel();
System.out.println("dead");
Socket s = null;
try {
s = sc.socket();
s.close();
} catch( IOException ie ) {
System.err.println( "Error closing socket "+s+": "+ie );
} catch( IOException ie ) {
ie.printStackTrace();
// On exception, remove this channel from the selector
key.cancel();
System.err.println( "Error raised in this socket");
try {
sc.close();
} catch( IOException ie2 ) { System.out.println( ie2 ); }
System.out.println( "Closed "+sc );
else if ((key.readyOps() & SelectionKey.OP_WRITE) ==
SelectionKey.OP_WRITE) {
System.out.println("Enter Writing");
String response = new String();
if((response=this.test.getInfo())!=null){
resBuf.clear();
SocketChannel sc = (SocketChannel)key.channel();
resBuf = ByteBuffer.wrap( response.getBytes("ISO-8859-1" ) );
sc.write( resBuf );
synchronized (selector) {
key.interestOps(key.interestOps() & ~SelectionKey.OP_WRITE);
// We remove the selected keys, because we've dealt
// with them.
keys.clear();
} catch( IOException ie ) {
System.err.println( ie );
private boolean processInput( SelectionKey key ) throws IOException {
buffer.clear();
SocketChannel sc = (SocketChannel)key.channel();
sc.read( buffer );
buffer.flip();
String response = new String("response ok");
// If no data, close the connection
if (buffer.limit()==0) {
return false;
Charset charset=Charset.forName("ISO-8859-1");
CharsetDecoder decoder = charset.newDecoder();
CharBuffer charBuffer = decoder.decode(buffer);
System.out.println(charBuffer.toString());
System.out.println( "Processed "+buffer.limit()+" from "+sc );
return true;
static public void main( String args[] ) throws Exception {
int port = Integer.parseInt( args[0] );
System.out.println(port);
new Server( port );
cilent:
import java.io.*;
import java.net.*;
import java.util.*;
public class Client implements Runnable
private String host;
private int port;
private int acport;
//the size of buffer on how much we write and read per cycle
private static final int maxWriteSize = 128;
public Client( String host, int port, int numThreads ) {
this.host = host;
this.port = port;
for(int i =0;i<50;i++){//initialize 50 client threads
new Thread(this).start();
public void run() {
byte buffer[] = new byte[maxWriteSize];
byte buffer2[] = new byte[maxWriteSize];
try {
Socket s = new Socket( );
InetSocketAddress sa = new InetSocketAddress(host,this.port);
s.connect(sa);
System.out.println(s);
s.setTcpNoDelay(true);
InputStream in = s.getInputStream();
OutputStream out = s.getOutputStream();
for (int i=0; i<maxWriteSize; ++i) {
buffer[i] = (byte)'a';
out.write( buffer, 0, maxWriteSize );
int pause = 500;
in.read( buffer , 0 , maxWriteSize );
System.out.println( Thread.currentThread()+" wrote "+maxWriteSize);
String res = new String ( buffer );
String res2 = new String ( buffer2 );
System.out.println( res );
try { Thread.sleep( pause ); } catch( InterruptedException ie ) {}
} catch( Exception ie ) {
ie.printStackTrace();
System.err.println(ie.getMessage());
static public void main( String args[] ) throws Exception {
String host = "127.0.0.1";
int port = Integer.parseInt( args[0] );
int numThreads = Integer.parseInt( args[1] );
new Client( host, port, numThreads );

I have found the reason!!!
because of system resource limitation,windows can't afford to maintain
so many concurrent stream-IO,so some socket will be closed.
I modified the client side code,adding thes segments to client instantialize
such as :
public Client( String host, int port, int numThreads ) {
for(int i =0;i<1000;i++){
new Thread(this).start();
try {
Thread.currentThread().sleep(100);//give system some idle
} catch (InterruptedException e) {
/* ignore */
then the server can accept more than 1000 client request concurrently.

Non-blocking SocketChannel and close - huh?

It looks like closing a socketchannel that is in non-blocking mode can result in a dead drop of the connection, with some bytes that have already been sent and accepted (as in, 'consumed' from the buffer) being completely dropped.
In fact, I'm generally confused: Actual C non-blocking code has a similar setup for 'close' as you can see in SocketChannel's OP_CONNECT behaviour - just because you want to connect the socket doesn't mean it magically happends without blocking. Wait for a ready flag, then try again.
It should work the same way with close (you try to close, but it may not be possible without blocking).
Is this a huge gaping bug that no one quite figured out just yet, or did I miss something? I loathe to turn on linger, as that's just a crapshoot (you never know if it actually gets through. You could run into funny surprises once the server gets a bit busy. I'd rather not) and tends to cause massive leaks on linux, at least according to some google searches.
There seems to be slightly better performance (in that I have always received all data sofar) if I close the socket instead of the channel (socketChannel.socket().close() instead of socketChannel.close()) - but this has been a random attempt at 'making it work', and I can't find any documentation that backs up that this will DEFINITELY not lose any information without letting me know somehow. That still sounds impossible with this approach.

Actual C non-blocking code has a similar setup for
'close' as you can see in SocketChannel's
OP_CONNECT behaviour ...No it doesn't. I don't know what you mean by this.
Closing a socket is asynchronous, but it shouldn't lose any data - if the data can be delivered it will be, followed by the FIN. You don't know when it is delivered, and you don't get to hear about any errors such as an RST coming from the other end, say if it decided to close before reading all the data, or if some intermediate router hung you up.
I'm wondering if you are really dealing with all the short write and zero length write possibilities, i.e. whether the data isn't really still in your output buffer. Don't wish to teach you to suck eggs but there are some subtleties here.
Setting a positive linger timeout doesn't really help because Java doesn't tell you if the timeout expired. (I only asked for this about four years ago). You get to wait while any pending data is delivered, but you still have to guess about whether it all went or the timeout expired, and the behaviour after the timeout expires is platform-dependent: some (Windows) issue an RST, others (Unix) keep trying.
Blocking or non-blocking mode shouldn't make any difference to this (except that Linux will block on a positive linger timeout even in non-blocking mode, which is wrong), and whether you close the channel or the socket is immaterial as one calls the other anyway.
The reason why OP_CONNECT is different in blocking/non-blocking modes is that in blocking mode it won't return until the SYN-ACK is received, while in non-blocking mode it just sends the SYN and relies on you calling connect() again (at the C level) to collect the SYN-ACK, or not - this is what finishConnect() tells you.
tends to cause massive leaks on linux, at least
according to some google searchesIt can't, unless you are referring to the Helix client thing, which appears to be just a badly designed C++ class library with, for some reason, its own linger implementation outside the kernel.

What is non blocking IO?

I have heard that 1.4 supports non blocking IO, and that this is greath for servers. What is it, how does it work and why is it so good?

I could be wrong - but if they have not yet done so
a good optimization would be to rearrange the
select list - such that the sockets that have
an event appears at the top of the list.
This way - when the select completes - it tells
you that there are - say 2 - active events - you
would then just read the first two channels on
the select list.From the API javadoc:
The selected-key set is the set of keys such that each key's channel was detected to be ready for at least one of the operations identified in the key's interest set during a prior selection operation. This set is returned by the selectedKeys method. The selected-key set is always a subset of the key set.
ie- select and iterate. No polling involved.
They just completed the java EventListener model
for the GUI. It would have been simple and clean
to implement a similar model for io. You have
the io channel - you would just attach an event
listener to it much like you would do for a control.
When an io finishes on a channel, you would be
told immediately the channel that the io completed
and what event occured - read, write etc.
Now you could have a million sockets
( if ever unix could support that many file
discriptors )
and you when an io completes no need to poll
a bunch of idle sockets.Question: What thread would this run in?
* Does it run in the network layer? How many concurrent event notifications can the network layer at any one time? Is it likely it would be an EventQueue-esque single thread?
* Does it spawn a new thread for each event? This would certainly yield worse results than spawning a new thread for each socket, since each socket would generate a vast number of events.
* Does it have a thread pool to deal with the events? Then you would be using exactly the same model as java.nio's Selector.
FYI: The windows NT asynchronous IO model uses
an event model - IO completion ports. It is far more
modern, advanced and efficient that the select / poll
model used in unix.Do you have any links for more information?
Sun could have incorporated the most modern / best
features into java and make it competitive. Instead
they went for least common denominator.Sun's nio package was (somewhat) based on a community project, and was integrated into Java on JSR-051
http://www.cs.berkeley.edu/~mdw/proj/java-nbio/
If there were such an initiative for NT-style asynchronous IO, and this was proven to be more efficient, then I imagine it will be much more likely to be integrated with the language.
If it isn't, you could still use the community-based implementation, as you could with the nbio package before 1.4 was released.
Just because Sun doesn't do something, doesn't mean you can't!

Are the experts wrong about non-blocking SocketChannels?

Everyone says to use the new SocketChannel and Selector for "highly scalable" server applications. So I ran a couple of tests using non-blocking (via Selector) and thread-per-connection SocketChannels.
The Selector version consumes 8x more cpu than the thread-per-connecton version!
Using JDK 1.4.1 FCS on Win2K, with 1000 socket connections each sending 1k bytes per second, the Selector version was consuming 40% cpu with 10 threads; the thread-per-connection version (using blocking SocketChannels) was only consuming about 5% cpu with 1009 threads.
So, are the experts wrong? Is there a performance problem when number of SocketChannels exceed a certain threshold?
For anyone interested, here's the source code:
Non-Blocking Server using Selector
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
import java.nio.channels.FileChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
public class Server4 implements Runnable
private static int port = 80;
public static void main(String args[]) throws Exception
Server4 server = new Server4();
Thread thread = new Thread(server);
thread.setDaemon(true);
thread.start();
thread.join();
public Server4() throws IOException
ServerSocketChannel server = ServerSocketChannel.open();
InetSocketAddress isa = new InetSocketAddress(port);
server.configureBlocking(false);
server.socket().bind(isa);
m_selector = Selector.open();
server.register(m_selector, SelectionKey.OP_ACCEPT);
Charset utf8 = Charset.forName("UTF-8");
m_decoder = utf8.newDecoder();
m_encoder = utf8.newEncoder();
public void run()
int count = 0;
try
ByteBuffer buffer = ByteBuffer.allocateDirect(2048);
//FileOutputStream fos = new FileOutputStream("server4.dat");
//FileChannel fc = fos.getChannel();
while (m_selector.select() > 0)
Set keys = m_selector.selectedKeys();
for (Iterator itr = keys.iterator(); itr.hasNext(); )
SelectionKey key = (SelectionKey) itr.next();
itr.remove();
if (key.isAcceptable())
System.out.println("accept: " + (++count));
ServerSocketChannel server
= (ServerSocketChannel) key.channel();
SocketChannel channel = server.accept();
channel.configureBlocking(false);
channel.register(m_selector, SelectionKey.OP_READ);
else
SocketChannel channel = null;
try
if (key.isReadable())
channel = (SocketChannel) key.channel();
int bytes = channel.read(buffer);
if (bytes <= 0) // Linux does not throw IOException
channel.close(); // will also cancel key
System.out.println("connection closed " + count);
else
buffer.flip();
//fc.write(buffer);
buffer.clear();
catch (IOException ioe) // connection closed by client
System.out.println("readable: " + ioe.getMessage());
sm_logger.log(Level.INFO, ioe.getMessage(), ioe);
Throwable cause = ioe.getCause();
if (cause != null)
System.out.println("cause: "
+ cause.getClass().getName()
+ ": " + cause.getMessage());
channel.close(); // will also cancel key
--count;
catch (IOException e)
System.out.println("run: " + e.getMessage());
sm_logger.log(Level.SEVERE, e.getMessage(), e);
catch (Exception e)
System.out.println("run: " + e.getMessage());
sm_logger.log(Level.SEVERE, e.getMessage(), e);
private Selector m_selector;
private CharsetDecoder m_decoder;
private CharsetEncoder m_encoder;
private static Logger sm_logger = Logger.getLogger("Server");
Thread-Per-Connection Server
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
import java.nio.channels.FileChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
public class MultiThreadServer implements Runnable
private static int port = 80;
public static void main(String[] args) throws Exception
ServerSocketChannel server = ServerSocketChannel.open();
InetSocketAddress isa = new InetSocketAddress(port);
server.socket().bind(isa);
int count = 0;
while (true)
SocketChannel channel = server.accept();
System.out.println("accept: " + (++count));
MultiThreadServer worker = new MultiThreadServer(channel);
Thread thread = new Thread(worker);
thread.setDaemon(true);
thread.start();
public MultiThreadServer(SocketChannel channel) throws IOException
m_channel = channel;
public void run()
ByteBuffer buffer = ByteBuffer.allocateDirect(2048);
int bytes = 0;
try
while ((bytes = m_channel.read(buffer)) > 0)
buffer.flip();
// process buffer
buffer.clear();
System.out.println("connection closed");
m_channel.close();
catch (IOException e)
System.out.println("run: " + e.getMessage());
sm_logger.log(Level.SEVERE, e.getMessage(), e);
catch (Exception e)
System.out.println("run: " + e.getMessage());
sm_logger.log(Level.SEVERE, e.getMessage(), e);
private SocketChannel m_channel;
private static Logger sm_logger = Logger.getLogger("MultiThreadServer");
Client
import java.io.*;
import java.net.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.charset.*;
import java.util.Arrays;
import java.util.Iterator;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
public class MultiClient implements Runnable
public static void main(String[] args) throws Exception
if (args.length < 1)
System.out.println("usage: java MultiClient number [host]");
System.exit(1);
int number = Integer.parseInt(args[0]);
String host = (args.length == 2) ? args[1] : "localhost" ;
Thread[] threads = new Thread [number];
InetSocketAddress address = new InetSocketAddress(host, 80);
for (int i = 0; i < number; i++)
MultiClient client = new MultiClient(address, Integer.toString(i));
threads[i] = new Thread(client);
threads.setDaemon(true);
for (int i = 0; i < number; i++)
threads[i].start();
for (int i = 0; i < number; i++)
threads[i].join();
public MultiClient(InetSocketAddress address, String id)
throws InterruptedException, IOException
m_id = id;
Charset charset = Charset.forName("UTF-8");
m_decoder = charset.newDecoder();
m_encoder = charset.newEncoder();
m_channel = SocketChannel.open();
m_channel.connect(address);
if (id.equals("0"))
Socket socket = m_channel.socket();
System.out.println("SO_SNDBUF=" + socket.getSendBufferSize()
+ ",SO_TIMEOUT=" + socket.getSoTimeout()
+ ",SO_KEEPALIVE=" + socket.getKeepAlive());
byte[] buf = new byte [1024]; // bufsize = 1K
Arrays.fill(buf, (byte) m_id.charAt(0));
m_buffer = ByteBuffer.allocateDirect(1024);
m_buffer.put(buf);
m_buffer.flip();
Thread.currentThread().sleep(50L);
public void run()
System.out.print(m_id);
try
while (true)
m_channel.write(m_buffer);
m_buffer.rewind();
Thread.currentThread().sleep(1000L);
catch (IOException ioe)
ioe.printStackTrace();
catch (InterruptedException ie)
System.err.println(ie.toString());
private String m_id;
private CharsetEncoder m_encoder;
private CharsetDecoder m_decoder;
private SocketChannel m_channel;
private ByteBuffer m_buffer;

{This is a crosspost. I posted this earlier today at http://forum.java.sun.com/thread.jsp?forum=4&thread=319822 before I stumbled on a search phrase that located this older thread.
All follow-ups should be on haam's thread instead of mine. The important point below is that NIO select() behavior (vs. threading IO) is [b]worse under Windows but better under Solaris. This seems fundamentally broken. }
My company sells a scalable multi-user server platform built on Java 2.
It runs under Java 1.3.1 (and 1.4.0 windows) using multiple threads for communications, and 1.4.x (unix) using NIO. We were happy to see that 1.4.1 (windows) fixed the problem drastically limiting the number of selectable ports. :-)
The bad news is that whatever the VM is doing "under the sheets" to fix the problem seems to perform very poorly in terms of CPU:
I compared connecting 500 simulated users to a Solaris 8 and a Win2K box. These users were in 25 chat rooms, each sending a chat message every 30 seconds. (There was plenty of memory on each machine. There was no swapping in either case. Clock/CPU type doesn't matter as this isn't about comparing a machine to a machine, but different load characteristics -within- a machine environment.)
                Threaded IO      NIO/Select
Solaris 1.4.1     20-30%           15- 20%
Windows 1.4.1     40-50%           95-100%Numbers are % of CPU as reported by 'top' and the Win2K task manager.
Both platforms showed the expected significant improvement in memory usage when moving from standard threaded IO to NIO.
Strangely, the Windows implementation of the VM showed a significant (and unexpected) degradation of NIO performance vs. the threaded model, whereas the Solaris VM behaved as expected: NIO outperformed threaded IO.
Our best guess is that the Selector fix in 1.4.1 is implemented in some cpu-intensive way; perhaps polling. As a result, we still can't use NIO for Wintel boxes running our server. :-( To us, Selector
is still broken.
Has anyone else seen results like this? Have we missed some configuration parameter that will fix this?
I thought the big upside of using select() was supposed to be performance. :-P
F. Randall Farmer
State Software, Inc.
http://www.statesoftware.com

SQL Developer blocking vs non-blocking

Hi,
Is there a way in SQL Developer 3.0 to have a non-blocking SQL call? In Oracle Forms we can choose between blocking and non-blocking SQL Net connections to the database. Does SQL Developer have the same capability? If so where exactly are those options hidden in the preferences menus?
Annoyed,
ScottK
Edited by: ScottK on Jun 1, 2011 11:20 AM

Hi ScottK,
SQLDeveloper locks access to individual connections when they are in use, if you want to simulate
some aspects of non blocking behaviour you can use other connections.
The following features might help:
Use a different connection name back to the same schema in your database - it will be treated as an independent connection and 'blocking' on this connection will not affect your other connections.
This can be achieved temporarily in the worksheet by:
ctrl shift n
which creates a worksheet with new connection independent of your existing worksheet connection
though connected to the same schema and database.
-Turloch
SQLDeveloper team

ORA-03118 two-task error while doing a non blocking OCI call

Hi,
I have an application that runs on Linux and uses OCI API (version 8.1.6).
If I do the following in non blocking mode after polling about
70 times I get the error:
ORA-03118: two-task coroutine has invalid state
do {
call_cnt++;
rtc = OCIStmtFetch(stmtptr->stmt, oracle_err, 1, OCI_FETCH_NEXT,
OCI_DEFAULT);
} while (rtc == OCI_STILL_EXECUTING);
This doesn't happen all the time but it happens most often on big selects.
Does anyone have any idea what is happening here?
I have searched for related information but have come up dry. If anyone
knows anything or maybe a better place to ask this question please tell me.
Thanks,
Barry
null

Ask your basis guys to increase the table space...
check this thread...
[Error : DBIF_RSQL_SQL_ERROR;
--- Thanks...

Secondary non-blocking window

Similar Messages

Maybe you are looking for