By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
438,778 Members | 1,074 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 438,778 IT Pros & Developers. It's quick & easy.

Threads question

P: n/a
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?
Jul 17 '05 #1
Share this Question
Share on Google+
2 Replies


P: n/a
On Tue, 29 Jun 2004 04:48:09 GMT, fishfry
<BL**************@your-mailbox.com> wrote or quoted :
because there are two threads, each sharing the same object.

Are there names for these two ways of doing things?


Correct and incorrect.

The second way, if you run it long enough, you will eventually get
strange anomalies. You have to make sure the ++ is done atomically by
synchronising, not interleaving the fetch, add, store from two
different threads.
--
Canadian Mind Products, Roedy Green.
Coaching, problem solving, economical contract programming.
See http://mindprod.com/jgloss/jgloss.html for The Java Glossary.
Jul 17 '05 #2

P: n/a
fishfry wrote:
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?


You typically don't want to do the second of the two. It means that
instance fields of the Runnable are shared state, and need to be
protected with synchronization to guarantee consistent state. Something
that close the the thread's immediate task almost certainly ought to be
non-shared.

--
www.designacourse.com
The Easiest Way to Train Anyone... Anywhere.

Chris Smith - Lead Software Developer/Technical Trainer
MindIQ Corporation
Jul 17 '05 #3

This discussion thread is closed

Replies have been disabled for this discussion.