java的同步机制，大概是通过
1.synchronized；
2.Object方法中的wait,notify；
3.ThreadLocal机制
来实现的
其中synchronized有两种用法
1.对类的方法进行修饰
2.synchronized(对象）的方法进行修饰
所以我们这里有好几种场景，现在我对每个场景都举个例子说明，并且指出哪个例子是说明哪个场景的。最后说为什么需要ThreadLocal，以及ThreadLocal的用法。例子结合了从网上找的资料。
所有场景都要用到的类
package threadlocal.test;
public class Student {
private int age = 0;
public int getAge() {
return this.age;
}
public void setAge(int age) {
this.age = age;
}
}
一，第一个应用场景，无任何同步机制，整个程序运行时间约为5秒
package threadlocal.test;
import java.util.Random;
public class ThreadDemo1 implements Runnable {
Student student = new Student();
public static void main(String[] agrs) {
ThreadDemo1 td = new ThreadDemo1();
Thread t1 = new Thread(td, "a");
Thread t2 = new Thread(td, "b");
t1.start();
t2.start();
}
public void run() {
accessStudent();
}
public void accessStudent() {
String currentThreadName = Thread.currentThread().getName();
System.out.println(currentThreadName + " is running!");
Random random = new Random();
int age = random.nextInt(100);
System.out
.println("thread " + currentThreadName + " set age to:" + age);
this.student.setAge(age);
System.out.println("thread " + currentThreadName
+ " first read age is:" + this.student.getAge());
try {
Thread.sleep(5000);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
System.out.println("thread " + currentThreadName
+ " second read age is:" + this.student.getAge());
}
}
简述：两个线程同时开启，对同一个类实例进行操作，虽然速度很快，只占用一个线程运行时间，但是出现竞争使得整个代码变得无用。
二，第二个应用场景，synchronized修饰类方法。程序运行时间约为10秒
package threadlocal.test;
import java.util.Random;
/**
* 加了个synchronized，不会出现竞争了，但是效率极低
*
* @author dachuan
*
*/
public class ThreadDemo2 implements Runnable {
Student student = new Student();
public static void main(String[] agrs) {
ThreadDemo2 td = new ThreadDemo2();
// ThreadDemo2 td = new ThreadDemo2();
// ThreadDemo2 td2 = new ThreadDemo2();
Thread t1 = new Thread(td, "a");
Thread t2 = new Thread(td, "b");
//之所以t1,t2两个线程会在acessStudent函数处出现同步，是因为他们都是对同一个实例的函数进行访问
//t1,t2都在对ThreadDemo2这个类的实例td的函数accessStudent进行访问，所以会出现同步。
//也就是说，如果类A内部定义了一个synchronized方法，而a是A的一个实例，如果有不同的线程都对a.syn()进行访问，就会出现同步
//synchronized关键字是锁住了类的实例，让另外的线程进不去
//在这个例子中，t1,t2两个线程，总共运行时间肯定>=10秒，因为t1,t2在accessStudent这个地方是串行的。
//如果t1,t2是为了完成某件事情在合作，那么这个同步是值得的。
//现在的前提是，t1,t2必须使用同一个类的实例，但是又做的都是独立的事情。这个时候，synchronized方法显得很低效，反而降低了运算效率
//所以ThreadLocal的出现就是为了解决这个问题的。
//ThreadLocal的应用场合：
//1.多个线程都要使用同一个类实例
//2.这多个线程拿到这个类实例后做的事情是互相独立的
//生产者和消费者模型跟ThreadLocal的应用场合有一个区别
//1.生产者和消费者两个线程其实也是在使用同一个类实例
//2.但是这两个线程拿到类实例后做的事情是互相牵制的
t1.start();
t2.start();
}
/*
* (non-Javadoc)
*
* @see java.lang.Runnable#run()
*/
public void run() {
accessStudent();
}
public synchronized void accessStudent() {
String currentThreadName = Thread.currentThread().getName();
System.out.println(currentThreadName + " is running!");
// System.out.println("first read age is:"+this.student.getAge());
Random random = new Random();
int age = random.nextInt(100);
System.out
.println("thread " + currentThreadName + " set age to:" + age);
this.student.setAge(age);
System.out.println("thread " + currentThreadName
+ " first read age is:" + this.student.getAge());
try {
Thread.sleep(5000);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
System.out.println("thread " + currentThreadName
+ " second read age is:" + this.student.getAge());
}
}
简述：两个线程在accessStudent方法处串行操作，所以整个程序时间变长，大约10秒。消除了竞争
三，第三个应用场景，synchronized修饰类，程序运行时间大约10秒。
package threadlocal.test;
import java.util.Random;
/**
*
* @author dachuan
*
*/
public class ThreadDemo3 implements Runnable {
Student student = new Student();
public static void main(String[] agrs) {
ThreadDemo3 td = new ThreadDemo3();
Thread t1 = new Thread(td, "a");
Thread t2 = new Thread(td, "b");
t1.start();
t2.start();
}
/*
* (non-Javadoc)
*
* @see java.lang.Runnable#run()
*/
public void run() {
accessStudent();
}
public void accessStudent() {
String currentThreadName = Thread.currentThread().getName();
System.out.println(currentThreadName + " is running!");
// System.out.println("first read age is:"+this.student.getAge());
synchronized (this) {
Random random = new Random();
int age = random.nextInt(100);
System.out.println("thread " + currentThreadName + " set age to:"
+ age);
this.student.setAge(age);
System.out.println("thread " + currentThreadName
+ " first read age is:" + this.student.getAge());
try {
Thread.sleep(5000);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
System.out.println("thread " + currentThreadName
+ " second read age is:" + this.student.getAge());
}
}
简述：synchronized关键字都是用来锁住对象的，这个地方锁住了this，两个线程访问的都是同一个类实例，所以两个线程中的this都是指一个东西。整个程序无竞争，运行时间大约10秒
四，第四个应用场景，TheadLocal。程序无竞争，运行时间大约5秒
package threadlocal.test;
import java.util.Random;
public class ThreadLocalDemo implements Runnable {
private final static ThreadLocal studentLocal = new ThreadLocal();
public static void main(String[] agrs) {
ThreadLocalDemo td = new ThreadLocalDemo();
Thread t1 = new Thread(td, "a");
Thread t2 = new Thread(td, "b");
t1.start();
t2.start();
}
/*
* (non-Javadoc)
*
* @see java.lang.Runnable#run()
*/
public void run() {
accessStudent();
}
public void accessStudent() {
String currentThreadName = Thread.currentThread().getName();
System.out.println(currentThreadName + " is running!");
Random random = new Random();
int age = random.nextInt(100);
System.out
.println("thread " + currentThreadName + " set age to:" + age);
Student student = getStudent();
student.setAge(age);
System.out.println("thread " + currentThreadName
+ " first read age is:" + student.getAge());
try {
Thread.sleep(5000);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
System.out.println("thread " + currentThreadName
+ " second read age is:" + student.getAge());
}
protected Student getStudent() {
Student student = (Student) studentLocal.get();
if (student == null) {
student = new Student();
studentLocal.set(student);
}
return student;
}
protected void setStudent(Student student) {
studentLocal.set(student);
}
}
简述：ThreadLocal的出现使得两个线程虽然手中握有同一个类的实例，但是做同一样事情的时候却互不干扰。这就是ThreadLocal的应用场景。
五，第五个应用场景，生产者&消费者模型和ThreadLocal模型的区别
我个人总结，ThreadLocal的应用场景为：
1.多个线程都要使用同一个类实例
2.这多个线程拿到这个类实例后做的事情是互相独立的
而生产者消费者例子跟ThreadLocal有一点区别
1.生产者和消费者两个线程其实也是在使用同一个类实例
2.但是这两个线程拿到类实例后做的事情是互相牵制的
所以看到这里，就知道ThreadLocal的应用场景是什么了。
我在阅读Hadoop源码时，看到MapOutputFile这个类中使用了ThreadLocal，所以查了些资料总结了下。
在Hadoop源码中，有一处地方对Object的wait和notify进行了很好的诠释。以后有空再记录一下。
分享到：
相关推荐
ThreadLocal 用法详解.md
以上就是关于ThreadLocal的基本概念、使用方法、生命周期管理和实际应用示例的详细解释。了解并熟练掌握ThreadLocal可以帮助我们编写出更高效、更安全的多线程代码。在Java并发编程中，ThreadLocal是一个不可或缺的...
ThreadLocal通常被用来解决线程共享数据时可能出现的并发问题，避免了使用synchronized关键字进行同步控制的复杂性。 在Java中，ThreadLocal的工作原理是为每个线程创建一个单独的存储空间，每个线程可以独立地读写...
下面我们将深入探讨`ThreadLocal`的工作原理、使用场景以及常见误区。 `ThreadLocal`类的主要方法有以下几个： 1. `void set(T value)`：设置当前线程的线程局部变量的值。 2. `T get()`：返回当前线程的线程局部...
### 正确理解ThreadLocal：深入解析其工作原理与应用场景 #### 一、ThreadLocal的基本概念 `ThreadLocal`是Java平台提供的一种线程局部变量的解决方案，它为每一个使用该变量的线程都提供了独立的变量副本，使得每...
ThreadLocal的使用方法通常是创建一个ThreadLocal实例，然后在需要的地方通过它的`set()`方法设置线程局部变量的值，通过`get()`方法获取该变量的副本。在生命周期结束后，通常需要调用`remove()`方法清除线程的副本...
threadlocal源码解析
4. **减少锁的使用**: 当多个线程需要共享同一资源，但每个线程只需要读取自己相关的数据时，`ThreadLocal`可以避免锁的使用，提升效率。 **注意事项** - 使用`ThreadLocal`后，应确保及时清理不再使用的变量，...
ThreadLocal的使用方法是创建一个ThreadLocal实例，然后通过其set()方法设置线程局部变量，get()方法获取当前线程的该变量值。需要注意的是，ThreadLocal不是线程安全的，它只是保证了线程内部的隔离性，但不负责...
Java ThreadLocal用法实例详解 Java ThreadLocal是Java中的一种线程局部变量机制，用于保存每个线程独有的数据，以避免线程之间的数据共享问题。ThreadLocal的基本使用非常简单，只需要定义一个ThreadLocal变量，...
理解ThreadLocal的工作原理和使用方法对于编写高效、安全的多线程程序至关重要。 ### ThreadLocal简介 ThreadLocal并非一个线程对象，而是一个线程局部变量的容器。每个线程都有自己的ThreadLocal实例，它们各自...
* 在使用 ThreadLocal 时，需要确保 initialValue() 方法的正确实现，以避免线程之间的数据共享。 * 在使用 ThreadLocal 时，需要注意避免内存泄漏的问题，例如，在使用完毕后，需要将 ThreadLocal 变量设置为 null...
**ThreadLocal的使用方法：** 1. **创建ThreadLocal实例：** 首先，你需要创建一个ThreadLocal类型的实例，这将作为你在每个线程中存储值的容器。 ```java ThreadLocal<String> threadLocal = new ThreadLocal();...
理解ThreadLocal 理解ThreadLocal 理解ThreadLocal 理解ThreadLocal
在 `LeakingServlet` 的 `doGet` 方法中，如果 `ThreadLocal` 没有设置值，那么会创建一个新的 `MyCounter` 并设置到 `ThreadLocal` 中。关键在于，一旦 `MyCounter` 被设置到 `ThreadLocal`，那么它将与当前线程...
ThreadLocal的用法非常简单，首先创建一个ThreadLocal实例，然后通过`set()`方法设置线程局部变量的值，通过`get()`方法获取该值。需要注意的是，ThreadLocal中的变量并不是存储在堆内存中，而是存储在线程的...
本文将深入探讨ThreadLocal的使用以及Spring框架中的事务管理，这两个主题都是Java开发人员必须掌握的关键技能。 首先，让我们了解ThreadLocal。ThreadLocal是Java提供的一种线程绑定变量的工具类，它允许我们在一...
Java源码解析ThreadLocal及使用场景 ThreadLocal是Java中一个非常重要的类，它在多线程环境下经常使用，用于提供线程本地变量。这些变量使每个线程都有自己的一份拷贝，使得多个线程可以独立地使用变量，不会彼此...