QCache 缓存（类似于map的模板类，逻辑意义上的缓存Cache，方便管理，默认类似于LRU的淘汰算法）...

最新推荐文章于 2023-08-25 01:00:24 发布
最新推荐文章于 2023-08-25 01:00:24 发布
阅读量367 收藏 1
点赞数
文章标签： 数据结构与算法 c/c++ java
原文链接：http://www.cnblogs.com/MakeView660/p/10876545.html
版权

最近在学习缓存方面的知识，了解了缓存（Cache）的基本概念，为什么要使用缓存，以及一些缓存算法（缓存替换），如LRU、LFU、ARC等等。

这些缓存算法的实现过程会使用一些基本的数据结构，如list、map等。STL提供了一些标准的容器模板类可以拿来使用，我要在QT环境下测试，所以就近学习一下QT的容器类，如QList、QMap等。

 

可在QT官方帮助文档中关键词搜索“Container Classes”

这些容器类的设计比STL容器更轻，更安全，更易于使用。 如果您不熟悉STL，或者喜欢以“Qt方式”执行操作，则可以使用这些类而不是STL类。

这些容器类是隐式共享的，它们是可重用的，并且它们针对速度，低内存消耗和最小内联代码扩展进行了优化，从而导致较小的可执行文件。 此外，它们在用于访问它们的所有线程用作只读容器的情况下是线程安全的。

为了遍历存储在容器中的项，可以使用两种类型的迭代器之一：Java样式迭代器和STL样式迭代器。 Java样式的迭代器更易于使用并提供高级功能，而STL样式的迭代器更轻更高效，可以将Qt和STL的通用算法一起使用。

Qt还提供了一个foreach关键字，可以很容易地迭代存储在容器中的所有项目。

除了通用的容器类之外，Qt还包括三个模板类，在某些方面类似于容器。 这些类不提供迭代器，不能与foreach关键字一起使用。其中的一个模板类就是QCache。

QCache<Key, T>提供缓存以存储与键Key类型的键相关联的特定类型T的对象。

例如，下面的代码定义了一个缓存，里面存储的键是一个整数，值是我们自定义的Employee类型：

QCache<int, Employee> cache;

以下是如何在缓存中插入对象：

 C++ Code 
1
2
3
4
5
 
Employee *employee =  new  Employee;
employee->setId( 37 );
employee->setName( "Richard Schmit" );
...
cache.insert(employee->id(), employee);

使用QCache优于其它基于键key的数据结构（例如QMap或QHash）的地方主要表现在于QCache会自动获取插入到缓存中的对象的所有权，并删除它们以在必要时为新对象腾出空间。 将对象插入缓存时，可以指定其成本（cost），该成本应与对象占用的内存量具有某种近似关系。 当所有对象的成本（totalCost()）的总和超过缓存的限制（maxCost()）时，QCache就开始删除缓存中的对象以保持在限制之下，删除操作从最近访问较少的对象开始（内部的缓存淘汰机制）。

默认情况下，QCache的maxCost()为100。您可以在QCache构造函数中指定不同的值：

QCache<int, MyDataStructure> cache(5000);

每次调用insert()时，都可以将cost指定为第三个参数（在键和要插入的对象的指针插入之后）。 在调用之后，插入的对象由QCache拥有，QCache可以随时删除它以为其它对象腾出空间。

要在缓存中查找对象，请使用object()或operator []()。 此函数通过其键key查找对象，并返回指向缓存对象（由缓存拥有）的指针或空指针。

如果要从缓存中删除特定键的对象，请调用remove()， 这也将删除该对象。 如果要在没有QCache删除的情况下从缓存中删除对象，请使用take()。

 

至于，其他的操作，和普通容器类似。比如，

使用clear() 函数来释放缓存中所有的对象。

使用contains() 函数判断当前缓存中是否包含某个key。

使用count() 或 size() 函数获得当前缓存中保存的对象的个数。

使用isEmpty() 函数判断当前缓存是否包含有对象。

使用keys()函数获取当前缓存中的key列表。

使用setMaxCost ()函数设置缓存的最大允许总成本，如果当前总成本大于要设置的成本，则会立即删除某些对象。

 

下面是我实验的一个例子：

Employee有三个成员变量：访问次数access、id和名字name，并有其对应的seter和geter函数。

id和name通过随机数来产生，初始化cache为空并设置maxCost，如果能在缓存中找到id则访问次数access加1，否则就将其加入到缓存中去。

当达到最大maxCost数量时，QCache内部会淘汰掉最近访问较少的对象（即access次数较少的对象）。

 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
 
#include  <QCoreApplication>
 #include  <QRandomGenerator>
 #include  <QCache>
 #include  <QList>
 #include  <QDebug>

 class  Employee
{
 public :
    Employee()
    {
        m_nAccess =  0 ;
    }
    Employee( int  nId, QString strName)
    {
        m_nAccess =  0 ;
        m_nId = nId;
        m_strName = strName;
    }
    ~Employee()
    {

    }

     int  id()
    {
         return   m_nId;
    }
     int  access()
    {
         return  m_nAccess;
    }
    QString name()
    {
         return   m_strName;
    }
     void  setId( int  nId)
    {
        m_nId = nId;
    }
     void  setName(QString strName)
    {
        m_strName = strName;
    }
     void  addAccess()
    {
        m_nAccess++;
    }

 private :
     int          m_nAccess;           // 被访问次数
      int          m_nId;               // id
     QString     m_strName;           // 名字
 };

 int  main( int  argc,  char  *argv[])
{
    QCoreApplication a(argc, argv);
     // By default, QCache's maxCost() is 100. You can specify a different value in the QCache constructor
     QCache< int , Employee> cache( 5 );

     int  nCount =  0 ;
     while  (nCount <  50 )
    {
         int  nRandomId = QRandomGenerator::global()->bounded( 10 );
        qDebug() <<  "\nRequest ="  << nRandomId;
        QString strRandomName = QString::number(QRandomGenerator::global()->bounded( 100 ));
        Employee *pEmployee =  new  Employee(nRandomId, strRandomName);
         // 在缓存中查找
         Employee *pEmployeeTmp = cache.object(nRandomId);
         if  (pEmployeeTmp != nullptr)
        {
             // 找到了...
             qDebug() <<  "find ID ="  << pEmployeeTmp->id() <<   "Name ="  << pEmployeeTmp->name();
            pEmployeeTmp->addAccess();
        }
         else
        {
             // 没找到，则将其插入到缓存中去
             cache.insert(pEmployee->id(), pEmployee);
        }

         // 查看当前缓存中的情况
         QList< int > keys = cache.keys();
        qDebug() <<  "size of cache = "  << keys.size();
         for  ( int  i =  0 ; i < keys.size(); ++i)
        {
             int  nId = keys.at(i);
            Employee *pEmployee = cache.object(nId);
            qDebug() <<  "ID ="  << nId << \
                      "Name ="  << pEmployee->name() << \
                      "Access ="  << pEmployee->access();
        }
        nCount++;
    }

     return  a.exec();
}

输出结果：随着不断访问，缓存中访问最多的对象会保留，访问较少的的对象可能会被删除淘汰掉！

 NormalText Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
 
Request = 2
size of cache =  1
ID = 2 Name = "69" Access = 0

Request = 7
size of cache =  2
ID = 2 Name = "69" Access = 0
ID = 7 Name = "93" Access = 0

Request = 9
size of cache =  3
ID = 9 Name = "98" Access = 0
ID = 2 Name = "69" Access = 0
ID = 7 Name = "93" Access = 0

Request = 6
size of cache =  4
ID = 9 Name = "98" Access = 0
ID = 2 Name = "69" Access = 0
ID = 7 Name = "93" Access = 0
ID = 6 Name = "24" Access = 0

Request = 0
size of cache =  5
ID = 9 Name = "98" Access = 0
ID = 2 Name = "69" Access = 0
ID = 0 Name = "50" Access = 0
ID = 7 Name = "93" Access = 0
ID = 6 Name = "24" Access = 0

Request = 1
size of cache =  5
ID = 2 Name = "69" Access = 0
ID = 1 Name = "29" Access = 0
ID = 0 Name = "50" Access = 0
ID = 7 Name = "93" Access = 0
ID = 6 Name = "24" Access = 0

Request = 3
size of cache =  5
ID = 3 Name = "54" Access = 0
ID = 1 Name = "29" Access = 0
ID = 0 Name = "50" Access = 0
ID = 7 Name = "93" Access = 0
ID = 6 Name = "24" Access = 0

Request = 6
find ID = 6 Name = "24"
size of cache =  5
ID = 3 Name = "54" Access = 0
ID = 1 Name = "29" Access = 0
ID = 0 Name = "50" Access = 0
ID = 7 Name = "93" Access = 0
ID = 6 Name = "24" Access = 1

Request = 7
find ID = 7 Name = "93"
size of cache =  5
ID = 3 Name = "54" Access = 0
ID = 1 Name = "29" Access = 0
ID = 0 Name = "50" Access = 0
ID = 7 Name = "93" Access = 1
ID = 6 Name = "24" Access = 1

Request = 1
find ID = 1 Name = "29"
size of cache =  5
ID = 3 Name = "54" Access = 0
ID = 1 Name = "29" Access = 1
ID = 0 Name = "50" Access = 0
ID = 7 Name = "93" Access = 1
ID = 6 Name = "24" Access = 1

Request = 9
size of cache =  5
ID = 9 Name = "36" Access = 0
ID = 1 Name = "29" Access = 1
ID = 0 Name = "50" Access = 0
ID = 7 Name = "93" Access = 1
ID = 6 Name = "24" Access = 1

Request = 7
find ID = 7 Name = "93"
size of cache =  5
ID = 9 Name = "36" Access = 0
ID = 1 Name = "29" Access = 1
ID = 0 Name = "50" Access = 0
ID = 7 Name = "93" Access = 2
ID = 6 Name = "24" Access = 1

Request = 1
find ID = 1 Name = "29"
size of cache =  5
ID = 9 Name = "36" Access = 0
ID = 1 Name = "29" Access = 2
ID = 0 Name = "50" Access = 0
ID = 7 Name = "93" Access = 2
ID = 6 Name = "24" Access = 1

Request = 9
find ID = 9 Name = "36"
size of cache =  5
ID = 9 Name = "36" Access = 1
ID = 1 Name = "29" Access = 2
ID = 0 Name = "50" Access = 0
ID = 7 Name = "93" Access = 2
ID = 6 Name = "24" Access = 1

Request = 5
size of cache =  5
ID = 1 Name = "29" Access = 2
ID = 0 Name = "50" Access = 0
ID = 7 Name = "93" Access = 2
ID = 6 Name = "24" Access = 1
ID = 5 Name = "7" Access = 0

Request = 1
find ID = 1 Name = "29"
size of cache =  5
ID = 1 Name = "29" Access = 3
ID = 0 Name = "50" Access = 0
ID = 7 Name = "93" Access = 2
ID = 6 Name = "24" Access = 1
ID = 5 Name = "7" Access = 0

Request = 5
find ID = 5 Name = "7"
size of cache =  5
ID = 1 Name = "29" Access = 3
ID = 0 Name = "50" Access = 0
ID = 7 Name = "93" Access = 2
ID = 6 Name = "24" Access = 1
ID = 5 Name = "7" Access = 1

Request = 6
find ID = 6 Name = "24"
size of cache =  5
ID = 1 Name = "29" Access = 3
ID = 0 Name = "50" Access = 0
ID = 7 Name = "93" Access = 2
ID = 6 Name = "24" Access = 2
ID = 5 Name = "7" Access = 1

Request = 4
size of cache =  5
ID = 4 Name = "1" Access = 0
ID = 0 Name = "50" Access = 0
ID = 7 Name = "93" Access = 2
ID = 6 Name = "24" Access = 2
ID = 5 Name = "7" Access = 1

Request = 5
find ID = 5 Name = "7"
size of cache =  5
ID = 4 Name = "1" Access = 0
ID = 0 Name = "50" Access = 0
ID = 7 Name = "93" Access = 2
ID = 6 Name = "24" Access = 2
ID = 5 Name = "7" Access = 2

Request = 4
find ID = 4 Name = "1"
size of cache =  5
ID = 4 Name = "1" Access = 1
ID = 0 Name = "50" Access = 0
ID = 7 Name = "93" Access = 2
ID = 6 Name = "24" Access = 2
ID = 5 Name = "7" Access = 2

Request = 6
find ID = 6 Name = "24"
size of cache =  5
ID = 4 Name = "1" Access = 1
ID = 0 Name = "50" Access = 0
ID = 7 Name = "93" Access = 2
ID = 6 Name = "24" Access = 3
ID = 5 Name = "7" Access = 2

Request = 2
size of cache =  5
ID = 2 Name = "28" Access = 0
ID = 0 Name = "50" Access = 0
ID = 7 Name = "93" Access = 2
ID = 6 Name = "24" Access = 3
ID = 5 Name = "7" Access = 2

Request = 6
find ID = 6 Name = "24"
size of cache =  5
ID = 2 Name = "28" Access = 0
ID = 0 Name = "50" Access = 0
ID = 7 Name = "93" Access = 2
ID = 6 Name = "24" Access = 4
ID = 5 Name = "7" Access = 2

Request = 8
size of cache =  5
ID = 8 Name = "44" Access = 0
ID = 0 Name = "50" Access = 0
ID = 7 Name = "93" Access = 2
ID = 6 Name = "24" Access = 4
ID = 5 Name = "7" Access = 2

Request = 5
find ID = 5 Name = "7"
size of cache =  5
ID = 8 Name = "44" Access = 0
ID = 0 Name = "50" Access = 0
ID = 7 Name = "93" Access = 2
ID = 6 Name = "24" Access = 4
ID = 5 Name = "7" Access = 3

Request = 4
size of cache =  5
ID = 4 Name = "90" Access = 0
ID = 0 Name = "50" Access = 0
ID = 7 Name = "93" Access = 2
ID = 6 Name = "24" Access = 4
ID = 5 Name = "7" Access = 3

Request = 7
find ID = 7 Name = "93"
size of cache =  5
ID = 4 Name = "90" Access = 0
ID = 0 Name = "50" Access = 0
ID = 7 Name = "93" Access = 3
ID = 6 Name = "24" Access = 4
ID = 5 Name = "7" Access = 3

Request = 0
find ID = 0 Name = "50"
size of cache =  5
ID = 4 Name = "90" Access = 0
ID = 0 Name = "50" Access = 1
ID = 7 Name = "93" Access = 3
ID = 6 Name = "24" Access = 4
ID = 5 Name = "7" Access = 3

Request = 8
size of cache =  5
ID = 8 Name = "74" Access = 0
ID = 0 Name = "50" Access = 1
ID = 7 Name = "93" Access = 3
ID = 6 Name = "24" Access = 4
ID = 5 Name = "7" Access = 3

Request = 9
size of cache =  5
ID = 9 Name = "51" Access = 0
ID = 0 Name = "50" Access = 1
ID = 7 Name = "93" Access = 3
ID = 6 Name = "24" Access = 4
ID = 5 Name = "7" Access = 3

Request = 3
size of cache =  5
ID = 3 Name = "23" Access = 0
ID = 0 Name = "50" Access = 1
ID = 7 Name = "93" Access = 3
ID = 6 Name = "24" Access = 4
ID = 5 Name = "7" Access = 3

Request = 7
find ID = 7 Name = "93"
size of cache =  5
ID = 3 Name = "23" Access = 0
ID = 0 Name = "50" Access = 1
ID = 7 Name = "93" Access = 4
ID = 6 Name = "24" Access = 4
ID = 5 Name = "7" Access = 3

Request = 0
find ID = 0 Name = "50"
size of cache =  5
ID = 3 Name = "23" Access = 0
ID = 0 Name = "50" Access = 2
ID = 7 Name = "93" Access = 4
ID = 6 Name = "24" Access = 4
ID = 5 Name = "7" Access = 3

Request = 4
size of cache =  5
ID = 4 Name = "10" Access = 0
ID = 0 Name = "50" Access = 2
ID = 7 Name = "93" Access = 4
ID = 6 Name = "24" Access = 4
ID = 5 Name = "7" Access = 3

Request = 1
size of cache =  5
ID = 1 Name = "76" Access = 0
ID = 0 Name = "50" Access = 2
ID = 7 Name = "93" Access = 4
ID = 6 Name = "24" Access = 4
ID = 5 Name = "7" Access = 3

Request = 2
size of cache =  5
ID = 2 Name = "29" Access = 0
ID = 0 Name = "50" Access = 2
ID = 7 Name = "93" Access = 4
ID = 6 Name = "24" Access = 4
ID = 5 Name = "7" Access = 3

Request = 4
size of cache =  5
ID = 4 Name = "48" Access = 0
ID = 0 Name = "50" Access = 2
ID = 7 Name = "93" Access = 4
ID = 6 Name = "24" Access = 4
ID = 5 Name = "7" Access = 3

Request = 2
size of cache =  5
ID = 2 Name = "79" Access = 0
ID = 0 Name = "50" Access = 2
ID = 7 Name = "93" Access = 4
ID = 6 Name = "24" Access = 4
ID = 5 Name = "7" Access = 3

Request = 6
find ID = 6 Name = "24"
size of cache =  5
ID = 2 Name = "79" Access = 0
ID = 0 Name = "50" Access = 2
ID = 7 Name = "93" Access = 4
ID = 6 Name = "24" Access = 5
ID = 5 Name = "7" Access = 3

Request = 0
find ID = 0 Name = "50"
size of cache =  5
ID = 2 Name = "79" Access = 0
ID = 0 Name = "50" Access = 3
ID = 7 Name = "93" Access = 4
ID = 6 Name = "24" Access = 5
ID = 5 Name = "7" Access = 3

Request = 7
find ID = 7 Name = "93"
size of cache =  5
ID = 2 Name = "79" Access = 0
ID = 0 Name = "50" Access = 3
ID = 7 Name = "93" Access = 5
ID = 6 Name = "24" Access = 5
ID = 5 Name = "7" Access = 3

Request = 5
find ID = 5 Name = "7"
size of cache =  5
ID = 2 Name = "79" Access = 0
ID = 0 Name = "50" Access = 3
ID = 7 Name = "93" Access = 5
ID = 6 Name = "24" Access = 5
ID = 5 Name = "7" Access = 4

Request = 2
find ID = 2 Name = "79"
size of cache =  5
ID = 2 Name = "79" Access = 1
ID = 0 Name = "50" Access = 3
ID = 7 Name = "93" Access = 5
ID = 6 Name = "24" Access = 5
ID = 5 Name = "7" Access = 4

Request = 9
size of cache =  5
ID = 9 Name = "2" Access = 0
ID = 0 Name = "50" Access = 3
ID = 7 Name = "93" Access = 5
ID = 6 Name = "24" Access = 5
ID = 5 Name = "7" Access = 4

Request = 3
size of cache =  5
ID = 3 Name = "16" Access = 0
ID = 0 Name = "50" Access = 3
ID = 7 Name = "93" Access = 5
ID = 6 Name = "24" Access = 5
ID = 5 Name = "7" Access = 4

Request = 3
find ID = 3 Name = "16"
size of cache =  5
ID = 3 Name = "16" Access = 1
ID = 0 Name = "50" Access = 3
ID = 7 Name = "93" Access = 5
ID = 6 Name = "24" Access = 5
ID = 5 Name = "7" Access = 4

Request = 0
find ID = 0 Name = "50"
size of cache =  5
ID = 3 Name = "16" Access = 1
ID = 0 Name = "50" Access = 4
ID = 7 Name = "93" Access = 5
ID = 6 Name = "24" Access = 5
ID = 5 Name = "7" Access = 4

Request = 6
find ID = 6 Name = "24"
size of cache =  5
ID = 3 Name = "16" Access = 1
ID = 0 Name = "50" Access = 4
ID = 7 Name = "93" Access = 5
ID = 6 Name = "24" Access = 6
ID = 5 Name = "7" Access = 4

Request = 8
size of cache =  5
ID = 8 Name = "85" Access = 0
ID = 0 Name = "50" Access = 4
ID = 7 Name = "93" Access = 5
ID = 6 Name = "24" Access = 6
ID = 5 Name = "7" Access = 4

转载于:https://www.cnblogs.com/MakeView660/p/10876545.html

weixin_30791095
关注
Qt中QCache类的使用
HackMasterX的博客
09-09 496
Qt是一个流行的跨平台应用程序开发框架，提供了丰富的类和工具来简化应用程序开发。QCache是Qt框架中的一个类，用于在内存中缓存对象，以提高数据访问的效率。QCache类位于Qt的QtCore模块中，用于缓存对象并提供快速的访问。它通过使用键值对的方式存储对象，每个对象都有一个唯一的键用于访问和检索。以上是使用QCache类的基本步骤。这个示例程序创建了一个QCache对象，向缓存中插入了三个键值对，并通过键获取了一个对象。然后，它从缓存中移除了一个对象，并启用了自动删除功能，最后清空了整个缓存。
Qt之QCache和QContiguousCache
最新发布
草上爬的博客
12-05 2883
Qt之QCache和QContiguousCache
QCache 缓存
03-19 3883
在软件开发中，我们经常需要在内存中存储一些临时数据用于后续相关计算。我们一般把这些数据存储到某个数组里，或者STL中的某个合适的容器中。其实，在Qt中直接为我们提供了一个QCache类专用于这种需求。 QCache类是一个模板类。QCache 就定义了一个缓存，其类似于map，也是存储的键值对。例如，下面的代码定义了一个缓存，里面存储的键是一个整数，值是我们自定义的Employee类型：
QCache
友善啊，朋友的博客
09-20 1846
一、描述 QCache<Key, T> 定义了一个缓存，用于存储键值对。 与其他一些基于键的数据结构（例如 QMap 或 QHash）相比，使用 QCache 的优势在于 QCache 会自动获取插入缓存中的对象的所有权，并在必要时删除它们以为新对象腾出空间。 将对象插入缓存时，可以指定一个成本（cost），该成本与对象占用的内存量有一定的关系。当所有对象的成本总和 (totalCost()) 超过缓存的限制 (maxCost()) 时，QCache 开始删除缓存中的对象以保持在限制之下。
用Qt写软件系列一：QCacheViewer(浏览器缓存查看器)
weixin_34090562的博客
02-13 189
介绍      Cache技术广泛应用于计算机行业的软硬件领域。该技术既是人们对新技术探讨的结果，也是对当前软硬件计算能力的一种妥协。在浏览器中使用cache技术，可以大幅度提高web页面的响应速度，降低数据传输延迟，提高web用户的体验。因此，客户端在浏览网页的过程中，会在本地缓存许多文件。随着使用时间增长，本地缓存的文件日渐增多。对于用户来说，查看本地主机当前的缓存文件数目和种类成为一种迫切...
QCache:基于Raft 实现的分布式缓存
05-09
Raft Based Distributed Cache 基于Raft论文实现的,整体思路就是由Raft算法维持集群状态的一致性（节点丢失，增加问题）,一致性hash将数据分散到各个节点上 支持的功能 leader选举.不管是刚启动还是leader丢失,都能保证一轮选举选出新leader 集群成员动态更变,保证集群半数以上server活着,依然能对外提供服务 基于一致性hash保证缓存数据的负载均衡,客户端连接也是连接到目标数据节点上 客户端由于配置了集群的信息,也可以生成一致性hash,虽然跟服务器可能不一致,但是正常情况是命中率很高. 在集群没有节点丢失是100%命中,即出现不命中的情况,会同步服务的节点状况,发起二次请求,不影响后续的请求. 缓存数据的备份(内存快照 + 写操作的日志 = 完整缓存数据) 技术点 Raft算法. 一致性Hash. Netty,集群节点之间的通信使用的N
QCache本来就是模板类，将 QCache<QString,QVector<T>>t_cache;定义在模板类中，QCache.take()方法报错
06-01
如果你将`QCache, QVector<T>>`定义在一个模板类中，并且在模板类中使用`QCache`的`take`方法时出现了编译错误，可能是因为编译器无法确定使用哪个`take`方法。 为了解决这个问题，你可以使用作用域解析运算符`::`...
QCache本来就是模板类，将 QCache<QString,QVector<T>>t_cache;定义在模板类中，t_cache.take()方法报错
06-01
如果你将`QCache, QVector<T>>`定义在一个模板类中，并且在模板类中使用`t_cache`的`take`方法时出现了编译错误，可能是因为编译器无法确定使用哪个`take`方法。 为了解决这个问题，你可以使用作用域解析运算符`::`...
QCache本来就是模板类，将它定义在模板类中，QCache.take()方法报错
06-01
如果你将`QCache`定义在一个模板类中，并且在模板类中使用`QCache`的`take`方法时出现了编译错误，可能是因为编译器无法确定使用哪个`take`方法。 为了解决这个问题，你可以试着使用作用域解析运算符`::`来指定使用...
QT的QCache类的使用
希望我的博客，能帮上你解决学习中工作中所遇到的问题
12-03 1411
详细说明 QCache类是提供缓存的模板类。 QCache <Key，T>定义了一个高速缓存，用于存储与类型为Key的键相关联的类型为T的对象。 例如，这是缓存的定义，该缓存存储与整数键关联的Employee类型的对象： QCache<int, Employee> cache; 以下是在缓存中插入对象的方法： Employee *employee = new Employee; employee->setId(37); employee->setName("
qcachegrind for windows
09-12
The QCacheGrind branch of KCacheGrind compiled with the QT5 toolkit for use in Windows.
三十七、Qt缓存之QCache
panchang199266的博客
03-03 8047
这吊玩意，到处是坑！慎用！！！ 一、基本介绍   QCache类是一个模板类。QCache<key， T> 就定义了一个缓存，其类似于map，也是存储的键值对。bool QCache<Key,T>::insert(const Key &akey, T *aobject, int acost)：这是插入缓存操作，可以看到QCache里存储的值只能是一个指针。   用Q...
QT框架中的缓存：为什么有QHash和QMap，还设计了QCache和QContiguousCache？
QT性能优化QT原理源码QT界面美化
07-15 371
简介本文介绍了QT框架中可用于缓存的几个数据类型各自的特点；通过本文读者可以了解到为什么有QHash和QMap，还设计了QCache和QContiguousCache？目录QHash和QMap有哪些不足？QCache有什么优点？QContiguousCache有什么优点？正文。
qcache_inserts com_select 与缓存命中率
wzy0623的专栏
12-28 2234
高性能MySQL这本书中关于查询缓存有一段这样的描述： Cache invalidations can happen because of fragmentation, insufficient memory, ordata modifications. If you have allocated enough memory to the cache and tuned thequery_cach
QT中使用QCache类进行缓存
CodeLancerX的博客
08-25 426
另外，QCache类也提供了一系列其他的成员函数，例如setAutoDelete()函数用于设置缓存中的对象被删除时是否自动删除其对应的对象，setMaxCost()函数用于设置缓存最大容量等。其中，maxCost参数表示缓存所能容纳的最大条目数，size参数表示一个缓存条目的大小，autoDelete参数则表示当缓存中的对象被删除时，是否自动删除其对应的对象。本文将介绍QCache类的使用方法，并提供相应的源代码。QCache类是QT提供的一个缓存类，其中的缓存项可以通过插入键值对的方式保存到缓存中。
电脑中的cache文件夹可以删除吗？
jiamisoft的博客
08-08 8170
高速缓存之所以能提升系统的速度是基于一种统计规律，主板上的控制系统会自动统计内存中哪些数据会被频繁的使用，就把这些数据存在高速缓存中，CPU 要访问这些数据时，就会先到 Cache 中去找，从而提升整体的运行速度。不过现在的 Pentium II 的 CPU 已经将主板上的二级缓存封装在 CPU 的盒子中，AMD K6-3 的 CPU 内部也集成了 256K 的二级 Cache，对于这类 CPU 来说，主板上提供的已是三级缓存了。在浏览网页的过程中，网页会自动存储在网友的硬盘上。...
QList存储数据释放内存
yangxueyangxue的博客
01-30 3985
QList 1.T的类型为非指针，这时候直接调用clear()方法就可以释放 #include    #include    #include    int main(int argc, char *argv[])      {       QCoreApplication a(argc, argv);       typedef struct _test  
pyhton中__pycache__文件夹的产生与作用
热门推荐
yitiaodashu的博客
01-10 7万+
源起 今天和一新来的同事沟通，说他用python编写了一个工程，但在第一次运行后，发现工程根目录下生成了一个__pycache__文件夹，里面是和py文件同名的各种以 .cpython-35.pyc 结尾的文件，问同事都不太清楚，所以便抽空整理了一下该知识点。先解释下cpython-35，cpython代表的是c语言实现的Python解释器，-35代表的是版本为3.5版。 至于pyc，先来了解
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值