ThreadLocal, ThreadLocalRandom

Dalam pelajaran ini, kita akan berbicara secara umum tentang bekerja dengan kelas java.lang.ThreadLocal<> dan bagaimana menggunakannya dalam lingkungan multithreaded.

Kelas ThreadLocal digunakan untuk menyimpan variabel. Fitur khas dari kelas ini adalah bahwa ia menyimpan salinan nilai yang terpisah untuk setiap utas yang menggunakannya.

Menggali lebih dalam operasi kelas, kita bisa membayangkan Peta yang memetakan utas ke nilai, dari mana utas saat ini mengambil nilai yang sesuai saat perlu menggunakannya.

konstruktor kelas ThreadLocal

Metode

dapatkan() & atur()

Mari kita tulis contoh di mana kita membuat dua penghitung. Yang pertama, variabel biasa, untuk menghitung jumlah utas. Yang kedua kita akan membungkus ThreadLocal . Dan kita akan melihat bagaimana mereka bekerja sama. Pertama, mari kita tulis kelas ThreadDemo yang mewarisi Runnable dan berisi data kita dan metode run() yang sangat penting . Kami juga akan menambahkan metode untuk menampilkan penghitung di layar:

class ThreadDemo implements Runnable {

    int counter;
    ThreadLocal<Integer> threadLocalCounter = new ThreadLocal<>();

    public void run() {
        counter++;

        if(threadLocalCounter.get() != null) {
            threadLocalCounter.set(threadLocalCounter.get() + 1);
        } else {
            threadLocalCounter.set(0);
        }
        printCounters();
    }

    public void printCounters(){
        System.out.println("Counter: " + counter);
        System.out.println("threadLocalCounter: " + threadLocalCounter.get());
    }
}

Dengan setiap menjalankan kelas kami, kami meningkatkanmenangkalvariabel memanggil metode get() untuk mendapatkan data dari variabel ThreadLocal . Jika utas baru tidak memiliki data, maka kami akan menetapkannya menjadi 0. Jika ada data, kami akan menambahnya satu. Dan mari kita tulis metode utama kita:

public static void main(String[] args) {
    ThreadDemo threadDemo = new ThreadDemo();

    Thread t1 = new Thread(threadDemo);
    Thread t2 = new Thread(threadDemo);
    Thread t3 = new Thread(threadDemo);

    t1.start();
    t2.start();
    t3.start();

}

Menjalankan kelas kami, kami melihat bahwa variabel ThreadLocal tetap sama terlepas dari utas yang mengaksesnya, tetapi jumlah utas bertambah.

menghapus()

Untuk memahami cara kerja metode hapus , kami hanya akan sedikit mengubah kode di kelas ThreadDemo :

if(threadLocalCounter.get() != null) {
      threadLocalCounter.set(threadLocalCounter.get() + 1);
  } else {
      if (counter % 2 == 0) {
          threadLocalCounter.remove();
      } else {
          threadLocalCounter.set(0);
      }
  }

Dalam kode ini, jika penghitung utas adalah bilangan genap, maka kita akan memanggil metode remove() pada variabel ThreadLocal kita. Hasil:

Dan di sini kita dengan mudah melihat bahwa variabel ThreadLocal di utas kedua adalah null .

ThreadLocal.withInitial()

Metode ini membuat variabel thread-local.

Implementasi kelas ThreadDemo :

class ThreadDemo implements Runnable {

    int counter;
    ThreadLocal<Integer> threadLocalCounter = ThreadLocal.withInitial(() -> 1);

    public void run() {
        counter++;
        printCounters();
    }

    public void printCounters(){
        System.out.println("Counter: " + counter);
        System.out.println("threadLocalCounter: " + threadLocalCounter.get());
    }
}

Dan kita dapat melihat hasil dari kode kita:

Mengapa kita harus menggunakan variabel seperti itu?

ThreadLocal menyediakan abstraksi atas variabel lokal terkait dengan utas eksekusi java.lang.Thread .

Variabel ThreadLocal berbeda dari yang biasa karena setiap utas memiliki instance variabel yang diinisialisasi sendiri-sendiri, yang diakses melalui metode get() dan set() .

Setiap utas, yaitu turunan dari kelas Utas , memiliki peta variabel ThreadLocal yang terkait dengannya. Kunci peta adalah referensi ke objek ThreadLocal , dan nilainya adalah referensi ke variabel ThreadLocal yang "diperoleh" .

Mengapa kelas Acak tidak cocok untuk menghasilkan angka acak dalam aplikasi multithreaded?

Kami menggunakan kelas Random untuk mendapatkan angka acak. Tetapi apakah itu berfungsi dengan baik di lingkungan multithreaded? Sebenarnya tidak. Acak tidak cocok untuk lingkungan multithread, karena ketika banyak utas mengakses kelas pada saat yang sama, kinerja akan menurun.

Untuk mengatasi masalah ini, JDK 7 memperkenalkan kelas java.util.concurrent.ThreadLocalRandom untuk menghasilkan angka acak di lingkungan multithreaded. Ini terdiri dari dua kelas: ThreadLocal dan Random .

Nomor acak yang diterima oleh satu utas tidak bergantung pada utas lainnya, tetapi java.util.Random menyediakan nomor acak global. Selain itu, tidak seperti Random , ThreadLocalRandom tidak mendukung penyemaian eksplisit. Sebagai gantinya, metode ini menimpa metode setSeed() yang diwarisi dari Random , sehingga selalu melontarkan UnsupportedOperationException saat dipanggil.

Mari kita lihat metode kelas ThreadLocalRandom :

Mendapatkan nomor acak menggunakan ThreadLocalRandom.current()

ThreadLocalRandom adalah kombinasi dari kelas ThreadLocal dan Random . Ini mencapai kinerja yang lebih baik dalam lingkungan multithread hanya dengan menghindari akses bersamaan ke instance kelas Random .

Mari terapkan contoh yang melibatkan banyak utas dan lihat aplikasi kita melakukannya dengan kelas ThreadLocalRandom :

import java.util.concurrent.ThreadLocalRandom;

class RandomNumbers extends Thread {

    public void run() {
        try {
            int bound = 100;
            int result = ThreadLocalRandom.current().nextInt(bound);
            System.out.println("Thread " + Thread.currentThread().getId() + " generated " + result);
        }
        catch (Exception e) {
            System.out.println("Exception");
        }
    }

    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();

				for (int i = 0; i < 10; i++) {
            RandomNumbers randomNumbers = new RandomNumbers();
            randomNumbers.start();
        }

        long endTime = System.currentTimeMillis();

        System.out.println("Time taken: " + (endTime - startTime));
    }
}

Hasil dari program kami:

Dan sekarang mari kita ubah kelas RandomNumbers kita dan gunakan Random di dalamnya:

int result = new Random().nextInt(bound);

Untuk meringkas dan mengulangi perbedaan antara kelas Random dan ThreadLocalRandom :