ThreadLocal, ThreadLocalRandom

Bu derste, genel olarak java.lang.ThreadLocal<> sınıfıyla çalışmaktan ve onu çok iş parçacıklı bir ortamda nasıl kullanacağımızdan bahsedeceğiz .

ThreadLocal sınıfı , değişkenleri depolamak için kullanılır. Bu sınıfın ayırt edici bir özelliği, kendisini kullanan her iş parçacığı için bir değerin ayrı ve bağımsız bir kopyasını tutmasıdır.

Sınıfın işleyişini daha derinlemesine incelersek, dizileri, kullanması gerektiğinde uygun değeri aldığı mevcut iş parçacığının değerlerle eşlediği bir Harita hayal edebiliriz.

ThreadLocal sınıf yapıcısı

Yöntemler

hazırlan()

İki sayaç oluşturduğumuz bir örnek yazalım. Sıradan bir değişken olan ilki, iş parçacığı sayısını saymak için olacaktır. İkincisi, bir ThreadLocal içine saracağız . Ve birlikte nasıl çalıştıklarını göreceğiz. Öncelikle, Runnable'ı devralan ve verilerimizi ve çok önemli run() yöntemini içeren bir ThreadDemo sınıfı yazalım . Sayaçları ekranda görüntülemek için bir yöntem de ekleyeceğiz:

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());
    }
}

Sınıfımızın her çalışmasında,tezgahdeğişkeni, ThreadLocal değişkeninden veri almak için get() yöntemini çağırır . Yeni iş parçacığında veri yoksa, onu 0 olarak ayarlayacağız. Veri varsa, onu bir artıracağız. Ve ana yöntemimizi yazalım :

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();

}

Sınıfımızı çalıştırırken, ThreadLocal değişkeninin ona erişen thread ne olursa olsun aynı kaldığını fakat thread sayısının arttığını görüyoruz.

kaldırmak()

Remove yönteminin nasıl çalıştığını anlamak için ThreadDemo sınıfındaki kodu biraz değiştireceğiz :

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

Bu kodda, thread sayacı çift sayı ise, ThreadLocal değişkenimiz üzerinde remove() metodunu çağıracağız . Sonuç:

Ve burada kolayca ikinci iş parçacığındaki ThreadLocal değişkeninin null olduğunu görüyoruz .

ThreadLocal.withInitial()

Bu yöntem, yerel bir iş parçacığı değişkeni oluşturur.

ThreadDemo sınıfının uygulanması :

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());
    }
}

Ve kodumuzun sonucuna bakabiliriz:

Neden bu tür değişkenleri kullanmalıyız?

ThreadLocal, java.lang.Thread yürütme iş parçacığına ilişkin olarak yerel değişkenler üzerinde bir soyutlama sağlar.

ThreadLocal değişkenleri, her iş parçacığının , get() ve set() yöntemleriaracılığıyla erişilen kendi, bireysel olarak başlatılmış değişken örneğine sahip olması bakımından sıradan değişkenlerden farklıdır

Her iş parçacığı, yani Thread sınıfı örneği , kendisiyle ilişkili ThreadLocal değişkenlerinin bir haritasına sahiptir . Haritanın anahtarları, ThreadLocal nesnelerine referanslardır ve değerler, "edinilmiş" ThreadLocal değişkenlerine referanslardır .

Random sınıfı, çok iş parçacıklı uygulamalarda rasgele sayılar üretmek için neden uygun değil?

Rastgele sayılar elde etmek için Random sınıfını kullanırız . Ancak çok iş parçacıklı bir ortamda da aynı şekilde çalışıyor mu? Aslında hayır. Rastgele, çok iş parçacıklı ortamlar için uygun değildir, çünkü birden çok iş parçacığı bir sınıfa aynı anda eriştiğinde performans düşer.

Bu sorunu çözmek için JDK 7, çok iş parçacıklı bir ortamda rasgele sayılar üretmek için java.util.concurrent.ThreadLocalRandom sınıfını tanıttı. İki sınıftan oluşur: ThreadLocal ve Random .

Bir iş parçacığı tarafından alınan rasgele sayılar diğer iş parçacıklarından bağımsızdır, ancak java.util.Random genel olarak rasgele sayılar sağlar. Ayrıca, Random'dan farklı olarak , ThreadLocalRandom açık tohumlamayı desteklemez. Bunun yerine, Random öğesinden devralınan setSeed() yöntemini geçersiz kılar , böylece çağrıldığında her zaman bir UnsupportedOperationException atar.

Şimdi ThreadLocalRandom sınıfının metotlarına bakalım :

ThreadLocalRandom.current() kullanarak rasgele sayılar alma

ThreadLocalRandom, ThreadLocal ve Random sınıflarının birleşimidir. Random sınıfının örneklerine herhangi bir eşzamanlı erişimden kaçınarak çok iş parçacıklı bir ortamda daha iyi performans elde eder.

Birden fazla iş parçacığı içeren bir örnek uygulayalım ve uygulamamızın ThreadLocalRandom sınıfıyla ne yaptığını görelim:

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));
    }
}

Programımızın sonucu:

Şimdi RandomNumbers sınıfımızı değiştirelim ve içinde Random kullanalım:

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

Random ve ThreadLocalRandom sınıfları arasındaki farkları özetlemek ve yinelemek için :