cache 订阅
Caché,是 一种后关系型数据库。能并发访问同一数据的数据库技术。 展开全文
Caché,是 一种后关系型数据库。能并发访问同一数据的数据库技术。
信息
定    义
一种后关系型数据库
作    用
对事务数据的实时查询
针对对象
为专业开发者而设计
中文名
Caché
Caché简介
什么是 Caché?。它独一无二地提供了三种整合的、能并发访问同一数据的数据库技术:成熟的对象访问方式,高性能的 SQL 访问方式以及丰富的多维访问。在对象数据、关系型数据以及多维数据视图之间不需要映射,这样就大大节省了开发和运行时间。
收起全文
精华内容
参与话题
问答
  • cache

    千次阅读 2018-11-01 17:39:40
    CPU,内存和cache之间的关系 和 cache的操作 https://blog.csdn.net/vanbreaker/article/details/7470830 cache和内存的关联方式(associativity) https://blog.csdn.net/vanbreaker/article/details/7475093 ...

    CPU,内存和cache之间的关系  和 cache的操作

    https://blog.csdn.net/vanbreaker/article/details/7470830

    cache和内存的关联方式(associativity)

    https://blog.csdn.net/vanbreaker/article/details/7475093

    cache的写策略和多处理器支持

    https://blog.csdn.net/vanbreaker/article/details/7477853#comments

    cache读写机制

    https://blog.csdn.net/tc_xjyxhd/article/details/50603007

    首先是Write-through和Write-back的区别:(这部分参考:http://witmax.cn/cache-writing-policies.html)

    Write-through(直写模式、写透模式):数据更新时,同时写入Cache和下一级存储。不存在dirty问题。

    优点:简单可靠,不涉及cahce一致性问题;缺点:速度慢(因为同时写下一级存储(比如DDR))。

    Write-back(回写模式):数据更新时,只写Cache;当数据被替换出来时,才将该被修改的Cache数据写到下一级存储。涉及dirty这个概念。

    优点:速度快;下一级存储没有副本,若出现意外情况数据将丢失。

    顺便,dirty:是指cache某个位置数据被更新了,但是还没更新其对应的下一级存储位置(即cache不一致);相反

       clean:cache数据与下一级存储位置数据一致

    而allocate是针对cache miss时的处理方式,下面是我的理解:

    No-allocate:不论读、写操作,cache miss时,直接写下一级存储(如DDR)

    Read-allocate:读操作,cache miss时,在cache中分配一个空间,从下一级存储读取该数据到cache分配的这个空间,最后读取该值。注意:对于Write-back模式,如果分配的这个位置原数据是dirty的,需要将该数据先写回下一级存储。

    Write-allocate:写操作,cache miss时,在cache中分配一个空间,将数据先写入该位置,根据Write-back还是Write-through决定是否再写入下一级存储。注意:对于Write-back模式,如果分配的这个位置原数据是dirty的,需要将该数据先写回下一级存储。


    下面为参考网址给出的2个示例图,第一个是Write-through Read-allocate,第二个是Write-back Read and Write-allocate

    A Write-Through cache with No-Write Allocation

    简单总结一下该部分:Write-through和Write-back为写入cache的模式,区别是在写cache时是否还同时写下一级memory;allocate那堆只在cache miss时生效,负责分配cache空间给读和写中转用;另外,dirty只发生在Write-back模式,需要额外进行一步回写。
     

    Cache基础知识归纳总结

    https://blog.csdn.net/u010959074/article/details/52051606

    1、缓存行
    a) 缓存行:CPU不再是按字节访问内存,而是以64字节为单位的块(chunk)拿取,称为一个缓存行(cache line)。
    b) 当程序运行的时间主要与内存访问的次数相关时,Cache的影响很重要。
    c) 内存被分割成主存块(chunk)
    d) 数据对齐。
    2、L1和L2缓存
    a) L1数据缓存,一个32KB的L1指令缓存,还有一个4MB大小L2数据缓存。L1缓存是处理器独享的,L2缓存是成对处理器共享的。
    b) L1 速度 > L2 速度
    c) 计算机的计算数据需要从磁盘调度到内存,然后再调度到L2 Cache,再到L1 Cache,最后进CPU寄存器进行计算。
    3、指令级别的并发
    a) 指令级别的并发性:部分指令具有并发性,U/V两条流水线。
    4、缓存的关联性
     
    a) 缓存关联性
    b) 直接映射:每个内存块只能映射到一个特定的缓存槽
    c) N路组关联(N-way set associative cache):每个内存块能够被映射到N路特定缓存槽中的任意一路。
    d) 完全关联(Fully associative cache):每个内存块能够被映射到任意一个缓存槽。操作效果上相当于一个散列表。
    5、缓存行的为共享
    a) 缓存行的为共享:当一个处理器改变了属于它自己缓存中的一个值,其它处理器就再也无法使用它自己原来的值,因为其对应的内存位置将被刷新(invalidate)到所有缓存。而且由于缓存操作是以缓存行而不是字节为粒度,所有缓存中整个缓存行将被刷新!
    b) volatile关键字
    当变量被某个线程A修改值之后,其它线程比如B若读取此变量的话,立刻可以看到原来线程A修改后的值
    注:普通变量与volatile变量的区别是volatile的特殊规则保证了新值能立即同步到主内存,以及每次使用前可以立即从内存刷新,即一个线程修改了某个变量的值,其它线程读取的话肯定能看到新的值;
    6、硬件复杂性
    a) 有些处理器上,L1缓存能够并发处理两路访问,如果访问是来自不同的存储体(?),而对同一存储体的访问只能串行处理。而且处理器聪明的优化策略也会使你感到惊讶,比如在伪共享的例子中,以前在一些没有微调的机器上运行表现并不良好,但我家里的机器能够对最简单的例子进行优化来减少缓存刷新。


    a) 程序的运行存在时间和空间上的局部性
    前者是指只要内存中的值被换入缓存,今后一段时间内会被多次引用,后者是指该内存附近的值也被换入缓存。如果在编程中特别注意运用局部性原理,就会获得性能上的回报。
    比如C语言中应该尽量减少静态变量的引用,这是因为静态变量存储在全局数据段,在一个被反复调用的函数体内,引用该变量需要对缓存多次换入换出,而如果是分配在堆栈上的局部变量,函数每次调用CPU只要从缓存中就能找到它了,因为堆栈的重复利用率高。
    再比如循环体内的代码要尽量精简,因为代码(就是指令?)是放在指令缓存里的,而指令缓存都是一级缓存,只有几K字节大小,如果对某段代码需要多次读取,而这段代码又跨越一个L1缓存大小,那么缓存优势将荡然无存。
    b)关于CPU的流水线(pipeline)并发性简单说说,
    Intel Pentium处理器有两条流水线U和V,每条流水线可各自独立地读写缓存,所以可以在一个时钟周期内同时执行两条指令。但这两条流水线不是对等的,U流水线可以处理所有指令集,V流水线只能处理简单指令。
    CPU指令通常被分为四类,第一类是常用的简单指令,像mov, nop, push, pop, add, sub, and, or, xor, inc, dec, cmp, lea,可以在任意一条流水线执行,只要相互之间不存在依赖性,完全可以做到指令并发。
    第二类指令需要同别的流水线配合,像一些进位和移位操作,这类指令如果在U流水线中,那么别的指令可以在V流水线并发运行,如果在V流水线中,那么U流水线是暂停的。
    第三类指令是一些跳转指令,如cmp,call以及条件分支,它们同第二类相反,当工作在V流水线时才能通U流水线协作,否则只能独占CPU。
    第四类指令是其它复杂的指令,一般不常用,因为它们都只能独占CPU。
    如果是汇编级别编程,要达到指令级别并发,必须要注重指令之间的配对。尽量使用第一类指令,避免第四类,还要在顺序上减少上下文依赖。

    a) 缓存行的开始点?数据对齐?
    主存块(chunk),如果是8字节对齐则,起始地址为8的倍数。
    http://www.cnblogs.com/bakari/archive/2012/08/27/2658956.html
    Cache line alignment (cache对齐)
    数据跨越两个cache line,就意味着两次load或者两次store。如果数据结构是cache line对齐的,  就有可能减少一次读写。数据结构的首地址cache line对齐,意味着可能有内存浪费(特别是  数组这样连续分配的数据结构),所以需要在空间和时间两方面权衡。
    对于普通代码,内存边界对齐也是有好处的,可以降低高速缓存(Cache)和内存交换数据的次数。主要问题是在于Cache本身是分成很多Cache-Line,每条Cache-Line具有一定的长度,比如一般来说L1 Cache每条Cache Line长度在32个字节或64个字节;而L2的会更大,比如64个字节或128个字节。用户每次访问地址空间中一个变量,如果不在Cache当中,那么就需要从内存中先将数据调入Cache中.
    比如现在有个变量 int x;占用4个字节,它的起始地址是0x1234567F;那么它占用的内存范围就在0x1234567F-0x12345682之间。如果现在Cache Line长度为32个字节,那么每次内存同Cache进行数据交换时,都必须取起始地址时32(0x20)倍数的内存位置开始的一段长度为32的内存同Cache Line进行交换.   比如0x1234567F落在范围0x12345660~0x1234567F上,但是0x12345680~0x12345682落在范围 0x12345680~0x1234569F上,也就是说,为了将4个字节的整数变量0x1234567F~0x12345682装入Cache,我们必 须调入两条Cache Line的数据。但是如果int x的起始地址按4的倍数对齐,比如是 0x1234567C~0x1234567F,那么必然会落在一条Cache Line上,所以每次访问变量x就最多只需要装入一条Cache Line的数据了。比如现在一般的malloc()函数,返回的内存地址会已经是8字节对齐的,这个就是为了能够让大部分程序有更好的性能。

    b)多级缓存,级数设置?
    1级速度要求最高的速度,2级次之,3级最次,3个级数就够了,95%调用缓存,再多成本高。


    c)L1与L2的合作?
    http://coolshell.cn/articles/3236.html
    计算机的计算数据需要从磁盘调度到内存,然后再调度到L2 Cache,再到L1 Cache,最后进CPU寄存器进行计算。
    d) CPU的流水线?
    http://blog.jobbole.com/40844/
    I486拥有五级流水线。分别是:取指(Fetch),译码(D1, main decode),转址(D2, translate),执行(EX, execute),写回(WB)。某个指令可以在流水线的任何一级。
     
    但是这样的流水线有一个明显的缺陷。对于下面的指令代码,它们的功能是将两个变量的内
    容进行交换。
    1
    2
    3

    XOR a, b
    XOR b, a
    XOR a, b
    从8086直到386处理器都没有流水线。处理器一次只能执行一条指令。再这样的架构下,上面的代码执行并不会存在问题。
    但是i486处理器是首个拥有流水线的x86处理器,它执行上面的代码会发生什么呢?当你一下去观察很多指令在流水线中运行,你会觉得混乱,所以你需要回头参考上面的图。
    第一步是第一条指令进入取指阶段;然后在第二步第一条指令进入译码阶段,同时第二条指令进入取指阶段;第三步第一条指令进入转址阶段,第二条指令进入译码阶段,第三条指令进入取指阶段。但是在第四步会出现问题,第一条指令会进入执行阶段,而其他指令却不能继续向前移动。第二条xor指令需要第一条xor指令计算的结果a,但是直到第一条指令执行完成才会写回。所以流水线的其他指令就会在当前流水级等待直到第一条指令的执行和写回阶段完成。第二条指令会等待第一条指令完成才能进入流水线下一级,同样第三条指令也要等待第二条指令完成。
    这个现象被称为流水线阻塞或者流水线气泡。


    e) 本机中的缓存大小
    L1d cache:             12*32K  独享
    L1i cache:              12*32K独享
    L2 cache:              12*256K独享
    L3 cache:              30720K  一个物理cpu中所有内核共享
    NUMA node0 CPU(s):     0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46
    NUMA node1 CPU(s):     1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33,35,37,39,41,43,45,47
    f )  L1、L2缓存行大小。
    英特尔酷睿i7,酷睿, Atom和NetBurst, Core Solo和Pentium M处理器的L1,L2或L3缓存的高速缓存行是64个字节宽。


    g)写命中:
    http://blog.csdn.net/opensure/article/details/46669337
    当处理器将操作数写回到一个内存缓存的区域时,它首先会检查这个缓存的内存地址是否在缓存行中,如果不存在一个有效的缓存行,则处理器将这个操作数写回到缓存,而不是写回到内存,这个操作被称为写命中。

    ----------------------------------------------------------------------------

    术语 英文单词 描述
    共享变量 在多个线程之间能够被共享的变量被称为共享变量。共享变量包括所有的实例变量,静态变量和数组元素。他们都被存放在堆内存中,Volatile只作用于共享 变量。
    内存屏障 Memory Barriers 是一组处理器指令,用于实现对内存操作的顺序限制。
    备注: In the Java Memory Model a volatile field has a store barrier inserted after a write to it and a load barrier inserted before a read of it.
    缓冲行 Cache line 缓存中可以分配的最小存储单位。处理器填写缓存线时会加载整个缓存线,需要使用多个主内存读周期。
    原子操作 Atomic operations 不可中断的一个或一系列操作。
    缓存行填充 cache line fill 当处理器识别到从内存中读取操作数是可缓存的,处理器读取整个缓存行到适当的缓存(L1,L2,L3的或所有)
    缓存命中 cache hit 如果进行高速缓存行填充操作的内存位置仍然是下次处理器访问的地址时,处理器从缓存中读取操作数,而不是从内存。
    写命中 write hit 当处理器将操作数写回到一个内存缓存的区域时,它首先会检查这个缓存的内存地址是否在缓存行中,如果不存在一个有效的缓存行,则处理器将这个操 作数写回到缓存,而不是写回到内存,这个操作被称为写命中。
    写缺失 write misses the cache 一个有效的缓存行被写入到不存在的内存区域。
     

    展开全文
  • Cache

    千次阅读 2016-09-01 23:14:04
    Cache失效的原因 强制性失效 (Compulsory miss): 当第一次访问一个块时,该块不在 Cache中, 需从下一级存储中调入 Cache, 这就是强制性失效。这种失效也称为冷启动失效,或首次访问失效。(增加块大小,预取) 容量...
    1. Cache失效的原因
      1. 强制性失效 (Compulsory miss): 当第一次访问一个块时,该块不在 Cache中, 需从下一级存储中调入 Cache, 这就是强制性失效。这种失效也称为冷启动失效,或首次访问失效。(增加块大小,预取)
      2. 容量失效 (Capacity miss): 如果程序执行时所需的块不能全部调入 Cache 中, 则当某些块被替换后, 若又重新被访问, 就会发生失效。这种失效称为容量失效。(增加容量) 抖动现象。
      3. 冲突失效 (Conflict miss): 在组相联或直接映像 Cache 中, 若太多的块映像到同一组(块)中,则会出现该组中某个块被别的块替换、然后又被重新访问的情况。这就是发生了冲突失效。这种失效也称为碰撞失效 (collision) 或干扰失效 (interference)。(提高相联度)
    2. Cache性能的衡量标准
      1. 缺失率:访问Cache失效次数/访问内存总次数
        Miss Rate = Misses / Memory accesses
      2. 每条指令缺失次数:
        Misses/Instruction = Miss Rate * Memory accesses / Instruction
      3. 平均内存访问时间:
        Average memory access time = Hit time + Miss rate × Miss penalty
        hit time:cache 命中所需要的访问时间
        Miss penalty:失效开销,cache未命中,从内存取出相应块并替换cache中某块的时间之和
        注:平均内存访问时间虽然叫缺失率性能更好,但是它仍然是一种间接的方法,不能够直接代替执行时间。推测处理及可能执行其他指令在cache失效期间,能够弥补一部分损失。多线程的使用也能够容忍失效,避免处理机闲置。
    3. cache的基本优化方案
      1. 采用更大的块将低缺失率。
      2. 采用更大的cache降低缺失率。
      3. 搞关联性降低缺失率。
      4. 多级缓存降低缺失损失。
        average memory access time:
        Hit timeL1 + Miss rateL1 × (Hit timeL2 + Miss rateL2 × Miss penaltyL2)
      5. 给读缺失更高的优先级来降低缺失损失。
        在带有写缓冲的环境下适合使用这种优化方式。写缓冲有它的危害,写缓冲会保存更新的值,当一个读操作发送缺失时,由于缓冲和内存出现不一致情况下,读-写会产生危害。一种解决方案是在发生读缺失的情况下检查缓冲内容,如果没有和内存内容冲突,并且内存系统时可用的,那么先发送读操作,然后在写,降低缺失损失。这种方案没有额外的功率消耗。
      6. 在索引cache期间避免地址转换降低命中时间。
    展开全文
  • namespace Coldairarrow.Util { /// <summary>... public enum CacheType { /// <summary> /// 使用内存缓存(不支持分布式) /// </summary> Memory, /// <summary>
    namespace Coldairarrow.Util
    {
        /// <summary>
        /// 缓存类型
        /// </summary>
        public enum CacheType
        {
            /// <summary>
            /// 使用内存缓存(不支持分布式)
            /// </summary>
            Memory,
    
            /// <summary>
            /// 使用Redis缓存(支持分布式)
            /// </summary>
            Redis
        }
    }
    
    展开全文
  • 静态字段缓存基本使用 /// <summary> /// 1 客户端缓存-CDN缓存-反向代理缓存-本地缓存 /// 2 本地缓存原理和手写基础实现 /// 3 缓存更新/过期/多线程测试 /// 4 缓存类库封装和缓存应用总结 ...

    静态字段缓存基本使用

     /// <summary>
            ///  1 客户端缓存-CDN缓存-反向代理缓存-本地缓存
            ///  2 本地缓存原理和手写基础实现
            ///  3 缓存更新/过期/多线程测试 
            ///  4 缓存类库封装和缓存应用总结 
            /// </summary>
            /// <param name="args"></param>
            static void Main(string[] args)
            {
                try
                {
                    Console.WriteLine("开发进阶/蜕变架构!");
                    {
                        Console.WriteLine("***************DBHelper*****************");
                        for (int i = 0; i < 5; i++) //会重复查询数据
                        {
                            Console.WriteLine($"获取{nameof(DBHelper)} {i}次 {DateTime.Now.ToString("yyyyMMdd HHmmss.fff")}");
                            List<Program> programList = null;
                            string key = $"{nameof(Program)}_DBHelper.Query_{123}";
                            programList = CustomCache.GetT<List<Program>>(key, () =>
                            {
                                return DBHelper.Query<Program>(123);
                            });
                        }
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
                Console.Read();
            }
    
    /// <summary>
        ///模拟数据库查询
        /// </summary>
        public class DBHelper
        {
            /// <summary>
            /// 1 耗时耗资源
            /// 2 参数固定时,结果不变
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="index"></param>
            /// <returns></returns>
            public static List<T> Query<T>(int index)
            {
                Console.WriteLine("This is {0} Query", typeof(DBHelper));
                long lResult = 0;
                
                //耗时耗资源
                for (int i = index; i < 1_000_000_000; i++)
                {
                    lResult += i;
                }
    
                ///只要Index不变  返回值是不变的!
                List<T> tList = new List<T>();
                for (int i = 0; i < index % 3; i++)
                {
                    tList.Add(default(T));
                } 
                return tList;
            }
    
        }
    
    public class CustomCache
        {
            /// <summary>
            /// 字典缓存
            /// static:不会被Gc回收;
            /// Private:不让外部访问他 
            /// </summary>
            private static Dictionary<string, object> CustomCacheDictionary = new Dictionary<string, object>();
    
            public static void Add(string key, object value)
            {
                CustomCacheDictionary.Add(key, value);
            }
    
            public static T Get<T>(string key)
            {
                return (T)CustomCacheDictionary[key];
            }
    
            public static bool Exists(string key)
            {
                return CustomCacheDictionary.ContainsKey(key);
            }
    
            public static T GetT<T>(string key, Func<T> func)
            {
                T t = default(T);
                if (!Exists(key))
                {
                    t = func.Invoke();
                    Add(key, t);
                }
                else
                {
                    t = Get<T>(key);
                }
                return t;
            }
        }
    

    cache缓存封装

    /// <summary>
        /// Cache manager interface
        /// </summary>
        public interface ICache
        {
            /// <summary>
            /// Gets or sets the value associated with the specified key.
            /// </summary>
            /// <typeparam name="T">Type</typeparam>
            /// <param name="key">The key of the value to get.</param>
            /// <returns>The value associated with the specified key.</returns>
            T Get<T>(string key);
    
            /// <summary>
            /// Adds the specified key and object to the cache.
            /// </summary>
            /// <param name="key">key</param>
            /// <param name="data">Data</param>
            /// <param name="cacheTime">Cache time</param>
            void Add(string key, object data, int cacheTime = 30);
    
            /// <summary>
            /// Gets a value indicating whether the value associated with the specified key is cached
            /// </summary>
            /// <param name="key">key</param>
            /// <returns>Result</returns>
            bool Contains(string key);
    
            /// <summary>
            /// Removes the value with the specified key from the cache
            /// </summary>
            /// <param name="key">/key</param>
            void Remove(string key);
    
            /// <summary>
            /// Clear all cache data
            /// </summary>
            void RemoveAll();
    
            object this[string key] { get; set; }
    
            int Count { get; }
        }
    
    /// <summary>
        /// MemoryCacheCache
        /// </summary>
        public class MemoryCacheCache : ICache
        {
            public MemoryCacheCache() { }
    
            protected ObjectCache Cache
            {
                get
                {
                    return MemoryCache.Default;
                }
            }
    
            /// <summary>
            /// 读取缓存
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <returns></returns>
            public T Get<T>(string key)
            {
                if (Cache.Contains(key))
                {
                    return (T)Cache[key];
                }
                else
                {
                    return default(T);
                }
            }
    
            public object Get(string key)
            {
                return Cache[key];
            }
    
            /// <summary>
            /// 增加缓存
            /// </summary>
            /// <param name="key"></param>
            /// <param name="data"></param>
            /// <param name="cacheTime">分钟</param>
            public void Add(string key, object data, int cacheTime = 30)
            {
                if (data == null)
                    return;
    
                var policy = new CacheItemPolicy();
                policy.AbsoluteExpiration = DateTime.Now + TimeSpan.FromMinutes(cacheTime);
                Cache.Add(new CacheItem(key, data), policy);
            }
    
            /// <summary>
            /// 是否包含
            /// </summary>
            /// <param name="key"></param>
            /// <returns></returns>
            public bool Contains(string key)
            {
                return Cache.Contains(key);
            }
    
            public int Count { get { return (int)(Cache.GetCount()); } }
    
    
            /// <summary>
            /// 单个清除
            /// </summary>
            /// <param name="key">/key</param>
            public void Remove(string key)
            {
                Cache.Remove(key);
            }
    
            /// <summary>
            /// 正则表达式移除
            /// </summary>
            /// <param name="pattern">pattern</param>
            public void RemoveByPattern(string pattern)
            {
                var regex = new Regex(pattern, RegexOptions.Singleline | RegexOptions.Compiled | RegexOptions.IgnoreCase);
                var keysToRemove = new List<String>();
    
                foreach (var item in Cache)
                    if (regex.IsMatch(item.Key))
                        keysToRemove.Add(item.Key);
    
                foreach (string key in keysToRemove)
                {
                    Remove(key);
                }
            }
    
            /// <summary>
            /// 根据键值返回缓存数据
            /// </summary>
            /// <param name="key"></param>
            /// <returns></returns>
            public object this[string key]
            {
                get { return Cache.Get(key); }
                set { Add(key, value); }
            }
    
            /// <summary>
            /// 清除全部数据
            /// </summary>
            public void RemoveAll()
            {
                foreach (var item in Cache)
                    Remove(item.Key);
            }
        }
    

    缓存管理中心

    public class CacheManager
        {
            #region Identity
            private CacheManager()
            { }
    
            private static ICache cache = null;
    
            static CacheManager()
            {
                Console.WriteLine("开始缓存的初始化.....");
                //可以创建不同的cache对象
                cache = (ICache)Activator.CreateInstance(typeof(MemoryCacheCache));
                // 这里可以根据配置文件来选择
                //cache = (ICache)Activator.CreateInstance(typeof(CustomerCache));
            }
            #endregion Identity
    
            #region ICache
            /// <summary>
            /// 当前缓存数据项的个数
            /// </summary>
            public static int Count
            {
                get { return cache.Count; }
            }
    
            /// <summary>
            /// 如果缓存中已存在数据项键值,则返回true
            /// </summary>
            /// <param name="key">数据项键值</param>
            /// <returns>数据项是否存在</returns>
            public static bool Contains(string key)
            {
                return cache.Contains(key);
            }
    
            /// <summary>
            /// 获取缓存数据
            /// </summary>
            /// <param name="key"></param>
            /// <returns></returns>
            public static T GetData<T>(string key)
            {
                return cache.Get<T>(key);
            }
    
            /// <summary>
            /// 
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key">缓存的项</param>
            /// <param name="acquire">没有缓存的时候获取数据的方式</param>
            /// <param name="cacheTime">单位分钟  默认30</param>
            /// <returns></returns>
            public static T Get<T>(string key, Func<T> acquire, int cacheTime = 30)
            {
                if (!cache.Contains(key))
                {
                    T result = acquire.Invoke();
                    cache.Add(key, result, cacheTime);
                }
                return GetData<T>(key);
            }
    
            /// <summary>
            /// 添加缓存数据。
            /// 如果另一个相同键值的数据已经存在,原数据项将被删除,新数据项被添加。
            /// </summary>
            /// <param name="key">缓存数据的键值</param>
            /// <param name="value">缓存的数据,可以为null值</param>
            /// <param name="expiratTime">缓存过期时间间隔(单位:分钟)</param>
            public static void Add(string key, object value, int expiratTime = 30)
            {
                if (Contains(key))
                    cache.Remove(key);
                cache.Add(key, value, expiratTime);
            }
    
            /// <summary>
            /// 删除缓存数据项
            /// </summary>
            /// <param name="key"></param>
            public static void Remove(string key)
            {
                cache.Remove(key);
            }
    
            /// <summary>
            /// 删除所有缓存数据项
            /// </summary>
            public static void RemoveAll()
            {
                cache.RemoveAll();
            }
            #endregion
        }
    

    缓存优化

    /// <summary>
        /// 永不过期:当前就是
        /// 绝对过期:过了多长时间以后,就过期了 就不能用了
        /// 滑动过期:设定好过期时间后,如果在有效期内使用过,就往后滑动
        /// 1.Value;数据;
        /// 2.过期时间点:
        /// 3.滑动时间
        /// 普通cache
        /// </summary>
        public class CustomCache
        {
            static CustomCache() //CLR调用  整个进程执行且只执行一次
            {
                Task.Run(() => //
                {
                    while (true) //死循环来判断
                    {
                        try
                        {
                            List<string> delKeyList = new List<string>();
    
                            lock (obj_Lock)
                            {
                                foreach (var key in CustomCacheDictionary.Keys)
                                {
                                    DataModel model = CustomCacheDictionary[key];
                                    if (model.Deadline < DateTime.Now && model.ObsloteType != ObsloteType.Never)
                                    {
                                        delKeyList.Add(key);
                                    }
                                }
                            }
                            delKeyList.ForEach(key => Remove(key));
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine(ex.Message);
                            throw;
                        }
                    }
                });
            }
    
            /// <summary>
            /// static:不会被Gc回收;
            /// Private:不让外部访问他 
            /// </summary>
            private static Dictionary<string, DataModel> CustomCacheDictionary = new Dictionary<string, DataModel>();
    
            private static readonly object obj_Lock = new object();
    
    
            /// <summary>
            /// 默认你是不过期
            /// </summary>
            /// <param name="key"></param>
            /// <param name="value"></param>
            public static void Add(string key, object value)
            {
                lock (obj_Lock)
                    CustomCacheDictionary.Add(key, new DataModel()
                    {
                        Value = value,
                        ObsloteType = ObsloteType.Never
                    });
            }
    
            /// <summary>
            /// 绝对过期
            /// </summary>
            /// <param name="key"></param>
            /// <param name="value"></param>
            /// <param name="timeOutSecond"></param>
            public static void Add(string key, object value, int timeOutSecond) //3000
            {
                lock (obj_Lock)
                    CustomCacheDictionary.Add(key, new DataModel()
                    {
                        Value = value,
                        ObsloteType = ObsloteType.Absolutely,
                        Deadline = DateTime.Now.AddSeconds(timeOutSecond)
                    }); ;
            }
    
            public static void Add(string key, object value, TimeSpan durtion)
            {
                lock (obj_Lock)
                    CustomCacheDictionary.Add(key, new DataModel()
                    {
                        Value = value,
                        ObsloteType = ObsloteType.Relative,
                        Deadline = DateTime.Now.Add(durtion),
                        Duraton = durtion
                    }); ; ;
            }
    
    
            //清楚所有缓存,殃及池鱼!
            public static void RemoveAll()
            {
                lock (obj_Lock)
                    CustomCacheDictionary.Clear();//字典中的所有内容全部被清理到
            }
    
            public static void Remove(string key)
            {
                lock (obj_Lock)
                    CustomCacheDictionary.Remove(key);
            }
    
            public static void RemoveCondition(Func<string, bool> func)
            {
                List<string> keyList = new List<string>();
                lock (obj_Lock)
                    foreach (var key in CustomCacheDictionary.Keys)
                    {
                        if (func.Invoke(key))
                        {
                            keyList.Add(key);
                        }
                    }
                keyList.ForEach(s => Remove(s));
            }
    
            public static T Get<T>(string key)
            {
                return (T)(CustomCacheDictionary[key]).Value;
            }
    
            public static bool Exists(string key)
            {
                if (CustomCacheDictionary.ContainsKey(key))
                {
                    DataModel model = CustomCacheDictionary[key];
                    if (model.ObsloteType == ObsloteType.Never)
                    {
                        return true;
                    }
                    else if (model.Deadline < DateTime.Now) //
                    {
                        lock (obj_Lock)
                        {
    
                            CustomCacheDictionary.Remove(key);
                            return false;
                        }
    
                    }
                    else
                    {
                        if (model.ObsloteType == ObsloteType.Relative)
                        {
                            model.Deadline = DateTime.Now.Add(model.Duraton);
                        }
                        return true;
                    }
                }
                else
                {
                    return false;
                }
            }
    
            public static T GetT<T>(string key, Func<T> func)
            {
                T t = default(T);
                if (!Exists(key))
                {
                    t = func.Invoke();
                    Add(key, t);
                }
                else
                {
                    t = Get<T>(key);
                }
                return t;
            }
        }
        /// <summary>
        /// 线程安全cache
        /// </summary>
        public class CustomCacheNew
        {
    
            static CustomCacheNew() //
            {
                Task.Run(() => //
                {
                    while (true) //死循环来判断
                    {
                        try
                        {
                            //Thread.Sleep(60 * 1000 * 10); //十分钟后开始清理缓存
                            List<string> delKeyList = new List<string>();
                            foreach (var key in CustomCacheDictionary.Keys)
                            {
                                DataModel model = CustomCacheDictionary[key];
                                if (model.Deadline < DateTime.Now && model.ObsloteType != ObsloteType.Never) //
                                {
                                    delKeyList.Add(key);
                                }
                            }
                            delKeyList.ForEach(key => Remove(key));
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine(ex.Message);
                            throw;
                        }
                    }
                });
    
            }
    
            /// <summary>
            /// static:不会被Gc回收;
            /// Private:不让外部访问他 
            /// 
            /// 线程安全字典
            /// </summary>
            private static ConcurrentDictionary<string, DataModel> CustomCacheDictionary = new ConcurrentDictionary<string, DataModel>();
    
            /// <summary>
            /// 默认你是不过期
            /// </summary>
            /// <param name="key"></param>
            /// <param name="value"></param>
            public static void Add(string key, object value)
            {
                CustomCacheDictionary.TryAdd(key, new DataModel()
                {
                    Value = value,
                    ObsloteType = ObsloteType.Never
                });
            }
    
            /// <summary>
            /// 绝对过期
            /// </summary>
            /// <param name="key"></param>
            /// <param name="value"></param>
            /// <param name="timeOutSecond"></param>
            public static void Add(string key, object value, int timeOutSecond) //3000
            {
                CustomCacheDictionary.TryAdd(key, new DataModel()
                {
                    Value = value,
                    ObsloteType = ObsloteType.Absolutely,
                    Deadline = DateTime.Now.AddSeconds(timeOutSecond)
                }); ;
            }
    
            public static void Add(string key, object value, TimeSpan durtion)
            {
                CustomCacheDictionary.TryAdd(key, new DataModel()
                {
                    Value = value,
                    ObsloteType = ObsloteType.Relative,
                    Deadline = DateTime.Now.Add(durtion),
                    Duraton = durtion
                }); ; ;
            }
    
    
            //清楚所有缓存,殃及池鱼!
            public static void RemoveAll()
            {
                CustomCacheDictionary.Clear();//字典中的所有内容全部被清理到
            }
    
            public static void Remove(string key)
            {
                DataModel data = null;
                CustomCacheDictionary.TryRemove(key, out data);
            }
    
            
            public static T Get<T>(string key)
            {
                return (T)(CustomCacheDictionary[key]).Value;
            }
    
            /// <summary>
            /// 判断是否存在
            /// </summary>
            /// <param name="key"></param>
            /// <returns></returns>
            public static bool Exists(string key)
            {
                
                if (CustomCacheDictionary.ContainsKey(key))
                {
                    DataModel model = CustomCacheDictionary[key];
                    if (model.ObsloteType == ObsloteType.Never)
                    {
                        return true;
                    }
                    else if (model.Deadline < DateTime.Now) //
                    {
                        DataModel data = null;
                        CustomCacheDictionary.TryRemove(key, out data);
                        return false;
                    }
                    else
                    {
                        if (model.ObsloteType == ObsloteType.Relative)
                        {
                            model.Deadline = DateTime.Now.Add(model.Duraton);
                        }
                        return true;
                    }
                }
                else
                {
                    return false;
                }
            }
    
            public static T GetT<T>(string key, Func<T> func)
            {
                T t = default(T);
                if (!Exists(key))
                {
                    t = func.Invoke();
                    Add(key, t);
                }
                else
                {
                    t = Get<T>(key);
                }
                return t;
            }
        }
    
        internal class DataModel
        {
            public object Value { get; set; }
    
            public ObsloteType ObsloteType { get; set; }
    
            public DateTime Deadline { get; set; }
    
            public TimeSpan Duraton { get; set; }
        }
    
        public enum ObsloteType
        {
            Never,
            Absolutely,
            Relative
        }
    
        /// <summary>
        /// 解决性能问题
        /// </summary>
        public class CustomCacheNewproblem
        {
    
            private static List<Dictionary<string, DataModel>> dicCacheList = new List<Dictionary<string, DataModel>>();
            private static List<object> lockList = new List<object>();
    
            public static int CupNum = 0;
            static CustomCacheNewproblem()
            {
                CupNum = 3;//模拟获取获取CPU片数  
                //动态生成字典
                for (int i = 0; i < CupNum; i++)
                {
                    dicCacheList.Add(new Dictionary<string, DataModel>()); //CPU 有几片 就来几个字典
                    lockList.Add(new object());//没个字典对应一个锁
                }
    
    
                Task.Run(() => //
                {
                    while (true) //死循环来判断
                    {
                        try
                        {
    
                            for (int i = 0; i < CupNum; i++)
                            {
                                lock (lockList[i])
                                { 
                                    //Thread.Sleep(60 * 1000 * 10); //十分钟后开始清理缓存
                                    List<string> delKeyList = new List<string>();
                                    foreach (var key in dicCacheList[i].Keys)
                                    {
                                        DataModel model = dicCacheList[i][key];
                                        if (model.Deadline < DateTime.Now && model.ObsloteType != ObsloteType.Never) //
                                        {
                                            delKeyList.Add(key);
                                        }
                                    } 
                                    delKeyList.ForEach(key => dicCacheList[i].Remove(key));
                                }
                            }
    
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine(ex.Message);
                            throw;
                        }
                    }
                });
    
            }
    
            /// <summary>
            /// 默认你是不过期
            /// </summary>
            /// <param name="key"></param>
            /// <param name="value"></param>
            public static void Add(string key, object value)
            {
                int hash = key.GetHashCode() * (-1); //只要字符串变,hash值不变!
                int index = hash % CupNum;
                lock (lockList[index])
                    dicCacheList[index].Add(key, new DataModel()
                    {
                        Value = value,
                        ObsloteType = ObsloteType.Never
                    });
            }
    
            /// <summary>
            /// 绝对过期
            /// </summary>
            /// <param name="key"></param>
            /// <param name="value"></param>
            /// <param name="timeOutSecond"></param>
            public static void Add(string key, object value, int timeOutSecond) //3000
            {
                int hash = key.GetHashCode() * (-1); //只要字符串变,hash值不变!
                int index = hash % CupNum;
                lock (lockList[index])
                    dicCacheList[index].Add(key, new DataModel()
                    {
                        Value = value,
                        ObsloteType = ObsloteType.Absolutely,
                        Deadline = DateTime.Now.AddSeconds(timeOutSecond)
                    }); ;
            }
    
            public static void Add(string key, object value, TimeSpan durtion)
            {
                int hash = key.GetHashCode() * (-1); //只要字符串变,hash值不变!
                int index = hash % CupNum;
                lock (lockList[index])
                    dicCacheList[index].Add(key, new DataModel()
                    {
                        Value = value,
                        ObsloteType = ObsloteType.Relative,
                        Deadline = DateTime.Now.Add(durtion),
                        Duraton = durtion
                    }); ; ;
            }
    
    
            //清楚所有缓存,殃及池鱼!
            public static void RemoveAll()
            {
                for (int i = 0; i < CupNum; i++)
                {
                    dicCacheList[i].Clear();
                }
            }
    
            public static void Remove(string key)
            {
                int hash = key.GetHashCode() * (-1); //只要字符串变,hash值不变!
                int index = hash % CupNum;
    
                if (dicCacheList[index].ContainsKey(key))
                {
                    dicCacheList[index].Remove(key);
                }
    
            }
    
           
            public static T Get<T>(string key)
            {
                int hash = key.GetHashCode() * (-1); //只要字符串变,hash值不变!
                int index = hash % CupNum;
    
                return (T)(dicCacheList[index][key]).Value;
            }
    
            /// <summary>
            /// 判断是否存在
            /// </summary>
            /// <param name="key"></param>
            /// <returns></returns>
            public static bool Exists(string key)
            {
                int hash = key.GetHashCode() * (-1); //只要字符串变,hash值不变!
                int index = hash % CupNum;
                if (dicCacheList[index].ContainsKey(key))
                {
                    DataModel model = dicCacheList[index][key];
                    if (model.ObsloteType == ObsloteType.Never)
                    {
                        return true;
                    }
                    else if (model.Deadline < DateTime.Now) //
                    {
                        dicCacheList[index].Remove(key);
                        return false;
                    }
                    else
                    {
                        if (model.ObsloteType == ObsloteType.Relative)
                        {
                            model.Deadline = DateTime.Now.Add(model.Duraton);
                        }
                        return true;
                    }
                }
                else
                {
                    return false;
                }
            }
    
            public static T GetT<T>(string key, Func<T> func)
            {
                T t = default(T);
                if (!Exists(key))
                {
                    t = func.Invoke();
                    Add(key, t);
                }
                else
                {
                    t = Get<T>(key);
                }
                return t;
            }
        }
    
    展开全文
  • IntegerCache

    万次阅读 2020-09-11 12:09:32
    Integer CacheIntegerCache源码Integer 使用Cache源码瞎搞 IntegerCache源码 java.lang.Integer.IntegerCache { static final int low = -128; static final int high; static final Integer cache[]; ... } ...
  • 浅谈http中的Cache-Control

    万次阅读 多人点赞 2018-09-23 14:58:13
    前言 ... 第一部分General是概要,包含请求地址,请求方式,状态码,服务器地址以及Referrer 策略。 第二部分是应答头部,是服务器返回的。...在http中,控制缓存开关的字段有两个:Pragma 和 Cache-Contro...
  • 1.5 no-cache 防止从缓存中返回过去的资源,请求中如包含该命令,表示客户端不会接收缓存过的响应,必须向源放武器转发请求 如果响应中包含该命令,那么缓存服务器不能对其资源进行缓存,且源服务器也将不在对缓存...
  • hibernate cache配置问题

    2015-09-24 13:43:50
    WARN: HHH020003: Could not find a specific ehcache configuration for cache named [org.hibernate.cache.internal.StandardQueryCache]; using defaults. <!-- 定义Hibernate Session工厂 --> ``` ${...
  • 计算机缓存Cache以及Cache Line详解

    万次阅读 多人点赞 2018-06-06 10:56:36
    1.计算机存储体系简介 存储器是分层次的,离CPU越近的存储器,速度越快,每字节的成本越高,同时容量也因此越小。寄存器速度最快,离CPU最近,成本最高,所以个数容量有限,其次是高速缓存(缓存也是分级,有L1,...
  • 配置缓存 public class Startup { public Startup(IConfiguration configuration) { Configuration = configuration; } public IConfiguration Configuration { get;... public void ConfigureServices...
  • 打算再html中通过meta的Cache-Control:no-cache/ no-store来禁止页面的缓存,可是无论如何都不起作用,刷新页面时css/js脚本一直都是from cache,请问这是什么原因,改如何解决,难道是一定要通过服务器才能控制页面...
  • RESULT CACHE

    千次阅读 2015-12-18 10:46:17
    RESULT CACHE是11g的新特性。 RESULT CACHE MODE MANUAL: When set to MANUAL (the default), query results are not stored in the result cache. If cached results are required for individual qu
  • Cache Pattern

    千次阅读 2013-03-04 13:12:46
    Oracle EBS中,如果获取Item,Organization等基础数据的信息。你可以写SQL来查,这种做法的不好处就是,在不同Procedure或者Function中,...以获取Organization为例,系统中标准的做法是: l_return_value := INV_CACHE.
  • <meta http-equiv="Cache-Control" content="no-cache"> ``` nginx中写了 ``` expires 0s; ``` js、css都加了hash后缀。 极少情况还是能刷出来 200 from cache,确认不是后退,而是F5或是地址栏输入...
  • import org.springframework.cache.annotation.CachingConfigurerSupport; import org.springframework.cache.annotation.EnableCaching; import org.springframework.cache.interceptor.KeyGenerator; import org....
  • java.io.IOException: Can not lock the registry cache file C:\Users\Administrator\.dubbo\dubbo-registry-127.0.0.1.cache, ignore and retry later, maybe multi java process use the file, please config: ...
  • Cache总义Cache用法之页面声明

    千次阅读 2007-03-20 22:05:00
    Cache总义Cache用法之页面声明Duration="#ofseconds"Location="Any|Client|Downstream|Server|None"VaryByControl="ControlName"VaryByCustom="browser|customstring"VaryByHeader="headers"VaryByParam="Parameter...
  • Cache lines & Cache coherence & False sharing

    千次阅读 2012-04-12 15:51:36
    Cache lines The data in a cache is grouped into blocks called cache-lines, which are typically 64 or 128 bytes wide. These are the smallest units of memory that can be read from, or written ...
  • jetcache官网教程

    万次阅读 多人点赞 2018-05-09 22:58:57
    jetcache简介JetCache是一个基于Java的缓存系统封装,提供统一的API和注解来简化缓存的使用。 JetCache提供了比SpringCache更加强大的注解,可以原生的支持TTL、两级缓存、分布式自动刷新,还提供了Cache接口用于...
  • Cache-Control设置不起效

    2018-01-03 07:50:12
    response.setHeader("Cache-Control", "public,max-age=310"); long expires = new Date().getTime() + 10 * 60 * 1000; response.setDateHeader("Expires", expires); response.setHeader("Etag", "12345");...
  • Cache地址映射

    千次阅读 2018-09-01 15:17:35
    理解Cache地址映射之前补充一些基础知识,Cache的地址映射和MMU(内存管理单元)和TLB Cache(转译查找缓存)中的映射是有区别的。Cache、TLB Cache、MMU在CPU中结构如图1所示,图1展现的是Cortex A9 Processor内部...
  • SpringCache完整案例介绍

    万次阅读 多人点赞 2019-11-28 12:51:29
      Spring从3.1开始定义了org.springframework.cache.Cache和org.springframework.cache.CacheManager 接口来统一不同的缓存技术;并支持使用JCache(JSR-107)注解简化我们开发;Cache接口为缓存的组件规范定义,...
  • Cache entry deserialization failed, entry ignored 解决

    万次阅读 热门讨论 2018-06-04 10:49:32
    打开anaconda prompt之后,安装pip install –upgrade –...Cache entry deserialization failed, entry ignored的错误 怎么解决呢?很简单, 就是用管理员权限打开anaconda prompt之后再安装就没问题了。...

空空如也

1 2 3 4 5 ... 20
收藏数 150,628
精华内容 60,251
关键字:

cache