Vlakna(Threads) - priorita – Java – Fórum – Programujte.com

Ahojte hrál jsem si s prioritami vláken a nefunguje to správně. Můj zdroj si myslím, že mám tak jednoduchý že v něm chyba není. Podle mě je špatně naprogramována Java. Kód jsem si naprogramoval v takové logice kdy vlakna s určitou prioritou by měla proběhnout a nikoliv se uprostřed po instrukcích přepínat. ( žádnou metodu yield() v kódu nemám) . Přesto výpis

class Vlakna11 extends Thread {
	private String s;
	protected Vlakna11(String s,int priorita) {
		super(s);
		System.out.println("Konstruktor od vlakna\t"+s);
		this.setPriority(priorita);
		this.s=s;	}
	public void run() { 
		System.out.println(Thread.currentThread()+"\t"+s);   						
		int [] pole = new int [10000000];
		for(int i=0;i<pole.length;i++){
			pole[i]=i+i+i+i+i+i+i+i+i+i+i+i;	}
		System.out.println("Zde je vysledna hodnota :"+pole[9999999]+"\t vlakno :\t"+s);	}
}
public class Q_15VlaknaPriorita {
	public static void main(String [] args) {
		System.out.println("Zacatek programu");
		Vlakna11 vlakno1 = new Vlakna11("vlakno1",4);
		Vlakna11 vlakno2 = new Vlakna11("vlakno2",6);
		Vlakna11 vlakno3 = new Vlakna11("vlakno3",8);
		Vlakna11 vlakno4 = new Vlakna11("vlakno4",10);
		Vlakna11 vlakno5 = new Vlakna11("vlakno5",5);
		Vlakna11 vlakno6 = new Vlakna11("vlakno6",6);
		vlakno6.start();vlakno5.start();vlakno4.start();
		System.out.println("Testovaci vypis 1");
		vlakno3.start();vlakno2.start();vlakno1.start();
		System.out.println("Testovaci vypis 2");
		try {										
			vlakno1.join();vlakno2.join();
			vlakno3.join();vlakno4.join();
			vlakno5.join();vlakno6.join();} 
		catch (InterruptedException e) {
			e.printStackTrace();	}
		System.out.println("Konec programu");	}
}

Kromě toho že se výpis mění jak kdy, podle naprosto neznámé logiky, je to skutečně fascinující. Přikládám i výpis. Podle mě by celé vlákno mělo projet komplet a nikoliv se přepínat a to samozřejmě i včetně výpisu.

Zacatek programu

Konstruktor od vlakna vlakno1

Konstruktor od vlakna vlakno2

Konstruktor od vlakna vlakno3

Konstruktor od vlakna vlakno4

Konstruktor od vlakna vlakno5

Konstruktor od vlakna vlakno6

Thread[vlakno6,6,main] vlakno6

Testovaci vypis 1

Thread[vlakno3,8,main] vlakno3

Thread[vlakno4,10,main] vlakno4

Thread[vlakno2,6,main] vlakno2

Testovaci vypis 2

Thread[vlakno5,5,main] vlakno5

Zde je vysledna hodnota :119999988 vlakno : vlakno6

Zde je vysledna hodnota :119999988 vlakno : vlakno4

Zde je vysledna hodnota :119999988 vlakno : vlakno3

Thread[vlakno1,4,main] vlakno1

Zde je vysledna hodnota :119999988 vlakno : vlakno2

Zde je vysledna hodnota :119999988 vlakno : vlakno5

Zde je vysledna hodnota :119999988 vlakno : vlakno1

Konec programu

A na jakém OS to zkoušíš?

Win7 Prof - 32 bit - verze ENG

Java 7 update 21

Podle mě by celé vlákno mělo projet komplet a nikoliv se přepínat a to samozřejmě i včetně výpisu.

Ne.

#4 zlz
Takové typy příspěvků si strč do prdele. Buď se vyjádři konstruktivně anebo radši drž hubu. Nejsem na tento typ neinformace vůbec zvědav.

#5 NotBeginner
no jen rika, ze nemas pravdu... a to opravdu nemas... vlakna bezi libovolne dlouho a pokud by se cekalo na to, aby se cele vlakno dokoncilo a pak se teprve spustilo dalsi - tak bys ani nejak moc nemusel pouzivat dalsi vlakna...

nejprve si tedy precti o tom jak vlakna funguji (a to i v ramci jednotlivych OS), pak az se ptej na to, co presne nechapes

#6 KIIV
 

Špatně jsi pochopil můj text "vlákno mělo projet komplet" není myšleno že běží sériově za sebou. Ok, nezpochybňuji, že vlákna běží vedle sebe, nicméně priorita je prostě priorita. Procesor či OS by měl toto brát v potaz a při přepínání vláken by měly nejdřív proběhnout vlákna s vyšší prioritou. Proto jsem na svém dvoujádru udělal vláken 6 s různými prioritami. Ať se to někomu líbí či nikoliv v mém pokusu musí proběhnout první komplet vlákno4 vedle něj vlákno3 a pak až přijde řada na ostatní tak ten zbytek vlaken s nižší prioritou.

priorita je ze vlakno dostava casteji procesorovy cas... prepina se v zavislosti na systemu.. treba kazdych par milisekund a neda se pri tom spolehnout na moc veci... ani na to co nastartuje driv... ani jestli se nezastavi v pulce vypisu a tak... (zalezi jak je to vypisovani reseny .. a jestli ma nejaky zamky)

mimo to treba v linuxu je mensi cislo vetsi priorita ... tezko rict jestli to java nejak prevadi

Java samozřejmě mapuje svoje priority na priority v daném OS, ale problémů je tady víc. Jednak jak píše KIIV je jen věcí OS, jak s prioritami zachází a spoléhat se na něco u vláken je prostě chyba. Od toho jsou synchronizační prostředky. Další věc je, že ty máš dvoujádro, ale kolik umí dělat najednou vláken (jestli se v tom dneska vůbec někdo vyzná :)) ? A dále, tvůj příklad je řekněme velmi neprůkazný. Jednak spoléháš na výpisy, ale bez kritických sekcí a pak taky délka výpočtu není nijak velká a dále by si nejspíše měl vlákna spouštět najednou, tj. aby všechna vlákna čekala na začátku na nějaký semafor atd.

Problém vláken a priorit je poměrně složitá věc. A vzhledem k tomu, že začínáš "popírat", co si napsal :), tak si to asi taky začínáš uvědomovat.

V žádném případě nepopírám co jsem napsal. Věta " Podle mě by celé vlákno mělo projet komplet " netvrdí nic o tom, že vlakna neběží vedle sebe. To je nějaká tvoje či vaše doměnka. To, že jsem v kontextu mé věty provedl náznak ustoupení bylo projevem zdvořilosti. Prosil bych soustředte se na psaný text. Evidetně se ukazuje že i kluci v IT mají problém pochopením psaného textu.

Ve spoustě literatuře např. Herout Učebnice jazyka Java str 351  cituji " Každé vlákno má nastaveno svoji prioritu, podle které se řídí plánovač běhu vláken. Znamená to, že jsou-li běhuschopná dvě vlákna, bude vždy předáno řízení vláknu s vyšší prioritou."

- samozřejmě se nabízí možnost že Herout se v tomto náhodném případě mohl zmýlit. Podle pochopení daného citátu, by plánovač vláken se měl rozhodoval během vykonávání instrukcí v metodě run() a vždycky by se měl spustit vlákno s nejvyšší prioritou a tudíž by mělo první skončit vlákno4(proběhnout komplet celé).

Taktéž i jinde se píše ale už si nevzpomenu kde jsem to četl že proběhnout má celé vlákno( myšleno celý run() ) s nejvyšší prioritou.

PS. vzhledem k tomu, že diskuze na dané téma se ubírá úplně odlišným směrem, místo toho abychom si zde předvedli nějaké funkční kódy na priority vláken, považoval bych to asi za ukončené. V každém případě díky, že jste mi tu řekli, že ty priority vláken fungují nesystematicky(prakticky nefungují vůbec a tudíž jsou přesné paralelní algorytmy nepoužitelné).

Každé vlákno má nastaveno svoji prioritu, podle které se řídí plánovač běhu vláken. Znamená to, že jsou-li běhuschopná dvě vlákna, bude vždy předáno řízení vláknu s vyšší prioritou.

se můžu Herouta v pondělí zeptat, jestli chceš :) Vlákno určitě celé ne vždy projede, může se zaseknout na nějakém zdroji a potom ho OS přeplánuje a pustí jiné vlákno. Nicméně jsem zkusil jednu věc :

class Vlakna11 extends Thread {
	private String s;
	private Semaphore b;
        protected Vlakna11(String s,int priorita, Semaphore b) {
		super(s);
		this.setPriority(priorita);
		this.s = s;	
                this.b = b;
        }

	public void run() 
	{ 
        	b.acquire();
        	System.out.println(s);   						
        }
}

class Q_15VlaknaPriorita {
    public static void main(String [] args) {
        
        Semaphore b = new Semaphore(1);
        Vlakna11 vlakno1 = new Vlakna11("vlakno1",1,b);
        Vlakna11 vlakno2 = new Vlakna11("vlakno2",2,b);
        Vlakna11 vlakno3 = new Vlakna11("vlakno3",3,b);
        Vlakna11 vlakno4 = new Vlakna11("vlakno4",4,b);
        Vlakna11 vlakno5 = new Vlakna11("vlakno5",5,b);
        Vlakna11 vlakno6 = new Vlakna11("vlakno6",6,b);
        //uzavření semaforu dokud nebudou všechna vlákna vytv 
        b.acquire();
        vlakno6.start();vlakno2.start();vlakno3.start();vlakno           4.start();vlakno5.start();vlakno1.start();
        b.release();
    }
}

všechna vlákna jsem nechal zaseknout se na semaforu a potom, až jsou všechna spuštěna a zablokována jsem semafor uvolnil. Dne mého názoru by poté mělo být odblokováno vlákno s největší prioritou. No bohužel se mi jeví že, vlákna jsou spouštěna poměrně náhodně. 

Btw: Úplně se bojím kliknout na "odeslat", až mě Matěj sjede za pojmenování proměnnejch :D

#10 NotBeginner
Takže ještě jednou:

- priorita vláken nemá nic společného s Javou, ale s OS, kde program v Javě běží

- to jak OS nakládá s prioritami je jeho věc a pokud se ti to nelíbí, tak si napiš svůj OS, kde vlákna s vysokou prioritou budou mít vždy absolutní přednost a uvidíš, že to bude nepoužitelné.

- napsal jsem ti, že to zkoušíš na špatném příkladu nebo-li stejně jako v pohádce Sůl nad zlato dokazuješ slanečkem pachuť soli, protože kupříkladu, když jsem vzal ten tvůj příklad a rozšířil ho na 36 vláken (neb mám 6 jader), tak výpočet některých vlákem skončil dřív než se stačila všechna vytvořit, i to jsem ti vytknul a TheOndrap ukázal jak na to 

Nemá to cenu dále rozmazávat. Tady je příklad:

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;


class Vlakna11 extends Thread {
	private String s;
	protected Vlakna11(String s,int priorita) {
		super(s);
		System.out.println("Konstruktor od vlakna\t"+s);
		this.setPriority(priorita);
		this.s=s;	
	}

	public void run() { 		
		String a = new String();

		a = Thread.currentThread() + "\t" + s;
		System.out.println(a);   		
				
		for(int i=0;i<20;i++){
			try {
				for (int j = 0;j < 10000;j++) {
					a = sha1(sha1(sha1(a)));
				}
			}
			catch(NoSuchAlgorithmException e) {
			}
			//System.out.println(s + " - pruchod " + i);	
		}
		System.out.println(s + " - vysledek: " + a);	
	}

	static String sha1(String input) throws NoSuchAlgorithmException {
	        MessageDigest mDigest = MessageDigest.getInstance("SHA1");
        	byte[] result = mDigest.digest(input.getBytes());
	        StringBuffer sb = new StringBuffer();
        	for (int i = 0; i < result.length; i++) {
	            sb.append(Integer.toString((result[i] & 0xff) + 0x100, 16).substring(1));
        	}
         
	        return sb.toString();
	}
}
public class Q_15VlaknaPriorita {
	public static void main(String [] args) {
		System.out.println("Zacatek programu");

		Vlakna11[] vlakna = new Vlakna11[36];

		for (int i = 0;i < 36;i++) {
			vlakna[i] = new Vlakna11("vlakno" + i, i / 4 + 1);
		}


		for (int i = 0;i < 36;i++) {
			vlakna[i].start();
		}

		try {	
			for (int i = 0;i < 36;i++) {
				vlakna[i].join();
			}
			
		} 
		catch (InterruptedException e) {
			e.printStackTrace();	
		}
		
		System.out.println("Konec programu");	
	}
}

a na něm můžeš vidět, že nejdříve končí vlákna s vyšší prioritou. A tak je to správně. OS dává vláknům s vyšší prioritou větší procenta časových kvant procesoru, ale nic víc a nic míň. Pokud ses chtěl spoléhat na prioritu vláken, tak to je nejčastější chyba začátečníků, že místo synchronizačních prostředků typu semafor, mají pocit, že to přece musí fungovat tak, jak oni předpokládají. Základní pravidlo u vláken je: nemůžeš si být jist ničím.

Takže výsledek je takový, že to funguje podle očekávání - vlákna s vyšší prioritou dostávají přiděleno více času procesoru (tečka).

No a tady je výsledek na mém stroji:

vlakno33 - vysledek: 9ae7d6730623616e58ca7cfb38d0e96a51322a67
vlakno35 - vysledek: e1da993e7a7ec49280be1ca8b9a6be9a80a43676
vlakno32 - vysledek: 6ba42c23a6b472ebc3dd7bfdbbcf213a75d17d89
vlakno28 - vysledek: 3a6c7934ff45168aee01722bf2bc4832b3b4523f
vlakno34 - vysledek: 6b6dd7bbb091e8de2da9d2f4c513d3d44a739b33
vlakno30 - vysledek: 1a590d85b1c80603fc8d3eb22c6d2d040e551a58
vlakno31 - vysledek: 57375cd00e0e0f039ab9a1bff33227b90e311e85
vlakno24 - vysledek: cd2ded4f3c27a43cfb72e89d0745c9a8e1819e05
vlakno29 - vysledek: 72ff08f5178653462c34940795ecec1aae9cc0ef
vlakno25 - vysledek: 2d7fc3cfa540bcb7e0583f341539efca3f4e2f28
vlakno26 - vysledek: 36b79274db0a62a49926c1891dbbfd9110039e44
vlakno27 - vysledek: 81068c4a383287b42d88c1370684c9b9078f4077
vlakno21 - vysledek: f4df7dc9171b4ce3ecd02e46d0515c6da176d1a1
vlakno16 - vysledek: 12b5bd7ae8a7ee0daef07a092fdaa457c59e9958
vlakno19 - vysledek: 5e56825097fd99ab72980a24b19d06991fac9d0d
vlakno18 - vysledek: 68c5bb5e7f01b54122bb9e44577fe4d021c2b7d9
vlakno20 - vysledek: e0d5f8c6dc079d2dddf1e3349b3d4597f5318f18
vlakno22 - vysledek: b55046c53f826d9853b465c9f15a9a091e735c8a
vlakno23 - vysledek: 9d5bf47ba5e4d31efd296ccdf7469103caa71a89
vlakno17 - vysledek: 972505f1a0726c3f83d09a7f9801dc1c9b0e68e8
vlakno14 - vysledek: 56c41d6bc1b6581be54f38a2291733b4a42b31c7
vlakno13 - vysledek: 2147c66382486e6432206458b8ed34ea6c52171f
vlakno12 - vysledek: c26eb8f615d72b37cd9b4cfa922bb8a0cb54c4ab
vlakno9 - vysledek: 97797dd3bcf6fc9bf919442def3f6b472164393a
vlakno11 - vysledek: 51e7d9591fed7cf316116441d2f65cdf6f0bd037
vlakno10 - vysledek: d61d7cd2df6c0e3a3588a1722ebc1ea687fc5191
vlakno15 - vysledek: a93a4e1aada2a6beaaf5b8155589160f23ee328b
vlakno8 - vysledek: c0743e651aac8dd011b1d2aa00e44989fa00d392
vlakno6 - vysledek: d6749abe67353694d711c43789a529dcd909441c
vlakno1 - vysledek: d597c5eb0b1f8a74b85158e39849190a82daf6ba
vlakno0 - vysledek: 06b7da255a2a69f3411c06e7e2e688cce36a75c8
vlakno7 - vysledek: 747d5f6f624ae85327a8b0419c1057c7409cf701
vlakno2 - vysledek: e3b3ef05c48ebd5cd8851a67b945e937e3762fdc
vlakno3 - vysledek: 4142bbebb8a6865e8a9d7247f6cd8402e18f56a8
vlakno5 - vysledek: 9787901c88cdc1c432fc710ed50bb16e74d8080f
vlakno4 - vysledek: 6e296ef8ece05d6208f3ee3a91d28462f004cb54
Konec programu

nastaveni priority vlaken v JVM bylo kdysi zbozne prani lidi v Sunu. v realu je to zavisle na architekture CPU a OS. pokud si prectes JLS, tak zjistis ze se na tohle v zadnem pripade nemas spolehat protoze se ten planovac claken muze v dalsi verzi JVM zmenit a tvuj program muze v dusledku toho prestat spravne fungovat.

dokumentace k setPriority(int): http://docs.oracle.com/…/Thread.html#… - je to podmenene nekolika vecmi (procti si i reference v "see also")

dal si precti tenhle bug report http://bugs.sun.com/view_bug.do?… - vsimni si "resolution: won't fix" a tahle citace "Another excellent reference is Josh Bloch's "Effective Java", Item 51, "Don't depend on the thread scheduler"." - "rada 51, nespolehejte na planovace vlaken" taky doporucuju precist, klidne celou knihu (ma i druhe vydani ;) ). je to bestseller od Java architekta ktery napsal JCF (Java Collection Framework, cili kolekce v jave) a ted dela v Google.

Ted jeste trochu osobni poznamka - opravdu si myslis ze jsi chytrejsi nez tym inzenyru? takovych lidi je malo ;) trochu pokory :) (nerikam zohnout pred kazdym zada)