Az előadás letöltése folymat van. Kérjük, várjon

Az előadás letöltése folymat van. Kérjük, várjon

Fejlett Webes Technológiák

Hasonló előadás


Az előadások a következő témára: "Fejlett Webes Technológiák"— Előadás másolata:

1 Fejlett Webes Technológiák
10/4

2 A mai előadás tartalma:
Java nyelv alapjai JAR fájlok Hibakezelés Szál kezelés

3 Java nyelv I. Egyszerű Magasszintű Objetum orientált
a kezdők is könnyen boldogulnak vele (C,C++) Magasszintű komplex feladatok egyszerűen megoldhatóak vele (hálózat kezelés, grafika) Objetum orientált az alapoktól kezdve (a primitív adattípusok kivételével minden objektum) elosztott rendszerek (komponens alapú fejlesztés, újrafelhasználhatóság) Biztonságos, robosztus fordításkor ellenőrzés nincs pointer (NULL pointerre hivatkozás, levegőbe lógó mutatók) nincs automatikus konverzió dinamikus szemétgyűjtés (memory leak)

4 Java nyelv II. Platform független Interpretált, dinamikus Többszálú
nem tartalmaz architektúra függő elemeket (az int, mérete … nyelvi szinten definiált) Interpretált, dinamikus gyors fejlesztési ciklus (nincs szükség make-re) class loader (package) virtuális gép byte kód (a hivatkozások csak futás időben oldódnak fel) 10-20-szor lassabb mint gépi kódú megfelelője Többszálú Elosztott (a class loader képes hálózatról betölteni az osztályt, RMI, …)

5 Hol, hogyan használhatjuk?
Kliens oldal: Java Applet Java Kliens Java Swing Szerver oldal: JDBC Java Servlet JSP RMI JMS Java IDL JTS EJava Bean

6 Hogyan működik ? I. JVM Java API .java fájl javac osztaly.java
osztaly.class java osztaly

7 Hello World ! HelloWorldApp.java fájl javac HelloWorldApp.java
/** * A HelloWorldApp osztály mely a szabványos kimenetre kiírja a Hello World üdvözletet. */ public class HelloWorldApp { public static void main(String[] args) System.out.println("Hello World!"); //Kiírja a szöveget. } HelloWorldApp.java fájl javac HelloWorldApp.java HelloWorldApp.class java HelloWorldApp

8 Változók A minden változóhoz típust és nevet kell rendelnünk.
A változók nevét kicsi betűvel kezdjük, a több szóból álló változókat a szóhatárnál nagybetűvel választjuk el. bool isVisible; az aláhúzást mindenhol használhatjuk de csak a konstansokban szokás az utasítások végén ;

9 Példa public class MaxVariablesDemo {
public static void main(String args[]) { byte largestByte = Byte.MAX_VALUE; short largestShort = Short.MAX_VALUE; int largestInteger = Integer.MAX_VALUE; long largestLong = Long.MAX_VALUE; float largestFloat = Float.MAX_VALUE; double largestDouble = Double.MAX_VALUE; char aChar = 'S'; boolean aBoolean = true; System.out.println("The largest byte value is " + largestByte); }

10 Operátorok () [] . zárójelek, indexelés, osztály komponensére hivatkozás ! ~ instanceof (pre- vagy poszt-) inkremens és dekremens, logikai és bitenkénti negálás, típus ellenôrzés new (type)expression új egyed létrehozása * / % szorzás, osztás, moduló + - összeadás, kivonás << >> >>> bitenkénti léptetések < > >= <= összehasonlítások == != egyenlô, nem egyenlô & bitenkénti AND ^ bitenkénti XOR | bitenkénti OR && logikai AND || logikai OR ? : feltételes kifejezés = += -= *= /= %= ^= &= |= <<= >>= >>>= különbözô értékadások

11 Vezérlő szerkezetek I. ciklusok: döntési pontok: while do-while for
{ utasítások } while (kifejezés); while (kifejezés) { utasítások } ciklusok: while do-while for döntési pontok: if-else switch-case for (inicializálás; befejezés; növekmény) { utasítások } switch (változó(csak int)) { case érték1: utasítás1; break; case érték2: utasítás2; default: utasítás; } if (feltétel) { utasítás ha teljesül} else { utasítás ha nem teljesül }

12 Vezérlő szerkezetek II.
try { utasítások } catch (kivétel neve) { utasítások} finally kivétel kezelés: try-catch-finally elágazás break (kilép) continue (ellenőrzi a feltételt) return (kilép a metódusból)

13 Objektumok I. A primitív típusok kivételével minden objektum
Egy objektum létrehozásának fázisai: Deklarálás Példányosítás Inicializálás Point origin_one = new Point(23, 94); Rectangle rect_one = new Rectangle(origin_one, 100, 200); Rectangle rect_two = new Rectangle(50, 100);

14 Objektumok II. Az objektumok metódusait, változóit az objektumon keresztül érhetjük el. Nem célszerű a változókhoz közvetlen hozzáférést engedélyezni. Az objektumok felszabadításával a program futása után nem kell foglalkoznunk. A szemét gyűjtő megteszi ezt helyettünk (mi is meghívhatjuk System.gc()). finalize metódus (a szemétgyűjtő meghívja ezt mielőtt megszüntetné) Minden egyes objektumnak meghatározott típusa kell, hogy legyen. Minden változó hivatkozás. Érték adáskor erre figyelnünk kell ! Rectangle rect_one = new Rectangle(origin_one, 100, 200); int terulet = rect_one.area(); int w = rect_one.width;

15 Objektumok III. class teszt { public static void main(String[] args)
Point masolat; Point eredeti = new Point(23, 94); masolat = eredeti; masolat.x=1000; System.out.println(eredeti.x); } public class Point { protected int x = 0; protected int y = 0; public Point(int x, int y) { this.x = x; this.y = y; } if (x instanceof Person) System.out.println("x egy személy!");

16 Osztályok Osztályok létrehozása: Osztály deklaráció Osztály törzs
public – alapértelmezés, egyébként csak az azonos csomagban lévő osztályok használhatják abstract – az osztály nem pédányosítható final – az osztályból nem származtatható másik class osztálynév – az osztály neve extends – az osztály őse (mindenképpen kell egy ős) implements interface – a megvalósított egy, vagy több interfész Osztály törzs a változókat és a metódusokat tagoknak nevezzük konstrutor private – más osztály nem példányosíthatja az osztályunkat protected – csak alosztályok és az egy csomagban lévő osztályok példányosíthatják public – bármely osztály példányosíthatja

17 Konstruktorok public class Rectangle { public int width = 0;
public int height = 0; public Point origin; Rectangle() { origin = new Point(0, 0); } public Rectangle(Point p) origin = p; public Rectangle(int w, int h) this(new Point(0, 0), w, h); public Rectangle(Point p, int w, int h) origin = p; width = w; height = h;

18 Tag változók tag változók: hozzáférési szint:
private - osztály protected – osztály, csomag, alosztály public - mindneki package – osztály, csomag static – ez osztály változó (pl. példány számlálás) final – nem változtatható transient – nincs teljesen specifikálva de az objektum mentésnél az ilyen nem mentődik el voaliate – ritkán használt tulajdonság (megakadályozza a fordítót bizonyos optimalizálások elvégzésében)

19 Metódusok Kivétel kezelés Visszatérési érték Hozzáférési szint
Paraméterek deklaráció public Object push(Object item) throws … { items.addElement(item); return(item); } törzs

20 Metódusok I. Hozzáférési szint:
private - osztály protected – osztály, csomag, alosztály public - mindenki package – osztály, csomag Static – akkor is el lehet érni amikor nincs példányosítva public class teszt { public static int x; public static void pelda() System.out.println(x); } public class teszt1 { public static void main(String[] args) System.out.println(teszt.x); }

21 Metódusok II. abstract – nincs implementálva, csak absztrakt osztály tagja lehet (csak a koncepciót vázoljuk, a megvalósítás az alosztályok feladata lesz) final – nem írható felül (biztonsági okok (string - final), tervezés) native – más nyelven írt függvény(a JNI segítségével oldható meg) synchronised – párhuzamosan futó szálak metódusokat használhatnak, hogy hozzáférjenek a változókhoz. Ezzel oldhatjuk meg a zárolást

22 Metódusok III. throws exceptions – segítségével tudunk kivételeket kezelni az argumentumokat érték szerint adja át, a visszatérési értéket is. több metódusnak lehet egy neve, ekkor az argumentumok alapján dől el melyik hívódik meg Az alosztályokban lévő ilyen nevű metódusok felülírják az ős metódusait

23 Öröklődés I. az alap objektum az Object
belőle származik minden objektum közvetlenül vagy közvetve az alosztály örökli az ős metódusait, változóit (az össze elődét) melyek public vagy protected láthatóságúak örököl mindent aminél nincs specifikálva a láthatóság és egy csomagban vannak mivel a konstruktor-ok nem tagok azok nem öröklődnek

24 Öröklődés II. superclass – ősosztály
az egyforma nevű változóknál, metódusoknál az alosztályé érvényes final metódust nem lehet felülírni abstract metódust kötelező felülírni (vagy az alosztálynak absztraktnak kell lennie) super.valtozonev – az ős változója super.metodusnev() – az ős metódusa

25 Object minden osztály belőle származik közvetve vagy közvetlenül
felülírható metódusai: clone (klónozás) equals/hashCode (összehasonlítás, int) finalize (memória felszabadítás, super.finalize()) toString végleges metódusai: getClass notify notifyAll wait

26 getClass() végleges segítségével lekérhetjük az objektum osztályát, ősosztályát void PrintClassName(Object obj) { System.out.println("The Object's class is " + obj.getClass().getName()); } Object createNewInstanceOf(Object obj) return obj.getClass().newInstance();

27 Egymásba ágyazott osztályok I.
class TartalmazoOsztaly{ . . . class BeagyazottOsztaly { } } a beágyazott osztály hozzáfér a tartalmazó osztály minden tagjához a protected-hez is gyakran használják eseménykezelésre a beágyazott osztály lehet: teljes anonymous – egy metódusban definiáljuk

28 Egymásba ágyazott osztályok II.
anonymous public class kezelo implements ActionListener { helyette: public hourField.addActionListener() { new ActionListener() { public void actionPerformed(ActionEvent e) { Integer.parseInt(e.getActionCommand); }

29 Interfészek az interfész egy protokollt definiál mely bárhol megvalósítható. segítségével tulajdonképpen megvalósítható a többszörös öröklődés az interfész metódusokat definiál, de nem implementálja őket definiálhat változókat is különbség az absztrakt osztály és az interfész között: egy interfész nem implementálhat metódusokat egy osztály több interfészt megvalósíthat az interfész nem tagja az osztályhierarchiának

30 Interfész definiálása
az interfész örökölhet extends (őse a szuper interfész) a metódusok törzs nélküliek csak static, final módosítók használhatóak minden public public interface StockWatcher extends PStockWatcher{ final String sunTicker = "SUNW"; final String oracleTicker = "ORCL"; final String ciscoTicker = "CSCO"; void valueChanged(String tickerSymbol, double newValue); }

31 Interfész megvalósítása
minden az interfészben deklarált metódust meg kell valóstani az interfészt nem szabad módosítani! az extends az implements előtt szerepel public class StockApplet extends Applet implements StockWatcher { ... public void valueChanged(String tickerSymbol, double newValue) if (tickerSymbol.equals(sunTicker)) { ... } else if (tickerSymbol.equals(oracleTicker)) { ... } else if (tickerSymbol.equals(ciscoTicker)) { ... } }

32 Csomagkezelés az osztálykezelés egyszerűbbé tétele
feloldja az elnevezési problémákat az összefüggő osztályokat csomagokba lehet foglalni minden forrás fájl elejére oda kell tenni a package szót könyvtár elérési útvonal (CLASSPATH=c:\;) java csomag.progi a csomagon kívül csak a public tagok, osztályok hozzáférhetőek elnevezésre a cégek a cég URL címének inverze használható: com.company.package package graphics; public class Circle extends Graphic implements Draggable { . . . }

33 Csomagok használata Hivatkozhatunk a tagra a teljes névvel
A csomag tagot importáljuk Az egész csomagot importáljuk graphics.Rectangle myRect = new graphics.Rectangle(); import graphics.Circle; import graphics.*;

34 JAR fájlok Segítségükkel több fájlt egy archívumba pakolhatunk
Tipikusan egy alkalmazás class fájlait tartalmazza Az így csomagolt alkalmazás futtatható közvetlenül, appletként, az osztályai hozzáférhetőek Előnyei: biztonságos rövid letöltés tömörítés hordozhatóság

35 JAR fájlok kezelése jar cf jar-file input-file(s) - becsomagolás
jar tf jar-file – tartalom megtekintése jar xf jar-file [archived-file(s)] - kicsomagolás java -jar jar-file – futtatás jar uf jar-file input-file(s) – frissítés jarsigner jar-file alias – aláírás jarsigner -verify jar-file - ellesnőrzés

36 Hibakezelés I. Minden programban előfordulhat hiba. Ki kezeli le?
A Java nyelv biztosít hibakezelést A szabványos Java hibakezelők használatával érthetőbb a kód (nem áll nek mindenki saját elképzelése szerint megvalósítani a hibakezelést) A hibakezelés megkönnyíti a különböző alkalmazások együttműködését A programkód és a hibakezelés elkülöníthető egymástól

37 Hibakezelés II. Megfelelő hibához megfelelő hibakezelő jár
A runtime rendszer a Call stack-et nézi végig hibakezelő után kutatva. Ha több hibakezelőt is talál akkor a sorrend is számít Ha nem talál megfelelő kezelőt akkor a parancssoros rendszer leáll, a GUI tovább folytatja eseménykezelését

38 Hibakezelés metódusai
try – körülfogja a kezelendő részt catch (Excetption e) – adott hibatípust kezel finally – végrehajtódik throw – továbbadja

39 Példa public void writeList() { PrintWriter out = null;
try { System.out.println("Entering try statement"); out = new PrintWriter( new FileWriter("OutFile.txt")); for (int i = 0; i < size; i++) out.println("Value at: " + i + " = " + victor.elementAt(i)); } catch (ArrayIndexOutOfBoundsException e) { System.err.println("Caught ArrayIndexOutOfBoundsException: " + e.getMessage()); catch (IOException e) System.err.println("Caught IOException: " + e.getMessage()); finally { if (out != null) { System.out.println("Closing PrintWriter"); out.close(); } else { System.out.println("PrintWriter not open"); }

40 Hiba generálás hibák – jelentekeznek, de nem rendszeresek pl. IllegalAccessException , NegativeArraySizeException futásidejű hibák – a virtuális gépen következnek be pl. NullPointerException saját metódusaink jelezhetik a hibákat

41 Példa public Object pop() throws EmptyStackException {
Object obj; if (size == 0) throw new EmptyStackException(); obj = objectAt(size - 1); setObjectAt(size - 1, null); size--; return obj; }

42 Szál (thread) Egyszerű szekvenciális parancssor a programon belül.
Könnyűsúlyú folyamat: megosztva használja a kód és az adat szekciót csökken a ”context-switch” végrehajtási idő Segítségével egyszerre több feladatot végezhetünk: képernyő frissítés hálózat kezelés …

43 Thread osztály a Thread osztály egy általános szálat valósít meg mely nem csinál semmit a run metódus üres a run metódus felülírásával tudunk feladatot specifikálni két módon tudunk szálat megvalósító osztályt definiálni: a Thread osztályból származtatva és felülírva a run metódust megvalósítva a Runnable interfészt

44 A run metódus felülírása
public class SimpleThread extends Thread { public SimpleThread(String str) { super(str); } public void run() for (int i = 0; i < 10; i++) System.out.println(i + " " + getName()); try { sleep((long)(Math.random() * 1000)); } catch (InterruptedException e) {} System.out.println("DONE! " + getName()); } }

45 Futtatás 6 Fiji 0 Jamaica 7 Fiji 0 Fiji 5 Jamaica 1 Jamaica 8 Fiji
DONE! Fiji 8 Jamaica 9 Jamaica DONE! Jamaica 0 Jamaica 0 Fiji 1 Jamaica 1 Fiji 2 Fiji 2 Jamaica 3 Fiji 3 Jamaica 4 Jamaica 4 Fiji 5 Fiji public class TwoThreadsDemo { public static void main (String[] args) new SimpleThread("Jamaica").start(); new SimpleThread("Fiji").start(); }

46 A Runnable interfész megvalósítása
public class SimpleThread implements Runnable { Thread SimpleThread; public SimpleThread(String str) { SimpleThread = new Thread(this, str);} public void start() {SimpleThread.start(); } public void run() { for (int i = 0; i < 10; i++) { System.out.println(i + " " + myThread.getName()); try { myThread.sleep((long)(Math.random() * 1000)); } catch (InterruptedException e) {} } System.out.println("DONE! " + myThread.getName());

47 Mikor melyik módot válasszuk ?
Amennyiben osztályunknak származnia kell valahonnan akkor az interfész a megoldás (pl Applet esetén) Egyébként tetszőleges

48 A szál életciklusa done sleeping blokkolt suspend sleep új resume
start futtatható wait notify run metódus kilép halott stop

49 Állapotok I. új szál runnable
amikor a new operátorral létrehozzuk még nem fut ekkor a new állapotban van runnable a megfelelő erőforrások lefoglalását, a szál adminisztrálását, a szál futását a start metódus segítségével tudjuk elindítani a new állapotból. ebben az állapotban a szál nem feltétlenül fog futni. Az operációs rendszer feladata a megfelelő futási idő biztosítása számára. a szálak közötti váltás operációs rendszer függő (pl.: solaris esetén green threads, windows esetén mindegyik szálnak egy időszelet)

50 Állapotok II. blokkolt szálak a következő módokon kerülhetnek ebbe az állapotba: a sleep() metódus eredményeként (ekkor adott ideig lesz itt) egy olyan művelet végrehajtása esetén mely input/output műveletekkel blokkolt és addig nem tér vissza míg ezek be nem fejeződtek a wait() metódus meghívására (másik szálnak meg kell hívnia a notify vagy notifyAll metódust) amikor olyan objektumhoz próbál hozzáférni amely zárolt a suspend() metódus meghívására (ez már elavult) a resmue() metódussal lehet visszahozni. futtatható állapotba csak úgy kerülhetnek vissza ha a blokkolást előidéző eseménynek megfelelő esemény következik be

51 Állapotok III. halott szálak a run metódus kilép
hirtelen meghal mert egy kezeletlen kivétel miatt megszűnik a run metódus a stop metódus elavult ezért ne használjuk az isAlive metódus segítségével nézhetjük meg, hogy él-e még.

52 A run metódus kezelése I.
a feladat befejezése után kilép: public void run() { for (int i = 0; i < 10; i++) System.out.println(i + " " + getName()); try { sleep((long)(Math.random() * 1000)); } catch (InterruptedException e) {} } System.out.println("DONE! " + getName()); } }

53 A run metódus kezelése II.
Figyeli, hogy ki kell-e lépnie: public void run() { Thread myThread = Thread.currentThread(); while (clockThread == myThread) { repaint(); try { Thread.sleep(1000); } catch (InterruptedException e){} } public void stop() { clockThread = null;

54 Prioritás a szálak versenyeznek a CPU használatáért
nagyobb prioritású szálak előnyben vannak a kisebb prioritású szálakkal szemben a kisebb prioritású szálak csak akkor jutnak CPU időhöz, ha a nagyobb prioritású szálak már nem tartanak igényt a CPU-ra az egyenlő prioritású szálak kezelése operációs rendszer függő win9x, WinNT… az egyenlő prioritású szálak felváltva kapnak CPU időt (időosztás) solaris az egyenlő prioritású szálak csak között csak a feladat befejezése után történik váltás (probléma az önző szálak kezelése) a setPriority() metódussal lehet beállítani egy szál prioritását (MAX_PRIOROTY=10, MIN_PRIORITY=1)

55 Példa: public class SimpleThread implements Runnable {
Thread SimpleThread; public SimpleThread(String str) { SimpleThread = new Thread(this, str); } public void start() SimpleThread.start(); public void setPriority(int i) SimpleThread.setPriority(i); public void run() { Thread myThread = Thread.currentThread(); for (int i = 0; i < 10; i++) for (int c = 0; c < ; c++); System.out.println(i + " " + SimpleThread.getName()); System.out.println("DONE! " + SimpleThread.getName()); Példa:

56 Egyforma prioritás public class ThreeThreadsTest {
0 Kolumbia 1 Kolumbia 2 Kolumbia 0 Jamaica 1 Jamaica 2 Jamaica 3 Jamaica 4 Jamaica 3 Kolumbia 4 Kolumbia 5 Kolumbia 6 Kolumbia 5 Jamaica 6 Jamaica 7 Jamaica 8 Jamaica 9 Jamaica 7 Kolumbia 8 Kolumbia 9 Kolumbia DONE! Kolumbia DONE! Jamaica public class ThreeThreadsTest { public static void main (String[] args) { SimpleThread t; SimpleThread t1; t = new SimpleThread("Jamaica"); t.setPriority(1); t1 = new SimpleThread("Kolumbia"); t1.setPriority(1); t1.start(); t.start(); }

57 Különböző prioritás public class ThreeThreadsTest {
0 Jamaica 1 Jamaica 2 Jamaica 3 Jamaica 4 Jamaica 5 Jamaica 6 Jamaica 7 Jamaica 8 Jamaica 9 Jamaica DONE! Jamaica 0 Kolumbia 1 Kolumbia 2 Kolumbia 3 Kolumbia 4 Kolumbia 5 Kolumbia 6 Kolumbia 7 Kolumbia 8 Kolumbia 9 Kolumbia DONE! Kolumbia public class ThreeThreadsTest { public static void main (String[] args) { SimpleThread t; SimpleThread t1; t = new SimpleThread("Jamaica"); t.setPriority(10); t1 = new SimpleThread("Kolumbia"); t1.setPriority(1); t1.start(); t.start(); }

58 Megjegyzés olyan szálakat kell írnunk melyek nem önzőek
az operációs rendszerek különbözőek, ha platform független programot akarunk írni akkor nekünk kell gondoskodnunk a megfelelő időosztásról a yield() metódus segítségével tudjuk egy szál futását felfüggeszteni és a CPU-t átadni egy legalább ilyen prioritású szálnak (solaris) nem minden operációs rendszer rendelkezik 10 prioritási szinttel (pl winnt 7) a szálak prioritásukat a létrehozó száltól öröklik

59 Szálak szinkronizálása
Egyes feladatokat nem lehet megoldani egymástól független szálakkal (pl.: közös erőforrás használata módosítása) Hibás működéshez vezethet amennyiben nem gondoskodunk zárolásról a közös erőforrás használatakor pl.: két vagy több szál bankbetétek között végez tranzakciókat. A művelet bármikor megszakadhat (windows) és nem konzekvens állapot maradhat, amit egy másik szál felhasználhat. a problémát az adatmódosító metódus megszakíthatósága okozza

60 Zárolás synchronized a zárolt objektumhoz csak egy szál férhet hozzá
ha egy szál használ egy zárolt objektumot és meghív egy másik szálat akkor a másik szál hozzáférhet az objektumhoz minden objektumnak van egy zárolás számlálója egy szál egyszerre több objektumot is zárolhat a szál ütemező periodikusan aktiválja a szálakat, azok melyek egy zárolt objektumra várakoznak a következő soron kívüli futási jogot kapnak.

61 wait, notify, notifyAll előfordulhat olyan eset amikor egy szál a másik akciójára vár ilyenkor mivel a közös objektumot zárolt függvényeken keresztül lehet elérni ez végtelen ciklushoz vezetne wait – ha egy szál meghívja a wait() metódust akkor az objektum felszabadul és a szál blokkolva lesz amíg az adott objektumnál egy másik szál meg nem a hívja a notify, notifyAll metódust érdemes a notifyAll metódust használni mivel a másik a blokkolt szálak közül csak egyet szabadít fel azt is véltelenszerűen

62 Példa: Tároló objektum: Tarolo Adat forrás: Producer
Adat nyelő: Consumer main: PTest

63 Tarolo.java public class Tarolo {
private int contents; private boolean available = false; public synchronized int get() { while (available == false) { try { wait(); } catch (InterruptedException e) { } } System.out.println("Olvasgatok"); available = false; notifyAll(); return contents; public synchronized void put(int value) while (available == true) { System.out.println("Irogatok"); contents = value; available = true; notifyAll(); Tarolo.java

64 public class Producer extends Thread {
private Tarolo tarolo; private int number; public Producer(Tarolo c, int number) { tarolo = c; this.number = number; } public void run() { for (int i = 0; i < 10; i++) { tarolo.put(i); System.out.println("Producer #" + this.number + " beirtam: " + i); try { sleep((int)(Math.random() * 100)); } catch (InterruptedException e) { }

65 public class Consumer extends Thread {
private Tarolo tarolo; private int number; public Consumer(Tarolo c, int number) { tarolo = c; this.number = number; } public void run() { int value = 0; for (int i = 0; i < 10; i++) { value = tarolo.get(); System.out.println("Consumer #" + this.number + " kiolvastam: " + value);

66 Main public class PTest { public static void main(String[] args) {
Tarolo c = new Tarolo(); Producer p1 = new Producer(c, 1); Consumer c1 = new Consumer(c, 1); c1.start(); p1.start(); }

67 Eredmény H:\>java PTest Irogatok Olvasgatok
Consumer #1 kiolvastam: 0 Producer #1 beirtam: 0 …. Producer #1 beirtam: 8 Consumer #1 kiolvastam: 8 Producer #1 beirtam: 9 Consumer #1 kiolvastam: 9

68 Újrafoglalás public class Reentrant { public synchronized void a() {
System.out.println("here I am, in a()"); } public synchronized void b() { System.out.println("here I am, in b()");

69 Szál csoportok a szálakat csoportokba tudjuk foglalni
a csoportokon egyszerre tudunk műveleteket végrehajtani egy szál a létrehozásakor helyezhető egy csoportba, ezután már nem mozdítható el ha nem adunk meg mást akkor automatikusan a szülő szál csoportjába kerül új csoportokat létrehozása esetén az új csoport a szülő csoport gyerek csoportja lesz

70 Szál csoport metódusok
ThreadGroup(Sting name) – konstruktor ThreadGroup(ThreadGroup parent ,Sting name) – konstruktor, itt az ős a parent csoport int activeCount() – a csoportban lévő aktív szálak számát adja vissza int enumerate(Thread[] list) – a csoportban lévő szálak hivatkozásait gyűjti össze TheradGroup getParent() – a szülő csoportot adja vissza void interrupt() – megszakítja minden szál munkáját


Letölteni ppt "Fejlett Webes Technológiák"

Hasonló előadás


Google Hirdetések