PROCESSPROGRAMMERING
Föreläsning 1 (31.8.2010)
Innehåll:
Introduktion till paralellprogrammering (“concurrent programming”)
Introduktion till parallellprogrammering i Java: med trådar (threads)
Lågnivåprogrammering av trådobjekt
Introduktion till Java Applets
Introduktion till
paralellprogrammering
Traditionellt har man skrivit programkod för seriell processering (serial computing)
Planerade för att köras på en dator med en CPU
Ett problem spjälks upp i en diskret serie av instruktioner
Instruktioner exekveras en efter en
Endast en instruktion kan exekveras åt gången
Introduktion till
paralellprogrammering
I sin enklaste form är parallell processering (parallell computing) samtidig användning av
multipel “hårdvara” för att lösa ett problem.
Parallellprogrammering lämpar på datorer med multipla CPUn
Ett problem spjälks upp i diskreta delar som kan lösas samtidigt
Varje del spjälks upp vidare i en serie av instruktioner (som i seriell progr.)
Instruktioner från varje del exekveras samtidigt på olika CPUn
Introduktion till
paralellprogrammering
Paralellprogrammering lämpar sej väl inte endast på en dator med flere CPUn utan också
över ett nätverk dit flere datorer är kopplade eller en kombination av båda
Varför paralellisering av program?
Viktigaste orsakerna:
Spara tid
Lösa större problem
Möjliggöra “samtidighet” i program
Andra orsaker kan vara
Utnyttja datorressurser i ett nätverk
Kostnadsbesparing - använda multipla billiga datorresurser i stället för att satsa
på en superdator
Framtiden för parallellisering
Trenden för framtiden tyder på
Ännu snabbare nätverk
Distribuerade system
Datorarkitekturer med multipla processorer (gäller även vanliga bordsdatorer)
---> PARALLELLISERING ÄR FRAMTIDEN INOM DATATEKNIK!!!!
Olika typer av parallella program
Parallellisering kan klassificeras i fyra olika typer (enligt Flynn's klassiska taxonomi):
SISD (Single Instruction, Single Data)
SIMD (Single Instruction, Multiple Data)
MISD (Multiple Instruction, Single Data)
MIMD (Multiple Instruction, Multiple Data)
För mera info se http://www.ddj.com/212903586?cid=RSSfeed_DDJ_All
Paralellprogrammering i Java
m.h.a. trådar
Det enklaste sättet att åstadkomma parallell exekvering och “samtidighet” (concurrency) i
ett Java-program är att använda trådar (threads)
Trådar möjliggör att multipla strömmar av ett programs flöde kan existera inom en
process
Alla trådar inom en och samma process delar resurser som minne, (file handlers) osv.
men en tråd kan däremot ha egna lokala variabler, stackar osv.
Flere trådar inom samma program kan exekveras samtidigt på multipla processorer
(CPUn)
Fördelar med trådar
Förbättrar prestandan hos enskilda program om trådar används på rätt sätt
I multiprocessor datorer
Även i datorer med en processor (p.g.a. alternering, se tavlan!)
Förenklad hantering av asynkrona händelser
Tänk dej t.ex. en Web server som skall klara av att sätta upp HTTP-förbindelser
med flere Web klienter samtidigt!
Varje klientförbindelse kan startas upp i en egen tråd på Web servern
“Mottagligare” användargränssnitt
Trådprogrammering i Java
Trådar existerar i alla processer av Java program som exekveras.
Alla processer har åtminstone en huvudtråd.
Program med flera samtidigt exekverande trådar är viktig eganskap i Java platformen.
Huvudtråden (main thread) kan vid behov starta upp flera paralella trådar.
Trådprogrammering i Java
Varje tråd i Java är associerad med en instans av klassen Thread.
Det finns i Java två strategier för att använda Thread objekt för att göra program med
flera samtidigt exekverande trådar:
Lågnivå programmering av trådobjekt
Hantering av trådobjekt på hög nivå m.h.a ”executors”
Den förstnämnda strategin är baserad på en lågnivå ”API” som har varit en del av Java
sedan första början. Denna API lämpar sej bra för programmering av enkla
”multiprocessing” program.
För större program med massor av samtidgt exekverande trådar lämpar sej ”executors”modellen bättre. Denna metod har funnits fr.o.m. JDK Version 5.0.
Vi börjar med llågnivå modellen eftersom den är lättare att förstå!
Att definiera och starta en tråd
En applikation skapar en instans av klassen Thread och definierar den kod som skall
köras i en egen tråd.
Det finns två sätt att göra detta på.
Metod1:
public class TradTest implements Runnable
{
public void run()
{
System.out.println("Hej! Jag är en trad som kors parallelt med huvudtraden!");
}
public static void main(String args[])
{
Thread th = new Thread(new TradTest());
th.start();
System.out.println("Hej! Jag är huvudtraden!");
}
}
Att definiera och starta en tråd
I koden på föregående sida implementerar huvudklassen ett objekt av gränssnittet
Runnable.
Gränssnittet Runnable definierar en metod run() dit det är meningen att man skall
placera den kod som skall exekveras i en egen tråd.
I huvudmetoden startar man upp en ny tråd genom att skapa ett nytt objekt av klassen
Thread via vilket man anropar metoden start(). Runnable- objektet ges som parameter till
konstruktorn för klassen Thread().
Att definiera och starta en tråd
Metod2:
public class TradTest extends Thread
{
public void run()
{
System.out.println("Detta ar en paralell trad!");
}
public static void main(String args[])
{
(new TradTest()).start();
System.out.println("Detta är huvudtraden!");
}
}
Att definiera och starta en tråd
I koden på föregående sida nedärvs klassen Thread i huvudklassen.
Klassen Thread implementerar gränsnittet Runnable och behöver därför inte
implementeras i det egna Java-programmet.
Från huvudmetoden startar man upp en ny tråd genoma att skapa ett nytt Thread objekt
via vilket man anropar metoden start().
Att definiera och starta en tråd
VILKEN METOD ÄR BÄTTRE???
Metod 2 är enklare men mer begränsande eftersom en klass som hanterar flera
samtidiga trådar måste vara en underklass av klassen Thread.
I den här kursen kommer vi att koncentrera oss på metod1.
Klassen Thread
Exempel på metoder som kan användas via klassen Thread är:
start() – Startar en ny tråd
stop()- Stänge en tråd
sleep()- Pausar en tråd för en viss tid
Detaljerad information om klassen Thread med alla dess egenskaper hittas i Java API
dokumentationen: http://java.sun.com/javase/6/docs/api/
