Thread vs Non-Blocking - invoke thead

Hi,
My question related to Thread vs Non-Blocking IO used for network application. If my application needs to handle several thousands or even ten thousand connection simultaneously, did I little research, I concluded that instead of having 10,000 thread running (don't know even that number is possible), I should use NIO instead. My question is that, if I use NIO and fire up a thread everytime I had new data coming in to process, will over head of creating new thread reduce performance a lot than having all the thread running all the time? Should I handle incoming data sequentially and try to avoid blocking during the process?
TIA

If you would take the trouble of reading the previous 10 or 20 posts in this forum about threads and/or NIO you would have your answer, or at least most of it.

Similar Messages

Multiple non-blocking selectors in threads

About networking in java and sockets i read alot. I know about the 2 implementations witk thread per client and non-blocking IO (usage of select()). I ran a few tests of my own and i could't decide. So I wrote a server that uses them both. The Ideea is to have no more than 100 clients per each selector and each selector runs in a thread. so when you have 4000 clients you actualy have 40 threads running each 100 clients:D
However I'm stuck. I wrote this piece of code that has 2 objects one work thread with his own selector and a main thread with an accepting selector. The problem is that when I connect to it via telnet it only works when there is an even number of clients:(( when client nr 1 connects it blocks on channel.register(workSelector,SelectionKey.OP_READ);when client 2 gets connected it works:((
HELP!!!
here is the
import java.nio.*;
import java.nio.channels.*;
import java.nio.charset.*;
import java.io.*;
import java.net.*;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
//work thread with own selector
class workThread implements Runnable{
     public int userCount=0;
     public int ID=0;
     private Charset charset;
     private CharsetEncoder encoder;
     private CharsetDecoder decoder;
     private ByteBuffer buffer;
     private ConcurrentHashMap userMap;
     public Selector workSelector = null;
     public void addClient(SelectableChannel channel, int ops) throws IOException{
          if (channel == null) return;
          //channel.configureBlocking(false);
          System.out.println("Channel was added in workSelector : "+channel);
          channel.register(workSelector,SelectionKey.OP_READ);
          System.out.println("Client was added in work selector : " + ID);
          userCount++;
          System.out.println("Client nr : "+userCount);
     public boolean find(String name){
          return true;
     public workThread() throws IOException{
          charset = Charset.forName("ISO-8859-1");
          encoder = charset.newEncoder();
          decoder     = charset.newDecoder();
          buffer = ByteBuffer.allocate(256);
//          System.out.println("S-a creat selectorul");
          workSelector = Selector.open();
          System.out.println("Selector open ");
     private void doRead(SelectionKey key) throws IOException{
          SocketChannel clientChannel = (SocketChannel)key.channel();
          buffer.clear();
          System.out.println("Speaking to client");
          if(clientChannel.read(buffer) == -1){
               key.cancel();
               clientChannel.close();
          }else{
               buffer.flip();
               String message = decoder.decode(buffer).toString();
               System.out.println(message);
               if(message.trim().equals(".")){
                    clientChannel.write(encoder.encode(CharBuffer.wrap("BYE")));
                    key.cancel();
                    clientChannel.close();
               }else{
                    buffer.flip();
                    clientChannel.write(buffer);
     private void doWrite(SelectionKey key){
          System.out.println("WRITE!!!");
     public void run(){
          while(true){
               try{
               if(workSelector.select() > 0){
                    Set keys1 = workSelector.selectedKeys();
                    for(Iterator itr = keys1.iterator();itr.hasNext();){
                         SelectionKey key = (SelectionKey)itr.next();
                         itr.remove();
                         if(key.isReadable()) {doRead(key);}
                    //     if(key.isWritable()) {doWrite(key);}
          }catch(IOException e){
               System.out.println("Error in workthread "+ID+" "+e);
//main thread
public class msselect implements Runnable{
     private ServerSocketChannel server;
     private ServerSocket sock;
     private Selector acceptSelector;
     private workThread wk;
     public static void main(String args[]){
          try{
          msselect x = new msselect("80.97.89.73",6500,5);
          new Thread(x).start();
          }catch(IOException ex){
               System.out.println("Probleme"+ex);
     msselect(String host, int port, int numT) throws IOException{
          server = ServerSocketChannel.open();
          sock = server.socket();
          sock.bind(new InetSocketAddress(port));
          server.configureBlocking(false);
          acceptSelector = Selector.open();
          server.register(acceptSelector, SelectionKey.OP_ACCEPT);
/*          for(int i=0;i<numT;i++){
               wk[i] = new workThread();
               wk.ID = i;
               new Thread(wk[i]).start();
          wk = new workThread();
          wk.ID = 1;
          server.register(wk.workSelector, SelectionKey.OP_ACCEPT);
          new Thread(wk).start();
     public void run(){
          while(true){
               try{
               acceptSelector.select();
               Set keys = acceptSelector.selectedKeys();
               for(Iterator itr = keys.iterator();itr.hasNext();){
                    SelectionKey key = (SelectionKey)itr.next();
                    itr.remove();
                    if(key.isAcceptable()){
                         SocketChannel client = null;
                         client = server.accept();
                         client.configureBlocking(false);
                         System.out.println("Accepted "+client);
                         wk.addClient(client,SelectionKey.OP_READ);
          }catch(IOException e){
               System.out.println("Main Thread error"+e);

I compiled and ran your code.
The call channel.register(...) should block while selector is blocked in workSelector.select(). The fact that the registration succeeds is that you registered the server channel with both the work selector and the acceptor selector. The work selector is returning from select() because of a new client connection is accepted and is a matter of thread scheduling that the client.register() succeeeds (but only sometimes).
Possible solution:
- don't register the server channel with the work selector;
- probably call workSelector.wakeup() to make the client channel registration possible.

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...

Implementing non-blocking read

Hi all
I have some doubts about implementing non-blocking io in my application.
I am using Jsch library (an ssh implementation) to open an ssh connection with a host. The API only provides me with methods to open a connection and retreive the input & output streams. I want to make my read on inputstream non-blocking.In such a case is it possible to use nio for the purpose?
If it's not possible then I am planning to use threading to make read() non-blocking. Here also i need some clarifications. I am planning to use a ThreadPoolExecutor to create a thread pool for reading data. SO whenever i have a read i'll assign this task to the pool which will use one of the free threads to execute the inputStresm.read().
Now the question is if one of the threads in this pool blocks forever during a read since it didn't get any response from the other side, is there a way to stop that read and make that thread free again to execute more tasks? or will the thread block forever till the application is closed?
In my case i cannot afford to have too many such blocked threads, since this application will not be restarted very often. Once it is started it can go on for may be days or months.
Please suggest what would be best in my case taking into account performance as most important factor.
Thanks in advance.
Anu

endasil wrote:
First of all, let me state that I agree with the others in saying that I don't fully agree with your premises.
That said, I believe that this does a non-blocking read based on the contract of InputStream.available() and .read(byte[], int, int):
private int nonBlockingRead(InputStream in, byte[] buffer) throws IOException {
return in.read(buffer, 0, Math.min(in.available(), buffer.length));
If the InputStream is obtained from a JSSE socket then it is my understanding that available() always returns zero. This is allowed under the InputStream.available() contract as defined in the Javadoc - http://java.sun.com/javase/6/docs/api/java/io/InputStream.html#available() . If I am right then your code will never read anything from a JSSE socket InputStream and I would suspect that Jsch is using JSSE sockets.

SELECT of OCILobLocator in Non Blocking mode

Hi all.
I have problem:
I try select BLOB field into OCILobLocator* buffer in Non Blocking mode, and receive 'ORA-03106: fatal two-task communication protocol error' sometimes.
Details:
Application contains two threads : 1. select blob field, 2. update it.
I tried separate update and select to different apps (and run its in one time) - problem reproduced.
problem reproduced for OCIStmtFetch and OCIStmtFetch2.
If disable non blocking mode - problem disappear.
if error appear - record level error code contains 1405. Need wait few minutes for error message appearing (~1 minute in my case).
Using of OCI_DEFAULT in OCIDefineByPos instead OCI_DYNAMIC_FETCH don't solve problem.
I use oracle server and client library with version 10.2.0.4
Output sample:
execute_select(): can't make OCIStmtFetch2: status = -1, message = 'ORA-03106: fatal two-task communication protocol error
', error code = 3106, row errors: #877: 1405
execute_select(): can't make OCIStmtFetch2: status = -1, message = 'ORA-03106: fatal two-task communication protocol error
', error code = 3106, row errors: #54: 1405
execute_select(): can't make OCIStmtFetch2: status = -1, message = 'ORA-03106: fatal two-task communication protocol error
', error code = 3106, row errors: #877: 1405
execute_select(): can't make OCIStmtFetch2: status = -1, message = 'ORA-03106: fatal two-task communication protocol error
', error code = 3106, row errors: #54: 1405
Can anybody help me ?
m.b. exists workaround ?
#include <iostream>
#include <sstream>
#include <assert.h>
#include <oci.h>
#define _DYN 1
before run this test run next sql at DB:
CREATE TABLE ADSERVERTEST_BLOB(id NUMBER(10), text BLOB);
BEGIN
FOR i IN 0..999 LOOP
INSERT INTO ADSERVERTEST_BLOB(id, text) VALUES(i, utl_raw.cast_to_raw('init'));
END LOOP;
END;
template<typename Type, unsigned long TypeId>
class OCIHandlePtr
public:
OCIHandlePtr(): handle_(0) {}
OCIHandlePtr(Type* handle): handle_(handle) {}
~OCIHandlePtr()
reset(0);
void reset(Type* handle)
if(handle_)
sword result;
if((result = OCIHandleFree(
handle_,
TypeId)) != OCI_SUCCESS)
assert(0);
std::cerr << "Can't make OCIHandleFree" << std::endl;
handle_ = handle;
Type* get()
return handle_;
Type*& fill()
reset(0);
return handle_;
private:
Type* handle_;
template<typename Type, unsigned long TypeId>
class OCIDescriptorPtr
public:
OCIDescriptorPtr(): handle_(0) {}
OCIDescriptorPtr(Type* handle): handle_(handle) {}
~OCIDescriptorPtr()
reset(0);
void reset(Type* handle)
if(handle_)
sword result;
if((result = OCIDescriptorFree(
handle_,
TypeId)) != OCI_SUCCESS)
std::cerr << "Can't make OCIDescriptorFree" << std::endl;
handle_ = handle;
Type* get()
return handle_;
Type*& fill()
reset(0);
return handle_;
private:
Type* handle_;
void throw_oci_error(
const char* fun,
const char* oci_op,
long status,
OCIError* oci_error_handler,
const char* query = 0)
std::cerr << fun << ": can't make " << oci_op << ": status = " << status;
if(status == OCI_SUCCESS_WITH_INFO ||
status == OCI_ERROR)
std::cerr << ", message = '";
text err_buf[1024] = "";
sb4 err_code = 0;
OCIErrorGet(
oci_error_handler,
(ub4)1,
0,
&err_code,
err_buf,
sizeof(err_buf),
(ub4)OCI_HTYPE_ERROR);
std::cerr << err_buf << "', error code = " << err_code;
exit(1);
if(query)
std::cerr << ", sql = " << query;
OCIHandlePtr<OCIEnv, OCI_HTYPE_ENV> environment_handle;
void connect(
OCIEnv* environment_handle,
const char* db,
const char* user,
const char* password,
OCIHandlePtr<OCIError, OCI_HTYPE_ERROR>& error_handle,
OCIHandlePtr<OCIServer, OCI_HTYPE_SERVER>& server_handle,
OCIHandlePtr<OCISession, OCI_HTYPE_SESSION>& session_handle,
OCIHandlePtr<OCISvcCtx, OCI_HTYPE_SVCCTX>& svc_context_handle)
static const char* FUN = "connect()";
sword result;
// allocate an error handle
if((result = OCIHandleAlloc(
environment_handle,
(void **) &error_handle.fill(),
OCI_HTYPE_ERROR,
0, // extra memory to allocate
0)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIHandleAlloc", result, error_handle.get());
// allocate a server handle
if((result = OCIHandleAlloc(
environment_handle,
(void **) &server_handle.fill(),
OCI_HTYPE_SERVER,
0, // extra memory to allocate
0)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIHandleAlloc", result, error_handle.get());
if((result = OCIServerAttach(
server_handle.get(),
error_handle.get(),
(text*)db,
strlen(db),
OCI_DEFAULT)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIServerAttach", result, error_handle.get());
// allocate a service handle
if((result = OCIHandleAlloc(
environment_handle,
(void **) &svc_context_handle.fill(),
OCI_HTYPE_SVCCTX,
0, // extra memory to allocate
0)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIHandleAlloc", result, error_handle.get());
// set the server attribute in the service context handle
if((result = OCIAttrSet(
svc_context_handle.get(),
OCI_HTYPE_SVCCTX,
server_handle.get(),
sizeof(OCIServer*),
OCI_ATTR_SERVER,
error_handle.get())) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIHandleAlloc", result, error_handle.get());
// allocate a user session handle
if((result = OCIHandleAlloc(
environment_handle,
(void **)&session_handle.fill(),
OCI_HTYPE_SESSION,
0, // extra memory to allocate
0)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIHandleAlloc", result, error_handle.get());
// set username and password attributes in user session handle
if((result = OCIAttrSet(
session_handle.get(),
OCI_HTYPE_SESSION,
(text*)user,
strlen(user),
OCI_ATTR_USERNAME,
error_handle.get())) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIAttrSet", result, error_handle.get());
if((result = OCIAttrSet(
session_handle.get(),
OCI_HTYPE_SESSION,
(text*)password,
strlen(password),
OCI_ATTR_PASSWORD,
error_handle.get())) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIAttrSet", result, error_handle.get());
// start the session
if((result = OCISessionBegin(
svc_context_handle.get(),
error_handle.get(),
session_handle.get(),
OCI_CRED_RDBMS,
OCI_DEFAULT)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCISessionBegin", result, error_handle.get());
// set the user session attribute in the service context handle
if((result = OCIAttrSet(
svc_context_handle.get(),
OCI_HTYPE_SVCCTX,
session_handle.get(),
sizeof(OCISession*),
OCI_ATTR_SESSION,
error_handle.get())) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIAttrSet", result, error_handle.get());
ub1 attr_value = 1;
if((result = OCIAttrSet(
server_handle.get(),
OCI_HTYPE_SERVER,
&attr_value,
sizeof(attr_value),
OCI_ATTR_NONBLOCKING_MODE,
error_handle.get())) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIAttrSet", result, error_handle.get());
void disconnect(
OCIEnv* environment_handle,
OCIError* error_handle,
OCIServer* server_handle,
OCISession* session_handle,
OCISvcCtx* svc_context_handle)
static const char* FUN = "disconnect()";
sword result;
if((result = OCISessionEnd(
svc_context_handle,
error_handle,
session_handle,
OCI_DEFAULT)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCISessionEnd", result, error_handle);
if((result = OCIServerDetach(
server_handle,
error_handle,
OCI_DEFAULT)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIServerDetach", result, error_handle);
OCILobLocator* FETCH_BUFFER_1[10000*1024];
char IND_BUFFER_1[10000*1024];
ub2 ERROR_BUFFER_1[1024];
OCIDefine* define_handle_1;
void clear_blob_buf(
OCILobLocator** buf,
unsigned long fetch_size)
for(unsigned long i = 0; i < 1024; ++i)
OCIDescriptorFree(
buf,
(ub4)OCI_DTYPE_LOB);
::memset(buf, 0, fetch_size * 1024);
uint32_t RET_LEN4;
sb4 oci_blob_callback(
dvoid* ctx,
OCIDefine* define,
ub4 iter,
dvoid** bufpp,
ub4** alenpp,
ub1* piecep,
dvoid** indpp,
ub2** rcodepp)
RET_LEN4 = sizeof(OCILobLocator*);
*bufpp = FETCH_BUFFER_1[iter];
*alenpp = &RET_LEN4;
*piecep = OCI_ONE_PIECE;
*indpp = IND_BUFFER_1 + iter;
*rcodepp = ERROR_BUFFER_1 + iter;
//std::cout << "iter: " << iter << std::endl;
return OCI_CONTINUE;
int define_column(
OCIEnv* environment_handle,
OCISvcCtx* svc_handle,
OCIStmt* stmt_handle,
OCIError* error_handle,
OCIDefine** define_handle,
unsigned long pos,
long oci_type,
unsigned long fetch_size,
OCILobLocator** buf,
char* ind_buf,
ub2* err_buf)
static const char* FUN = "define_column()";
sword result;
if(oci_type == SQLT_BLOB)
::memset(buf, 0, fetch_size * 1024);
for(int i = 0; i < 1024; ++i)
if((result = OCIDescriptorAlloc(
(dvoid*)environment_handle,
(dvoid**)&buf[i],
(ub4)OCI_DTYPE_LOB,
(size_t)0,
(dvoid**)0)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIDescriptorAlloc", result, error_handle);
ub2 size = 0;
OCIDescriptorPtr<OCIParam, OCI_DTYPE_PARAM> param_handle;
// ub2 oci_data_type = 0;
if((result = OCIParamGet(
stmt_handle,
OCI_HTYPE_STMT,
error_handle,
reinterpret_cast<void**>(&param_handle.fill()),
pos)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIParamGet", result, error_handle);
if((result = OCIAttrGet(
param_handle.get(),
OCI_DTYPE_PARAM,
&size,
0,
OCI_ATTR_DATA_SIZE,
error_handle)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIAttrGet", result, error_handle);
if((result = OCIDefineByPos(
stmt_handle,
define_handle,
error_handle,
pos,
# ifdef _DYN
0,
-1,
#else
buf,
fetch_size,
#endif
oci_type,
ind_buf,
0,
err_buf, // ptr to array of column-level return codes
# ifdef _DYN
OCI_DYNAMIC_FETCH
# else
OCI_DEFAULT
# endif
)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIDefineByPos", result, error_handle);
# ifdef _DYN
if((result = OCIDefineDynamic(
*define_handle,
error_handle,
0,
oci_blob_callback)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIDefineByPos", result, error_handle);
# endif
return 0;
int define_columns(
OCIEnv* environment_handle,
OCISvcCtx* svc_handle,
OCIStmt* stmt_handle,
OCIError* error_handle)
static const char* FUN = "define_columns()";
define_handle_1 = 0;
int pos = 1;
::memset(ERROR_BUFFER_1, 0, 1024 * sizeof(ERROR_BUFFER_1[0]));
define_column(
environment_handle,
svc_handle,
stmt_handle,
error_handle,
&define_handle_1,
pos++,
SQLT_BLOB,
sizeof(OCILobLocator*),
FETCH_BUFFER_1,
IND_BUFFER_1,
ERROR_BUFFER_1);
return 0;
int execute_select(
const char* db,
const char* user,
const char* password)
static const char* FUN = "execute_select()";
const unsigned long FETCH_COUNT = 1024;
OCIHandlePtr<OCIError, OCI_HTYPE_ERROR> error_handle;
OCIHandlePtr<OCIServer, OCI_HTYPE_SERVER> server_handle;
OCIHandlePtr<OCISession, OCI_HTYPE_SESSION> session_handle;
OCIHandlePtr<OCISvcCtx, OCI_HTYPE_SVCCTX> svc_context_handle;
connect(
environment_handle.get(),
db,
user,
password,
error_handle,
server_handle,
session_handle,
svc_context_handle);
OCIHandlePtr<OCIStmt, OCI_HTYPE_STMT> stmt_handle;
sword result;
if((result = OCIHandleAlloc(
environment_handle.get(),
(void**)&stmt_handle.fill(),
OCI_HTYPE_STMT,
0,
0)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIHandleAlloc", result, error_handle.get());
const char QUERY[] = "SELECT text FROM ADSERVERTEST_BLOB";
ub4 rows = 0;
if((result = OCIAttrSet(
stmt_handle.get(),
OCI_HTYPE_STMT,
(dvoid *)&rows,
(ub4)sizeof(ub4),
OCI_ATTR_PREFETCH_ROWS,
error_handle.get())) != OCI_SUCCESS)
throw_oci_error(
FUN, "OCIAttrSet(OCI_ATTR_PREFETCH_ROWS)", result, error_handle.get());
if((result = OCIStmtPrepare(
stmt_handle.get(),
error_handle.get(),
(text*)QUERY,
strlen(QUERY),
OCI_NTV_SYNTAX,
OCI_DEFAULT)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIStmtPrepare", result, error_handle.get());
ub2 stmt_type;
if((result = OCIAttrGet(
stmt_handle.get(),
OCI_HTYPE_STMT,
&stmt_type,
0,
OCI_ATTR_STMT_TYPE,
error_handle.get())) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIAttrGet", result, error_handle.get());
ub4 prev_fetched = 0;
while((result = OCIStmtExecute(
svc_context_handle.get(),
stmt_handle.get(),
error_handle.get(),
0,
0,
0,
0,
OCI_DEFAULT)) != OCI_SUCCESS)
if(result != OCI_STILL_EXECUTING)
throw_oci_error(FUN, "OCIStmtExecute", result, error_handle.get());
define_columns(
environment_handle.get(),
svc_context_handle.get(),
stmt_handle.get(),
error_handle.get());
ub4 all_fetched_count = 0;
while(true)
while((result = OCIStmtFetch2(
stmt_handle.get(),
error_handle.get(),
FETCH_COUNT,
OCI_FETCH_NEXT,
1,
OCI_DEFAULT)) == OCI_STILL_EXECUTING
# ifdef _DYN
// || result == OCI_NEED_DATA
# endif
if (result != OCI_SUCCESS &&
result != OCI_NO_DATA &&
result != OCI_SUCCESS_WITH_INFO)
std::cerr << FUN << ": can't make OCIStmtFetch2: status = " << result;
std::cerr << ", message = '";
text err_buf[1024] = "";
sb4 err_code = 0;
OCIErrorGet(
error_handle.get(),
(ub4)1,
0,
&err_code,
err_buf,
sizeof(err_buf),
(ub4)OCI_HTYPE_ERROR);
std::cerr << err_buf << "', error code = " << err_code << ", row errors: ";
for(const ub2* cur = ERROR_BUFFER_1;
cur < ERROR_BUFFER_1 + 1024; ++cur)
if(*cur)
std::cerr << "#" << (cur - ERROR_BUFFER_1) << ": " <<
*cur << std::endl;
ub4 fetched_count = 0;
if((result = OCIAttrGet (
stmt_handle.get(),
OCI_HTYPE_STMT,
&fetched_count,
0,
OCI_ATTR_ROW_COUNT,
error_handle.get())) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIAttrGet", result, error_handle.get());
all_fetched_count += fetched_count;
if(fetched_count > 0)
for(unsigned long i = 0; i < fetched_count - 1; ++i)
ub4 lob_size;
while((result = OCILobGetLength(
svc_context_handle.get(),
error_handle.get(),
FETCH_BUFFER_1[i],
&lob_size)) == OCI_STILL_EXECUTING)
if(result != OCI_SUCCESS)
throw_oci_error(FUN, "OCILobGetLength", result, error_handle.get());
std::cout << "#" << i << ": ind = " << (unsigned long)IND_BUFFER_1[i] <<
", len = " << lob_size << std::endl;
if(fetched_count - prev_fetched < FETCH_COUNT)
break;
prev_fetched = fetched_count;
clear_blob_buf(
FETCH_BUFFER_1,
sizeof(OCILobLocator*));
while((result = OCIStmtFetch(
stmt_handle.get(),
error_handle.get(),
0,
OCI_FETCH_NEXT,
OCI_DEFAULT)) == OCI_STILL_EXECUTING
disconnect(
environment_handle.get(),
error_handle.get(),
server_handle.get(),
session_handle.get(),
svc_context_handle.get());
return 0;
int execute_update(
const char* db,
const char* user,
const char* password)
static const char* FUN = "execute_update()";
OCIHandlePtr<OCIError, OCI_HTYPE_ERROR> error_handle;
OCIHandlePtr<OCIServer, OCI_HTYPE_SERVER> server_handle;
OCIHandlePtr<OCISession, OCI_HTYPE_SESSION> session_handle;
OCIHandlePtr<OCISvcCtx, OCI_HTYPE_SVCCTX> svc_context_handle;
connect(
environment_handle.get(),
db,
user,
password,
error_handle,
server_handle,
session_handle,
svc_context_handle);
OCIHandlePtr<OCIStmt, OCI_HTYPE_STMT> stmt_handle;
for(int i = 0; i < 1000; ++i)
sword result;
if((result = OCIHandleAlloc(
environment_handle.get(),
(void**)&stmt_handle.fill(),
OCI_HTYPE_STMT,
0,
0)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIHandleAlloc", result, error_handle.get());
std::ostringstream sql;
std::string str;
std::string et("\xEB\xB2\x88");
unsigned long rep = ::rand() % 500 + 1;
str.reserve(rep*et.size());
for(unsigned long ei = 0; ei < rep; ++ei)
str.append(et);
sql << "BEGIN " <<
"UPDATE ADSERVERTEST_BLOB SET text = "
"utl_raw.cast_to_raw('" << str << "') "
"WHERE id = " << i <<
"END;";
if((result = OCIStmtPrepare(
stmt_handle.get(),
error_handle.get(),
(text*)sql.str().c_str(),
sql.str().length(),
OCI_NTV_SYNTAX,
OCI_DEFAULT)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIStmtPrepare", result, error_handle.get());
while((result = OCIStmtExecute(
svc_context_handle.get(),
stmt_handle.get(),
error_handle.get(),
1,
0,
0,
0,
OCI_DEFAULT)) != OCI_SUCCESS)
if(result != OCI_STILL_EXECUTING)
throw_oci_error(FUN, "OCIStmtExecute", result, error_handle.get());
disconnect(
environment_handle.get(),
error_handle.get(),
server_handle.get(),
session_handle.get(),
svc_context_handle.get());
return 0;
void* select_thread(void* ctx)
while(true)
execute_select(
"//oraclept.ocslab.com/addbpt.ocslab.com",
"bs_unittest_4",
"adserver");
// std::cout << "select finished" << std::endl;
return ctx;
void* update_thread(void* ctx)
while(true)
execute_update(
"//oraclept.ocslab.com/addbpt.ocslab.com",
"bs_unittest_4",
"adserver");
// std::cout << "update finished" << std::endl;
return ctx;
int main()
static const char* FUN = "main()";
sword result;
// allocate an environment handle
if((result = OCIEnvCreate(
&environment_handle.fill(),
OCI_OBJECT | OCI_THREADED,
0, // context
0, // malloc
0, // realloc
0, // free
0, // extra memory to allocate
0) // pointer to user-memory
) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIEnvCreate", result, 0);
pthread_t th1, th2;
pthread_create(&th1, 0, select_thread, 0);
pthread_create(&th2, 0, update_thread, 0);
pthread_join(th1, 0);
pthread_join(th2, 0);
return 0;
Edited by: user13011391 on 20.04.2010 5:50
Edited by: user13011391 on 20.04.2010 6:00
Edited by: user13011391 on 20.04.2010 6:15

Hi all.
I have problem:
I try select BLOB field into OCILobLocator* buffer in Non Blocking mode, and receive 'ORA-03106: fatal two-task communication protocol error' sometimes.
Details:
Application contains two threads : 1. select blob field, 2. update it.
I tried separate update and select to different apps (and run its in one time) - problem reproduced.
problem reproduced for OCIStmtFetch and OCIStmtFetch2.
If disable non blocking mode - problem disappear.
if error appear - record level error code contains 1405. Need wait few minutes for error message appearing (~1 minute in my case).
Using of OCI_DEFAULT in OCIDefineByPos instead OCI_DYNAMIC_FETCH don't solve problem.
I use oracle server and client library with version 10.2.0.4
Output sample:
execute_select(): can't make OCIStmtFetch2: status = -1, message = 'ORA-03106: fatal two-task communication protocol error
', error code = 3106, row errors: #877: 1405
execute_select(): can't make OCIStmtFetch2: status = -1, message = 'ORA-03106: fatal two-task communication protocol error
', error code = 3106, row errors: #54: 1405
execute_select(): can't make OCIStmtFetch2: status = -1, message = 'ORA-03106: fatal two-task communication protocol error
', error code = 3106, row errors: #877: 1405
execute_select(): can't make OCIStmtFetch2: status = -1, message = 'ORA-03106: fatal two-task communication protocol error
', error code = 3106, row errors: #54: 1405
Can anybody help me ?
m.b. exists workaround ?
#include <iostream>
#include <sstream>
#include <assert.h>
#include <oci.h>
#define _DYN 1
before run this test run next sql at DB:
CREATE TABLE ADSERVERTEST_BLOB(id NUMBER(10), text BLOB);
BEGIN
FOR i IN 0..999 LOOP
INSERT INTO ADSERVERTEST_BLOB(id, text) VALUES(i, utl_raw.cast_to_raw('init'));
END LOOP;
END;
template<typename Type, unsigned long TypeId>
class OCIHandlePtr
public:
OCIHandlePtr(): handle_(0) {}
OCIHandlePtr(Type* handle): handle_(handle) {}
~OCIHandlePtr()
reset(0);
void reset(Type* handle)
if(handle_)
sword result;
if((result = OCIHandleFree(
handle_,
TypeId)) != OCI_SUCCESS)
assert(0);
std::cerr << "Can't make OCIHandleFree" << std::endl;
handle_ = handle;
Type* get()
return handle_;
Type*& fill()
reset(0);
return handle_;
private:
Type* handle_;
template<typename Type, unsigned long TypeId>
class OCIDescriptorPtr
public:
OCIDescriptorPtr(): handle_(0) {}
OCIDescriptorPtr(Type* handle): handle_(handle) {}
~OCIDescriptorPtr()
reset(0);
void reset(Type* handle)
if(handle_)
sword result;
if((result = OCIDescriptorFree(
handle_,
TypeId)) != OCI_SUCCESS)
std::cerr << "Can't make OCIDescriptorFree" << std::endl;
handle_ = handle;
Type* get()
return handle_;
Type*& fill()
reset(0);
return handle_;
private:
Type* handle_;
void throw_oci_error(
const char* fun,
const char* oci_op,
long status,
OCIError* oci_error_handler,
const char* query = 0)
std::cerr << fun << ": can't make " << oci_op << ": status = " << status;
if(status == OCI_SUCCESS_WITH_INFO ||
status == OCI_ERROR)
std::cerr << ", message = '";
text err_buf[1024] = "";
sb4 err_code = 0;
OCIErrorGet(
oci_error_handler,
(ub4)1,
0,
&err_code,
err_buf,
sizeof(err_buf),
(ub4)OCI_HTYPE_ERROR);
std::cerr << err_buf << "', error code = " << err_code;
exit(1);
if(query)
std::cerr << ", sql = " << query;
OCIHandlePtr<OCIEnv, OCI_HTYPE_ENV> environment_handle;
void connect(
OCIEnv* environment_handle,
const char* db,
const char* user,
const char* password,
OCIHandlePtr<OCIError, OCI_HTYPE_ERROR>& error_handle,
OCIHandlePtr<OCIServer, OCI_HTYPE_SERVER>& server_handle,
OCIHandlePtr<OCISession, OCI_HTYPE_SESSION>& session_handle,
OCIHandlePtr<OCISvcCtx, OCI_HTYPE_SVCCTX>& svc_context_handle)
static const char* FUN = "connect()";
sword result;
// allocate an error handle
if((result = OCIHandleAlloc(
environment_handle,
(void **) &error_handle.fill(),
OCI_HTYPE_ERROR,
0, // extra memory to allocate
0)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIHandleAlloc", result, error_handle.get());
// allocate a server handle
if((result = OCIHandleAlloc(
environment_handle,
(void **) &server_handle.fill(),
OCI_HTYPE_SERVER,
0, // extra memory to allocate
0)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIHandleAlloc", result, error_handle.get());
if((result = OCIServerAttach(
server_handle.get(),
error_handle.get(),
(text*)db,
strlen(db),
OCI_DEFAULT)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIServerAttach", result, error_handle.get());
// allocate a service handle
if((result = OCIHandleAlloc(
environment_handle,
(void **) &svc_context_handle.fill(),
OCI_HTYPE_SVCCTX,
0, // extra memory to allocate
0)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIHandleAlloc", result, error_handle.get());
// set the server attribute in the service context handle
if((result = OCIAttrSet(
svc_context_handle.get(),
OCI_HTYPE_SVCCTX,
server_handle.get(),
sizeof(OCIServer*),
OCI_ATTR_SERVER,
error_handle.get())) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIHandleAlloc", result, error_handle.get());
// allocate a user session handle
if((result = OCIHandleAlloc(
environment_handle,
(void **)&session_handle.fill(),
OCI_HTYPE_SESSION,
0, // extra memory to allocate
0)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIHandleAlloc", result, error_handle.get());
// set username and password attributes in user session handle
if((result = OCIAttrSet(
session_handle.get(),
OCI_HTYPE_SESSION,
(text*)user,
strlen(user),
OCI_ATTR_USERNAME,
error_handle.get())) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIAttrSet", result, error_handle.get());
if((result = OCIAttrSet(
session_handle.get(),
OCI_HTYPE_SESSION,
(text*)password,
strlen(password),
OCI_ATTR_PASSWORD,
error_handle.get())) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIAttrSet", result, error_handle.get());
// start the session
if((result = OCISessionBegin(
svc_context_handle.get(),
error_handle.get(),
session_handle.get(),
OCI_CRED_RDBMS,
OCI_DEFAULT)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCISessionBegin", result, error_handle.get());
// set the user session attribute in the service context handle
if((result = OCIAttrSet(
svc_context_handle.get(),
OCI_HTYPE_SVCCTX,
session_handle.get(),
sizeof(OCISession*),
OCI_ATTR_SESSION,
error_handle.get())) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIAttrSet", result, error_handle.get());
ub1 attr_value = 1;
if((result = OCIAttrSet(
server_handle.get(),
OCI_HTYPE_SERVER,
&attr_value,
sizeof(attr_value),
OCI_ATTR_NONBLOCKING_MODE,
error_handle.get())) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIAttrSet", result, error_handle.get());
void disconnect(
OCIEnv* environment_handle,
OCIError* error_handle,
OCIServer* server_handle,
OCISession* session_handle,
OCISvcCtx* svc_context_handle)
static const char* FUN = "disconnect()";
sword result;
if((result = OCISessionEnd(
svc_context_handle,
error_handle,
session_handle,
OCI_DEFAULT)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCISessionEnd", result, error_handle);
if((result = OCIServerDetach(
server_handle,
error_handle,
OCI_DEFAULT)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIServerDetach", result, error_handle);
OCILobLocator* FETCH_BUFFER_1[10000*1024];
char IND_BUFFER_1[10000*1024];
ub2 ERROR_BUFFER_1[1024];
OCIDefine* define_handle_1;
void clear_blob_buf(
OCILobLocator** buf,
unsigned long fetch_size)
for(unsigned long i = 0; i < 1024; ++i)
OCIDescriptorFree(
buf,
(ub4)OCI_DTYPE_LOB);
::memset(buf, 0, fetch_size * 1024);
uint32_t RET_LEN4;
sb4 oci_blob_callback(
dvoid* ctx,
OCIDefine* define,
ub4 iter,
dvoid** bufpp,
ub4** alenpp,
ub1* piecep,
dvoid** indpp,
ub2** rcodepp)
RET_LEN4 = sizeof(OCILobLocator*);
*bufpp = FETCH_BUFFER_1[iter];
*alenpp = &RET_LEN4;
*piecep = OCI_ONE_PIECE;
*indpp = IND_BUFFER_1 + iter;
*rcodepp = ERROR_BUFFER_1 + iter;
//std::cout << "iter: " << iter << std::endl;
return OCI_CONTINUE;
int define_column(
OCIEnv* environment_handle,
OCISvcCtx* svc_handle,
OCIStmt* stmt_handle,
OCIError* error_handle,
OCIDefine** define_handle,
unsigned long pos,
long oci_type,
unsigned long fetch_size,
OCILobLocator** buf,
char* ind_buf,
ub2* err_buf)
static const char* FUN = "define_column()";
sword result;
if(oci_type == SQLT_BLOB)
::memset(buf, 0, fetch_size * 1024);
for(int i = 0; i < 1024; ++i)
if((result = OCIDescriptorAlloc(
(dvoid*)environment_handle,
(dvoid**)&buf[i],
(ub4)OCI_DTYPE_LOB,
(size_t)0,
(dvoid**)0)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIDescriptorAlloc", result, error_handle);
ub2 size = 0;
OCIDescriptorPtr<OCIParam, OCI_DTYPE_PARAM> param_handle;
// ub2 oci_data_type = 0;
if((result = OCIParamGet(
stmt_handle,
OCI_HTYPE_STMT,
error_handle,
reinterpret_cast<void**>(&param_handle.fill()),
pos)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIParamGet", result, error_handle);
if((result = OCIAttrGet(
param_handle.get(),
OCI_DTYPE_PARAM,
&size,
0,
OCI_ATTR_DATA_SIZE,
error_handle)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIAttrGet", result, error_handle);
if((result = OCIDefineByPos(
stmt_handle,
define_handle,
error_handle,
pos,
# ifdef _DYN
0,
-1,
#else
buf,
fetch_size,
#endif
oci_type,
ind_buf,
0,
err_buf, // ptr to array of column-level return codes
# ifdef _DYN
OCI_DYNAMIC_FETCH
# else
OCI_DEFAULT
# endif
)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIDefineByPos", result, error_handle);
# ifdef _DYN
if((result = OCIDefineDynamic(
*define_handle,
error_handle,
0,
oci_blob_callback)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIDefineByPos", result, error_handle);
# endif
return 0;
int define_columns(
OCIEnv* environment_handle,
OCISvcCtx* svc_handle,
OCIStmt* stmt_handle,
OCIError* error_handle)
static const char* FUN = "define_columns()";
define_handle_1 = 0;
int pos = 1;
::memset(ERROR_BUFFER_1, 0, 1024 * sizeof(ERROR_BUFFER_1[0]));
define_column(
environment_handle,
svc_handle,
stmt_handle,
error_handle,
&define_handle_1,
pos++,
SQLT_BLOB,
sizeof(OCILobLocator*),
FETCH_BUFFER_1,
IND_BUFFER_1,
ERROR_BUFFER_1);
return 0;
int execute_select(
const char* db,
const char* user,
const char* password)
static const char* FUN = "execute_select()";
const unsigned long FETCH_COUNT = 1024;
OCIHandlePtr<OCIError, OCI_HTYPE_ERROR> error_handle;
OCIHandlePtr<OCIServer, OCI_HTYPE_SERVER> server_handle;
OCIHandlePtr<OCISession, OCI_HTYPE_SESSION> session_handle;
OCIHandlePtr<OCISvcCtx, OCI_HTYPE_SVCCTX> svc_context_handle;
connect(
environment_handle.get(),
db,
user,
password,
error_handle,
server_handle,
session_handle,
svc_context_handle);
OCIHandlePtr<OCIStmt, OCI_HTYPE_STMT> stmt_handle;
sword result;
if((result = OCIHandleAlloc(
environment_handle.get(),
(void**)&stmt_handle.fill(),
OCI_HTYPE_STMT,
0,
0)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIHandleAlloc", result, error_handle.get());
const char QUERY[] = "SELECT text FROM ADSERVERTEST_BLOB";
ub4 rows = 0;
if((result = OCIAttrSet(
stmt_handle.get(),
OCI_HTYPE_STMT,
(dvoid *)&rows,
(ub4)sizeof(ub4),
OCI_ATTR_PREFETCH_ROWS,
error_handle.get())) != OCI_SUCCESS)
throw_oci_error(
FUN, "OCIAttrSet(OCI_ATTR_PREFETCH_ROWS)", result, error_handle.get());
if((result = OCIStmtPrepare(
stmt_handle.get(),
error_handle.get(),
(text*)QUERY,
strlen(QUERY),
OCI_NTV_SYNTAX,
OCI_DEFAULT)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIStmtPrepare", result, error_handle.get());
ub2 stmt_type;
if((result = OCIAttrGet(
stmt_handle.get(),
OCI_HTYPE_STMT,
&stmt_type,
0,
OCI_ATTR_STMT_TYPE,
error_handle.get())) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIAttrGet", result, error_handle.get());
ub4 prev_fetched = 0;
while((result = OCIStmtExecute(
svc_context_handle.get(),
stmt_handle.get(),
error_handle.get(),
0,
0,
0,
0,
OCI_DEFAULT)) != OCI_SUCCESS)
if(result != OCI_STILL_EXECUTING)
throw_oci_error(FUN, "OCIStmtExecute", result, error_handle.get());
define_columns(
environment_handle.get(),
svc_context_handle.get(),
stmt_handle.get(),
error_handle.get());
ub4 all_fetched_count = 0;
while(true)
while((result = OCIStmtFetch2(
stmt_handle.get(),
error_handle.get(),
FETCH_COUNT,
OCI_FETCH_NEXT,
1,
OCI_DEFAULT)) == OCI_STILL_EXECUTING
# ifdef _DYN
// || result == OCI_NEED_DATA
# endif
if (result != OCI_SUCCESS &&
result != OCI_NO_DATA &&
result != OCI_SUCCESS_WITH_INFO)
std::cerr << FUN << ": can't make OCIStmtFetch2: status = " << result;
std::cerr << ", message = '";
text err_buf[1024] = "";
sb4 err_code = 0;
OCIErrorGet(
error_handle.get(),
(ub4)1,
0,
&err_code,
err_buf,
sizeof(err_buf),
(ub4)OCI_HTYPE_ERROR);
std::cerr << err_buf << "', error code = " << err_code << ", row errors: ";
for(const ub2* cur = ERROR_BUFFER_1;
cur < ERROR_BUFFER_1 + 1024; ++cur)
if(*cur)
std::cerr << "#" << (cur - ERROR_BUFFER_1) << ": " <<
*cur << std::endl;
ub4 fetched_count = 0;
if((result = OCIAttrGet (
stmt_handle.get(),
OCI_HTYPE_STMT,
&fetched_count,
0,
OCI_ATTR_ROW_COUNT,
error_handle.get())) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIAttrGet", result, error_handle.get());
all_fetched_count += fetched_count;
if(fetched_count > 0)
for(unsigned long i = 0; i < fetched_count - 1; ++i)
ub4 lob_size;
while((result = OCILobGetLength(
svc_context_handle.get(),
error_handle.get(),
FETCH_BUFFER_1[i],
&lob_size)) == OCI_STILL_EXECUTING)
if(result != OCI_SUCCESS)
throw_oci_error(FUN, "OCILobGetLength", result, error_handle.get());
std::cout << "#" << i << ": ind = " << (unsigned long)IND_BUFFER_1[i] <<
", len = " << lob_size << std::endl;
if(fetched_count - prev_fetched < FETCH_COUNT)
break;
prev_fetched = fetched_count;
clear_blob_buf(
FETCH_BUFFER_1,
sizeof(OCILobLocator*));
while((result = OCIStmtFetch(
stmt_handle.get(),
error_handle.get(),
0,
OCI_FETCH_NEXT,
OCI_DEFAULT)) == OCI_STILL_EXECUTING
disconnect(
environment_handle.get(),
error_handle.get(),
server_handle.get(),
session_handle.get(),
svc_context_handle.get());
return 0;
int execute_update(
const char* db,
const char* user,
const char* password)
static const char* FUN = "execute_update()";
OCIHandlePtr<OCIError, OCI_HTYPE_ERROR> error_handle;
OCIHandlePtr<OCIServer, OCI_HTYPE_SERVER> server_handle;
OCIHandlePtr<OCISession, OCI_HTYPE_SESSION> session_handle;
OCIHandlePtr<OCISvcCtx, OCI_HTYPE_SVCCTX> svc_context_handle;
connect(
environment_handle.get(),
db,
user,
password,
error_handle,
server_handle,
session_handle,
svc_context_handle);
OCIHandlePtr<OCIStmt, OCI_HTYPE_STMT> stmt_handle;
for(int i = 0; i < 1000; ++i)
sword result;
if((result = OCIHandleAlloc(
environment_handle.get(),
(void**)&stmt_handle.fill(),
OCI_HTYPE_STMT,
0,
0)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIHandleAlloc", result, error_handle.get());
std::ostringstream sql;
std::string str;
std::string et("\xEB\xB2\x88");
unsigned long rep = ::rand() % 500 + 1;
str.reserve(rep*et.size());
for(unsigned long ei = 0; ei < rep; ++ei)
str.append(et);
sql << "BEGIN " <<
"UPDATE ADSERVERTEST_BLOB SET text = "
"utl_raw.cast_to_raw('" << str << "') "
"WHERE id = " << i <<
"END;";
if((result = OCIStmtPrepare(
stmt_handle.get(),
error_handle.get(),
(text*)sql.str().c_str(),
sql.str().length(),
OCI_NTV_SYNTAX,
OCI_DEFAULT)) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIStmtPrepare", result, error_handle.get());
while((result = OCIStmtExecute(
svc_context_handle.get(),
stmt_handle.get(),
error_handle.get(),
1,
0,
0,
0,
OCI_DEFAULT)) != OCI_SUCCESS)
if(result != OCI_STILL_EXECUTING)
throw_oci_error(FUN, "OCIStmtExecute", result, error_handle.get());
disconnect(
environment_handle.get(),
error_handle.get(),
server_handle.get(),
session_handle.get(),
svc_context_handle.get());
return 0;
void* select_thread(void* ctx)
while(true)
execute_select(
"//oraclept.ocslab.com/addbpt.ocslab.com",
"bs_unittest_4",
"adserver");
// std::cout << "select finished" << std::endl;
return ctx;
void* update_thread(void* ctx)
while(true)
execute_update(
"//oraclept.ocslab.com/addbpt.ocslab.com",
"bs_unittest_4",
"adserver");
// std::cout << "update finished" << std::endl;
return ctx;
int main()
static const char* FUN = "main()";
sword result;
// allocate an environment handle
if((result = OCIEnvCreate(
&environment_handle.fill(),
OCI_OBJECT | OCI_THREADED,
0, // context
0, // malloc
0, // realloc
0, // free
0, // extra memory to allocate
0) // pointer to user-memory
) != OCI_SUCCESS)
throw_oci_error(FUN, "OCIEnvCreate", result, 0);
pthread_t th1, th2;
pthread_create(&th1, 0, select_thread, 0);
pthread_create(&th2, 0, update_thread, 0);
pthread_join(th1, 0);
pthread_join(th2, 0);
return 0;
Edited by: user13011391 on 20.04.2010 5:50
Edited by: user13011391 on 20.04.2010 6:00
Edited by: user13011391 on 20.04.2010 6:15

Non blocking worker servlet ?

Hi friends,
I have an issue to implement. We implemented a web application and now I want to separate some parts of this application. I can express the action shorter and simple below.
if a user requests x-y ticket {
��try {
��check db if x-y is available
��if true send available
��else not
��}catch (NonExistentData) {
��addJob2Queue(x-y)
��send available
��}
class AvailabilityHelper extends Thread{
��run(){
��while(true){
��checkQueue
��if there is job, updateDBfor(org,dest)
��}
��}
* updateDBfor(org,dest) includes other ejb references to request data and insert it into db
This web aplication runs with JSP 1.2 EL support on WAS 5.1
the check for db and the thread implementation was in a seperate package and were used in actions of web application. Now they also want to use these checks for other (non web) applications. So i think there should be a session bean in ejb and should process these requests and I used JMS (Message-Driven Bean) with WebSphere MQ to undertake the thread and queue mechanism.
Now it works like this :
class exampleSessionBean{
��getAvalibability(org, dest){
��try {
��check db if x-y is available
��if true send available
��else not
��}catch (NonExistentData) {
��queueSender.sendMessage(update x-y)
��send available;
��}
��}
class queueMDB{
��onMessage(){
��updateDBfor(org,dest)
��}
The purpose of this applications was, not to block the user for db update process, if there is data in db select and show to the user. the update process of db includes other ejb references and takes so much time. It is nonsense to make the user wait such time. And the info is not a big deal, because of this when i put a request for update, without blocking i send it as available...
So what is the problem ? :) Deployment team don't want to pay for websphere MQ and hire a admin for that. Also they don't want to use Embedded Messaging server client (JMS Server) of WAS. So I am asking you: is there a way to implement a non blocking servlet so that i will just make a request and don't wait for response, or a servlet will take the request and release the connection but will continue to process the request ?
thanks for all...

I tried to implement a web application and add a ServletContextListener as stevejluke suggests. But on contextInitialized function when creating new JobConsumer it gets following errors on server.
6/27/06 12:51:36:391 CEST] 33238138 WebContainer A SRVE0169I: Loading Web Module: non-blocking.
[6/27/06 12:51:36:438 CEST] 33238138 SystemOut O OlaListener initializing...
[6/27/06 12:51:36:516 CEST] 33238138 SystemOut O OlaListener - Queue added
[6/27/06 12:51:36:516 CEST] 33238138 SystemOut O OlaListener - keepWorking
[6/27/06 12:51:36:672 CEST] 33238138 WebApp E SRVE0015E: Failure to initialize Web application non-blocking
[6/27/06 12:51:36:844 CEST] 33238138 WebGroup E SRVE0054E: An error occurred while loading Web application
public class OlaListener implements ServletContextListener {
     * @see javax.servlet.ServletContextListener#void (javax.servlet.ServletContextEvent)
     public void contextDestroyed(ServletContextEvent event) {
             ServletContext context = event.getServletContext();
             context.setAttribute("keepWorking", Boolean.FALSE);
     * @see javax.servlet.ServletContextListener#void (javax.servlet.ServletContextEvent)
     public void contextInitialized(ServletContextEvent event) {
             System.out.println("OlaListener initializing...");
             ServletContext context = event.getServletContext();
             WorkQueue newJobs = new WorkQueue();
             context.setAttribute("newJobs", newJobs);
             System.out.println("OlaListener - Queue added");
             context.setAttribute("keepWorking", Boolean.TRUE);
             System.out.println("OlaListener - keepWorking");
             JobConsumer jc = new JobConsumer();
             System.out.println("OlaListener - Job Consumer created");
             jc.setContext(context);
             System.out.println("OlaListener - context set");
             Thread t = new Thread(jc);
             t.start();
public class JobConsumer implements Runnable{
     /*log4j*/     private static final Logger logger = Logger.getLogger(JobConsumer.class);
     private ServletContext context = null;
     public void run(){
             System.out.println("JobConsumer - run Start");
             processQueue(context);
             System.out.println("JobConsumer - run End");
}

Non-blocking serialization

Dear all,
Does anybody know whether PI/XI supports the non-blocking serialization function?
And in which version?
If not, is there any work-around?
Thanks a lot.
best regards
Jing

HI
Serialization plays an important role in distributing interdependent objects, especially when master data is being distributed.
IDocs can be created, sent and posted in a specified order by distributing message types serially.
Errors can then be avoided when processing inbound IDocs.
Interdependent messages can be serially distributed in the following ways:
Serialization by Object Type
Serialization by Message Type
Serialization at IDoc Level
(not for IDocs from generated BAPI-ALE interfaces)
Serialization at IDoc Level
Use
Delays in transferring IDocs may result in an IDoc containing data belonging to a specific object arriving at its destination before an "older" IDoc that contains different data belonging to the same object. Applications can use the ALE Serialization API to specify the order IDocs of the same message type are processed in and to prevent old IDocs from being posted if processing is repeated.
ALE provides two function modules to serialize IDocs which the posting function module has to invoke:
u2022 IDOC_SERIALIZATION_CHECK
checks the time stamps in the serialization field of the IDoc header.
u2022 IDOC_SERIAL_POST
updates the serialization table.
Check the following link:
http://help.sap.com/saphelp_nw04s/helpdata/en/0b/2a66d6507d11d18ee90000e8366fc2/frameset.htm
http://help.sap.com/saphelp_nw04s/helpdata/en/78/2175a751ce11d189570000e829fbbd/frameset.htm
How to serialize IDoc XML messages fed into XI
cheers

Non blocking sockets

Hi All,
Anybody have some idea about how to implement non blocking sockets using two threads/Can u help me with some sites where i can get more information in this topic.
Regards
Priya

hi,
you could have a look at the nonblocking io (nio) api's present in jdk1.4, that should do the trick. this link ought to get u started i suppose..
http://developer.java.sun.com/developer/technicalArticles/releases/nio/
hope this helps.
cheerz
ynkrish

Non-blocking SocketChannels

I'm trying to learn how to use non-blocking socket channles, but I haven't found much info (nor luck) so far.
To learn, I'm building a server and a client. The server accepts input from the clients and process it in only one thread. The clients should send Objects to the server, and the server process them and return the result also as an Object. For this, I'm trying to use ObjectOutputStream and ObjectInputStream.
The problem I don't know how to solve is that the SocketChannel is in non-bolcking mode, so I can't use their input/output streams (I get a IllegalBlockingModeException). In the server process loop I can reconfigure the SocketChannel to blocking mode to be able to read the Object, but I can't configure it to non-blocking mode again because I get a CancelledKeyException.
Does anyone know how to work with InputStreams and non-blocking channels? Or where to find more info about it?
Here are the relevant part of the server code:
Set ready = selector.selectedKeys();
Iterator i = ready.iterator();
while (i.hasNext()) {
   try {
      SelectionKey sk = i.next();
      i.remove();
      if (sk.isAcceptable()) {
         ServerSocketChannel ssc = (ServerSocketChannel)sk.channel();
         SocketChannel sc = ssc.accept();
         sc.configureBlocking(false);
         sc.register(selector, SelectionKey.OP_READ);
      } else if (sk.isReadable()) {
         SocketChannel sc = (SocketChannel)sk.channel();
         // PROBLEM: If the channel is in non-blocking mode
         // I cannot use InputStreams
         sk.cancel();
         sc.configureBlocking(true);
         // Read the object sent by the client
         ObjectInputStream in = new ObjectInputStream(Channels.newInputStream(sc));
         Object o = in.readObject();
         // PROBLEM: Can't put the channel back to non-blocking mode
         sc.configureBlocking(false);
         sc.register(selector, SelectionKey.OP_READ); // CancelledKeyException
   } catch (...){
}

In my client, this is working fine:
ObjectOutputStream oos = null;
ObjectInputStream ois = null;
for (int i = 0; i < 30000; i++) {
   oos = new ObjectOutputStream(sc.socket().getOutputStream());
   oos.writeObject(object);
   oos.flush();
   ois = new ObjectInputStream(sc.socket().getInputStream());
   Object o = ois.readObject();
}But trying to do it like this throws a StreamCorruptedException at the server side.
ObjectOutputStream oos = new ObjectOutputStream(sc.socket().getOutputStream());
ObjectInputStream ois = new ObjectInputStream(sc.socket().getInputStream());
for (int i = 0; i < 30000; i++) {
   oos.writeObject(object);
   oos.flush();
   Object o = ois.readObject();
}Do you know why?

OCCI and non-blocking

I'd like to use the OCCI interface in a non-blocking mode. Does anyone have any experience with this? Looks like I need to use a combo of OCI and OCCI calls to set the OCI_HTYPE_SERVER handle with the OCI_ATTR_NONBLOCKING MODE. However, my stmt->executeQuery() method seems to be throwing an exceptions, which I would have though would have been the OCI_STILL_EXECUTING error, but it's not. The exeception is an "ORA-32103 error from OCI call". If I continue to do another stmt->executeQuery(), I eventually get an access exception.
Anyone have any code snippets using OCCI in non-blocking mode?

I use threads. ACE/TAO to be precise.
I have singleton class that manages the Oracle environment and connection as well as being a statement
factory.
Just have a thread perform your stmt->executeXXX() method and you will not need to worry about non-blocking.
That's how I do it and it works well.

"SocketException: No buffer space available" on a non-blocking socket?

Why do i get "SocketException: No buffer space available" on non-blocking DatagramChannel.send()? According to the docs, it's just supposed to return 0 as the number bytes written, no?

Why did you crosspost this when it had already been answered?
http://forum.java.sun.com/thread.jspa?threadID=740520&tstart=0

Non-blocking connection on a SocketChannel?

I'm trying out the non-blocking connection of a SocketChannel. So I wrote the following test code and supply a list of IPs (both good and bad IPs). But disregard the IPs I always get the result of a channel being in connection pending state (even for some bogus IPs). Any help will be great.
public class ConnectTest
    public static void main(String[] args) throws
Exception
        List<SocketChannel> channels = new ArrayList<SocketChannel>();
        for ( String s: args )
            SocketChannel channel = SocketChannel.open();
            channel.configureBlocking(false);
            channels.add(channel);
            InetSocketAddress remote = new InetSocketAddress(s, 80);
            channel.connect(remote);
        System.out.println("wait for timeout...");
        Thread.sleep(10000);
        for ( SocketChannel c : channels )
            if ( c.isConnected() )
                System.out.println(c.socket().getInetAddress() + " connected ");
            else if ( c.isConnectionPending() )
                System.out.println(c.socket().getInetAddress() + " connection pending ");
            else
                System.out.println(c.socket().getInetAddress() + " timeout ");
            c.close();
}

Forget the sleep: use a Selector, selecting on OP_CONNECT. When you get it, call SocketChannel.finishConnect() for the channel(s) selected. If that method returns 'true', the connection is complete. If it returns 'false', the connection is still pending (and in fact OP_CONNECT should not have fired); if it throws an exception, the connection attempt has failed.
If the connection is complete you must also deregister it for OP_CONNECT before registering it for OP_READ or OP_WRITE.

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 I/O Implementation Issue

Hi All,
I am trying out the latest JDK 1.4 java.nio.* package. I modified the NBTimeServer and wrote a client which connects to the NBTimeServer and tries to pass messages to and fro. I always succeed to pass on roundtrip of msgs and then Server blocks my client forever. I have modified NBTimeServer to accomodate one client only. Any help or comments on this would be really appreciated. Code is below. Feel free to try it out if want to see what I am trying to convey in this message.
/*******Server Code*******/
Modified this code to test mulitple to and fro msgs between client and server.
Only one client will ever be able to connect to this server during life of a server.
My point here is to demonstrate the to and fro comm between one client and one server
import java.io.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.channels.spi.*;
import java.net.*;
import java.util.*;
import java.nio.charset.*;
import java.util.regex.*;
// Listen on a port for connections and write back the current time.
public class NBTimeServer {
private static final int DEFAULT_TIME_PORT = 8900;
// Constructor with no arguments creates a time server on default port.
public NBTimeServer() throws Exception {
     acceptConnections(this.DEFAULT_TIME_PORT);
// Constructor with port argument creates a time server on specified port.
public NBTimeServer(int port) throws Exception {
     acceptConnections(port);
// Accept connections for current time. Lazy Exception thrown.
private static void acceptConnections(int port) throws Exception {
     // Selector for incoming time requests
     Selector acceptSelector = SelectorProvider.provider().openSelector();
     Selector rwSelector = SelectorProvider.provider().openSelector();
     // Create a new server socket and set to non blocking mode
     ServerSocketChannel ssc = ServerSocketChannel.open();
     ssc.configureBlocking(false);
     // Bind the server socket to the local host and port
     InetAddress lh = InetAddress.getLocalHost();
     InetSocketAddress isa = new InetSocketAddress(lh, port);
     ssc.socket().bind(isa);
     // Register accepts on the server socket with the selector. This
     // step tells the selector that the socket wants to be put on the
     // ready list when accept operations occur, so allowing multiplexed
     // non-blocking I/O to take place.
     SelectionKey acceptKey = ssc.register(acceptSelector,
                         SelectionKey.OP_ACCEPT);
     int keysAdded = 0;
     // Here's where everything happens. The select method will
     // return when any operations registered above have occurred, the
     // thread has been interrupted, etc.
     while ((keysAdded = acceptSelector.select()) > 0) {
     // Someone is ready for I/O, get the ready keys
     Set readyKeys = acceptSelector.selectedKeys();
     Iterator i = readyKeys.iterator();
     // Walk through the ready keys collection and process date requests.
     while (i.hasNext()) {
          SelectionKey sk = (SelectionKey)i.next();
          i.remove();
          // The key indexes into the selector so you
          // can retrieve the socket that's ready for I/O
          ServerSocketChannel nextReady =
          (ServerSocketChannel)sk.channel();
          // Accept the date request and send back the date string
          Socket s = nextReady.accept();
                    SocketChannel sc = s.getChannel();
System.out.println("Got client channel..");
          sc.configureBlocking(false);
          SelectionKey readKey = sc.register(rwSelector,
                         SelectionKey.OP_READ|SelectionKey.OP_WRITE);
          int count = 0;
while(true) {
if((count = rwSelector.select(1000L)) > 0) {
Set readKeys = rwSelector.selectedKeys();
Iterator i1 = readKeys.iterator();
while(i1.hasNext()) {
System.out.println("Loop in Iterator");
SelectionKey sk1 = (SelectionKey)i1.next();
i1.remove();
if(sk1.isReadable()) {
DataInputStream sin = new DataInputStream(new BufferedInputStream(s.getInputStream(), 4096));
System.out.println(sin.readInt());
if(sk1.isWritable()) {
DataOutputStream sout = new DataOutputStream(new BufferedOutputStream(s.getOutputStream(), 4096));
PrintWriter out = new PrintWriter(sout, true);
          Date now = new Date();
          out.println(now);
// Entry point.
public static void main(String[] args) {
     // Parse command line arguments and
     // create a new time server (no arguments yet)
     try {
          NBTimeServer nbt = new NBTimeServer();
     } catch(Exception e) {
          e.printStackTrace();
/******End Server Code********/
/*****Begin Client Code********/
import java.io.*;
import java.net.*;
import java.util.*;
// Listen on a port for connections and write back the current time.
public class NBTimeClient {
private static final int DEFAULT_TIME_PORT = 8900;
public static void main(String args[]) throws Exception {
InetAddress lh = InetAddress.getLocalHost();
Socket s = new Socket(lh, DEFAULT_TIME_PORT);
DataInputStream din = new DataInputStream(new BufferedInputStream(s.getInputStream(), 4096));
DataOutputStream dout = new DataOutputStream(new BufferedOutputStream(s.getOutputStream(), 4096));
//Read the time
System.out.println(din.readLine());
//send some junk which is read by server
dout.writeInt(1299);
dout.flush();
//read time again -- I never get anything here and I am blocked here...
System.out.println(din.readLine());
//send some junk back to the server
dout.writeInt(1299);
dout.flush();
s.close();
/*******End Client Code**********/
thanks,
Xtrimity

The reason it blocks forever is that you need to keep reusing your main select. That is where the non-blocking event will come from. Here is a bit of code that doesn't block forever.
Tim
http://tim.owlmountain.com
import java.io.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.channels.spi.*;
import java.net.*;
import java.util.*;
import org.apache.log4j.*;
public class NBServer3 {
int _port = 4000;
Selector _selector = null;
ServerSocketChannel _selectableChannel = null;
int _keysAdded = 0;
static Category log =
Category.getInstance(NBServer3.class.getName());
static String QUIT_SERVER = "quit";
public NBServer3() {
public NBServer3( int port ) {
this._port = port;
public void initialize()
throws IOException {
this._selector = SelectorProvider.provider().openSelector();
this._selectableChannel = ServerSocketChannel.open();
     this._selectableChannel.configureBlocking(false);
     InetAddress lh = InetAddress.getLocalHost();
     InetSocketAddress isa = new InetSocketAddress(lh, this._port );
     this._selectableChannel.socket().bind(isa);
public void finalize()
throws IOException {
this._selectableChannel.close();
this._selector.close();
public void acceptConnections()
throws IOException {
Selects a set of keys whose corresponding channels are ready for I/O
operations. This method performs a non-blocking selection operation.
If no channels have become selectable since the previous selection
operation then this method immediately returns zero.
Returns:
The number of keys, possibly zero, whose ready-operation sets
were updated by the selection operation
do {
SelectionKey acceptKey =
this._selectableChannel.register( this._selector,
SelectionKey.OP_ACCEPT );
log.debug( "Acceptor loop..." );
while (( this._keysAdded = acceptKey.selector().select()) > 0 ) {
log.debug( "Selector returned "
+ this._keysAdded + " ready for IO operations" );
Set readyKeys = this._selector.selectedKeys();
Iterator i = readyKeys.iterator();
while (i.hasNext()) {
SelectionKey key = (SelectionKey)i.next();
i.remove();
if ( key.isAcceptable() ) {
ServerSocketChannel nextReady =
(ServerSocketChannel)key.channel();
log.debug( "Processing selection key read="
+ key.isReadable() + " write=" + key.isWritable() +
" accept=" + key.isAcceptable() );
Socket s = nextReady.accept();
s.getChannel().configureBlocking( false );
SelectionKey readKey =
s.getChannel().register( this._selector,
SelectionKey.OP_READ );
readKey.attach( s );
else if ( key.isReadable() ) {
SelectableChannel nextReady =
(SelectableChannel) key.channel();
log.debug( "Processing selection key read="
+ key.isReadable() + " write=" + key.isWritable() +
" accept=" + key.isAcceptable() );
Socket socket = (Socket) key.attachment();
BufferedReader in = new BufferedReader(
new InputStreamReader( socket.getInputStream() ));
String line = null;
if ( (line = in.readLine() ) != null )
log.debug( line );
log.debug( "End acceptor loop..." );
} while ( false ); //FIXIT tim this should be false. justa test
public static void main( String[] args ) {
BasicConfigurator.configure();
NBServer3 nbServer = new NBServer3();
try {
nbServer.initialize();
} catch ( IOException e ) {
e.printStackTrace();
System.exit( -1 );
try {
nbServer.acceptConnections();
catch ( IOException e ) {
e.printStackTrace();
log.error( e );

SO timeout relevance in non-blocking NIO ServerSocketChannel

I converted a threaded blocking server from using the standard blocking IO with a thread for each connection to using non-blocking NIO channels. Works great but I'm trying to understand the SO timeout relevance in the context of non-blocking NIO channels. Is there any relevance and should I set an SO timeout on the ServerSocket associated with a ServerSocketChannel and if so how should I handle it?

No. Socket timeouts are for blocking mode. If you need timeouts in non-blocking mode you have to do them yourself, taking advantage of the Selector.select(long timeout) method and keeping track of activity times per channel yourself. You should use that select() method anyway, rather than just blocking indefinitely, as it gives you a chance to catch up on housekeeping, dead channels, etc. For example as a very naive approach if nothing happens in say a select timeout of 10 minutes you might want to close all accepted SocketChannels.

Thread vs Non-Blocking - invoke thead

Similar Messages

Maybe you are looking for