Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
statnice:bakalar:b0b36pjv [2025/05/31 22:03] – zapleka3statnice:bakalar:b0b36pjv [2026/05/23 21:14] (current) – [GC] fix syntax mates1n
Line 1: Line 1:
-==== Programování v jazyce JAVA: vlastnosti a koncepce jazyka. Principy objektového programování. ====+====== Programování v jazyce JAVA: vlastnosti a koncepce jazyka. Principy objektového programování. ======
  
 [[https://fel.cvut.cz/cz/education/bk/predmety/50/10/p5010706.html|B0B36PJV]] [[https://cw.fel.cvut.cz/wiki/courses/b0b36pjv/prednasky|Webové stránky předmětu]] [[https://fel.cvut.cz/cz/education/bk/predmety/50/10/p5010706.html|B0B36PJV]] [[https://cw.fel.cvut.cz/wiki/courses/b0b36pjv/prednasky|Webové stránky předmětu]]
Line 14: Line 14:
 ==== JDK, JRE, JVM ==== ==== JDK, JRE, JVM ====
 Většinu programovacích jazyků je možné rozdělit do dvou kategorií: Většinu programovacích jazyků je možné rozdělit do dvou kategorií:
-  * **kompilované** - program je zkompilovaný do spustitelného souboru, skládá se z nativních procesorových instrukcí, které přímo vykonává procesor a musí být tedy kompilován pro konkrétní architekturu a systém. Mezi tyto jazyky patří například C/C++.+  * **kompilované** - program je zkompilovaný do spustitelného souboru, skládá se z nativních procesorových instrukcí, které přímo vykonává procesor a musí být tedy kompilován pro konkrétní architekturu a systém. Mezi tyto jazyky patří například C/<nowiki>C++</nowiki>
   * **interpretované** - program není zkompilovaný, pro spuštění je nutný jiný program (interpreter), který program při spuštění převádí do nativních procesorových instrukcí, které může počítač vykonávat. Typický interpretovaný jazyk je třeba Python.   * **interpretované** - program není zkompilovaný, pro spuštění je nutný jiný program (interpreter), který program při spuštění převádí do nativních procesorových instrukcí, které může počítač vykonávat. Typický interpretovaný jazyk je třeba Python.
  
Line 64: Line 64:
 Garbage Collector běží na pozadí **JVM**. Běží ve vlastním vlákně (nebo i více vláknech), takže neblokuje běh samotného programu (asynchronní). Drží si seznam všech referencí na data na **heap** a jakmile zjistí, že už žádné reference neexistují, tak data uvolní (dealokuje). Garbage Collector běží na pozadí **JVM**. Běží ve vlastním vlákně (nebo i více vláknech), takže neblokuje běh samotného programu (asynchronní). Drží si seznam všech referencí na data na **heap** a jakmile zjistí, že už žádné reference neexistují, tak data uvolní (dealokuje).
  
-Garbage Collector sice nebude nikdy tak efektivní jako korektní manuální dealokace jako např. v C/C++, ale zjednodušuje psaní programu, jeho udržitelnost a značně snižuje riziko memory leaků kvůli špatným manuálním dealokacím.+Garbage Collector sice nebude nikdy tak efektivní jako korektní manuální dealokace jako např. v C/<nowiki>C++</nowiki>, ale zjednodušuje psaní programu, jeho udržitelnost a značně snižuje riziko memory leaků kvůli špatným manuálním dealokacím.
  
 ==== Profilování a optimalizace ==== ==== Profilování a optimalizace ====
Line 224: Line 224:
  
  
-===== 3. Výčtové typy ===== +===== 3.  Výčtové typy, kolekce, iterátor, generické typy ===== 
-Výčtový typ / enumerate, je typ který může nabývat jenom předem stanovených hodnot. Hodí se například pro uchovávání nějakého stavu, místo arbitrárně zvolených čísel.+ 
 +==== Výčtové typy (enum) ==== 
 + 
 +Výčtový typ (angl. enumeration) je datový typ, který může nabývat pouze předem daných hodnot.   
 +Zvyšuje čitelnost a typovou bezpečnost programu – místo čísel nebo řetězců použijeme symbolická jména.
  
 Například: Například:
Line 241: Line 245:
  
 Day today = Day.MONDAY; Day today = Day.MONDAY;
 +```
 +</markdown>
  
 +Výčtové typy jsou ve skutečnosti speciální typ třídy – lze do nich přidat:
 +  - konstruktor,
 +  - metody,
 +  - pole.
 +
 +<markdown>
 +```java
 public enum Suit { public enum Suit {
     CLUBS(Color.BLACK),     CLUBS(Color.BLACK),
Line 265: Line 278:
 </markdown> </markdown>
  
-===== 4. Vnitřní a anonymní třídy ===== +==== Kolekce (Java Collection Framework) ==== 
-Třída která je definovaná uvnitř jiné třídy.+ 
 +Java Collections Framework (JCF) je sada rozhraní a tříd pro práci s obecnými datovými strukturami. 
 + 
 +Základní vlastnosti: 
 +  * umožňují efektivní ukládání, vyhledávání a zpracování objektů, 
 +  * hierarchicky uspořádané – Collection, List, Set, Map, Queue atd. 
 + 
 +Základní typy kolekcí: 
 +  * List – uspořádaná kolekce s indexy (ArrayList, LinkedList) 
 +  * Set – množina bez duplicit (HashSet, TreeSet) 
 +  * Map – páry klíč–hodnota (HashMap, TreeMap) 
 +  * Queue – fronta (LinkedList, PriorityQueue) 
 + 
 +Příklad: 
 +<markdown> 
 +```java 
 +List<String> names = new ArrayList<>(); 
 +names.add("Alice"); 
 +names.add("Bob"); 
 +``` 
 +</markdown> 
 + 
 +==== Iterátor ==== 
 + 
 +Iterátor je objekt, který umožňuje bezpečně procházet kolekce bez znalosti jejich vnitřní struktury. 
 + 
 +Použití: 
 +<markdown> 
 +```java 
 +Iterator<String> it = names.iterator(); 
 +while (it.hasNext()) { 
 +    System.out.println(it.next()); 
 +} 
 +``` 
 +</markdown> 
 + 
 +Zkrácený zápis pomocí for-each: 
 +<markdown> 
 +```java 
 +for (String name : names) { 
 +    System.out.println(name); 
 +} 
 +``` 
 +</markdown> 
 + 
 +Rozhraní Iterable umožňuje použít kolekci ve for-each smyčce. 
 + 
 +Poznámka: Kolekce nelze bezpečně měnit během iterace jinak než metodou it.remove().   
 +Jinak hrozí ConcurrentModificationException. 
 + 
 +==== Generické typy ==== 
 + 
 +Generické typy (generika) umožňují psát obecný, opakovatelný a typově bezpečný kód, který lze aplikovat na různé datové typy bez nutnosti přetypování. 
 + 
 +Deklarace: 
 +<markdown> 
 +```java 
 +List<Integer> numbers = new ArrayList<>(); 
 +numbers.add(10); 
 +``` 
 +</markdown> 
 + 
 +Výhody generik: 
 +  - typová bezpečnost, 
 +  - žádné přetypování, 
 +  - opakovatelnost kódu. 
 + 
 +Generická metoda: 
 +<markdown> 
 +```java 
 +public static <T> void printAll(List<T> list) { 
 +    for (T item : list) { 
 +        System.out.println(item); 
 +    } 
 +} 
 +``` 
 +</markdown> 
 + 
 +Poznámka: Generika jsou v Javě implementována pomocí type erasure – typová informace se za běhu ztrácí (např. nelze napsat new T()). 
 + 
 + 
 +===== 4. Vnitřní a anonymní třídy, Imutabilita, Vzor singleton, Proměnné a metody třídy vs. instance ===== 
 + 
 +==== Vnitřní třídy ==== 
 +Vnitřní třída (inner class) je třída, která je definovaná uvnitř jiné třídy. Má přístup ke všem členům (včetně privátních) vnější třídy a typicky slouží jako pomocná třída. 
 + 
 +Je-li vnitřní třída označena jako static, jedná se o statickou vnitřní třídu, která nemá přístup k instanci vnější třídy. 
 + 
 +Výhodou je lepší zapouzdření a přehlednost kódu – vnitřní třídy se používají tam, kde nemá smysl jejich existence samostatně. 
 <markdown> <markdown>
 ```java ```java
Line 278: Line 380:
 ``` ```
 </markdown> </markdown>
 +
 +
 +==== Anonymní třídy ====
 +Anonymní vnitřní třída je bezejmenná třída, která je definována a zároveň instanciována na místě. Používá se tam, kde potřebujeme jednorázově implementovat nějaké rozhraní nebo rozšířit třídu.
 +
 +Typicky se využívá např. pro callbacky nebo posluchače událostí.
  
 Anonymní třída je třída vnitřní bez názvu, pro kterou je vytvořen pouze jediný objekt. Anonymní třída je třída vnitřní bez názvu, pro kterou je vytvořen pouze jediný objekt.
Line 312: Line 420:
 ``` ```
 </markdown> </markdown>
 +
 +==== Imutabilita ====
 +Imutabilní objekt je takový objekt, jehož stav po vytvoření již nelze změnit. To znamená:
 +  * všechny atributy jsou private a final,
 +  * objekt neposkytuje žádné metody, které by umožnily změnu stavu,
 +  * objekt nevrací reference na své vnitřní proměnné.
 +
 +Výhody:
 +  * bezpečnost při vícevláknovém přístupu,
 +  * snazší ladění a testování.
 +
 +==== Vzor Singleton ====
 +Singleton je návrhový vzor, který zajišťuje, že daná třída má právě jednu instanci. Toho se docílí:
 +  * soukromým (private) konstruktorem,
 +  * statickou proměnnou pro instanci třídy,
 +  * veřejnou statickou metodou pro přístup k instanci.
 +
 +<markdown>
 +```java
 +public class Singleton {
 +  private static final Singleton instance = new Singleton();
 +
 +  private Singleton() {}
 +
 +  public static Singleton getInstance() {
 +    return instance;
 +  }
 +}
 +```
 +</markdown>
 +
 +==== Proměnné a metody třídy vs. instance ====
 +
 +  * Instanční proměnné – náleží konkrétní instanci třídy, každá instance může mít jiné hodnoty.
 +  * Třídní proměnné (statické) – sdílené všemi instancemi, existují nezávisle na instanci.
 +
 +  * Instanční metody – pracují s instančními daty, volají se na konkrétních objektech.
 +  * Statické metody – patří třídě, volají se bez instance, nemají přístup k nestatickým členům.
 +
  
 ===== 5. Mechanismus výjimek ===== ===== 5. Mechanismus výjimek =====
  
-Výjimka (//exception//) je **neočekávaná událost** během běhu programu, kvůli níž nelze pokračovat v běžném průběhu.   +Výjimka (//exception//) je **neočekávaná událost** během běhu programu.  Znemožňuje dokončení běžného toku programu, pokud není správně ošetřena. 
-Typickým příkladem je dělení nulou nebo přístup mimo rozsah pole.+ Výjimky se typicky používají pro chybové stavy, jako je dělení nulou nebo přístup mimo rozsah pole.
  
-==== Hierarchie ==== +==== Hierarchie výjimek v Javě ==== 
-  * Vše začíná třídou ''Throwable''. +* Všechny výjimky jsou potomky třídy `Throwable`. 
-    * **''Error''** – vážné chyby JVM (např. ''OutOfMemoryError''), většinou je *nechytáme. +  * `Error` – závažné chyby JVM (např. `OutOfMemoryError`). Nejsou určeny k zachytávání. 
-    * **''Exception''** – vše, co smysluplně ošetřujeme.+  * `Exception` – výjimky, které lze (a měly by se) ošetřit. 
 +    * `RuntimeException` – běhové výjimky (např. `NullPointerException`, `IllegalArgumentException`).
  
-==== Checked × Unchecked ====+==== Checked vs. Unchecked výjimky ====
   * **Checked** – kompilátor hlídá; musíš je buď zachytit pomocí ''catch'', nebo předat dál klíčovým slovem ''throws'' (např. ''FileNotFoundException'').   * **Checked** – kompilátor hlídá; musíš je buď zachytit pomocí ''catch'', nebo předat dál klíčovým slovem ''throws'' (např. ''FileNotFoundException'').
   * **Unchecked** – všechny výjimky odvozené od ''RuntimeException'' **a také ''Error''**; kompilátor jejich ošetření nevynucuje (např. ''NullPointerException'').   * **Unchecked** – všechny výjimky odvozené od ''RuntimeException'' **a také ''Error''**; kompilátor jejich ošetření nevynucuje (např. ''NullPointerException'').
  
-==== Ošetření („try-catch-finally“) ====+==== Ošetření výjimek ==== 
 + 
 +Výjimky se ošetřují pomocí konstrukcí `try-catch-finally`. 
 <code java> <code java>
 try { try {
     // rizikový kód     // rizikový kód
 } catch (IOException | SQLException ex) {  // multi-catch od Java 7 } catch (IOException | SQLException ex) {  // multi-catch od Java 7
 +    e.printStackTrace();  // ošetření výjimky
     log(ex);     log(ex);
     throw ex;         // volitelné předání dál     throw ex;         // volitelné předání dál
Line 339: Line 491:
 </code> </code>
  
-  * **try-with-resources** (Java 7+) – vše, co implementuje ''AutoCloseable'', se zavře automaticky:+  * `catch` může být více, podle typu výjimky. 
 +  * `finally` se vždy vykoná – i když dojde k výjimce nebo `return`. 
 + 
 +==== Try-with-resources ==== 
 +Od Javy 7 existuje `try-with-resources`, který automaticky zavře prostředky (např. soubory, streamy) implementující `AutoCloseable`. 
 <code java> <code java>
 try (BufferedReader br = Files.newBufferedReader(Path.of("data.txt"))) { try (BufferedReader br = Files.newBufferedReader(Path.of("data.txt"))) {
Line 347: Line 504:
  
 ==== Vlastní výjimky ==== ==== Vlastní výjimky ====
 +Vlastní výjimky se vytvářejí děděním ze třídy `Exception` nebo `RuntimeException`.
 +
 <code java> <code java>
-public class DataFormatException extends Exception {           // checked +public class MyException extends Exception { 
-    public DataFormatException() {} +    public MyException() {} 
-    public DataFormatException(String msg)       { super(msg); } +    public MyException(String msg) { super(msg); } 
-    public DataFormatException(String msg, Throwable cause) { +    public MyException(String msg, Throwable cause) { super(msg, cause); }
-        super(msg, cause);+
     }     }
 } }
Line 359: Line 517:
   * **Kdy se hodí?** Když stávající výjimky nedostačují a potřebuješ popsat specifickou situaci.   * **Kdy se hodí?** Když stávající výjimky nedostačují a potřebuješ popsat specifickou situaci.
   * Rozhodni se, zda má být **checked** (nutí volající k ošetření) nebo **unchecked** (dědí z ''RuntimeException'').   * Rozhodni se, zda má být **checked** (nutí volající k ošetření) nebo **unchecked** (dědí z ''RuntimeException'').
 +
 +  * Pokud dědíme z `Exception`, jedná se o checked výjimku – musí být ošetřena.
 +  * Pokud dědíme z `RuntimeException`, jedná se o unchecked výjimku – nemusí být ošetřena.
  
 ==== Best practices ==== ==== Best practices ====
-  * Vyhazuj co nejkonkrétnější výjimky, ať je volající může smysluplně řešit. +  * Zachytávej co nejkonkrétnější typy výjimek, až poté obecné (`Exception`, `Throwable`). 
-  * Nezachytávej zbytečně obecné ''Exception''/''Throwable'' – skrýváš tím chyby. +  * Nepoužívej prázdné `catch` bloky – vždy loguj nebo informuj uživatele. 
-  * Vždy uvolňuj prostředky (soubor, socket…) v ''finally'' nebo ještě lépe v try-with-resources. +  * Uvolňuj prostředky pomocí `finally` nebo `try-with-resources`. 
-  * Přidávej smysluplné chybové zprávy, aby bylo z logu jasné *proč* se výjimka stala.+  * Přidávej popisné chybové zprávy (`new IOException("Soubor nenalezen")`). 
 +  * Vlastní výjimky používej pro specifické, smysluplné chyby v aplikaci. 
 + 
 +==== Shrnutí podle typu výjimky ==== 
 +* `Throwable` – kořenová třída, zachytitelná, ale neměla by se běžně používat. 
 +* `Exception` – standardní ošetřitelné výjimky. 
 +  * `IOException`, `SQLException`, `ParseException` – checked výjimky. 
 +  * `RuntimeException`, `NullPointerException`, `IndexOutOfBoundsException` – unchecked. 
 +* `Error` – závažné chyby – většinou se nezachytávají (`OutOfMemoryError`, `StackOverflowError`).
  
 ===== Práce se soubory (java.io) ===== ===== Práce se soubory (java.io) =====
 +
 +Soubor je množina údajů uložená ve vnější paměti. Přístup k němu probíhá pomocí proudů (streamů), které umožňují čtení a zápis dat sekvenčně nebo náhodně. Dělíme je podle typu dat na textové a binární.
  
 ==== Klíčové třídy ==== ==== Klíčové třídy ====
-  * **''File''** – abstraktní reprezentace cesty; umí zjišťovat existenci, práva, velikost a vytvářet adresáře/základní soubory.   +  * **File** – reprezentuje cestu k souboru nebo adresáři. Lze ověřit existenci, práva, velikost, vytvořit složky/soubory. 
-  * **''InputStream'' / ''OutputStream''** – bajtové proudy (binární data).   +  * **InputStream / OutputStream** – bajtové proudy (pro binární data). 
-    * Dekorátory: ''Buffered*'' (buffer), ''Data*'' (primitiva), ''Object*'' (serializace), ''GZIP*'' (komprese)…   +    * Dekorátory: Buffered* (vyrovnávací paměť), Data* (primitiva), Object* (serializace), GZIP* (komprese)… 
-  * **''Reader'' / ''Writer''** – znakové proudy (text, kódování).   +  * **Reader / Writer** – znakové proudy (pro textová data). 
-    * Typicky ''BufferedReader'', ''InputStreamReader'' (převod bajt→znak), ''FileWriter'' atd.   +    * Často používané: BufferedReader, InputStreamReader, FileWriter. 
-  * **''RandomAccessFile''** – čtení/zápis s libovolným posuvem uvnitř souboru.   +  * **RandomAccessFile** – umožňuje číst/zapisovat na libovolnou pozici (náhodný přístup). 
-  * **Rozhraní ''Closeable'' / ''Flushable'' / ''Serializable''** – sjednocují zavírání, flush a serializaci.+  * Rozhraní: Closeable, Flushable, Serializable – sjednocují chování při zavírání, flushování a serializaci objektů.
  
-==== Vytvoření a použití proudů ====+==== Otevření binárních proudů ====
 <code java> <code java>
 try (InputStream  in  = new FileInputStream("logo.png"); try (InputStream  in  = new FileInputStream("logo.png");
Line 390: Line 561:
 </code> </code>
  
-==== Otevření jednoduchého textového souboru (java.io) ====+==== Otevření a čteni textového souboru (java.io) ====
  
 Nejčastější (a dodnes plně dostačující) kombinací je dvojice **``FileReader`` + ``BufferedReader``**: Nejčastější (a dodnes plně dostačující) kombinací je dvojice **``FileReader`` + ``BufferedReader``**:
Line 405: Line 576:
 </code> </code>
  
-  * **``FileReader``** čte **znaky** (automaticky použije defaultní kódování platformy, nebo explicitně zadej např. ``StandardCharsets.UTF_8``). :contentReference[oaicite:0]{index=0}   +  * **``FileReader``** čte **znaky** (automaticky použije defaultní kódování platformy, nebo explicitně zadej např. ``StandardCharsets.UTF_8``).   
-  * **``BufferedReader``** obalí čtení do větších bloků → méně systémových volání, vyšší výkon. :contentReference[oaicite:1]{index=1}   +  * **``BufferedReader``** obalí čtení do větších bloků → méně systémových volání, vyšší výkon.  
-  * Konstrukce **try-with-resources** (Java 7+) zavře reader i v případě výjimky. :contentReference[oaicite:2]{index=2}  +  * Konstrukce **try-with-resources** (Java 7+) zavře reader i v případě výjimky.   
  
-==== Textové vs. binární ==== +==== Textové vs. binární soubory ==== 
-  * **Text** → ''Reader''/''Writer'', nutné správné kódování (UTF-8 od JDK 18 default).   +  * **Textové** – čitelné pro člověka, pracujeme se znaky pomocí Reader/Writer. Nutné správné kódování (UTF-8, ASCII...). 
-  * **Binární** → ''InputStream''/''OutputStream''; rychlejší, ale nečitelné pro člověka.+  * **Binární** – rychlejší, nečitelné, používáme InputStream/OutputStream. Vhodné pro obrázky, audio, objekty apod.
  
 ==== Serializace objektů ==== ==== Serializace objektů ====
Line 421: Line 592:
 </code> </code>
   * Třída musí implementovat ''Serializable''.     * Třída musí implementovat ''Serializable''.  
-  * Pozor na kompatibilitu verzí tříd (pole ''serialVersionUID'').+  * Lze uložit i více objektů. Pozor na kompatibilitu verzí tříd (pole ''serialVersionUID''). 
 + 
 +==== Přístup k datům ==== 
 +  * **Sekvenční** – čtení/zápis po sobě jdoucích bajtů/řádků (většina proudů). 
 +  * **Náhodný (Random Access)** – přímý přístup k určitému místu v souboru (RandomAccessFile). 
 + 
 +==== Cesty k souborům ==== 
 +  * **Absolutní** – začíná kořenem systému (např. /home/user/file.txt nebo C:\Users\file.txt). 
 +  * **Relativní** – relativní k pracovnímu adresáři aplikace.
  
 ==== Best practices ==== ==== Best practices ====
-  * Vždy používej **try-with-resources** – žádné zapomenuté ''close()''.   +  * Vždy používej try-with-resources – eliminuje riziko nezavření souboru. 
-  * Bufruj I/O (''Buffered*'') kvůli výkonu.   +  * Při práci s textem dej pozor na kódování (UTF-8 doporučeno). 
-  * Nezachytávej holou ''Exception''; loguj a přeposílej konkrétní typy.   +  * Bufruj vstupy/výstupy pomocí Buffered* – zvyšuje výkon. 
-  * Při sériové práci se soubory preferuj nové NIO API (''java.nio.file.Path'') – ošetří limity ''File'' a umí asynchronní I/O, ale porozumění ''java.io'' je nutný základ.+    * Nezachytávej holou ''Exception''; loguj a přeposílej konkrétní typy.   
 +    * Při sériové práci se soubory preferuj nové NIO API (''java.nio.file.Path'') – ošetří limity ''File'' a umí asynchronní I/O, ale porozumění ''java.io'' je nutný základ.
  
 ===== Sokety ===== ===== Sokety =====
 +
 +Soket je objekt, který propojuje aplikaci se síťovým protokolem. Umožňuje síťovou komunikaci mezi dvěma koncovými body (např. klientem a serverem) prostřednictvím definovaných API. V Javě se sokety používají pro komunikaci přes protokoly TCP a UDP.
  
 ==== Typy soketů a API ==== ==== Typy soketů a API ====
-| Třída                 | Protokol | Povaha | Typická použití | + 
-| ''Socket'' / ''ServerSocket'' | TCP | spojované, spolehlivé | chat, přenos souborů  | +| Třída                   | Protokol        | Povaha                  | Typická použití              | 
-| ''DatagramSocket''            | UDP | nespojované, best-effort | streaming, hry | +|-------------------------|------------------|--------------------------|-------------------------------| 
-| ''MulticastSocket''           | UDP multicast | skupinový přenos | discovery, multicast video |+| Socket / ServerSocket   | TCP              | spojované, spolehlivé    | chat, přenos souborů         | 
 +| DatagramSocket          | UDP              | nespojované, best-effort | streaming, multiplayer hry   | 
 +| MulticastSocket         | UDP multicast    | skupinový přenos         | discovery, video broadcast   |
  
 ==== TCP vs. UDP – typy spojení ==== ==== TCP vs. UDP – typy spojení ====
-  * **TCP** – potvrzuje doručení a pořadí, detekuje ztráty; pomalejší, ale jistý.   + 
-  * **UDP** – žádné záruky, ale nízká latence; sám si případně řešíš potvrzení či opakování paketů.  +**TCP (Transmission Control Protocol)**   
 +  * Spojovaný protokol – před komunikací naváže spojení   
 +  * Zaručuje doručení, pořadí zpráv a detekci chyb   
 +  * Pomalejší, ale spolehlivý   
 + 
 +**UDP (User Datagram Protocol)**   
 +  * Nespojovaný protokol – žádné spojení, zprávy mohou být ztraceny nebo doručeny jinak   
 +  * Rychlý, nízká latence, žádné záruky   
 +  * Nutno si případně ošetřit potvrzení a opakování ručně  
  
 ==== Ukázkový TCP server/klient ==== ==== Ukázkový TCP server/klient ====
Line 465: Line 657:
 } }
 </code> </code>
 +
 +==== Primitiva soketu ====
 +
 +  * **create** – vytvoření nového soketu  
 +  * **bind** – přiřazení lokální adresy a portu  
 +  * **connect** – navázání spojení (klient)  
 +  * **listen** – čekání na spojení (server)  
 +  * **accept** – přijetí spojení  
 +  * **send / receive** – odeslání a příjem dat  
 +  * **shutdown / close** – uzavření spojení
  
 ==== Best practices ==== ==== Best practices ====
Line 472: Line 674:
   * Pro šifrovaný přenos sáhni po ''SSLSocket'' / ''SSLServerSocket'' nebo moderním klientovi ''java.net.http''.     * Pro šifrovaný přenos sáhni po ''SSLSocket'' / ''SSLServerSocket'' nebo moderním klientovi ''java.net.http''.  
   * Vždy uzavírej soket v ''try-with-resources'' nebo ''finally''.   * Vždy uzavírej soket v ''try-with-resources'' nebo ''finally''.
- 
  
 ===== 6. Paralelismus ===== ===== 6. Paralelismus =====
 +
 +Paralelismus umožňuje efektivnější využití systémových prostředků (více jader CPU, paralelní zpracování vstupů, vyšší výkon, reakce na události). V Javě se používá vícevláknové programování pomocí třídy `Thread`, rozhraní `Runnable`, případně thread poolu (`ExecutorService`).
 +
 Nutné dodržet pravidla synchronizace, aby se zabránilo deadlocku. Nutné dodržet pravidla synchronizace, aby se zabránilo deadlocku.
 +
 +==== Vytváření a spouštění vláken ====
 +
 +Vlákno lze vytvořit buď děděním od třídy `Thread`, nebo implementací rozhraní `Runnable`:
  
 <markdown> <markdown>
Line 534: Line 742:
 ``` ```
 </markdown> </markdown>
 +
 +==== Synchronizace a problémy souběhu ====
 +
 +Při práci s více vlákny vznikají typické problémy:
 +  * Race condition – více vláken přistupuje ke sdíleným datům bez koordinace. Výsledek je nedefinovaný.
 +    * Řešení: synchronized bloky, volatile proměnné
 +  * Deadlock – dvě nebo více vláken čekají na zdroje, které drží jiná vlákna.
 +    * Řešení: správné pořadí zamykání, timeouty, algoritmy prevence deadlocku
 +  * Producer/Consumer – problém koordinace mezi vlákny produkujícími a spotřebovávajícími data (např. fronta).
 +    * Řešení: wait(), notify(), fronty z balíku java.util.concurrent
 +  * Reader/Writer – vícero vláken čte a/nebo zapisuje do stejného objektu.
 +    * Řešení: ReadWriteLock nebo rozdělení na operace pouze pro čtení a zápis
 +
 +==== Synchronized, Volatile, Join ====
 +
 +  * synchronized – zajišťuje, že kód (kritická sekce) provádí v daném čase jen jedno vlákno
 +  * volatile – proměnná může být měněna z více vláken, JVM nezachová její hodnotu v cache (když se změní na false - informuje to ostatní vlákna, ale ne jako counter)
 +  * join() – čeká na dokončení jiného vlákna
 +  * wait() / notify() – vlákna čekají a signalizují si mezi sebou (pouze uvnitř synchronized bloku)
 +
 +==== Thread Pool (Executor) ====
 +
 +Používá se místo ručního vytváření velkého počtu vláken. Efektivnější správa a recyklace.
 +
 +<markdown>
 +```java
 +ExecutorService executor = Executors.newFixedThreadPool(4);
 +executor.submit(new WorkerRunnable(1, 10));
 +executor.shutdown();
 +```
 +</markdown>
 +
 +  * ExecutorService – spravuje vláknový pool
 +  * submit() – spustí úkol
 +  * shutdown() – ukončí Executor
 +  * Future – objekt s výsledkem nebo stavem asynchronního výpočtu
 +
 +==== Kdy použít paralelismus ====
 +
 +  * Více úloh může běžet souběžně – více jádrový procesor
 +  * Aplikace provádí dlouhé IO operace, ale musí zůstat responzivní (např. GUI)
 +  * Kontrola nebo úkoly na pozadí (např. notifikace, synchronizace)
 +

Trace: • b6b36ts1 • b4b35osy • be4b39vgo • b4b38psia • b4b39hry

Navigation

Playground

QR Code
QR Code statnice:bakalar:b0b36pjv (generated for current page)