Pausa caffè #160. Approfondimento in Java ThreadLocal. Classe scanner in Java

Approfondimento su Java ThreadLocal

Fonte: Devgenios Oggi imparerai a conoscere ThreadLocal, una delle classi più comuni utilizzate nello sviluppo di applicazioni Java.

Cos'è ThreadLocal?

La classe ThreadLocal memorizza variabili locali per i thread. Queste variabili sono isolate tra thread diversi e sono accessibili solo dal proprio thread. Casi d'uso per ThreadLocal :

1. Isolare i dati tra i thread.
2. Gestione delle sessioni per le connessioni al database.
3. Memorizzazione delle informazioni sulle transazioni del thread.

Come utilizzare ThreadLocal?

Diamo un'occhiata a un semplice esempio.

public static void main(String[] args) {
    //Создаем ThreadLocal
    ThreadLocal<String> local = new ThreadLocal<>();
    //Создаем новый класс Random
    Random random = new Random();
    //Создаем 5 потоков
    IntStream.range(0, 5).forEach(a-> new Thread(()-> {
        //Присваиваем meaning каждому потоку
        local.set(a+"  "+random.nextInt(100));
        System.out.println("Thread number and its local value  "+ local.get());
    }).start());
}

Nel codice sopra, creiamo una classe ThreadLocal , creiamo 5 thread, assegniamo un valore a ThreadLocal in ogni thread e stampiamo. Durante l'output otteniamo:

Cosa c'è sotto il cofano?

Se osservi attentamente, puoi vedere che esistono due metodi importanti in ThreadLocal da questo esempio di codice.

• pubblico T get() {}

• insieme pubblico nullo (valore T) {}

Diamo un'occhiata al metodo setter nel codice sorgente ThreadLocal :

public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
}

Il metodo setter innanzitutto ottiene il thread corrente e chiama il metodo getMap() per ottenere la classe ThreadLocalMap . Se map esiste, prendi il flusso corrente t come chiave, il parametro di input come valore e imposta la coppia {chiave:valore} su map. In caso contrario, crea una mappa . Ora potresti avere una domanda: cos'è ThreadLocalMap ?

static class ThreadLocalMap {
   /**
    * The entries in this hash map extend WeakReference, using
    * its main ref field as the key (which is always a
    * ThreadLocal object).  Note that null keys (i.e. entry.get()
    * == null) mean that the key is no longer referenced, so the
    * entry can be expunged from table.  Such entries are referred to
    * as "stale entries" in the code that follows.
    */
    static class Entry extends WeakReference<ThreadLocal<?>> {
       /** The value associated with this ThreadLocal. */
       Object value;
       Entry(ThreadLocal<?> k, Object v) {
           super(k);
           value = v;
       }
    }
}

ThreadLocalMap è una classe statica interna in ThreadLocal che definisce una classe Entry per archiviare i dati. Entry utilizza l' istanza ThreadLocal come chiave e imposta il valore che passiamo. Se a questo punto sembra troppo confuso, ricorda semplicemente che è la classe Entry in ThreadLocalMap che esegue l'effettiva memorizzazione dei valori. Per ottenere dati da ThreadLocal utilizziamo il metodo getter :

public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
}

Nel metodo getter , utilizzeremo currentThread come chiave per ottenere ThreadLocalMap . Quindi map getEntry () in base all'istanza ThreadLocal e restituirà l' istanza Entry e quindi il valore memorizzato. Ecco uno schema per aiutarti a capirlo:

1. Ogni thread mantiene un riferimento a ThreadLocalMap .

2. ThreadLocalMap è una classe statica interna di ThreadLocal e utilizza la classe Entry per l'archiviazione.

3. Una chiave ThreadLocalMap è un'istanza di ThreadLocal e può avere più ThreadLocal .

4. ThreadLocal stesso non memorizza un valore, ma è una chiave per il thread che aiuterà a ottenere il valore da ThreadLocalMap .

Da notare che è meglio rimuovere ThreadLocal per evitare OOM (Out-of-Memory Error) a causa di un riferimento “debole” nella classe Entry .

Classe scanner in Java

Fonte: Medium Questo post ti aiuterà a familiarizzare con la classe Scanner in Java. La classe Scanner in Java è una classe che utilizziamo quando vogliamo ottenere un valore dall'utente. Il modo più semplice per capirlo è con gli esempi, quindi vediamolo più chiaramente. La creazione di una classe Scanner è uno dei tre passaggi che eseguiamo per ottenere un valore dall'utente. Il primo passo è creare un oggetto dalla classe scanner.

Scanner scan=new Scanner(System.in);

Ora abbiamo un oggetto scanner. Questo oggetto avrà le proprietà Scanner della classe Scanner . Dopo il primo passaggio, l'utente può già inserire il valore desiderato, ma se non guidiamo l'utente e non visualizziamo il valore nella console o nell'applicazione, non sarà molto buono in termini di usabilità. Pertanto è meglio informare e guidare l’utente:

System.out.println("Please enter your name");
String name=scan.next();
System.out.println("Your Name:"+name);

Nella prima riga chiediamo all'utente cosa vogliamo da lui. Questo in realtà non ha nulla a che fare con lo scanner, ma è sempre bene dare suggerimenti ai tuoi utenti. Nella seconda riga assegneremo il valore che l'utente inserisce nei dati e lo salveremo per poterlo utilizzare in seguito. Nell'ultima riga vediamo che possiamo utilizzare il valore ricevuto dall'utente a nostra discrezione. Aggiungiamo qualche dettaglio in più al nostro codice:

System.out.println("Please enter your last name");

String lastName=scan.next();

System.out.println("Your Name " + name + " " + "Your Last Name" + lastName);

Fondamentalmente, abbiamo ripetuto le due righe precedenti, abbiamo chiesto il valore all'utente e lo abbiamo salvato. Ora nell'ultima riga abbiamo utilizzato due valori che abbiamo preso dall'utente e che ora vengono utilizzati insieme.