Java 高并发缓存与Guava Cache

一.背景

      缓存是我们在开发中为了提高系统的性能,把经常的访问业务的数据第一次把处理结果先放到缓存中,第二次就不用在对相同的业务数据在重新处理一遍,这样就提高了系统的性能。缓存分好几种:

(1)本地缓存。

(2)数据库缓存。

(3)分布式缓存。

      分布式缓存比较常用的有memcached等,memcached是高性能的分布式内存缓存服务器,缓存业务处理结果,减少数据库访问次数和相同复杂逻辑处理的时间,以提高动态Web应用的速度、 提高可扩展性。

   

二.本地缓存在高并发下的问题以及解决

     今天我们介绍的是本地缓存缓存,我们这边采用java.util.concurrent.ConcurrentHashMap来保存,ConcurrentHashMap是一个线程安全的HashTable,并提供了一组和HashTable功能相同但是线程安全的方法,ConcurrentHashMap可以做到读取数据不加锁,提高了并发能力。我们先不考虑内存元素回收或者在保存数据会出现内存溢出的情况,我们用ConcurrentHashMap模拟本地缓存,当在高并发环境一下,会出现一些什么问题?

我们这边采用实现多个线程来模拟高并发场景。

 第一种:我们先来看一下代码:

public class TestConcurrentHashMapCache<K,V> {
	private final ConcurrentHashMap<K, V>  cacheMap=new ConcurrentHashMap<K,V> (); 
	
	public  Object getCache(K keyValue,String ThreadName){
		System.out.println("ThreadName getCache=============="+ThreadName);
		Object value=null;
		//从缓存获取数据
		value=cacheMap.get(keyValue);
		//如果没有的话,把数据放到缓存
		if(value==null){
			return putCache(keyValue,ThreadName);
		}
		return value;
	}
	
	public Object putCache(K keyValue,String ThreadName){
		System.out.println("ThreadName 执行业务数据并返回处理结果的数据(访问数据库等)=============="+ThreadName);
		//可以根据业务从数据库获取等取得数据,这边就模拟已经获取数据了
		@SuppressWarnings("unchecked")
		V value=(V) "dataValue";
		//把数据放到缓存
		 cacheMap.put(keyValue, value);
		return value;
	}
 
	
	public static void main(String[] args) {
		final TestConcurrentHashMapCache<String,String> TestGuaVA=new TestConcurrentHashMapCache<String,String>();
		
		Thread t1=new Thread(new Runnable() {
			@Override
			public void run() {
				
				System.out.println("T1======start========");
			    Object value=TestGuaVA.getCache("key","T1");
			    System.out.println("T1 value=============="+value);
				System.out.println("T1======end========");
				
			}
		});
		
		Thread t2=new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("T2======start========");
				Object value=TestGuaVA.getCache("key","T2");
			    System.out.println("T2 value=============="+value);
				System.out.println("T2======end========");
				
			}
		});
		
		Thread t3=new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("T3======start========");
				Object value=TestGuaVA.getCache("key","T3");
			    System.out.println("T3 value=============="+value);
				System.out.println("T3======end========");	
			}
		});
		
		t1.start();
		t2.start();
		t3.start();
	}
 
}

我们看一下执行结果,如图所示:

     我们实现了本地缓存代码,我们执行一下结果,发现在多线程时,出现了在缓存里没有缓存时,会执行一样执行多次的业务数据并返回处理的数据,我们分析一下出现这种情况的:

   (1)当线程T1访问cacheMap里面有没有,这时根据业务到后台处理业务数据并返回处理数据,并放入缓存。

   (2)当线程T2访问cacheMap里面同样也没有,也把根据业务到后台处理业务数据并返回处理数据,并放入缓存。

第二种:

    这样相同的业务并处理两遍,如果在高并发的情况下相同的业务不止执行两遍,这样这样跟我们当初做缓存不相符合,这时我们想到了Java多线程时,在执行获取缓存上加上Synchronized,代码如下:

public class TestConcurrentHashMapCache<K,V> {
	private final ConcurrentHashMap<K, V>  cacheMap=new ConcurrentHashMap<K,V> (); 
	
	public synchronized Object getCache(K keyValue,String ThreadName){
		System.out.println("ThreadName getCache=============="+ThreadName);
		Object value=null;
		//从缓存获取数据
		value=cacheMap.get(keyValue);
		//如果没有的话,把数据放到缓存
		if(value==null){
			return putCache(keyValue,ThreadName);
		}
		return value;
	}
	
	public Object putCache(K keyValue,String ThreadName){
		System.out.println("ThreadName 执行业务数据并返回处理结果的数据(访问数据库等)=============="+ThreadName);
		//可以根据业务从数据库获取等取得数据,这边就模拟已经获取数据了
		@SuppressWarnings("unchecked")
		V value=(V) "dataValue";
		//把数据放到缓存
		 cacheMap.put(keyValue, value);
		return value;
	}
 
	
	
	public static void main(String[] args) {
		final TestConcurrentHashMapCache<String,String> TestGuaVA=new TestConcurrentHashMapCache<String,String>();
		
		Thread t1=new Thread(new Runnable() {
			@Override
			public void run() {
				
				System.out.println("T1======start========");
			    Object value=TestGuaVA.getCache("key","T1");
			    System.out.println("T1 value=============="+value);
				System.out.println("T1======end========");
				
			}
		});
		
		Thread t2=new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("T2======start========");
				Object value=TestGuaVA.getCache("key","T2");
			    System.out.println("T2 value=============="+value);
				System.out.println("T2======end========");
				
			}
		});
		
		Thread t3=new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("T3======start========");
				Object value=TestGuaVA.getCache("key","T3");
			    System.out.println("T3 value=============="+value);
				System.out.println("T3======end========");
				
			}
		});
		t1.start();
		t2.start();
		t3.start();
	}
 
}

执行结果,如图所示:

 这样就实现了串行,在高并发行时,就不会出现了第二个访问相同业务,肯定是从缓存获取,但是加上Synchronized变成串行,这样在高并发行时性能也下降了。

 第三种:

    我们为了实现性能和缓存的结果,我们采用Future,因为Future在计算完成时获取,否则会一直阻塞直到任务转入完成状态和ConcurrentHashMap.putIfAbsent方法,代码如下:

public class TestFutureCahe<K,V> {
	private final ConcurrentHashMap<K, Future<V>>  cacheMap=new ConcurrentHashMap<K, Future<V>> (); 
	
	public   Object getCache(K keyValue,String ThreadName){
		Future<V> value=null;
		try{
			System.out.println("ThreadName getCache=============="+ThreadName);
			//从缓存获取数据
			value=cacheMap.get(keyValue);
			//如果没有的话,把数据放到缓存
			if(value==null){
				value= putCache(keyValue,ThreadName);
				return value.get();
			}
			return value.get();
				
		}catch (Exception e) {
		}
		return null;
	}
	
	public Future<V> putCache(K keyValue,final String ThreadName){
//		//把数据放到缓存
		Future<V> value=null;
		Callable<V> callable=new Callable<V>() {
				@SuppressWarnings("unchecked")
				@Override
				public V call() throws Exception {
					//可以根据业务从数据库获取等取得数据,这边就模拟已经获取数据了
					System.out.println("ThreadName 执行业务数据并返回处理结果的数据(访问数据库等)=============="+ThreadName);
					return (V) "dataValue";
				}
			};
			FutureTask<V> futureTask=new FutureTask<V>(callable);
			value=cacheMap.putIfAbsent(keyValue, futureTask);
			if(value==null){
				value=futureTask;
				futureTask.run();
			}
		return value;
	}
	
	public static void main(String[] args) {
		final TestFutureCahe<String,String> TestGuaVA=new TestFutureCahe<String,String>();
		
		Thread t1=new Thread(new Runnable() {
			@Override
			public void run() {
				
				System.out.println("T1======start========");
				Object value=TestGuaVA.getCache("key","T1");
				System.out.println("T1 value=============="+value);
				System.out.println("T1======end========");
				
			}
		});
		
		Thread t2=new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("T2======start========");
				Object value=TestGuaVA.getCache("key","T2");
				System.out.println("T2 value=============="+value);
				System.out.println("T2======end========");
			}
		});
		
		Thread t3=new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("T3======start========");
				Object value=TestGuaVA.getCache("key","T3");
				System.out.println("T3 value=============="+value);
				System.out.println("T3======end========");
				
			}
		});
		t1.start();
		t2.start();
		t3.start();
	}
 
}

线程T1或者线程T2访问cacheMap,如果都没有时,这时执行了FutureTask来完成异步任务,假如线程T1执行了FutureTask,并把保存到ConcurrentHashMap中,通过PutIfAbsent方法,因为putIfAbsent方法如果不存在key对应的值,则将value以key加入Map,否则返回key对应的旧值。这时线程T2进来时可以获取Future对象,如果没值没关系,这时是对象的引用,等FutureTask执行完,在通过get返回。

    我们问题解决了高并发访问缓存的问题,可以回收元素这些,都没有,容易造成内存溢出,Google  Guava Cache在这些问题方面都做得挺好的,接下来我们介绍一下。

三.Google  Guava Cache的介绍和应用

     http://www.java2s.com/Code/Jar/g/Downloadguava1401jar.htm  下载对应的jar包
    Guava Cache与ConcurrentMap很相似,Guava Cache能设置回收,能解决在大数据内存溢出的问题,源代码如下:

public class TestGuaVA<K,V> {
    private   Cache<K, V> cache=  CacheBuilder.newBuilder() .maximumSize(2).expireAfterWrite(10, TimeUnit.MINUTES).build(); 
    public   Object getCache(K keyValue,final String ThreadName){
        Object value=null;
        try {
            System.out.println("ThreadName getCache=============="+ThreadName);
//从缓存获取数据
            value = cache.get(keyValue, new Callable<V>() {  
                               @SuppressWarnings("unchecked")
            public V call() {  
            System.out.println("ThreadName 执行业务数据并返回处理结果的数据(访问数据库等)=============="+ThreadName);
                return (V) "dataValue";
           }  
                           });  
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        return value;
    }

    public static void main(String[] args) {
        final TestGuaVA<String,String> TestGuaVA=new TestGuaVA<String,String>();


        Thread t1=new Thread(new Runnable() {
            @Override
            public void run() {

                System.out.println("T1======start========");
                Object value=TestGuaVA.getCache("key","T1");
                System.out.println("T1 value=============="+value);
                System.out.println("T1======end========");

            }
        });

        Thread t2=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("T2======start========");
                Object value=TestGuaVA.getCache("key","T2");
                System.out.println("T2 value=============="+value);
                System.out.println("T2======end========");

            }
        });

        Thread t3=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("T3======start========");
                Object value=TestGuaVA.getCache("key","T3");
                System.out.println("T3 value=============="+value);
                System.out.println("T3======end========");
            }
        });

        t1.start();
        t2.start();
        t3.start();
    }
}

说明:

   CacheBuilder.newBuilder()后面能带一些设置回收的方法:

     (1)maximumSize(long):设置容量大小,超过就开始回收。

     (2)expireAfterAccess(long, TimeUnit):在这个时间段内没有被读/写访问,就会被回收。

     (3)expireAfterWrite(long, TimeUnit):在这个时间段内没有被写访问,就会被回收 。

        (4)removalListener(RemovalListener):监听事件,在元素被删除时,进行监听。

执行结果,如图所示:

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值