ThreadLocal, ThreadLocalRandom

Trong bài học này, chúng ta sẽ nói chung về cách làm việc với lớp java.lang.ThreadLocal<> và cách sử dụng nó trong môi trường đa luồng.

Lớp ThreadLocal được sử dụng để lưu trữ các biến. Một tính năng đặc biệt của lớp này là nó giữ một bản sao độc lập riêng biệt của một giá trị cho mỗi luồng sử dụng nó.

Tìm hiểu sâu hơn về hoạt động của class, chúng ta có thể hình dung ra một Map ánh xạ luồng tới giá trị, từ đó luồng hiện tại lấy giá trị phù hợp khi cần sử dụng.

Hàm tạo lớp ThreadLocal

phương pháp

được thiết lập()

Hãy viết một ví dụ trong đó chúng ta tạo hai bộ đếm. Đầu tiên, một biến thông thường, sẽ dùng để đếm số luồng. Thứ hai, chúng tôi sẽ bọc trong một ThreadLocal . Và chúng ta sẽ xem cách họ làm việc cùng nhau. Trước tiên, hãy viết một lớp ThreadDemo kế thừa Runnable và chứa dữ liệu của chúng ta cũng như phương thức run() cực kỳ quan trọng . Chúng tôi cũng sẽ thêm một phương thức để hiển thị bộ đếm trên màn hình:

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

Với mỗi lần chạy của lớp chúng tôi, chúng tôi tăngquầy tính tiềnbiến gọi phương thức get() để lấy dữ liệu từ biến ThreadLocal . Nếu luồng mới không có dữ liệu, thì chúng tôi sẽ đặt nó thành 0. Nếu có dữ liệu, chúng tôi sẽ tăng nó lên một. Và hãy viết phương thức chính của chúng ta :

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

}

Chạy lớp của chúng tôi, chúng tôi thấy rằng biến ThreadLocal vẫn giữ nguyên bất kể luồng nào truy cập nó, nhưng số lượng luồng tăng lên.

di dời()

Để hiểu cách hoạt động của phương thức xóa , chúng ta sẽ chỉ thay đổi một chút mã trong lớp ThreadDemo :

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

Trong mã này, nếu bộ đếm luồng là một số chẵn, thì chúng ta sẽ gọi phương thức remove() trên biến ThreadLocal của chúng ta. Kết quả:

Và ở đây chúng ta dễ dàng nhận thấy biến ThreadLocal ở thread thứ 2 là null .

ThreadLocal.withInitial()

Phương pháp này tạo ra một biến thread-local.

Triển khai lớp 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());
    }
}

Và chúng ta có thể xem kết quả của mã của chúng ta:

Tại sao chúng ta nên sử dụng các biến như vậy?

ThreadLocal cung cấp một sự trừu tượng hóa các biến cục bộ liên quan đến luồng thực thi java.lang.Thread .

Các biến ThreadLocal khác với các biến thông thường ở chỗ mỗi luồng có phiên bản riêng, được khởi tạo riêng của biến, được truy cập thông qua các phương thức get() và set() .

Mỗi luồng, tức là thể hiện của lớp Chủ đề , có một bản đồ các biến ThreadLocal được liên kết với nó. Các khóa của bản đồ là các tham chiếu đến các đối tượng ThreadLocal và các giá trị là các tham chiếu đến các biến ThreadLocal "đã nhận" .

Tại sao lớp Ngẫu nhiên không phù hợp để tạo số ngẫu nhiên trong các ứng dụng đa luồng?

Chúng tôi sử dụng lớp Random để lấy số ngẫu nhiên. Nhưng nó có hoạt động tốt trong môi trường đa luồng không? Trên thực tế, không. Random không phù hợp với môi trường đa luồng, bởi vì khi nhiều luồng truy cập vào một lớp cùng một lúc, hiệu suất sẽ bị ảnh hưởng.

Để giải quyết vấn đề này, JDK 7 đã giới thiệu lớp java.util.concurrent.ThreadLocalRandom để tạo các số ngẫu nhiên trong môi trường đa luồng. Nó bao gồm hai lớp: ThreadLocal và Random .

Các số ngẫu nhiên mà một luồng nhận được độc lập với các luồng khác, nhưng java.util.Random cung cấp các số ngẫu nhiên trên toàn cầu. Ngoài ra, không giống như Random , ThreadLocalRandom không hỗ trợ tạo hạt rõ ràng. Thay vào đó, nó sẽ ghi đè phương thức setSeed() được kế thừa từ Random để nó luôn ném ra một ngoại lệ UnsupportedOperationException khi được gọi.

Hãy xem các phương thức của lớp ThreadLocalRandom :

Nhận số ngẫu nhiên bằng ThreadLocalRandom.current()

ThreadLocalRandom là sự kết hợp của các lớp ThreadLocal và Random . Nó đạt được hiệu suất tốt hơn trong môi trường đa luồng bằng cách đơn giản tránh mọi truy cập đồng thời vào các phiên bản của lớp Ngẫu nhiên .

Hãy triển khai một ví dụ liên quan đến nhiều luồng và xem ứng dụng của chúng ta thực hiện với lớp 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));
    }
}

Kết quả của chương trình của chúng tôi:

Và bây giờ, hãy thay đổi lớp RandomNumbers của chúng ta và sử dụng Random trong đó:

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

Để tổng hợp và nhắc lại sự khác biệt giữa các lớp Random và ThreadLocalRandom :