Threads question

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

  • Next message: Roedy Green: "Re: Threads question" 
    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?

  • Next message: Roedy Green: "Re: Threads question"

    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.help)
    • 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)