Java

public class Counter implements Counting
{
    private int value = 0;

    public int incrementAndGet()
    {
        return this.value++;
    }

    public int decrementAndGet()
    {
        return this.value--;
    }
}

public class CounterClient implements Runnable
{
    //shared data    
    private Counting counter;

    public CounterClient(Counting counter)
    {
        this.counter = counter;
    }

    public void run()
    {
        while(true)
        {
            System.out.println("Incrementing from " + Thread.currentThread().getName() );                
            System.out.println("Counter value in " + Thread.currentThread().getName() + " = " + counter.incrementAndGet());                
            
            try
            {
                Thread.sleep(2000L);
            } catch (InterruptedException ex)
            {
                Logger.getLogger(CounterClient.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
    
}

public class TestCounter
{
    public static void main(String args[])
    {
        Counter counter = new Counter();
        SafeCounter safeCounter = new SafeCounter();
        
        Executor exec = Executors.newCachedThreadPool();
        
        exec.execute(new CounterClient(counter));
        exec.execute(new CounterClient(counter));        
        /*
        exec.execute(new CounterClient(safeCounter));
        exec.execute(new CounterClient(safeCounter));
         */
         
    }
    
}

Incrementing from pool-1-thread-1
Incrementing from pool-1-thread-2
Counter value in pool-1-thread-1 = 0
Counter value in pool-1-thread-2 = 1
Incrementing from pool-1-thread-2
Incrementing from pool-1-thread-1
Counter value in pool-1-thread-2 = 2
Counter value in pool-1-thread-1 = 3
Incrementing from pool-1-thread-2
Incrementing from pool-1-thread-1
Counter value in pool-1-thread-1 = 4
Counter value in pool-1-thread-2 = 5
Incrementing from pool-1-thread-2
Incrementing from pool-1-thread-1
Counter value in pool-1-thread-1 = 6
Counter value in pool-1-thread-2 = 7
Incrementing from pool-1-thread-1
Counter value in pool-1-thread-1 = 8
Incrementing from pool-1-thread-2
Counter value in pool-1-thread-2 = 9
Incrementing from pool-1-thread-2
Counter value in pool-1-thread-2 = 10
Incrementing from pool-1-thread-1
Counter value in pool-1-thread-1 = 11
Incrementing from pool-1-thread-1
Incrementing from pool-1-thread-2
Counter value in pool-1-thread-2 = 13
Counter value in pool-1-thread-1 = 12

import java.applet.*;
import java.awt.*;
import java.io.*;
import java.net.*;
import javax.swing.*;
import javax.swing.event.*;
import java.awt.event.*;
import java.awt.TextField.*;
import java.lang.*;
import java.util.*;

public class AMClient extends JApplet implements ActionListener{
	static public Socket localSocket;
	static final long serialVersionUID = 42L;
    static public PrintWriter out;
    static public InputStream in;
    static public JFrame fAMClient;
	static public JPanel nPanel,cPanel,sPanel;
    static public JButton btnConnect;
    static public JTextField tfInput;
	static public JTextArea taMud;

	public void init()
    {
		        try
		        {
					System.out.println("1");
					System.getSecurityManager().checkPermission(new SocketPermission("asylum-mud.org", "connect"));
					localSocket = new Socket("asylum-mud.org", 6715);
					System.out.println("2");
					in = new BufferedInputStream(localSocket.getInputStream());
					System.out.println("3");
					out= new PrintWriter(localSocket.getOutputStream(),true);
				}
				catch(Exception e)
				{
					System.out.println(e);
		}
		tfInput= new JTextField(30);
		btnConnect = new JButton("Connect");
		taMud = new JTextArea(30,50);
		add(btnConnect);
		add(taMud);
		add(tfInput);
		//display d = new display();
        //getContentPane().add(d);
        btnConnect.addActionListener(this);
    }
    public void actionPerformed(ActionEvent e)
    {
		//makes sure source is the connect button
		//& disable the button so it won't call
		//upon itself while active.
        if(e.getSource() == btnConnect)
        {
			btnConnect.enable(false);
			//btnConnect.setVisible(false);
		}
        //Create the socket to asylum-mud.org 6715
        try
        {
			//While we have a connection
            // get user input value and store it as a string
			taMud.append("6");
			String stdInn;
			taMud.append("7");
			stdInn = slurp(in,4122 );
			taMud.append("8");
			taMud.append(stdInn);
			taMud.append("9");
			out.flush();
        }
        catch(Exception ioe)
        {
            System.out.println(ioe.getMessage());
        }
    }

    public static void main( String[] args )
    {
        try
        {
			System.out.println("1");
			localSocket = new Socket("asylum-mud.org", 6715);
			System.out.println("2");
			in = new BufferedInputStream(localSocket.getInputStream());
			System.out.println("3");
			out= new PrintWriter(localSocket.getOutputStream(),true);
		}
		catch(Exception e)
		{
			System.out.println(e);
		}
		fAMClient = new JFrame();
		System.out.println("init 1");
		JApplet aAMClient = new JApplet();
		aAMClient.init();

		fAMClient.getContentPane().add(aAMClient);
		fAMClient.setSize(1200, 1200);
        fAMClient.setVisible(true);
        fAMClient.setTitle("AbsentMirage Client");
        aAMClient.start();
    }

    public static String slurp(final InputStream is, final int bufferSize)
	{
		final char[] buffer = new char[bufferSize];
	    final StringBuilder slurpOut = new StringBuilder();
	    taMud.append("slurp1");
	    try
	    {
			taMud.append("slurp2");
		    final Reader slurpIn = new InputStreamReader(is, "UTF-8");
	        taMud.append("slurp3");
	        try
	        {
	             final int rsz = slurpIn.read(buffer, 0, buffer.length);
	             slurpOut.append(buffer, 0, rsz);
	        }
	        catch (IOException ex)
	        {
				System.out.println(ex);
	    	}
	    finally
	    {
			try
			{
				in.close();
			}
	        catch (IOException ex)
	        {
				System.out.println(ex);
			}
	    }
	  }
	  catch (UnsupportedEncodingException ex)
	  {
		  System.out.println(ex);
	  }
	  return out.toString();
	}

}

import java.util.AbstractList;

/**
* An implementation of the List interface that allows for fast modifications
* at both the head and tail.
*
* @param <T> the type of objects stored in this list
*/
public class ArrayDeque2<T> extends AbstractList<T> {
    /**
     * The class of elements stored in this queue
     */
    protected Factory<T> f;

    /**
     * Array used to store elements
     */
    public T[] a;

    /**
     * Index of next element to de-queue
     */
    public int j;

    /**
     * Number of elements in the queue
     */
    public int n;

    /**
     * Grow the internal array
     */
    protected void resize() {
        T[] b = f.newArray(Utils.max(2*n,1));
        for (int k = 0; k < n; k++)
            b[k] = a[(j+k >= a.length) ? j+k-a.length : j+k];
        a = b;
        j = 0;
    }

    /**
     * Constructor
     */
    public ArrayDeque2(Class<T> t) {
        f = new Factory<T>(t);
        a = f.newArray(1);
        j = 0;
        n = 0;
    }

    public int size() {
        return n;
    }

    public T get(int i) {
        if (i < 0 || i > n-1) throw new IndexOutOfBoundsException();
        return a[(j+i >= a.length) ? j+i-a.length : j+i];
    }

    public T set(int i, T x) {
        if (i < 0 || i > n-1) throw new IndexOutOfBoundsException();
        T y = a[(j+i >= a.length) ? j+i-a.length : j+i];
        a[(j+i >= a.length) ? j+i-a.length : j+i] = x;
        return y;
    }

    public void add(int i, T x) {
        if (i < 0 || i > n) throw new IndexOutOfBoundsException();
        if (n+1 > a.length) resize();
        if (i < n/2) {
            // shift elements 0,...,i-1 left in a
            j = (j == 0) ? a.length - 1 : j - 1;
            for (int k = 0; k < i-1; k++)
                a[(j+k >= a.length) ? j+k-a.length : j+k] = a[(j+k+1 >= a.length) ? j+k+1-a.length : j+k+1];
        } else {
            // shift elements i,...,n-1 right in a
            for (int k = n; k > i; k--)
                a[(j+k >= a.length) ? j+k-a.length : j+k] = a[(j+k-1 >= a.length) ? j+k-1-a.length : j+k-1];
        }
        a[(j+i >= a.length) ? j+i-a.length : j+i] = x;
        n++;
    }

    public T remove(int i) {
        if (i < 0 || i > n - 1) throw new IndexOutOfBoundsException();

        T x = a[(j+i >= a.length) ? j+i-a.length : j+i];
        if (i < n/2) {
            for (int k = i; k > 0; k--)
                a[(j+k >= a.length) ? j+k-a.length : j+k] = a[(j+k-1 >= a.length) ? j+k-1-a.length : j+k-1];
            j = (j+1 >= a.length) ? j+1-a.length : j+1;
        } else {
            for (int k = i; k < n-1; k++)
                a[(j+k >= a.length) ? j+k-a.length : j+k] = a[(j+k+1 >= a.length) ? j+k+1-a.length : j+k+1];
        }
        n--;
        return x;
    }

    public void clear() {
        a = f.newArray(1);
        n = 0;
        resize();
    }
}