Threads beenden

[andy0566]

Hallo,

ich habe ein Problem mit ThreadBeenden.
Hier ist meine ThreadKlasse:

public class ThreadText extends Thread{
	String m_Msg;
	public ThreadText(String msg){
		m_Msg=msg;
	}
	public void run(){
		while(true){
			System.out.println(m_Msg);
			try{
				
				//Thread.sleep(1000);
				Thread.sleep((int)(Math.random()*1500));
			}catch(InterruptedException e){
			}
		}
		
	}public static void main(String[]args){
		ThreadText a=new ThreadText("Moin...!!");
		ThreadText b=new ThreadText("juhu...");
		a.start();
		b.start();
	}
	
}

Wie kann ich alle Threads beenden,sobald einer der Threads 1000 mal den übergebenen String ausgegeben haben.
(WICHTIG: das Problem darf nicht mit System.exit beendet werden.)

 

[Beni]

Mit einem synchronisierten Zähler arbeiten:

public class Counter{
  public int count = 0;
}

public class ThreadText extends Thread{
   private Counter counter;
   private String m_Msg;

   public ThreadText(String msg, Counter counter){
      m_Msg=msg;
      this.counter = counter;
   }
   public void run(){
      while(true){
         synchronized( counter ){
           counter.count++;

           if( counter.count >= 1000 )
             return;

           System.out.println(m_Msg);
         }
         try{
            
            //Thread.sleep(1000);
            Thread.sleep((int)(Math.random()*1500));
         }catch(InterruptedException e){
         }
      }
      
   }public static void main(String[]args){
      Counter c = new Counter();
      ThreadText a=new ThreadText("Moin...!!", c);
      ThreadText b=new ThreadText("juhu...", c);
      a.start();
      b.start();
   }
   
}

P.S. das ist nur so schnell hingeschrieben, habs nicht getestet, und schöner Code ist es auch nicht :bae:

 

[andy0566]

Wer weiß,wie folgender Code in oberer Klasse funtioniert ?

public void run(){
		while(!isInterrupted()){
			
				System.out.println(m_Msg);
				
				try{
						Thread.sleep((int)(Math.random()*1000));
				}catch(InterruptedException e){
					interrupted();
				}
			
		}
		
	}

 

[foobar]

public void run()
{
      while(!isInterrupted())   // solange der Thread nicht interrupted wurde
      {
            System.out.println(m_Msg); // String ausgeben
            try
            {
                  Thread.sleep((int)(Math.random()*1000)); // zufäliige Anzahl Millisekunden schlafen
            }
            catch(InterruptedException e)
            {
               interrupted();  // Falls eine Exception fliegt, Thread beenden
            }
    }
 }

 

[Icewind]

mit Benis Lösung würden die Threads doch beendet werden wenn beide zusammen schon mehr als 1000 mal die ausgabe gemacht haben oder??

 

[muddin]

Hi!

public class ThreadTest extends Thread
{ 
	private String m_Msg; 

	private static ThreadGroup thrG;

	public ThreadTest(String msg,ThreadGroup tg)
	{       
		super(tg,"Thread"); 
		m_Msg=msg; 
	} 

	public void run()
	{ 
		int counter = 0;
		while(true)
	    { 
	
    		System.out.println(m_Msg);
            
            if( counter >= 1000)
            {
            	thrG.interrupt();
            	return;
            }
	
	          
	        try
	        { 	            
				Thread.sleep((int)(Math.random()*1500)); 
			}
			catch(InterruptedException e)
			{ 
				return;
			}
	    	counter++; 
	    }
	} 
	
	public static void main(String[]args)
	{ 
      int c = 0;
      
      thrG = new ThreadGroup("1");
      
      ThreadTest a=new ThreadTest("Moin...!!",thrG); 
      ThreadTest b=new ThreadTest("juhu...",thrG);
      
      a.start(); 
      b.start(); 
            
   } 
    
}

Wenn man die Threads einer Thread-Gruppe zuweist, werden einfach alle Threads der Gruppe unterbrochen, sobald irgendein Thread 1000mal den String ausgegeben hat.