Java: Selected Topics

Creating Threads

Here is an example of extending the Thread class, and here is the same behavior implemented using the Runnable interface.
To extend Thread in general we do something like

    class Foo extends Thread
    {
        .............
	void run() {
	    // here is the code we want executed by the thread
	}
	.............
    }
then we create an instance with
    Thread x = new Foo();
and start its execution with
    x.start();
which will start the new thread executing the run method.

    class Foo implements Runnable
    {
        .............
        void run() {
            // here is the code we want executed by the thread
        }
        .............
    }
then we create a thread as follows
    Foo y = new Foo();
    Thread x = new Thread(y)
and again start its execution with
    x.start();
which will start the new thread executing the run method of y.

Traditional Synchronization

Here is an implementation for the problem of Producers communicating with Consumers though a Protected Bounded Buffer using the traditional synchronized approach.

Simple Sockets for Client-Server Interaction

InputStreamReader reader = new InputStreamReader(connected.getInputStream());
OutputStreamWriter writer = new OutputStreamWriter(connected.getOutputStream());

Explicit Synchronization with Locks and Conditions

Here is another version of the Producers and Consumers problem using explicit locks and conditions.

LockFree Atomic Operations

volatile in x = 0;
..
x++;

For atomicity on simple variable Java gives us the package java.util.concurrent.atomic. In it we find AtomicBoolean, AtomicInteger, AtomicIntegerArray, AtomicLong, AtomicLongArray, AtomicReference, AtomicReferenceArray, plus field updaters.
Let's look at AtomicInteger.

    AtomicInteger x = new AtomicInteger(); // x initialez to 0
    AtomicInteger y = new AtomicInteger(3);// y initialized to 3
    int a = y.get(); // store in a value of y
    int b = y.getAndSet(5); // b gets old value of y, 3, and y is set to 5 
    int c = x.addAndGet(6); // value of x is incremented by 6 and returned
			    // now x has value 6
    int d = x.decrementAndSet(2)// value of x decremented by 2 and returned
			    // now x has value 4
    boolean updated = x.compareAndSwap(4,11); // If the value of x is 4,
			    // change it to 11 and return true; otherwise
			    // x is unchanged and false is returned
    x.set(21); // x is set to 21 

    class Counter {
	private final AtomicInteger count = new AtomicInteger(0);
	public int increment() {
	    return count.getAndIncrement();
	}
    }

Java NIO

Buffers

1. capacity: the number of elements that it can contain.
2. limit: it represents the high water mark allowed for reading or writing to the buffer
3. position: like the cursor in Unix files, the current position where we can read or write
4. mark: a position that can be remembered with the mark() operation and later reestablished as current position with the reset() call.

Initially position is 0, the limit is equal to capacity, and the mark is undefined. The clear() operation will empty the content of the buffer, set limit to capacity, position to 0 and mark is undefined. The flip() operation sets limit to the current position, position to 0, and mark is undefined. It is used to read out what was written into the buffer. The rewind() operation sets the position to 0, the mark is undefined, and limit is unchanged. The hasRemaining() operation tells us if the position is less than limit (thus we can write/read something to/from the current position).
Buffers are not threadsafe.

Channels, SelectionKeys, and Selectors

Here is an example of use of ByteBuffer in conjunction with channels. And here is a trivial use of the MappedByteBuffer concept.

A SelectionKey represents the registration of a selectable channel such as SocketChannel or ServerSocketChannel, with a selector. A selection key corresponds to one of possible operations applicable to a channel, connect, accept, read, and write. That operation is specified when the selectable channel is registered with a selector. For example, if server is a ServerSocketChannel, selector is a Selector, and we want to register with the selector the server to wait on an accept operation, we say
server.register(selector, SelectionKey.OP_ACCEPT);
and if instead we want to register a SocketChannel client to wait on a read operation, we say
client.register(selector, SelectionKey.OP_READ);
Before being registered with a selector the channels should be places in non-blocking mode with
client.configureBlocking(false); and server.configureBlocking(false);

The selector had been created with
Selector selector = Selector.open();
and then, after the channels are registered, it blocks in the select call until a significant event occurs:
selector.select();
When this call returns it means that one or more significant event among those that were registered has occurred. We determine what are the ready channels (i.e. channels where significant events have occurred) with
Set readyKeys = selector.selectedKeys();
Then we iterate thru the ready keys and carry out the corresponding operations

      Iterator iterator = readyKeys.iterator( );
      while (iterator.hasNext( )) {
          SelectionKey key = iterator.next( );
          iterator.remove( );
	  try {
	      if (key.isAcceptable()) {
	          ............
	      } else if (key.isReadable()) {
	          ............
	      } else if (key.isWritable()) {
	          ............
	      } else if (key.isConnectable()) {
	          ............
	      }
 	   } catch (Exception e) {
	      ...........
	   }

Executors and Thread Pools

Java Remote Method Invocation (RMI)