Threads i Java

Threads i Java sköter prioriteringsordningen för hur ett program ska exekvera koden

Vad är Threads i Java?

De flesta program exekveras med enbart en thread (“tråd”) som sköter prioriteringsordningen för hur programmet ska exekveras. Men vad händer om det finns flera operationer som behöver exekveras exakt samtidigt? Genom att skapa flera trådar som körs parallellt, kan man möjliggöra detta. Detta kan vara användbart i större program, exempelvis i ett multiplayer-spel som behöver hantera flera input samtidigt.

En Thread i Java kan skapas på två olika sätt,

Genom att ärva (extend) klassen Thread
Implementera interfacet Runnable

Vi kommer självklart kolla på hur vi gör för båda. Men först, det finns en skillnad mellan dom som är bra att känna till,

Om vi ärver klassen Thread så kan vi inte ärva någon annan klass. Java stödjer inte så kallad flertalet/multipla arv då en klass ärver kod från flera klasser. Men använder vi interfacet Runnable så kan vi fortfarande ärva från en klass.

I vårt enklare spel kommer vi enbart behöva en tråd. Vi har valt att använda Runnable interface i vårt spel och är det vi normalt brukar använda när vi jobbar med Threads.

Varför använda Threads i Java?

Vi skulle kunna se det som att Threads möjliggör multitasking. Vi använder trådar i Java för att göra programmet snabbare genom att vi kan göra flera saker samtidigt. Vidare, ytterligare användningsområden skulle kunna vara när vi vill behandla flera användare samtidigt. Till exempel ett program som ska ta hand om kunder på en webbsida. När man handlar online vill man inte behöva vänta i en lång kö på att andra ska bli färdig innan man får slutföra sin beställning.

Avslutningsvis, genom att vi möjliggör multitasking så kan vi snabbare svara på den information en användare ger till programmet. Till exempel, om vi har ett GUI som ska rita ut något baserat på vad användaren gör. Om det sker sekventiellt och programmet måste vänta hela tidens till användaren är helt klart, och sen måste användaren vänta till GUI är helt klar med operationen. Använder vi trådar i Java så kan vi utföra det parallellt och utföra var och en av dom uppgifterna löpande bredvid varandra.

Skapa en tråd genom att ärva Thread-klassen

Vi skapar en tråd genom att ärva Thred klassen där metoden run() är definierad.

Syntaxen för att skapa en tråd genom att ärva klassen är,

import java.lang.*;

// Ärver Thread
public class Counter extends Thread      
{
        // Skapar en ny tråd
        Thread T; 

        // Ordningen i hur programmet ska exekveras                             
        public void run()                     
        {                              
        ....            
        }
}

Skapa en Thread med Runnable Interface

På liknande sätt kan vi skapa en tråd genom att implementera Runnable där metoden run() också är definierad.

Syntaxen för att skapa en tråd med Runnable är,

import java.lang.*;

//Implementerar Runnable
public class Counter implements Runnable      
{
        // Skapar en ny tråd
        Thread T; 

        // Ordningen i hur programmet ska exekveras                             
        public void run()                     
        {                              
        ....            
        }
}

Använda Threads i Java

Det finns ett par olika tillstånd en tråd kan ha,

New: När vi skapar en ny tråd är den New-tillståndet. Tråden har ännu inte börjat köra när den befinner sig i detta tillstånd.
Runnable: När tråden är redo att starta exekvera, förflyttar den sig till Runnable-tillståndet. Man kan se det som att tråden ligger och väntar på grönt ljus för att få köra.
Running: Som namnet antyder så är det i Running-tillståndet som tråden exekverar uppgifter.
Not Runnable: I det här tillståndet så kör inte tråden och tar ingen kraft från datorns CPU. Skillnaden mot Runnable är att i Runnable så tar tråden CPU kraft från datorn när den väntar på ett få exekvera nästa uppgift. Det gör den däremot inte när den är i Not Runnable-tillståndet. En tråd i det här tillståndet kan inte fortsätta exekveringen förrän den är tillbaka i running-tillståndet.
Terminated: Tråden avslutas i det här tillståndet. Normalt sett på grund av hela koden för tråden har genomförts av programmet. Men det kan även bero på att någon ovanlig och oförutsedd händelse som skapat ett error.

Bilden nedan visar exempel på hur vi kan använda några av de olika metoder tillgängliga till att skapa en tråd. Notera hur vi har olika tillstånd, så kallade States, och kan med hjälp av metoderna anpassa tillståndet för vår tråd.

Metoder för Threads i Java

start() : Skapar en ny tråd som kommer använda run() metoden. Så vill du skapa en NY tråd som ska börja exekvera använder du start(). Vill du istället använda en befintlig tråd och exekvera använder du run().
run() : Används för att starta exekveringen av tråden. Metoden kommer inte att skapa någon ny tråd utan enbart köra befintliga trådar. Obs, run() metoden fungerar endast med Runnable interfacet.
sleep() : Får den nuvarande exekverande tråden att pausas (tillfälligt upphöra exekveringen) för den angivna tiden
yield () : Man kan se det som att i princip den här tråden inte gör något särskilt viktigt och om några andra trådar eller processer behöver köras, bör de köras. Annars kommer den aktuella tråden att köras.
wait() : Tråden pausas och väntar på att bli “väckt” igen. Notera att den aktuella tråden kommer då vänta tills en annan tråd använder metoderna notify() eller notifyAll() för att väcka den igen. Generellt kan man säga att sleep() används för att kontrollera tiden för en tråd och wait() för synkronisering med flera trådar.
interrupt() : Varje gång vi använder interrupt() till en tråd, bör det stoppa vilken uppgift den utför. Det är mycket troligt att när tråden tar emot ett interrupt() , ska den avslutas. Det finns inget naturligt sätt att avsluta en tråd i förtid (innan den är klar), då tidigare metoder visade sig ha problem. Men metoden interrupt() verkar vara den mest använda och rekommenderade.

För en komplett lista på metoder till Runnable interfacet se Oracle hemsida

Föregående sida

Nästa sida