Thread mehrmals starten

[Guest]

Hallo Leute,

ich habe einen Thread geschrieben. Der Threadaufruf klappt auch gut mit:

	Thread t = new Thread();
		t.start();
		try {
			t.join(5000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		t.stop();

Dabei ist es wichtig, dass der Thread nach 5 Sekunden beendet wird, wenn er noch nicht fertig ist.

Nun möchte ich, um die ganze Sache zu beschleunigen diesen Thread gleich 10 mal parallel nebeneinander laufen lassen. Das Problem dabei ist. Ich habe eine Liste mit ein paar hundert Einträgen. Bei jedem Threadaufruf wird davon ein Element abgearbeitet. Also müssen die Threads stoppen, wenn man am Ende der Liste angelangt ist.

Ich hoffe ihr könnt mir ein bisschen weiterhelfen

Gruß Streamer

 

[tfa]

Was du suchst nennt man Thread-Pool, z.B. http://java.sun.com/javase/6/docs/api/java/util/concurrent/ThreadPoolExecutor.html

Und benutze niemals Thread.stop(). Diese Methode ist kaputt und deswegen deprecated.

 

[Guest]

ok danke,

mit den thread pools habe ich auch schon herumhantiert und habe dabei dieses beispiel gefunden:

package fenster;

import java.util.*;
import java.util.concurrent.*;

public class ThreadExecutor {

	public static void main(String[] args) throws Exception {
		MyCallable c = new MyCallable("1", 1000);
		MyCallable c1 = new MyCallable("2", 200);
		MyCallable c2 = new MyCallable("3", 4000);
		MyCallable c3 = new MyCallable("4", 6000);

		List<Callable<String>> l = new LinkedList<Callable<String>>();
		l.add(c);
		l.add(c1);
		l.add(c2);
		l.add(c3);

		ExecutorService service = Executors.newFixedThreadPool(l.size());
		List<Future<String>> ll = service.invokeAll(l, 5, TimeUnit.SECONDS);
		
		for (Future<String> future : ll) {
			try {
				System.out.println(future.get());
			} catch (CancellationException e) {
				System.out.println("cancelled");
			}
		}
	}

	static class MyCallable implements Callable<String> {
		private final String b;

		private int i;

		MyCallable(String b, int k) {
			this.b = b;
			i = k;
		}

		public String call() throws Exception {
			Thread.sleep(i);
			return b;
		}
	}
}

Der Threadpool hier wird gefüllt und bricht nach 5 Sekunden ab. MyCallable c1 ist aber z.b. schon nach 0,2 Sekunden fertig und macht dann 4,8 Sekunden nichts weiter. Was ich nun suche ist, dass der ExecutorService so lange "gefüllt" wird, bis eine Liste abgearbeitet ist.

Gruß Streamer

 

[Guest]

Also ich glaube ich bin der Lösung schon ganz Nahe. Es funktioniert schon teilweise. Leider kommen am Ende noch Fehler (Wenn man das Sleep entfernt kommen nur noch Fehler). Wäre nett, wenn sich ein Profi das hier nochmal angucken könnte:

package main;

import java.util.concurrent.*;

public class MyTPE {

	int index = 0;

	int poolSize = 3, maxPoolSize = 3;

	long keepAliveTime = 10;

	LinkedBlockingQueue<Runnable> queue = new LinkedBlockingQueue<Runnable>();

	ThreadPoolExecutor threadPool = null;

	public MyTPE() {
		threadPool = new ThreadPoolExecutor(poolSize, maxPoolSize,
				keepAliveTime, TimeUnit.SECONDS, queue);
	}

	public void runTask(Runnable task) {
		threadPool.execute(task);
	}

	public void shutDown() {
		threadPool.shutdown();
	}

	/**
	 * @param args
	 */

	public void printArray(final String[] array) {

		Runnable r = new Runnable() {
			public void run() {
				System.out.println(array[index++]);
				try {
					Thread.sleep((int)Math.round( Math.random() * 10000 ));
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		};

		index = 0;

		while (index < 9)
			this.runTask(r);
		this.shutDown();
	}

	public static void main(String[] args) {
		String[] array = { "1", "2", "3", "4", "5", "6", "7", "8", "9", "10" };
		MyTPE tpe = new MyTPE();
		tpe.printArray(array);
	}

}

So wie das Programm gedacht ist, sollten jetzt für jede Zahl im Array ein Runnable geschaffen werden, das dann eine zufällige Zeit zwischen 0 und 10 Sekunden wartet. D.h. die Zahlen sollten eigentlich durcheinander ausgegeben werden, oder?

Vielen Dank

Streamer

 

[diel2001]

Hallo
warum machst du es nicht einfach so

Thread thread = new Thread();
thread.start();
thread = new Thread();
thread.start();

Aus meinem Beispiel dann eine Methode bauen ,die der
Referenz des Threads ein neues Object zuweist

Gruß
Diel