F
fishfry
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?
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?