OutOfMemoryError: unable to create native thread

Question

Why do I get OutOfMemory exceptions even if there is plently of Memory.
JVM settings are -Xms256M and -Xmx1024M.
Debug at runtime (Runtime.totalMemory()) shows that it never got above 260M. Why does the JVM not grab some more memory -instead of throwing OutOfMemory exception.
I am creating quite a lot of threads 800+ within a few minutes
Any ideas?

Answer 1

I googled a bit and one thing i came across was
"In those hypothetical configurations, the error java.lang.OutOfMemoryError: unable to create new native thread would begin to saturate the JRun logs. To clarify the error text, the error message means that no more native, or OS, threads can be created for the JVM process, causing the JVM to throw an exception. The exception type is java.lang.outOfMemoryError, but I find that to be rather misleading since the resource limitation on the OS thread count, not memory usage. "
So it looks like you're looking for OS specific settings rather than anything pure java.
Note that a thread per socket is not necessary, even when not using NIO:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class ForumQuestion { 
    // i'm assuming character based input
    static final List<Reader> readers = new LinkedList<Reader>();
    static final Map<Reader,StringBuffer> buffers = new HashMap<Reader,StringBuffer>();
    static final Map<Reader,Socket> sockets = new HashMap<Reader,Socket>();
    public static void main( String[] args ) throws IOException {
        // using single thread (for simplicity) to handle all sockets
        // the main trick is making sure that your thread(s) doing the reading
        // don't sit and "spin" around the inputStreams when they have nothing
        // at all waiting... wasting CPU. Here i just make the worker sleep
        // for 1000 nanos between attempts where it hasn't read anything. I'm
        // sure you can do better!
        Executors.newScheduledThreadPool( 1 ).scheduleWithFixedDelay( new Runnable() {
            public void run() {
                checkStreams();
        }, 1000, 1000, TimeUnit.NANOSECONDS );
        // create server socket and use main thread to block waiting for connections
        ServerSocket serverSock = new ServerSocket( 1138 );
        System.out.println( "Accepting connections on port 1138" );
        while( true ) {
            Socket s = serverSock.accept();
            synchronized( readers ) {
                Reader r = new BufferedReader( new InputStreamReader( s.getInputStream() ) );
                readers.add( r );
                buffers.put( r, new StringBuffer() );
                sockets.put( r, s );
                System.out.printf( "Connection: %s%n", s );
    private static void checkStreams() {
        // i've been lazy (over zealous) with the synchronization for simplicity. you'd want to
        // Do something cleverer than blocking accepts() while work is being done
        synchronized( readers ) {
            if ( readers.size() == 0 ) {
                return;
            // carry on until no work was done for any incoming sockets
            while( true ) {
                boolean workDone = false;
                for( Reader r : readers ) {
                    try {
                        StringBuffer buff = buffers.get( r );
                        while( r.ready() ) {
                            char c = (char)r.read();
                            buff.append( c );
                            checkBuffer( r, buff, c );
                            workDone = true;
                    } catch( IOException e ) {
                        // do something here, client prob dead
                // if no work done (no sockets had anything) then rest the thread
                if ( !workDone ) break;
    private static void checkBuffer( Reader r, StringBuffer buff, char last ) {
        if ( last == '\n' ) {
            System.out.printf( "Read \"%s\" from %s%n", buff.toString().trim(), sockets.get( r ) );
            buff.delete( 0, buff.length() );
Accepting connections on port 1138
Connection: Socket[addr=/127.0.0.1,port=1776,localport=1138]
Connection: Socket[addr=/127.0.0.1,port=1777,localport=1138]
Read "hello" from Socket[addr=/127.0.0.1,port=1776,localport=1138]
Read "hi" from Socket[addr=/127.0.0.1,port=1777,localport=1138]
Read "we're two sockets, but only using one thread to read from both of us!!" from Socket[addr=/127.0.0.1,port=1776,localport=1138]
Read "Oh! YAY!!!!" from Socket[addr=/127.0.0.1,port=1777,localport=1138]It's massively inferior to using NIO, but better than having thousands of dedicated threads