Java缓存和读写锁

先说最常见的一道面试题:

hibernate 中的load()方法和get()方法的区别

用这些代码解释最好

User user = session.load(id,User.class);
        User user = session.load(id,User.class);
        //缓存代理
        User$Proxy extends User{
            private Integer id = id;
            User realUser = null;
            getName(){
                if(realUser == null){
                    realUser = session.get(id);
                    if(realUser == null){
                        throw execption
                    }
                        return realUser.getName();
                }
            }

}

再看看API中附带的一段代码就可以明白什么事缓存了

class CachedDate{
    Object date;
    volatile boolean cacheValid;
    ReentrantReadWriteLock rql = new ReentrantReadWriteLock();
    void processCachedDate(){
        rwl.readLock().lock();
        if(!cacheValid){
            rwl.readLock().unlock();
            rwl.writeLock().lock();
            if(!cacheValid){
                data = ....
                cacheValid = true;
            }
            rwl.readLock().lock();
            rwl.readLock().unlock();
        }
        use(date);
        rwl.readLock().unlock();
    }
}

这段代码明白了不仅明白缓存还明白了什么是读写锁了一举两得

附带一个缓存的代码

public class CacheDemo {
    private Map<String,Object> cache = new HashMap<>();
    public static void main(String[] args) {
        
    }
    private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    public synchronized Object getDatt(String key){
        rwl.readLock().lock();
        Object value = cache.get(key);
        try{
            if (value == null) {
                rwl.readLock().unlock();
                rwl.writeLock().lock();
                try{
                    if (value == null) {
                        value = "到数据库查询";
                    }
                }finally{
                    rwl.writeLock().unlock();
                }
                rwl.readLock().lock();
            }
        }finally{
            rwl.readLock().unlock();
        }
        return value;
    }
}

以上主要听张孝祥老师讲课整理

向张老师致敬!愿他在那边不要那么辛苦!

时间: 2024-08-06 16:01:03

Java缓存和读写锁的相关文章

java缓存及读写锁实例应用

package com.thread.demo.lock; import java.util.Collections; import java.util.HashMap; import java.util.Map; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; /** * * @author Torey * */ public c

JAVA 并发编程-读写锁之模拟缓存系统(十一)

在多线程中,为了提高效率有些共享资源允许同时进行多个读的操作,但只允许一个写的操作,比如一个文件,只要其内容不变可以让多个线程同时读,不必做排他的锁定,排他的锁定只有在写的时候需要,以保证别的线程不会看到数据不完整的文件.这时候就需要使用读写锁. /** * 简单读写锁demo * @author hejingyuan * */ public class ReadWriteLockTest { public static void main(String[] args) { final Queu

java中ReentrantReadWriteLock读写锁的使用

ReentrantReadWriteLock读写锁的使用 Lock比传统线程模型中的synchronized方式更加面向对象,与生活中的锁类似,锁本身也应该是一个对象.两个线程执行的代码片段要实现同步互斥的效果,它们必须用同一个Lock对象. 读写锁:分为读锁和写锁,多个读锁不互斥,读锁与写锁互斥,这是由jvm自己控制的,你只要上好相应的锁即可.如果你的代码只读数据,可以很多人同时读,但不能同时写,那就上读锁:如果你的代码修改数据,只能有一个人在写,且不能同时读取,那就上写锁.总之,读的时候上读

java并发编程-读写锁

最近项目中需要用到读写锁 读写锁适用于读操作多,写操作少的场景,假设你的程序中涉及到对一些共享资源的读和写操作,且写操作没有读操作那么频繁.在没有写操作的时候,两个线程同时读一个资源没有任何问题,所以应该允许多个线程能在同时读取共享资源.但是如果有一个线程想去写这些共享资源,就不应该再有其它线程对该资源进行读或写,也就是说 读-读能共存,读-写不能共存,写-写不能共存 我们直接使用java的读写锁  ReadWriteLock 如下代码是使用缓存的典型场景: public class ReadW

java中的读/写锁

读写锁接口:ReadWriteLock,它的具体实现类为:ReentrantReadWriteLock 使用场景: 对于一个资源,读读能共存,读写不能共存,写写不能共存. 锁降级:从写锁变成读锁: 锁升级:从读锁变成写锁. ReentrantReadWriteLock不支持锁升级,支持锁降级 ReadWriteLock rtLock = new ReentrantReadWriteLock(); rtLock.readLock().lock(); System.out.println("get

22、Java并发性和多线程-Java中的读/写锁

以下内容转自http://ifeve.com/read-write-locks/: 相比Java中的锁(Locks in Java)里Lock实现,读写锁更复杂一些.假设你的程序中涉及到对一些共享资源的读和写操作,且写操作没有读操作那么频繁.在没有写操作的时候,两个线程同时读一个资源没有任何问题,所以应该允许多个线程能在同时读取共享资源.但是如果有一个线程想去写这些共享资源,就不应该再有其它线程对该资源进行读或写(译者注:也就是说:读-读能共存,读-写不能共存,写-写不能共存).这就需要一个读/

java多线程 -- ReadWriteLock 读写锁

写一条线程,读多条线程能够提升效率. 写写/读写 需要"互斥";读读 不需要互斥. ReadWriteLock 维护了一对相关的锁,一个用于只读操作,另一个用于写入操作.只要没有 writer,读取锁可以由多个 reader 线程同时保持.写入锁是独占的. ReadWriteLock 读取操作通常不会改变共享资源,但执行写入操作时,必须独占方式来获取锁.对于读取操作占多数的数据结构. ReadWriteLock 能提供比独占锁更高的并发性.而对于只读的数据结构,其中包含的不变性可以完全

ReentrantReadWriteLock读写锁详解

一.读写锁简介 现实中有这样一种场景:对共享资源有读和写的操作,且写操作没有读操作那么频繁.在没有写操作的时候,多个线程同时读一个资源没有任何问题,所以应该允许多个线程同时读取共享资源:但是如果一个线程想去写这些共享资源,就不应该允许其他线程对该资源进行读和写的操作了. 针对这种场景,JAVA的并发包提供了读写锁ReentrantReadWriteLock,它表示两个锁,一个是读操作相关的锁,称为共享锁:一个是写相关的锁,称为排他锁,描述如下: 线程进入读锁的前提条件: 没有其他线程的写锁, 没

读写锁ReadWriteLock

为了提高性能,Java提供了读写锁,在读的地方使用读锁,在写的地方使用写锁,灵活控制,如果没有写锁的情况下,读是无阻塞的,在一定程度上提高了程序的执行效率. Java中读写锁有个接口java.util.concurrent.locks.ReadWriteLock,也有具体的实现ReentrantReadWriteLock,详细的API可以查看JavaAPI文档. ReentrantReadWriteLock 和 ReentrantLock 不是继承关系,但都是基于 AbstractQueuedS