thread communication

[nitin kumar]

Hi
i got a problem in multithreading. In my project I have 10 threads and each thread shud run one after another ie 1,2,3,4------,10 after the completion of the 10 thread again the 1 thread shud run.For inter thread communication I know that wait and notify are one means but how to give the preference if many threads are there. Is there anything like thread priority. I will be thankful if someone provides me with code
bye
nitin

[Dave Wingate]

Nitin,
you can set a Thread's priority by using its setPriority(int) method.
However,be forewarned that setting one thread to a higher priority does not guarantee that thread will finish before any other thread is started.

[Paulo Salgado]

Nitin,
you want to restart T1 after all ten threads are dead, is that right ? (considering T8 can finish after T9, for instance)
If that's the case, in the loop where you'll be doing the restart, you can check if there's still threads alive. For instance:

public void yourMethod() {
 
   boolean mainCond = true;
   boolean stillAlive = false;
   // Below is your runnable object...
   ThreadObj[] yourThread = new ThreadObj[10];
   while (mainCond) {
   
     for (int i=0;i<yourThread.length;i++) {
       yourThread[i].start();
     }
     stillAlive = false;
     
     do {
       for (int i=0;i<yourThread.length;i++){
         if (yourThread[i].isAlive()) {
           stillAlive = true;
           break;
         }
       }
       // You may add some interruptible code here to break out of the while
     } while (stillAlive);
   // Recheck main condition
  }
}

If you just want to check for the tenth Thread then replace the for loop in the do-while by yourThread[9].isAlive();
[ August 23, 2002: Message edited by: Paulo Salgado ]

[Dave Wingate]

With respect to restarting threads......I always thought that you cannot restart a dead thread.

[Anthony Villanueva]

Originally posted by Dave Winn:
Nitin,
you can set a Thread's priority by using its setPriority(int) method.
However,be forewarned that setting one thread to a higher priority does not guarantee that thread will finish before any other thread is started.
With respect to restarting threads......I always thought that you cannot restart a dead thread.

True and true. However, it is also possible to cheat . See the sample code below:

public class Test30
{
private static Thread [] t = new Thread[10];
private static char [] threadName = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'};
public static void main(String args[])
{
initialize(new Runner(new SomeObject()));
}
private static void initialize(Runner r)
{
for(int i=0;i<10;i++)
{
t[i] = new Thread(r, "Thread " + threadName[i]);
t[i].start();
}
}
}
class Runner implements Runnable
{
private SomeObject obj;
Runner(SomeObject o)
{
obj = o;
}

public void run()
{
String currentThread = Thread.currentThread().getName();
try
{
if (currentThread.charAt(7) != 'A') Thread.currentThread().yield(); 
for(; :wink: 
{
synchronized(obj)
{
System.out.println(currentThread + " is entering block.");
for(int i=0;i<5;i++)
{
obj.add();
obj.print();
Thread.sleep(500);
}
System.out.println(currentThread + " is leaving block.");
}

if (!Runner.precedes(Thread.currentThread().getName().charAt(7), currentThread.charAt(7))) Thread.currentThread().yield(); 

}

}
catch(InterruptedException e)
{
e.printStackTrace();
}
}
private static boolean precedes(char c1, char c2)
{
if (c1 == 'J' && c2 == 'A') return true;
return c1 > c2;
}

}
class SomeObject
{
private int value = 0;
void add()
{
value++;
}
void print()
{
System.out.println(value);
}
}

Ok, so it's not elegant, but I did it in a hurry...

[James Carman]

Originally posted by nitin kumar:
Hi
i got a problem in multithreading. In my project I have 10 threads and each thread shud run one after another ie 1,2,3,4------,10 after the completion of the 10 thread again the 1 thread shud run.For inter thread communication I know that wait and notify are one means but how to give the preference if many threads are there. Is there anything like thread priority. I will be thankful if someone provides me with code
bye
nitin

Why are you using threads in the first place? You have pieces of code (10 of them) that must run one after the other. Once the last one is complete, you run the process again. Wouldn't one thread do the trick here with a looping construct of some sort?

[Paulo Salgado]

James, that was the reason of my first assumption.
Dave, ooooppssss... completely right. It wouldn't work this way. The threads in the array would have to be reallocated at every loop iteration.
Anthony, that's a cool piece of code.
[ August 27, 2002: Message edited by: Paulo Salgado ]

[Anthony Villanueva]

So sorry friends but this code is not cool at all . On second look it's logic is faulty. It only looks as if it's working because the threads are started in the desired order and they all have the same default priority. Anyway I'll try to make a real solution when I'm free.

[Jim Yingst]

I'm with James Carman here; I'm not convinced that recent posts have anything to do with what Nitin originally asked about; which doesn't seem to really require threads at all. But I do note that if you do want to wait until all ten threads are dead, there's a simple solution which does not keep bothering the processor when nothing has happened:

    for (int index = 0; index < yourThread.length; index ++)
      yourThread[index].join();

The join() method waits patiently for a thread to die; if it's already dead, the method completes without waiting.
My time is short, so I'll leave Anthony alone while he works on his code. Except to note that Doug Lea's Concurrent Programming in Java may have some relevant ideas (if you haven't already looked there). Cheers...
[ August 27, 2002: Message edited by: Jim Yingst ]

[Anthony Villanueva]

Okay, I promised to give something, so here it is.
The premise I was acting on was that 10 threads would access the same object in a certain order: A first, then B, C, etc until J and then A again ad nauseam. Whether or not this is actually a valid interpretation of Nitin's problem, I am no longer inclined to argue. I just want to see if this premise can be implemented.
I deliberately initialized the threads in reverse order and set them in "opposing" priorities to test if the code really did what was asked. It also successfully sifted out thread A to access the common object first, even though it had the least priority.
I didn't clean up the code anymore to be "tighter" and more elegant; i just wanted to see if it would work. Bear with me

public class Test34
{
private static Thread [] r = new Runner[10];
private static char [] threadName = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I' ,'J'};

public static void main(String args[])
{
SomeObject obj = new SomeObject();
for(int i=9;i>=0;i--)
{
r[i] = new Runner(obj, "Thread " + threadName[i]);
r[i].setPriority(i+1);
r[i].start();
}
}
}
class Runner extends Thread
{
private SomeObject obj;
private char threadId;
Runner(SomeObject o, String name)
{
super(name);
threadId = setThreadId();
obj = o;
}
private char setThreadId()
{
return this.getName().charAt(7);
}

char getThreadId()
{
return threadId;
}
public void run()
{
if (obj.isFirstAccessed())
{
try
{
synchronized(obj)
{
for(; :wink: 
{
System.out.println("I am " + Thread.currentThread().getName());
if (!this.isFirstThread())
{
Thread.sleep(2000);
if (obj.isDone()) break;
 obj.wait(100);
System.out.println(Thread.currentThread().getName() + " is waiting...");
}
else
{
Thread.sleep(2000);
System.out.println("FIRST TIME");
obj.switchOn();

System.out.println(Thread.currentThread().getName() + " is entering block.");
System.out.println("Its priority is " + Thread.currentThread().getPriority());
for(int i=0;i<5;i++)
{
obj.add();
obj.print();
Thread.sleep(500);
}
System.out.println(Thread.currentThread().getName() + " is leaving block.");

obj.done();
obj.setOldThread( (Runner) Thread.currentThread() );
System.out.println(Thread.currentThread().getName() + " notifying all...");
obj.notifyAll();
break;
}
}
}
}
catch(InterruptedException e)
{
System.out.println("Exception at first access");
e.printStackTrace();
}

}

for(; :wink: 
{
try
{


synchronized(obj)
{
obj.setNewThread( (Runner) Thread.currentThread() );

if(obj.getNewThread().precedes(obj.getOldThread()))
{
//System.out.println("Old thread is " + obj.getOldThread().getName());
//System.out.println("New thread is " + obj.getNewThread().getName());
//System.out.println("newThread.precedes(oldThread)? " + obj.getNewThread().precedes(obj.getOldThread()));
System.out.println(Thread.currentThread().getName() + " is entering block.");
System.out.println("Its priority is " + Thread.currentThread().getPriority());
for(int i=0;i<5;i++)
{
obj.add();
obj.print();
Thread.sleep(500);
}
System.out.println(Thread.currentThread().getName() + " is leaving block.");
obj.setOldThread( (Runner) Thread.currentThread() );
}

}
}

catch(InterruptedException e)
{
e.printStackTrace();
}
}

}
private boolean precedes(Runner r)
{
if (this.threadId == 'A' && r.threadId == 'J') return true;
return (this.threadId - r.threadId) == 1;
}
private boolean isFirstThread()
{
return this.threadId == 'A'; 
}

}
class SomeObject
{
private int value = 0;
private boolean firstTimeSwitch = true;
Runner newThread, oldThread;
private boolean firstThreadDone = false;
SomeObject(int i)
{
value = i;
}
void setNewThread(Runner r)
{
newThread = r;
}
void setOldThread(Runner r)
{
oldThread = r;
}
Runner getNewThread()
{
return newThread;
}
Runner getOldThread()
{
return oldThread;
}
SomeObject()
{
value = 0;
}
synchronized void switchOn()
{
firstTimeSwitch = false;
}
synchronized boolean isFirstAccessed()
{
return firstTimeSwitch;
}

void add()
{
value++;
}
void print()
{
System.out.println(value);
}
boolean isDone()
{
return firstThreadDone;
}
void done()
{
firstThreadDone = true;
}
}

[Anthony Villanueva]

:sigh: I really hate it when the (;; ) for loops do that...
Also, swap

obj.wait(100);
System.out.println(Thread.currentThread().getName() + " is waiting...");

to

System.out.println(Thread.currentThread().getName() + " is waiting...");
obj.wait(100);

[ September 01, 2002: Message edited by: Anthony Villanueva ]

[Peter Haggar]

Originally posted by nitin kumar:
Hi
i got a problem in multithreading. In my project I have 10 threads and each thread shud run one after another ie 1,2,3,4------,10 after the completion of the 10 thread again the 1 thread shud run.For inter thread communication I know that wait and notify are one means but how to give the preference if many threads are there. Is there anything like thread priority. I will be thankful if someone provides me with code
bye
nitin

To solve this problem you can use what's called specific notificaiton. It's pretty simple and is described, with sample code here.
Peter Haggar

[Anthony Villanueva]

A much more sober approach of course, was already suggested by both James and Jim. Only one thread is made at a time and run, to avoid mucking around with the scheduler. The code is cleaner and more elegant.

public class Test38
{   
final static int THREAD_COUNT = 10;
public static void main(String [] args) throws InterruptedException 
{
SomeObject o = new SomeObject();
RelayThread r = RelayThread.generateInstance(o, 1);
r.start(); 
for(int i=1;;i++)
{
r.join();
r = RelayThread.generateInstance(o, i%Test38.THREAD_COUNT+1);
r.setPriority(getRandomValue());
r.start(); 
}
}
private static int getRandomValue()
{
return (int) Math.ceil(Math.random()*10);
}
}
abstract class RelayThread extends Thread 
{
private SomeObject obj;
private int threadCounter;
RelayThread(SomeObject o, String name)
{
super(name);
obj = o;
threadCounter++;
}
public void run()
{
try
{
System.out.println("Its priority is " + Thread.currentThread().getPriority());
System.out.println("Current thread count is " + threadCounter);
for(int i=0;i<5;i++)
{
obj.add();
obj.print();
Thread.sleep(750);
}
}
catch(InterruptedException e)
{
e.printStackTrace();
}
finally
{
System.out.println(Thread.currentThread().getName() + " is ending task.");
threadCounter--;
}
}
static RelayThread generateInstance(SomeObject o, int index)
{
switch(index)
{
case 1: return new ThreadA(o);
case 2: return new ThreadB(o);
case 3: return new ThreadC(o);
case 4: return new ThreadD(o);
case 5: return new ThreadE(o);
case 6: return new ThreadF(o);
case 7: return new ThreadG(o);
case 8: return new ThreadH(o);
case 9: return new ThreadI(o);
case 10: return new ThreadJ(o);
}
return null;
}
}
class SomeObject
{
private int value = 0;
SomeObject(int i)
{
value = i;
}
SomeObject()
{
value = 0;
}
void add()
{
value++;
}
void print()
{
System.out.println(value);
}
}
class ThreadA extends RelayThread
{
ThreadA(SomeObject o)
{
super(o, "Thread A");
}
public void run()
{
System.out.println("Doing special ThreadA tasks...");
super.run();
}
}
class ThreadB extends RelayThread
{
ThreadB(SomeObject o)
{
super(o, "Thread B");
}
public void run()
{
System.out.println("Doing special ThreadB tasks...");
super.run();
}
}
class ThreadC extends RelayThread
{
ThreadC(SomeObject o)
{
super(o, "Thread C");
}
public void run()
{
System.out.println("Doing special ThreadC tasks...");
super.run();
}
}
class ThreadD extends RelayThread
{
ThreadD(SomeObject o)
{
super(o, "Thread D");
}
public void run()
{
System.out.println("Doing special ThreadD tasks...");
super.run();
}
}
class ThreadE extends RelayThread
{
ThreadE(SomeObject o)
{
super(o, "Thread E");
}
public void run()
{
System.out.println("Doing special ThreadE tasks...");
super.run();
}
}
class ThreadF extends RelayThread
{
ThreadF(SomeObject o)
{
super(o, "Thread F");
}
public void run()
{
System.out.println("Doing special ThreadF tasks...");
super.run();
}
}
class ThreadG extends RelayThread
{
ThreadG(SomeObject o)
{
super(o, "Thread G");
}
public void run()
{
System.out.println("Doing special ThreadG tasks...");
super.run();
}
}
class ThreadH extends RelayThread
{
ThreadH(SomeObject o)
{
super(o, "Thread H");
}
public void run()
{
System.out.println("Doing special ThreadH tasks...");
super.run();
}
}
class ThreadI extends RelayThread
{
ThreadI(SomeObject o)
{
super(o, "Thread I");
}
public void run()
{
System.out.println("Doing special ThreadI tasks...");
super.run();
}
}
class ThreadJ extends RelayThread
{
ThreadJ(SomeObject o)
{
super(o, "Thread J");
}
public void run()
{
System.out.println("Doing special ThreadJ tasks...");
super.run();
}
}

[Ron Newman]

But if you don't want any concurrency, why use threads at all?

[Anthony Villanueva]

Originally posted by Ron Newman:
But if you don't want any concurrency, why use threads at all?

Oh I quite agree. Why use ten when one will do? It was purely an academic exercise
Hmmm... maybe I should take up a hobby...