Shared data is one of the most critical features of concurrent programs. This is a very week-important aspect for objects that inherit from the thread class, or for objects that implement the Runnable interface.
If you create an object for a class that implements the Runnable interface and use that object to start a series of threads, all of these threads share the same properties. In other words, if a thread modifies a property, all the remaining threads will be affected by this change.
Sometimes, we prefer to use the agenda online instead of sharing it with other threads that start with the same object. The Java Concurrency interface provides a clear mechanism to meet this requirement, which is called a local thread variable. The performance of this mechanism is also very considerable.
Know it
Follow the steps shown below to complete the sample program.
1. First, the implementation of a procedure with the above problems. Create a class named Unsafetask and implement the Runnable interface. Declares a private property of a java.util.Date type in a class. The code is as follows:
2. Implement the Unsafetask Run () method, which instantiates the StartDate property and outputs its value to the console. Hibernate randomly for a period of time, and then output the value of the StartDate property to the console again. The code is as follows:
try {
TimeUnit.SECONDS.sleep ((int) math.rint (math.random () * 10));
catch (Interruptedexception e) {
E.printstacktrace ();
}
System.out.printf ("Thread finished:%s:%s\n",
Thread.CurrentThread (). GetId (), startdate);
}
3. The main class that implements the problem program. Create a class with the main () method, Unsafemain. In the main () method, create a Unsafetask object and use the object to create 10 thread objects to start 10 threads. In the middle of each thread, hibernate for 2 seconds. The code is as follows:
4. From the above logic, each thread has a different start time. However, according to the output log below, many of the same time values appear. As follows:
5. As indicated above, we are prepared to use the local thread variable (the thread-local variables) mechanism to resolve this problem.
6. Create a class named Safetask and implement the Runnable interface. The code is as follows:
8. Implement the Run () method of the Safetask class. This method, like the Unsafetask Run () method, is just a slight adjustment to the way the StartDate property is used. The code is as follows:
try {
TimeUnit.SECONDS.sleep ((int) math.rint (math.random () * 10));
catch (Interruptedexception e) {
E.printstacktrace ();
}
System.out.printf ("Thread finished:%s:%s\n",
Thread.CurrentThread (). GetId (), Startdate.get ());
}
9. The main class of the security example and the main class of the Unsafetask program are basically the same, except that you need to modify it to safetask. The specific code is as follows:
10. Run the program to analyze the difference of two inputs.
For the purpose of canonical class naming, the main class in this article has a slightly different naming and text. In addition, the original procedure and the text narration are inconsistent. It should be a clerical error.
Know the reason why
The following is the result of the security example execution. From the results, it is easy to see that each thread has a StartDate property value that belongs to the respective thread. The program is entered as follows:
A thread-local variable stores a copy of a property for each thread. You can use the threadlocal get () method to obtain the value of a variable, using the Set () method to set the value of the variable. If the thread-local variable is first accessed and the variable has not yet been assigned, the InitialValue () method is invoked to initialize a value for each thread.
Endless
The Threadlocal class also provides a remove () method that deletes the value of the local variable stored in the thread that called the method.
In addition, the Java Concurrency API provides a inheritablethreadlocal class that allows child threads to receive the initial values of all inheritable thread-local variables to obtain the values that the parent thread has. If thread A has a thread-local variable, and when thread a creates thread B, thread B will have the same thread-local variables as thread A. You can also override Childvalue () to initialize the thread-local variables of the child thread. The method will accept the value of the thread-local variable passed from the parent thread as a parameter.
Copycat
This article is from the "Java 7 Concurrency Cookbook" (D-Gua to "Java7 concurrent Sample Set") translation, only as learning materials used. No authorization shall be applied to any commercial act.
Small has become
The following is a full version of all the code contained in the example in this section.
Complete code for the Unsafetask class:
Import Java.util.Date;
Import Java.util.concurrent.TimeUnit;
/**
* No guarantee of thread safety examples
* date:2013-09-23
* time:23:58
*/
public class Unsafetask implements Runnable {
Private Date StartDate;
@Override
public void Run () {
StartDate = new Date ();
System.out.printf ("Starting Thread:%s:%s\n",
Thread.CurrentThread (). GetId (), startdate);
try {
TimeUnit.SECONDS.sleep ((int) math.rint (math.random () * 10));
catch (Interruptedexception e) {
E.printstacktrace ();
}
System.out.printf ("Thread finished:%s:%s\n",
Thread.CurrentThread (). GetId (), startdate);
}
}
Complete code for the Unsafemain class:
Import Java.util.concurrent.TimeUnit;
/**
* Unsafe Threads sample
* date:2013-09-24
* time:00:04
*/
public class Unsafemain {
public static void Main (string[] args) {
Unsafetask task = new Unsafetask ();
for (int i = 0; i < i++) {
Thread thread = new thread (Task);
Thread.Start ();
try {
TimeUnit.SECONDS.sleep (2);
catch (Interruptedexception e) {
E.printstacktrace ();
}
}
}
}
Complete code for the Safetask class:
Import Java.util.Date;
Import Java.util.concurrent.TimeUnit;
/**
* use thread-local variables to guarantee thread security
* date:2013-09-29
* time:23:34
*/
public class Safet Ask implements Runnable {
private static threadlocal<date> StartDate = new
& nbsp; threadlocal<date> () {
@Override
protected Date InitialValue () {
return new Date ( );
}
};
@Override
public void Run () {
System.out.printf ("Starting Thread:%s:%s\n",
Thread.CurrentThread (). GetId (), Startdate.get ());
try {
TimeUnit.SECONDS.sleep ((int) math.rint (math.random () * 10));
catch (Interruptedexception e) {
E.printstacktrace ();
}
System.out.printf ("Thread finished:%s:%s\n",
Thread.CurrentThread (). GetId (), Startdate.get ());
}
}
Complete code for the Safemain class:
Import Java.util.concurrent.TimeUnit;
/**
* Secure Threading Sample
* date:2013-09-24
* time:00:04
*/
public class Safemain {
public static void Main (string[] args) {
Safetask task = new Safetask ();
for (int i = 0; i < i++) {
Thread thread = new thread (Task);
Thread.Start ();
try {
TimeUnit.SECONDS.sleep (2);
catch (Interruptedexception e) {
E.printstacktrace ();
}
}
}
}
Start building with 50+ products and up to 12 months usage for Elastic Compute Service
1 on 1 presale consultation
24/7 Technical Support 6 Free Tickets per Quarter Faster Response
Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.
A comprehensive suite of global cloud computing services to power your business
Payment Methods We Support
