שלום
אני מחפש אובייקט/שיטה מתועדת להמתנה לקבוצה של אובייקטים (לאובייקט בודד ניתן לעשות wait\notify)

האם מישהו נתקל בבעיה כזאת ופתר אותה (ולא ע"י לולאה שממתינה לכולם סדרתית)

דוג:
יש לי 10 threadים, כל אחד מרחיב את java.lang.object לכן ניתן לבצע עליו wait,
בתוך הthread יש לי notifyall על עצמי,
אני מעוניין בmain להמתין במקביל (ועם הגבלת זמן) לכל הthreadים

אני מכיר מטודה בWINSOCK המאזינה למספר socketים במקביל, מכיר גם הרחבה שלה שיכולה להמתין למספר event control blocks ולקבל פיקוח, השאלה אם זה קיים גם בjava :-)

תודה מראש

אם תצרף קוד ואז תסביר מה הבעיה זה מאד יעזור.

בתודה,
talika g.

הינה ממשתמצית, מקווה שזה מייצג את הבעייה:

קוד:

 
import java.util.Iterator;
import java.util.LinkedList;
public class TestPad extends Thread
{
public static Object SyncRes = new Object();
public static LinkedList BackSyncs = new LinkedList();
 
public static void main(String[] args)
{
System.out.println("Begining...");
LinkedList lsThreads = new LinkedList();
 
// Create All Threads
for (int i = 0; i < 10; i++)
{
lsThreads.add(new TestPad());
}
 
// Start All Threads 
Iterator itThreads = lsThreads.iterator();
while (itThreads.hasNext())
{
TestPad element = (TestPad) itThreads.next();
element.start();
}
 
System.out.println("Activating Agents...");
// Make All Threads Work
synchronized (SyncRes)
{
SyncRes.notifyAll();
}
 
System.out.println("Waiting Agents To Complete Part Of Work...");
// Wait On All Objects In List (The Problematic Part)
synchronized (BackSyncs)
{
Iterator itSyncs = BackSyncs.iterator();
while (itSyncs.hasNext())
{
	Object element = itSyncs.next();
//	This Number Shuld Be Absolute (For All Waited Threads Simultaniously)
	try
	{
	 synchronized (element)
	 {
	 element.wait(2000);
	 }
	}
	catch (InterruptedException e)
	{
	 e.printStackTrace();
	}
}
}
System.out.println("Ending...");
}
// This method is called when the thread runs
public void run()
{
try
{ 
Object BackSync = new Object();
synchronized (BackSyncs)
{
	BackSyncs.add(BackSync);
}
 
synchronized (SyncRes)
{
	SyncRes.wait();
}
 
Thread.sleep(1000);
 
synchronized (BackSync)
{
	BackSync.notifyAll();
}
 
// Do More Work (So join on thread is not an option)
 
synchronized (BackSyncs)
{
	BackSyncs.remove(BackSync);
}
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
 

הסבר קצר של מה שאני מנסה כאן:
אני יוצר 10 תהליכים, ומעוניין ביכולת לעצור ולהמשיך אותם מתהליך אחר (ללא suspend\resume כי ישנה רק נקודה אחת בה אני מוכן שכל אחד מהתהליכים ייעצר בה - נקודה קונסיסטנטית)

הבעיה היא בwhile על כל רשימת הBackSyncs שפשוט לא באמת ממתינה כמו שצריך...

תודה מראש