Pri používaní klasických konzolových aplikácií používateľ uvažuje lineárne: aplikácia si od neho postupne vyžaduje údaje, ktoré sú do nej postupne zadávané z klávesnice.

Enter username:
> novotnyr
New UNIX password: 
> ******
Retype new UNIX password: 
> ******
passwd: all authentication tokens updated successfully.

V prípade grafických aplikácii sa však spôsob zmýšľania mení -- a to nielen na strane používateľa, ale i na strane vývojára.

Aplikácia musí reagovať na udalosti, ktoré používateľ vyvoláva na jej ovládacích prvkoch, a v závislosti na nich aktualizovať a prekresľovať používateľské rozhranie.

Kritickým problémom sú dlhotrvajúce operácie: kým v konzolovej aplikácii stačí vypísať „Prosím čakajte...“ a o prekresľovanie sa starať netreba (všetky dáta sú už totiž zobrazené), v grafickom používateľskom rozhraní je situácia presne opačná. Ak aplikácia vykonáva tiahly výpočet, nesmie zabudnúť na spracovávanie používateľovho vstupu a následné prekresľovanie, pretože v opačnom prípade získa používateľ mylný pocit, že program vytuhol a treba ho násilne ukončiť.

Kým bežná konzolová aplikácia v Jave si vystačí s jediným vláknom (tzv. main), swingová aplikácia po spustení vytvorí viacero vlákien, ktoré sú zodpovedné za prekresľovanie, vybavovanie udalostí a ich rozosielanie jednotlivým event handlerom (teda kódu obsluhy udalostí) a ďalšie nízkoúrovňové operácie. Vlákna v typickej aplikácii sú zobrazené na nasledovnom obrázku:

Zo všetkých vlákien v swingovskej aplikácii sú však najdôležitejšie dve:

Predstavme si kód z jednoduchej aplikácie, kde vytvoríme tlačidlo JButton a priradíme mu obsluhu udalosti, ktorá nastane po kliknutí naň: Kód v rámci metódy actionPerformed() predstavuje obsluhu udalostí (event handler).

Čo sa stane po kliknutí myšou?

Vlákno EDT v sebe obsahuje tzv. rad udalostí (event queue). Akákoľvek akcia, ktorú vyvolá používateľ v používateľskom rozhraní -- či už pohyb myšou, kliknutie, stlačenie klávesy atď -- spôsobí vytvorenie objektu udalosť (v skutočnosti potomkovia triedy AWTEvent, to však nie je dôležité) a jeho zaradenie na koniec tohto radu.

Z jeho opačného konca EDT postupne vyberá jednotlivé objekty udalostí a rozposiela ich do jednotlivých komponentov, ktoré ich ďalej posielajú do svojich event handlerov, resp. listenerov. Tu však platí dôležitá a kritická zásada: objekt udalosti je z radu vybratý až potom, čo dobehne kód v event handleri (listeneri), ktorý obslúži predošlú udalosť.

Z tejto dôležitej zásady vyplýva prvé dôležité pravidlo pri práci so Swingom:

Ukážme si príklad, čo sa stane, ak to nedodržíme. Predstavme si kód v listeneri tlačidla, ktorý vykonáva dlhotrvajúcu operáciu, napríklad výpočet najväčšieho prvočísla.

JButton button = new JButton("Hello!");
button.addActionListener(new ActionListener() {
  public void actionPerformed(ActionEvent e) {
    /* dlhotrvajúci výpočet... */
    stiahniSúbor("http://en.wikipedia.org/wiki/File:Java_logo.svg");
  }
});
add(button);

Po kliknutí na príslušný gombík sa do radu udalostí zaradí nová inštancia udalosti ActionEvent. Po spracovaní udalostí, ktoré sú pred ňou, sa dostane na začiatok radu. EDT ju z radu vyberie, a pošle príslušnému komponentu (teda gombíku button), ktorý ju odošle do svojho action listenera. Ten vykoná kód vo svojej metóde actionPerformed(), a po jeho dobehnutí umožní vláknu EDT spracovať ďalšie udalosti vo fronte.

Kód v tejto metóde však predstavuje kritický bod: kým beží vyhľadávanie najväčšieho prvočísla, nemôže prebiehať spracovanie udalostí vo rade. Z toho vyplýva doslova viditeľný dôsledok: používateľské rozhranie „vytuhne“. Ak je pozastavené spracovanie udalostí, neprebieha ani prekresľovanie používateľského rozhrania a používateľ začne byť nervózny.

Predošlý obrázok ukazuje príklad zamrznutého používateľského rozhrania. Používateľ stlačil tlačidlo, začal sa vykonávať action listener, ale prekresľovanie ustalo -- rozbehne sa až po dobehnutí kódu v listeneri. Všimnime si negatívny dôsledok: tlačidlo ostalo zobrazené v medzistave, teda v stave „používateľ stlačil tlačidlo myši“. Nervózny používateľ zrejme začne „zbesilo“ klikať do okna, prípadne sa snažiť ukončiť aplikáciu, lenže jeho pokusy budú márne. Každý klik, či posun myši len vyvolá ďalšiu udalosť, ktorá sa zaradí na koniec radu udalostí. Ich spracovanie je však pozastavené; čaká sa totiž na dobehnutie action listenera.

Morálne ponaučenie sme už spomenuli: dlhotrvajúce operácie nesmú prebiehať v EDT, inak zablokujú spracovávanie udalostí. Z toho však vyplýva ešte jeden dôsledok, ktorý budeme musieť brať do úvahy v druhej časti pravidiel pre prácu so Swingom:

Jedným z tradičných spôsobov, ktorými možno riešiť beh dlhotrvajúcich úloh bez toho, aby sme narušili prekresľovanie používateľského rozhrania, je použitie triedy SwingWorker.

SwingWorker je veľmi flexibilná trieda, ktorá umožňuje elegantne riešiť typické úlohy pri práci s viacerými vláknami v Swingu.

Vytváranie a spustenie SwingWorkera, ktoré vykoná dlhotrvajúcu operáciu, je možné vložiť do kódu metódy actionPerformed() v action listeneri.

V prípade, že je SwingWorker komplexnejší a plánuje sa jeho použitie v rámci volania action listenera, môžeme vytvoriť samostatnú triedu, ktorá bude dediť od SwingWorkera a implementovať interfejs ActionListener:

public class DownloadActionListener extends SwingWorker<Void, Void> 
  implements ActionListener 
{
  private URL url;

  public DownloadActionListener(String url) {
    try {
      this.url = new URL(url);
    } catch (MalformedURLException e) {
      throw new IllegalArgumentException(
        "Illegal protocol in URL.", e);
    }
  }

  public DownloadActionListener(URL url) {
    this.url = url;
  }

  protected Void doInBackground() throws Exception {
    // dlhý výpočet
    return null;
  }

  public void actionPerformed(ActionEvent e) {
    new DownloadActionListener(url).execute();
  }
}

Metóda actionPerformed() následne vytvorí novú inštanciu SwingWorkera a spustí ju, teda je ekvivalentná volaniu metódy execute(). Pridanie asynchrónnej akcie do tlačidla je potom jednoduché:

button.addActionListener(
 new DownloadActionListener(
  "http://en.wikipedia.org/wiki/File:Java_logo.svg"))

Kód pre preberanie súboru má jednu značnú nevýhodu: používateľ vonkoncom netuší, v akom stave je jeho priebeh, pretože používateľské rozhranie nedáva na známosť, či preberanie ešte stále beží alebo už skončilo. SwingWorker dáva k dispozícii metódu done(), ktorú možno prekryť a realizovať v nej kód, ktorý sa má vykonať po dobehnutí operácie v doInBackground(). Typickým príkladom je aktualizácia používateľského rozhrania, napr. zmenou textu v nejakom popisku label.

public class DownloadActionListener extends SwingWorker<Void, Void>
  implements ActionListener 
{

  private JLabel label;

  public DownloadActionListener(String url, JLabel labe) {
    //...
  }

  // ...

  protected void done() {
    label.setText("Hotovo.");
  }
}

Alternatívny spôsob využíva možnosť sledovania zmien vlastností (properties) v JavaBeanoch. SwingWorker umožňuje sledovať zmeny svojich properties, a jednou z nich je status. Ak zaregistrujeme na SwingWorkeri inštanciu triedy PropertyChangeListener, kde zistíme, či vlastnosť status má hodnotu DONE, vieme následne aktualizovať používateľské rozhranie.

swingWorker.addPropertyChangeListener(new PropertyChangeListener() {
  public void propertyChange(PropertyChangeEvent event) {
    if ("state".equals(event.getPropertyName())
      && SwingWorker.StateValue.DONE == event.getNewValue()) {
      label.setText("Hotovo.");
    }
  }
});

Tento druhý spôsob umožňuje striktnejšie oddeliť funkcionalitu SwingWorkera od samotných komponentov používateľského rozhrania, hoci na úkor komplexnosti.

Metóda done() slúži na notifikáciu ukončenia úlohy. Ako však informovať o priebežnom stave? Zoberme si kus kódu, ktorý začne sťahovať dáta z webovej adresy:

protected Void doInBackground() throws Exception {
  //...
    InputStream stream = ...
  BufferedOutputStream out = ...

  int b = -1;
  int progress = 0;
  while((b = stream.read()) != -1) {
    out.write(b);
    // priebežne aktualizujeme UI
    aktualizujUI(progress, contentLength);
  }
  // ...
}

Po zapísaní bajtu môžeme aktualizovať používateľské rozhranie -- napríklad môžeme využiť „teplomer“ v podobe JProgressBar, ktorý dokáže zobraziť percentuálny stav úlohy. Ak poznáme dĺžku sťahovaného súboru, percentuálny progres vieme odvodiť nasledovne:

progressBar.setValue((int) (((double) progress / (double) contentLength) * 100));

Samozrejme, to predpokladá, že SwingWorker má inštančnú premennú s progress barom, ktorú sme doň vopred dodali.

private void aktualizujUI(double progress, double length) {
  int percents = (int) ((progress / contentLength) * 100);
  progressBar.setValue(percents);
}

Uvedený kus kódu je na prvý pohľad korektný, ale je v ňom jedna zásadná chyba, ktorá súvisí s prácou so swingovskými vláknami. Metóda doInBackground(), ako už bolo viackrát zmienené, beží v samostatnom vlákne. V tom istom vlákne bežia aj metódy, ktorá sú z nej volané -- teda i naša metóda aktualizujUI(), v ktorej aktualizujeme stav progress baru. V Swingu však platí dôležitá zásada:

Toto je druhá a posledná kritická zásada práce so Swingom. Jej ignorovanie nevedie k syntaktickým chybám, a aplikácia zrejme pobeží. Skôr či neskôr, a hlavne v kritických situáciách, sa môže prejaviť nečakaným správaním, ktoré sa môže prejaviť nesprávnym prekresľovaním komponentov či iným čudným správaním.

Metóda aktualizujUI() túto zásadu ignoruje, pretože nebeží v rámci EDT. Ako to však opraviť?

V samotnej podstate tu ide o problém odovzdávania dát medzi vláknami a ich koordinácie. V bežnom konkurentnom programovaní je to nepríliš ľahká úloha. SwingWorker však poskytuje elegantnú možnosť, ako to dosiahnuť bez väčších ťažkostí.

Ak chceme priebežne sledovať percentuálny priebeh úlohy, môžeme tiež použiť alternatívny spôsob, ktorý využíva metódu setProgress() zabudovanú v SwingWorkeri. Má jeden parameter v intervale 0..100, ktorý vieme nastaviť property s názvom progress.

protected Void doInBackground() throws Exception {
  //...
  while((b = stream.read()) != -1) {
    // .. priebežne publikujeme progres
    setProgress(percentProgress);
  }
  // ...
}

Zmenu stavu možno sledovať zaregistrovaním inštancie PropertyChangeListener na inštancii SwingWorkera.

V niektorých prípadoch chceme vykonať dlhotrvajúcu operáciu tak, aby používateľ musel vyslovene počkať na výsledok. Chceme mu zabrániť v používaní grafického rozhrania, ale zároveň chceme predísť vytuhnutiu aplikácie. Dokumentácia k SwingWorkeru v tomto prípade radí trik, ktorý využíva modálne okno.

Implementovaním interfejsu Runnable je umožnené spúšťanie inštancie SwingWorkera pomocou klasickej triedy vlákna Thread. Nasledovný kód spustí vo vlákne Thread inštanciu workera presne tak, ako akúkoľvek inú inštanciu Runnable:

SwingWorker<Void, Integer> worker = ...
Thread thread = new Thread(worker);
thread.start();

Tento kód je zhruba ekvivalentný štandardnému spusteniu cez worker.execute(). V tomto prípade však explicitne určíme vlákno, ktoré bude spracovávať danú úlohu.

Keďže SwingWorker implementuje Runnable, možno ho zaslať do exekútora. Táto možnosť má zmysel napr. v prípade, že chceme synchronizovať beh viacerých vlákien. Predstavme si, že chceme zobraziť okno, ktoré má viacero progress barov indikujúcich paralelné sťahovanie viacerých súborov a po dokončení sťahovania sa automaticky zatvorí.

Tento problém vieme elegantne vyriešiť pomocou exekútora, teda inštancie triedy ExecutorService. Doňho vieme odoslať viacero úloh, ktoré sa spustia asynchrónne v samostatných vláknach. V tomto konkrétnom prípade navyše vieme využiť metódu invokeAll(), ktorá blokuje dovtedy, kým nedobehnú všetky úlohy. Inak povedané, spustíme úlohy, blokujeme a po ich dobehnutí zatvoríme okno. Drobným nedostatkom je fakt, že invokeAll() vyžaduje úlohu v podobe inštancie typu Callable. Našťastie, volaním Executors.callable() vieme previesť Runnable na Callable.

setVisible(true);
try {
  ExecutorService executor = Executors.newCachedThreadPool();
  List<Callable<Object>> tasks 
    = new LinkedList<Callable<Object>>();
  for (Component c : this.getContentPane().getComponents()) {
    if (c instanceof DownloadProgressPanel) {
      // panel s progress barom a popiskom
      DownloadProgressPanel panel = (DownloadProgressPanel) c;
      // vytvoríme inštanciu SwingWorkera
      DownloadTask task
      = new DownloadTask(panel.getUrl(),
        panel.getProgressBar());
      // prevedieme ho na Callable a zaradíme do zoznamu úloh
      Callable<Object> callable = Executors.callable(task);
      tasks.add(callable);
    }
  }
  // vykonáme všetky úlohy. Volanie metódy čaká, kým nedobehnú úlohy.
  executor.invokeAll(tasks);
} catch (InterruptedException e) {
  e.printStackTrace();
} finally {
  setVisible(false);
}

V prípade, že sa snažíme pustiť úlohu reprezentovanú SwingWorkerom opakovane, treba dať pozor na jednu významnú zásadu.

Táto vlastnosť v podstate zabraňuje opakovanému spúšťaniu úloh.