Androidon a nem úgy megy a fejlesztés, mint asztali környezetben, ezt kezdem megszokni. Az egyik ilyen probléma, a szálak kezelése. Ez elég egyszerű a közönséges Java programoknál. Ott az sem gond, ha a fő szál sokáig vár, például mert várja, hogy egy másik gép csatlakozzon hozzá.
Androidon ez probléma. Ott nem lehet a felhasználói felületet lebénítani, csak azért, mert egy esemény bekövetkezésére várunk. Ezért ezeket a problémás lépéseket egy új szálra helyezzük, ami kedvére várhat, miközben a tapicskolás is megmarad.
De mi a helyzet, ha több párhuzamos szálat akarok? Néhány próba kódot mutatok be, aminek nem is az a lényege, hogy hatalmas műhelytitkokat áruljak el, mert gondolom a profiknak ezek triviális megállapítások. Én viszont nem vagyok profi Android programozó, ezért rácsodálkozhatok ezekre a jelenségekre. Kipróbálok pár módszert, még akkor is, ha azok rossz programozói gyakorlatok.
Tehát a célom, hogy egy gomb megnyomására két párhuzamos szál induljon. Az egyiket nevezzük Bunak, a másikat Funak, mint a kínai emigránsokat a viccből.
AsynchTask
A doksi szerint ez a legegyszerűbb és legtisztább megoldás:
public class ParaThread extends AsyncTask<String, Integer, Long> {
@Override
protected Long doInBackground(String... names) {
for(int i = 0; i < 15; i++) {
Log.d("ParaThread", "Thread: " + names[0] + " is running" + i);
try {
Thread.sleep(500);
} catch(InterruptedException e){
e.printStackTrace();
}
}
return null;
}
}
Tegyük is bele egy gomb onClick metódusába:
public void onClick(View view) {
new ParaThread().execute("Fu");
new ParaThread().execute("Bu");
}
Ez alapján arra számítok, hogy a gomb megnyomása esetén Bu és Fu felváltva hagy üzenetet a logban. De nem ez történik. Először Fu üzeneteit látom, utána Bu üzeneteit. Ha rövid időn belül többször is megnyomom a gombot, akkor az eseményeket szépen puffereli. Tehát ez a megoldás nagyon jó, ha nem akarom millió szállal szétfagyasztani a rendszeremet. Tökéletesen biztonságos, annyiszor használom, ahányszor csak akarom.
De én ennél többet akarok, mert egy cowboy vagyok, aki szeret veszélyesen élni.
Thread
Készíthetünk saját osztályt, ami kiegészíti a Thread osztályt.
public class ParaThread extends Thread {
private String name;
public ParaThread(String myname){
name = myname;
}
public void run() {
for(int i = 0; i < 15; i++) {
Log.d("ParaThread", "Thread: " + name + " is running" + i);
try {
Thread.sleep(500);
} catch(InterruptedException e){
e.printStackTrace();
}
}
}
}
Sok változás nincs. Példányosítjuk a két osztályt.
private ParaThread pt1 = new ParaThread("Fu");
private ParaThread pt2 = new ParaThread("Bu");
Meghívjuk a szálakat a gomb lenyomásánál.
public void onClick(View view) {
pt1.start();
pt2.start();
}
Ez már jó! Bu és Fu felváltva írnak a logba. Ha többször akarjuk indítani, akkor is csak 2 szál fog futni. De ilyet nem szabad csinálni, azt mondják. Akkor csináljuk Runnable implementációval, hogy javasolják.
Runnable
Az osztályunk implementációja csak egy sorban tér el, ezért az nem írom le újból, de a használatához új szálat kell létrehozni.
public void onClick(View view) {
new Thread(new ParaThread("Fu")).start();
new Thread(new ParaThread("Bu")).start();
}
Ez már igen! Ha többször klikkelünk a gombra, akkor még két szálat létrehoz minden egyes klikkre! Ezzel már gond nélkül írhatjuk a veszélyes programokat.
