Lõimed

Väikses lihtsas programmis on enamasti üks tööjärg. Käske täidetakse
üksteise järel. Enne ei alustata uut toimingut, kui eelmine on valmis.
Sellist tööjärge nimetatakse lõimeks (thread). 
Lõime peatumine
Lõim võib peatuda näiteks ootamaks sisestust kasutajalt, andmeid Internetist
või on ta lihtsalt mingiks ajaks seisma pandud. Siis ei toimu programmis
enne midagi, kui ollaks ootamise kohast üle saanud. Ühelõimelises programmis
saab vigu leida, kontrollides iga käsu järel et see oleks täidetud
korrektselt. Pole karta, et muutujad "salapäraselt" oma väärtusi muudaksid. 

import java.io.*;
public class Loim1{
  public static void main(String argumendid[]) throws Exception{
    System.out.println("Oodatakse reavahetust");
    new BufferedReader(new InputStreamReader(System.in)).readLine();
    System.out.println("Lihtsalt 5 sekundiline paus");
    Thread.sleep(5000);
    System.out.println("Programmi ots");
  }
}
 Mitmelõimeline programm
Kui programm peab sooritama korraga mitu teineteisest sõltumatut tegevust,
on mõistlik nad tööle panna eraldi lõimedena, et peatus ühes lõimes ei
takistaks teise töö sooritamist. Näiteks nagu kasutajatega suhtleval
Interneti serveril on mõistlik luua iga kasutaja jaoks omaette lõim, et
server saaks samaaegselt teenindada mitut kasutajat ilma et programmi looja
peaks muretsema arvuti tööaja jagamise üle kasutajate vahel. 
Järgnevas näites on lõime alamklass Pall2. Igal pallil on koordinaadid x ja
y ning iga sammuga muutuvad need dx ja dy võrra. Iga pall liigub omaette
lõimes, s.t. programmi muudest osadest sõltumatult. Pall alandab enese
prioriteeti, s.t. et protsessori tööaja jagamisel loeb ta end keskmiselt
vähem tähtsamaks. Prioriteedi alandamine on vajalik selleks, et pallide
liigutamine ei hakkaks märkimisväärselt aeglustama teisi lõimi, näiteks
ekraanile joonistamist. Muidu võib juhtuda, et suure hulga pallide puhul
jäävad ülejäänud tegevused suhteliselt unarusse.  Käsk yield tähendab, et
lõim annab oma tööjärje üle järgmisele ning asub ise järjekorda uuesti
protsessori aega ootama. 
Raami alamklass Loim2 loob enesele viis palli isendit ning laseb nad
liikuma. Loim2 ise realiseerib liidest Runnable, s.t., et tema run-meetodit
on samuti võimalik panna tööle eraldi lõimes. Selle lõime ülesandeks on
joonistada iga natukese aja tagant uus ekraanipilt vastavalt pallide  uutele
koordinaatidele. 

import java.awt.*;
public class Loim2 extends Frame implements Runnable{
 Pall2[] pallid;
 public Loim2(){
   pallid=new Pall2[5];
   for(int i=0; i<pallid.length; i++)
     pallid[i]=new Pall2();
   setSize(200, 200);
   setVisible(true);
   new Thread(this).start();
 }
 public void joonista(){
   Image pilt=createImage(200, 200);
   Graphics piltg=pilt.getGraphics();
   for(int i=0; i<pallid.length; i++){
     piltg.drawOval(pallid[i].x()-10, pallid[i].y()-10, 20, 20);
   }
   this.getGraphics().drawImage(pilt, 0, 0, this);
 }
 public void run(){
   while(true){
     joonista();
     Thread.yield();
     try{Thread.sleep(100);}catch(Exception e){}
   }
 }
 public static void main(String argumendid[]){
   new Loim2();
 }
}

class Pall2 extends Thread{
  double x=200, y=200, dx, dy;
  int vasak=20, ulal=50, parem=200, all=200;
  public Pall2(){
    dx=5*Math.random();
    dy=5*Math.random();
    start();
  }
  public int x(){
    return (int)x;
  }
  public int y(){
    return (int)y;
  }
  public void run(){
    setPriority(Thread.NORM_PRIORITY-2);
    while(true){
      if(x>parem)dx=-Math.abs(dx);
      if(y>all)dy=-Math.abs(dy);
      if(x<vasak)dx=Math.abs(dx);
      if(y<ulal)dy=Math.abs(dy);
      x+=dx;
      y+=dy;
      yield();
      try{Thread.sleep(100);}catch(Exception e){}
    }
  }
}
	Lõime töö lõpu ootamine
Eraldi lõime on mõistlik panna tegevused, mis võtavad aega, kuid mida saab
siiski suhteliselt sõltumatult teha. Mõnikord saab iseseisva tööotsa jooksma
panna, samas programmi sees muid asju ajada. Kui aga ühel hetkel pole
võimalik enam ilma selle iseseisva tööotsa tulemusteta edasi töötada, siis
tuleb tema tulemusi ootama jääda. Selline olukord võib näiteks juhtuda, kui
saadame Internetis asuvasse andmebaasi päringu vabade bussipiletite kohta.
Siis saame lasta programmi kasutajal sisestada oma andmed. Kui andmed on
sees, aga aegu pole veel saabunud, siis tuleb jääda neid ootama. Java keeles
saab üht lõime panna teise järele ootama käsu join abil. Järgnevas näites
lastakse iseseisval lõimel enne kümneni lugeda ning alles siis minnakse
peaprogrammi tööjärjega edasi. 
public class Loim3{
  public static void main(String argumendid[]) throws Exception{
    Thread nr=new Numbrid();
    nr.start();
    Thread.sleep(2000);
    System.out.println("Ootan, kuni numbrid loetud");
    nr.join();
    System.out.println("Ongi loetud, saab muud edasi teha");
  }
}

class Numbrid extends Thread{
  public void run(){
    for(int i=0; i<10; i++){
      System.out.println(i);
      try{
        Thread.sleep(1000);
      }catch(Exception e){}
    }
  }
}
Objekti taga ootamine
Ootama saab jääda ka suvalise objekti taha, käsuga wait. Tööjärg läheb
sellest kohast edasi alles siis, kui muu lõime poolt on vastava objekti taha
ootama jäänu edasi lastud käsuga notifyAll. Siin näites loob main-meetodis
olev peaprogramm raami tekstikasti ning nupuga ning jääb siis luku taha
ootama. Nupule vajutus vabastab luku taga ootaja ning peaprogramm saab edasi
minna. Nii saab ära oodata kasutaja vastuse ning sellega siis edasi
tegutseda. 

import java.awt.*;
import java.awt.event.*;

public class Loim4{
  public static void main(String argumendid[]) throws Exception{
    Frame f=new Frame("Sisestusraam");
    TextField tf=new TextField();
    Button b=new Button("OK");
    Object lukk=new Object();
    f.setLayout(new GridLayout(2, 1));
    f.add(tf);
    f.add(b);
    b.addActionListener(new Nupukuular4(lukk));
    f.setSize(200, 100); 
    f.setVisible(true);
    synchronized(lukk){
      lukk.wait();
    }
    f.setVisible(false);
    System.out.println("Kirjutati "+tf.getText());
    System.exit(0);
  }
}


class Nupukuular4 implements ActionListener{
  Object lukk;
  public Nupukuular4(Object uuslukk){
    lukk=uuslukk;
  }
  public void actionPerformed(ActionEvent e){
    synchronized(lukk){
      lukk.notifyAll();
    }
  }
}

Sünkroniseerimine
Mõnikord tuleb hoolitseda, et andmetele pääseks korraga ligi vaid üks lõim.
Samuti tuleb mõne sündumuse toimumise ajaks mõni muu tegevus peatada või
ümber suunata. Nii nagu vaikust nõudvat helilindistust ei saa teha kui
kõrval maasse auke raiutakse, nii ka lõimede juures saab määrata
programmilõike, mida ei või täita samaaegselt. Monitor lubab korraga toimuda
vaid ühel neist tegevustest. Kui üks monitori all olev programmilõik töötab,
peavad ülejäänud sama monitori vajavad lõimed järjekorras ootama kuni
monitor vabaneb. Monitori kehtestamiseks programmilõigule tuleb see panna
synchronized-plokki, määrates milline objekt on ploki monitoriks. Kui
meetodi piiritlejaks on syncronized, tähendab see, et meetodi monitoriks on
isend, kelle meetod see on. See tähendab, et ühel isendil võib korraga
töötada vaid üks synchornized-piiritlejaga märgitud meetod. 
Järgnevas näites võtab serverprogramm vastu oksjonipakkumisi jättes meelde
rohkem pakkunu nime ning pakutud summa. Selleks ajaks aga, kui kasutajale on
öeldud parasjagu kõrgeim hind ning ta oma pakkumist mõtleb, peavad teised
kasutajad jääma ootama. Pakkumisjärjekorrast järgmine saab alles siis
kehtiva hinna teada ning oma pakkumist mõtlema hakata, kui eelmine oma
pakkumise teinud on. 

import java.net.*;
import java.io.*;
public class Loim5{
  public static void main(String argumendid[]) throws IOException{
    ServerSocket ss=new ServerSocket(3001);
    Object lukk=new Object();
    while(true){
      new Loim5abi(ss.accept(), lukk);
    }
  }
}
class Loim5abi extends Thread{
  Socket sc;
  Object lukk;
  static String failinimi="summa.txt";
  public Loim5abi(Socket usc, Object ulukk){
    sc=usc;
    lukk=ulukk;
    start();
  }
  public void run(){
    try{
      BufferedReader sisse=new BufferedReader(
        new InputStreamReader(sc.getInputStream())
      );
      PrintWriter valja=new PrintWriter(
        sc.getOutputStream(), true
      );
      valja.println("Palun teie nimi:");
      String uusnimi=sisse.readLine();
      valja.println("Oota praegust hinda");
      synchronized(lukk){
        BufferedReader failist=new BufferedReader(
          new FileReader(failinimi)
        );
        String vananimi=failist.readLine();
        int vanasumma=Integer.parseInt(failist.readLine());
        failist.close();
        valja.println("Viimati pakkus "+vananimi+" "+vanasumma+" krooni.");
        valja.println("Kirjuta suurem summa voi loobumiseks pass");
        String vastus=sisse.readLine();
        if(!vastus.equals("pass")){
          int uussumma=Integer.parseInt(vastus);
          if(uussumma>vanasumma){
            PrintWriter faili=new PrintWriter(new FileWriter(failinimi));
            faili.println(uusnimi);
            faili.println(uussumma);
            faili.close();
          }
        }
      }
      sc.close();
    }catch(Exception e){

    }
  }
}

Kokkuvõte

Lõim on programmi tööjärg. Ühes lõimes täidetakse käske järgemööda. Lõime
saab ootama panna käsuga Thread.sleep, andes parameetriteks ootamise aja
millisekundites. Samuti saab lõime panna ootama ükskõik millise objekti
taha. Sellisese ootamise lõppemiseks peab miski ütlema sellele objektile
notifyAll, mille tulemusena lastakse objekti taga ootaval lõimel edasi
töötada. Lõim jääb ootama ka näiteks kasutajalt sisestust või võrgust
andmeid oodates. 
Programmisiseste suhteliselt sõltumatute tegevuste korral saab need panna
jooksma eraldi lõime. Sel juhul jagatakse protsessori tööaega lõimede vahel.
Lõimede prioriteeti saab muuta, andes mõnele lõimele enam või vähem
ressursse kui teistele. Kui on vaja hoolitseda, et mingid tegevused ei
toimuks üheaegselt, saab neile seada monitori.