How to use ThreadLocal function in Java for thread local variable manipulation

As computer performance improves, multi-threaded programming becomes more and more common. Multi-threaded programming in Java is a powerful feature that allows us to perform multiple tasks simultaneously. In multi-threaded programming, the thread local variable (ThreadLocal) function is a very useful mechanism that allows each thread to have its own copy of the variable, thereby avoiding competition between threads and data pollution problems. In this article, we will discuss how to use ThreadLocal function in Java for thread local variable manipulation.

ThreadLocal Overview

The ThreadLocal class is one of the very important classes in Java and is mainly used to create thread local variables. ThreadLocal variables are usually static variables used to store information closely related to the execution of the thread. In the Java platform, ThreadLocal variables are a thread-local storage mechanism. ThreadLocal variables are different from ordinary variables in that their values ​​can only be accessed by the current thread.

Use the ThreadLocal function in Java to operate thread local variables

1. Create ThreadLocal variables

In Java, you can create ThreadLocal variables to store thread local variables , as shown below:

ThreadLocal<String> localVariable = new ThreadLocal<String>();

The above statement creates a ThreadLocal variable, which uses generics to specify the stored data type. In this case, String type data is stored.

2. Storing and Accessing ThreadLocal Variables

Once a ThreadLocal variable is created, you can use the set() function to store a value into it, as shown below:

localVariable.set("Hello World");

The above statement stores the string "Hello World" into the ThreadLocal variable. To access the value from the ThreadLocal variable, you can use the get() function as follows:

String value = localVariable.get();

The above statement reads and stores the value stored in the ThreadLocal variable into the variable value.

3. Delete the ThreadLocal variable

When the ThreadLocal variable is no longer needed, it should be deleted to free up memory, as shown below:

localVariable.remove();

The above statement The stored value will be removed from the ThreadLocal variable and the memory will be released.

Example of thread local variables

Now, let’s look at an example of how to use the ThreadLocal function. In this example, we will create a multi-threaded program where each thread will have its own ThreadLocal variable.

import java.util.Random;

public class ThreadLocalExample {

    // 创建ThreadLocal变量
    public static final ThreadLocal<Integer> randomNumber =
            new ThreadLocal<Integer>() {
                @Override
                protected Integer initialValue() {
                    Random rand = new Random();
                    return rand.nextInt(1000);
                }
            };

    public static void main(String[] args) {

        // 创建5个线程
        Thread[] threads = new Thread[5];
        for (int i = 0; i < 5; i++) {
            threads[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    int randomValue = randomNumber.get();
                    System.out.println(Thread.currentThread().getName()
                            + ": " + randomValue + " is a random number");
                    randomNumber.remove();
                }
            });
            threads[i].start();
        }
    }
}

Output result:

Thread-0: 155 is a random number
Thread-1: 764 is a random number
Thread-2: 283 is a random number
Thread-3: 633 is a random number
Thread-4: 245 is a random number

In the above example, we created a ThreadLocal variable that stores random integers. In the main() function, we create 5 threads and access the ThreadLocal variable in each thread. The initial value of the ThreadLocal variable is set to a random number before accessing the variable. Each thread then reads a random number from the ThreadLocal variable and prints it to the console. After printing the value, we use the remove() function to delete the value in the ThreadLocal variable.

Conclusion

In this article, we learned how to use ThreadLocal function in Java for thread local variable operations. Thread-local variables are a very useful mechanism that allows each thread to have its own copy of a variable. This avoids thread contention and data pollution issues. Creation and access of ThreadLocal variables is very simple and straightforward. To create a ThreadLocal variable, just use the constructor of the ThreadLocal class. To store a value into a ThreadLocal variable, just use the set() function. To read a value from a ThreadLocal variable, just use the get() function. Finally, when the ThreadLocal variable is no longer needed, we can delete it using the remove() function.

The above is the detailed content of How to use ThreadLocal function in Java for thread local variable manipulation. For more information, please follow other related articles on the PHP Chinese website!