La diferencia entre las variables locales de subprocesos compartidos ThreadLocal y el mecanismo de sincronización de subprocesos
Para problemas de intercambio de recursos de múltiples subprocesos, el mecanismo de sincronización adopta el método de "intercambiar tiempo por espacio", mientras que ThreadLocal adopta el método de "intercambiar espacio por tiempo". El primero solo proporciona una variable para que diferentes subprocesos se pongan en cola para acceder, mientras que el segundo proporciona una variable para cada subproceso, por lo que se puede acceder a él al mismo tiempo sin afectarse entre sí.
ThreadLocal no puede reemplazar los mecanismos de sincronización, se enfrentan a diferentes áreas problemáticas.
1: El mecanismo de sincronización es sincronizar el acceso concurrente de múltiples subprocesos al mismo recurso y es una forma efectiva de comunicarse entre múltiples subprocesos.
2.threadLocal son los datos; que aísla múltiples subprocesos. Compartir fundamentalmente no comparte variables entre múltiples subprocesos, por lo que, por supuesto, no es necesario sincronizar múltiples subprocesos.
Importar Java . util . random;
Clase pública ThreadSocpeShareData {
static ThreadLocal lt integer gtt = new ThreadLocal lt integer gt();
Public static void main(String[] args) {
for(int I = 0;ilt3;i){
new Thread(new Runnable() {< / p>
@Override
Public void run(){
int data = new Random();
system out . hilo actual(). getName() "poner" datos);
t.set(data);
MyThreadScopeData.getInstance().
MyThreadScopeData.getInstance().setAge(datos de "edad");
Nueva A().get();
Nueva B().get();
}
}).start();
}
}
Clase estática A{
public void get(){
int datos = t . get();
MyThreadScopeData mis datos = MyThreadScopeData getinstance ();
sistema. println("Un" hilo. hilo actual().
getName() " " datos mis datos . getage() mis datos . getName()/* ms . p>clase estática B{
public void get(){
int data = t . get()
system out. " hilo . hilo actual().getName() " " datos);
}
}
}
Clase MyThreadScopeData{
privado MyThreadScopeData(){}
Hilo estático privado local ltMyThreadScopeData gtmap = new ThreadLocal ltMyThreadScopeData gt()
MyThreadScopeData estático público getInstance(){
Instancia MyThreadScopeData = mapa . get();
if(instancia == null){
instancia = new MyThreadScopeData();
map.set(instancia);
}
Devolver instancia;
}
Nombre de cadena privada;
Edad de cadena privada;
Cadena pública getName() {
Devolver nombre;
}
public void setName(char Nombre de cadena ) {
this.name = nombre
}
Cadena pública getAge() {
Edad de retorno;
p>
}
Almacenamiento público vacío (edad de cadena) {
this.age = edad
}
}
De hecho, la variable que configuramos en ThreadLocal no la almacena ThreadLocal, sino el propio objeto ThreadThread. Cuando el usuario llama al set (Objeto o) del objeto ThreadLocal, el método obtiene el hilo actual a través de Thread.currentThread () y almacena la variable en un Mapa en el hilo. La clave del Mapa es la instancia actual de ThreadLocal.
Mirando el código fuente, estas son las dos funciones principales. Podemos ver la relación de llamada entre ThreadLocal y Thread:
Conjunto público vacío (valor T){
thread t = thread. .currentthread();
ThreadLocalMap mapa = obtener mapa(t);
if (mapa!=null)
map.set(este, valor) ;
Otro
createMap(t, valor);
}
ThreadLocalMap getMap(Thread t) {
Return t.threadLocals
}
conjunto vacío público (valor T){ Thread T = Thread actual Thread(); mapa de ThreadLocalMap = obtener mapa (t); Figura! = null) map.set(this, value); de lo contrario createMap(t, value);} ThreadLocalMap get map(Thread t){ return t Thread locals;}
Puedes buscar dentro de la fuente. código, pero una cosa que se puede confirmar es que la copia del hilo creada en Threadlocal se puede limpiar sin llamar a eliminar, porque la jvm reciclará automáticamente la basura cuando descubra que la comisión del hilo ya no se usa, pero el programa que escribí antes es Limpia con frecuencia después de usar Threadlocal. (Para evitar el uso de memoria, si la cantidad de copias creadas no es demasiado grande, la máquina virtual puede borrarlas automáticamente).