[Java lista] szálkezelés?

[Jozsef Tabanyi]

Szija,

> Van-e valami más ok amiatt akkor is jobban járok ha implementálom a
> Runnable-t, minthogy örököljem a Thread osztályt?
Mivel a Java-ban nincs tobbszoros orokles, ezert ha az osztalyod a
Thread osztalybol szarmazik, akkor mar nem tud masbol.
Viszont a feladat gyakran megkoveteli, hogy masbol szarmaztasd az
osztalyod. Szoval szerintem inkabb ne szarmaztass a Thread-bol,
hanem ha szukseged van egy uj szalra, akkor az egy peldanyvaltozo
legyen, es a befogado osztaly meg implementalja a Runnable interfeszt.

Lehetne meg vaganykodni nevtelen belso osztalyokkal,
de szerintem te meg nem tartassz ott.

> Sok féle példát mutat a szállak leállítására.
A szalak leallitasanak egyetlen civilizalt modja, ha a vezerles
elhagyja a run() metodust. Tehat ha a run()-ban porog egy while
ciklus, akkor arrol kell gondoskodni, hogy ez valahogy leallithato
legyen. Az teljesen mindegy, hogy mi az a logikai feltetel, hogy
egy sima boolean valtozo vagy a Thread objektum referencioa null-ra
lett-e allitva. Ez a te szabad dontesed.

Es vegul egy egyszeru pelda:

public final class Engine implements Runnable {

	private Thread thread;

	/**
	 *
	 */
	public Engine() {
		super();
		// TODO Auto-generated constructor stub
	}


	public void start() {
		if(thread == null) {
			thread = new Thread(this);
			thread.start();
		}
	}

	public void run() {
		// TODO Auto-generated method stub
		while(thread != null) {

			//do something here

			try {
				Thread.sleep(100);//lets run other threads
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				stop();
				break;
			}
		}
	}

	public void stop() {
		thread = null;
	}
}


joco

Jozsef Tabanyi
mailto:jozsef at tabanyi.hu
http://www.tabanyi.hu
On Tue, 30 Jan 2007, [iso-8859-2] Maglódszki Viktor wrote:

> Sziasztok !
>
> Már nem is tudom, hogy hová soroljam a levelet :) Legyen szálkezelés az egyszerûség kedvéért.
> Szeretném kihangsúlyozni, hogy a tegnapi nap elolvastam a kék Java könyv elsõ  kötetében a 15ös fejezetet "Párhuzamosság, szálkezelés".
> Már-már csak félve teszem fel kérdéseimet, amik némi zavarodásból adódnak, az itt és a könyvben olvasottakból.
> Igyekszem szépen érthetõen, pontokban összefoglalva irni ja és írásjeleket is igyekszem használni :)
>
> 1.
> Thread osztály öröklése és a Runnable interfész implementálása témakör.
> A könyv nagyon sok példában a Thread-et örökölteti, persze megemlíti (és igen értem is), hogy ott a Runnable is.
> Ha az osztályunk már öröklõdik akkor muszály az implementálás->ok ezt értem.
> Kérdésem:
> Van-e valami más ok amiatt akkor is jobban járok ha implementálom a Runnable-t, minthogy örököljem a Thread osztályt?
>
> 2.
> Sok féle példát mutat a szállak leállítására.
> Van az alap logikai változó
> while (isRunning()) .... féle megoldás running = false ha meg akarom állitani a szállat kivûlrõl egy synchronized stop metódusban
> a könyv szerint: "...gondoskodni kell egy volatile módosítással ellátott Thread típusú refernciáról ami a futó szálra mutat."
> private volatile boolean isRunning = true; (már tudom a volatile hatását is)
> ezt a példát egy olyan osztályon mutatja ami kiterjeszti a Thread-et
> "...a Runnable interfész esetén szükséges egy Thread, vagy annak egy alosztályára utaló referenciát definiálnunk..."
>
> private volatile Thread runningId = this;
> public void run() {
>  while (runningId == this) {
>  ...
>  }
> }
> stop() {
>  runningId = null;
> }
>
> viszont amiben ezt a példát mutatja az is extends Thread
> bár simán lehet, hogy csak nem furcsa
> azt mondja a könyv, hogy a Runnable-nél kell ilyen, erre bemutatja egy olyan osztályon ami extends Thread
> kérdésem: van-e valami számottevõ különbség a kettõ között?
>
> elõre is köszönöm!
>
> üdv, MV