Threads question

From: fishfry (BLOCKSPAMfishfry_at_your-mailbox.com)
Date: 06/29/04 

Date: Tue, 29 Jun 2004 04:48:09 GMT

I'm learning about threads and I noticed there are two different ways I
can implement a runnable object. In one way, I have one object and two
threads; in the other way, I have two objects and two threads. Like this:

// Two objects, two threads
public class Counter implements Runnable {
    Thread t;
    int Count;

    Counter(String threadname) {
        Count=0;
        t = new Thread(this, threadname);
        t.start();
    }

    public void run() {
        while(t == Thread.currentThread()) {
            Count++;
            System.out.println("Thread " + t.getName()
                + " count = " + Count);
            try {
                t.sleep(1000); // in milliseconds
             } catch (InterruptedException e) {}
        }
    }

    public void stop() {
        t = null;
    }

    public static void main(String args[]) {
        // Two objects.
        Counter c1 = new Counter("foo");
        Counter c2 = new Counter("bar");
    }
}

The output of this program is

Thread foo count = 1
Thread bar count = 1
Thread foo count = 2
Thread bar count = 2
Thread foo count = 3
Thread bar count = 3
Thread foo count = 4
Thread bar count = 4
etc.

Since each thread operates on its own instance of the object Counter,
each thread has its own copy of the instance variable Count.

// One object, two threads.
public class Counter2 implements Runnable {
    int Count = 0;

    Counter2() {
    }

    public void run() {
        Thread t;
        t = Thread.currentThread();
        while(true) {
            Count++;
            System.out.println("Thread " + t.getName()
                + " count = " + Count);
            try {
                t.sleep(1000); // in milliseconds
            } catch (InterruptedException e) {}
        }
    }

    public void stop() {
      // t = null;
    }

    public static void main(String args[]) {
        Counter2 c1 = new Counter2();

        // One object, two threads.
        Thread t1 = new Thread(c1);
        Thread t2 = new Thread(c1);

        t1.start();
        t2.start();
    }
}

The output is

Thread Thread-0 count = 1
Thread Thread-1 count = 2
Thread Thread-0 count = 3
Thread Thread-1 count = 4
Thread Thread-0 count = 5
Thread Thread-1 count = 6
Thread Thread-0 count = 7
Thread Thread-1 count = 8
etc.

because there are two threads, each sharing the same object.

Are there names for these two ways of doing things? What are the
implications for synchronization, etc.? What else should I know about
these? And why don't any of the tutorials mention this interesting
distinction?

Relevant Pages

  • Threads question
    ... I'm learning about threads and I noticed there are two different ways I ... public class Counter implements Runnable { ... Thread foo count = 1 ... Thread bar count = 1 ...
    (comp.lang.java.programmer)
  • Threads question
    ... I'm learning about threads and I noticed there are two different ways I ... public class Counter implements Runnable { ... Thread foo count = 1 ... Thread bar count = 1 ...
    (comp.lang.java)