C#

connSocket.BeginReceive( mainBuffer_, 0, mainBuffer_.Length, SocketFlags.None, out socketError_, new AsyncCallback( receivedata ), connSocket );

private SocketError socketError; 
private volatile byte[] mainBuffer;
private volatile int receivedDataSize;
private volatile Thread processingThread;
private volatile AutoResetEvent autoResetEvent;
private volatile Queue<List<byte>> receivedDataQueue;

...

private void receiveData( IAsyncResult aSyncResult ) {
    try {
        // Extract the delivered Socket
        Socket connSocket = ( Socket ) aSyncResult.AsyncState;

        // End Asyncronen Operation
        receivedDataSize = connSocket.EndReceive( aSyncResult, out socketFehler_ );
        

        // are data available ?
        if( receivedDataSize > 0 ) {

              // Is the receivedDataSize bigger than the ReceiveBufferSize?
              if( receivedDataSize != connSocket_.ReceiveBufferSize ) {

                  // extract the data from the mainBuffer
                  byte[] tmpBuffer = new byte[ receivedDataSize ];
                  Array.Copy( mainBuffer, tmpBuffer, receivedDataSize );

                  // add the mainBuffer-data to the receivedDataQueue
                  receivedDataQueue.Enqueue( new List<byte>( tmpEingangsPuffer ) );
              }
              else {
                  // add the mainBuffer-data to the receivedDataQueue
                  receivedDataQueue.Enqueue( new List<byte>( mainBuffer ) );
              }

              // start second Thread when the connections is still alive and the second Thread is null or is not alive
              if( ( socketClosed == false ) &&
                  ( ( processingThread == null ) || ( processingThread.IsAlive == false ) ) ) {

                  
                  // Starte processing-Thread.
                  processingThread = new Thread( new ThreadStart( empfangsDatenVerarbeitung_ThreadMethode ) );
                  processingThread.IsBackground = true;
                  processingThread.Start();
              }

              // Signalize the processingThread that it can go further
              autoResetEvent_.Set();
            
        }
        else {
            // Close the Connection
            closeConnection();
        }

        // if the socket wasnt closed then start again the async receiving
        if( socketClosed == false ) {
        
            // clear MainBuffer.
            Array.Clear( mainBuffer, 0, mainBuffer.Length );

            // start async receiving
            connSocket.BeginReceive( mainBuffer, 0, mainBuffer.Length, SocketFlags.None, out socketFehler_, new AsyncCallback( receiveData ), connSocket );
        }
    }
    catch( SocketException ) {
        closeConnection();
    }
    catch( ThreadStateException ) {
        closeConnection();
    }
    catch( ObjectDisposedException ) { }

private void empfangsDatenVerarbeitung_ThreadMethode() {

// Loop until the Connection is alive
while( socketClosed  == false ) {

    // start only if there is something to do
    if( receivedDataQueue.Count > 0 ) {

        // loop until there is something to do
        while( receivedDataQueue.Count != 0 ) {
        
          // process the Data ...

        }

    }

    // Wait until some that are available
    autoResetEvent_.WaitOne();

}