我要评论一、前言
前些时间看别人写的一段关于锁的（对象缓存+线程本地变量）的一段代码，这段代码大致描述了这么一个功能：
外部传入一个key，需要根据这个key去全局变量里面找是否存在，如有有则表示有人对这个key加锁了，往下就不执行具体业务代码，同时，同时哦 还要判断这个key是不是当前线程持有的，如果不是当前线程持有的也不能往下执行业务代码～
然后哦 还要在业务代码执行完成后释放这个key锁，也就是要从 threadlocal 里面移除这个key。
当然需求不仅于此，就是业务的特殊性需要 threadlocal 同时持有多个不同的key，这就表明 threadlocal 的泛型肯定是个list或set。
然后再说下代码，为了演示问题代码写的比较简略，以下我再一一说明可能存在的问题🎈
二、基本逻辑
功能大致包含两个函数:
lock : 主要是查找公共缓存还有线程本地变量是否包含传入的指定key，若无则尝试写入全局变量及 threadlocal 并返回true以示获取到锁
release ： 业务逻辑处理完成后调用此，此函数内主要是做全局缓存以及 threadlocal 内的key的移除并返回状态(true/false)
contains : 公共方法，供以上两个方法使用，逻辑：判断全局变量或 threadlocal 里面有否有指定的key，此方法用 private 修饰
好了，准备看代码 😂
代码如下：
public class cacheobjectlock {
// 全局对象缓存
private static list<object> global_cache = new arraylist<object>(8);
// 线程本地变量
private static threadlocal<list<object>> thread_cache = new threadlocal<list<object>>();
// 尝试加锁
public synchronized boolean lock(object obj){
if(this.contains(obj)){
return false;
}
list al = null;
if((al=thread_cache.get())==null){
al = new arraylist(2);
thread_cache.set(al);
}
al.add(obj);
global_cache.add(obj);
return true;
}
// 判断是否存在key
public boolean contains(object obj){
list<object> objs;
return global_cache.contains(obj)?true:(objs=thread_cache.get())==null?false:objs.contains(obj);
}
// 释放key锁，与上面的 lock 方法对应
public boolean release(object obj){
if( this.contains(obj) ){
list<object> objs = thread_cache.get();
if(null!=objs){
objs.remove(obj);
global_cache.remove(obj);
}
return true;
}
return false;
}
}
三、测试代码
因为是锁，所以必须要使用多线程测试，这里我简单使用 parallel stream +多轮循环去测试:
public class cacheobjectlocktest {
private cacheobjectlock lock = new cacheobjectlock();
public void test1(){
intstream.range(0,10000).parallel().foreach(i->{
if(i%3==0){
i-=2;
}
boolean b = null;
if((b=lock.lock(i))==false ){
return ;
}
boolean c = null;
try {
// do something ...
// timeunit.milliseconds.sleep(1);
} catch (exception e) {
throw new runtimeexception(e);
}finally {
c = lock.release(i);
}
if(b!=c){
system.out.println("b:"+b+" c:"+c+" => "+thread.currentthread().getname());
}
});
// lock.contains(9);
}
@test
public void test2(){
for(int i=0;i<10;i++){
this.test1();
}
}
}
测试结果
分析
显而易见，这是没有对 release 加锁导致的，其实呢，这样说是不准确的…
首先要明白 lock 上加的 synchronized 的同步锁的范围是对当前实例的，而 release 是没有加 synchronized ，所以 release 是无视 lock 上加的 synchronized
再仔细看看 global_cache 是什么？arraylist ，明白了吧 arraylist 不是线程安全的，因为 synchronized 的范围只是 lock 函数这一 函数内 ，从测试代码可看到 lock.lock(i)
开始一直到 lock.release(i) 这中间是没有加同步锁的，所以到 lock.lock(i) 开始一直到 lock.release(i) 这中间是存在线程竞争的，恰好又碰到 arraylist 这一不安全因素自然会抛错的！
因为存在不安全类，所以我们有理由怀疑 thread_cache 的泛型变量也是存在多线程异常的，因为它这个泛型也是 arraylist ！
四、解决锁问题
好了，明白了问题之所在，自然解决办法也十分easy：
在 release 方法上添加 synchronized 声明，这样简单粗暴
分别对 objs.remove(obj); 以及 global_cache.remove(obj); 加同步锁，这样颗粒度更细
因为 synchronized 是写独占的，所以无需在 contains 中单独加锁
代码 (这里仅有 release 变更)
public synchronized boolean release(object obj){
if( this.contains(obj) ){
list<object> objs = thread_cache.get();
if(null!=objs){
// synchronized (objs){
objs.remove(obj);
// }
// synchronized (global_cache){
global_cache.remove(obj);
// }
}
return true;
}
return false;
}
测试结果
分析😂
测试了多轮都是成功的，没有任何异常，难道就一定没有异常了？？？
非也，非也~~~
为了让问题体现的的更清晰，先修改下测试用例并把 contains 方法置为 public,然后测试用例:
public class cacheobjectlocktest {
private cacheobjectlock2 lock = new cacheobjectlock2();
public void test1(){
intstream.range(0,10000).parallel().foreach(i->{
// string it = "k"+i;
if(i%3==0){
i-=2;
}
boolean b = null;
if((b=lock.lock(i))==false ){
return ;
}
boolean c = null;
try {
// do something ...
// timeunit.milliseconds.sleep(1);
} catch (exception e) {
throw new runtimeexception(e);
}finally {
c = lock.release(i);
}
if(b!=c){
system.out.println("b:"+b+" c:"+c+" => "+thread.currentthread().getname());
}
});
lock.contains(9);
}
@test
public void test2(){
for(int i=0;i<10;i++){
this.test1();
}
}
}
在这一行打上断点 lock.contains(9); 然后逐步进入到 threadlocal 的 get() 方法中：
看到没，虽然key已经被移除的，但是 threadlocal 里面关联的是 key外层的 arraylist , 因为开发机配置都较好，一旦导致 threadlocal 膨胀,则 oom 是必然的事儿！
我们知道 threadlocal 的基本特性，它会根据线程分开存放各自线程的所 set 进来的对象，若没有调用其 remove 方法，变量会一直存在 threadlocal 这个 map 中，
若上述的测试代码放在线程池里面被管理，线程池会根据负载会增减线程，如果每一次执行上述代码用的线程都不是固定的 threadlocal 必然会导致 jvm oom 😂
这就像 java 里面的 文件读写，open 之后必须要 要有 close 操作。
五、 解决threadlocal问题
最后更改代码如下：
public class cacheobjectlock3 {
private static list<object> global_cache = new arraylist<object>(8);
private static threadlocal<list<object>> thread_cache = new threadlocal<list<object>>();
public synchronized boolean lock(object obj){
if(this.contains(obj)){
return false;
}
list al = null;
if((al=thread_cache.get())==null){
al = new arraylist(2);
thread_cache.set(al);
}
al.add(obj);
global_cache.add(obj);
return true;
}
public boolean contains(object obj){
list<object> objs;
return global_cache.contains(obj)?true:(objs=thread_cache.get())==null?false:objs.contains(obj);
}
public synchronized boolean release(object obj){
if( this.contains(obj) ){
list<object> objs = thread_cache.get();
if(null!=objs){
// synchronized (objs){
objs.remove(obj);
if(objs.isempty()){
thread_cache.remove();
}
// }
// synchronized (global_cache){
global_cache.remove(obj);
// }
}
return true;
}
return false;
}
}
测试结果
测试 ok 通过 ~
总结
到此这篇关于java线程本地变量导致的缓存问题解决方法的文章就介绍到这了,更多相关java线程本地变量缓存问题内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！
发表评论