Vlákna (mohli jsme také někde slyšet "lightweight procesy") jsou mechanismus, který umožňuje souběžné vykonávání více činností (výpočetních úkonů). Jedno vlákno reprezentuje právě jednu posloupnost operací, která je prováděna v rámci nějakého procesu. Každý proces (z pohledu operačního systému) musí mít minimálně jedno vlákno, ale může jich mít více. Tato vlákna pak mohou sdílet zdroje (proměnné, objekty, přístupy k zařízením) a je třeba zabývat se okolnostmi jejich současného běhu hlavně z pohledu přístupu k těmto společným zdrojům.

Vlákna jsou v Javě "uchopitelná" pomocí objektů třídy Thread.

Vytvoříme je tedy buďto:

Každopádně jde o to napsat "někam" kód, který bude ve vlákně provádět.

class CounterThread extends Thread {
    // Tato metoda obsahuje kód, 
    // který bude vykonáván v našem vlákně 
    public void run() {
        for(int i = 0; i < 10; i++) {
            System.out.println(i);
        }
    }
}
 
// Vytvoříme nové vlákno
Thread counterThread = new CounterThread();
 
// spustíme vlákno, kód metody CounterThread.run()
// se od této chvíle začne vykonávat v novém vlákně
counterThread.start();
// !!! nevolat přímo counterThread.run(); !!!

class Counter implements Runnable {
    // Tato metoda obsahuje kód, 
    // který bude vykonáván v našem vlákně 
    public void run() {
        for(int i = 0; i < 10; i++) {
            System.out.println(i);
        }
    }
}
 
Runnable counter = new Counter();
 
// Vytvoříme nové vlákno, jako parametr
// konstruktoru předáme referenci na 
// naši implementaci rozhraní Runnable
Thread counterThread = new Thread(counter);
 
// spustíme vlákno, kód metody Counter.run()
// se od této chvíle začne vykonávat v novém vlákně
counterThread.start();

class Counter {
    // sdílená proměnná reprezentující stav objektu
    private int currentValue = 0;
    public synchronized int next() {
        // toto je kritická sekce, která musí proběhnout atomicky
        return ++currentValue;
    }
}

	Poznámka
	Celá metoda se zamkne monitorem objektu "this" - vždy.

class Counter {
    // sdílená proměnná reprezentující stav objektu
    private int currentValue = 0;
    public int next() {
        synchronized(this) {
            // toto je kritická sekce, která musí proběhnout atomicky
            return ++currentValue;
        }
    }
}

	Poznámka
	Blok se zamkne se monitorem objektu "this" - mohli bychom i jiným.

Nadbytečná synchronizace může zejména na moderních architekturách představovat zbytečnou zátěž navíc a zpomalení běhu aplikace. Proto bychom měli synchronizovat právě to, co je třeba. Co není třeba synchronizovat?

class Counter {
    private static int currentValue = 0;
    public synchronized int next() {
        return ++currentValue;
    }
}

class Counter {
    private static int currentValue = 0;
    public synchronized int next() {
        return ++currentValue;
    }
}

	Poznámka
	Při volání next se zamyká pouze instance Counter, nikoli sdílená hodnota (protože ta je static, společná všem objektům Counter).

class Counter {
    private int currentValue = 0;
    private static Object LOCK = new Object();
    public int next() {
        synchronized(LOCK) {
            return ++currentValue;
        }
    }
}

class Counter {
    private int currentValue = 0;
    private static Object LOCK = new Object();
    public int next() {
        synchronized(LOCK) {
            return ++currentValue;
        }
    }
}

	Poznámka
	Při volání next se nesprávně zamyká přes LOCK, který je společný všem instancím Counter, ostatní "Countery" budou zbytečně blokovány.

public class SomeThreadSafeClass {
 
    private List<String> data = Collections.synchronizedList(new ArrayList<String>());
 
    public void addData(String newObject) {
        data.add(newObject);
    }
 
    public synchronized void dumpData() {
        for(String s : data) {
            System.out.println(s);
        }
    }
 
}

public class SomeThreadSafeClass {
 
    private List<String> data = Collections.synchronizedList(new ArrayList<String>());
 
    public void addData(String newObject) {
        data.add(newObject);
    }
 
    public synchronized void dumpData() {
        for(String s : data) {
            System.out.println(s);
        }
    }
 
}

	Poznámka
	Chybou je synchronizovat jen dumpData a ne addData, protože takto během iterace v dumpData klidně proběhne (nevyloučené) vložení do kolekce data a ta se při iteraci stane nekonzistentní.

Sun Java tutoriál, kapitoly k souběžnému počítání (concurrency)

Wiki FI: