Python可以做什么？你所不知道的Python——生活中的奇妙用途
Posted 住隔壁的王叔
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Python可以做什么？你所不知道的Python——生活中的奇妙用途相关的知识，希望对你有一定的参考价值。
大家都知道Python可以用来做数据分析、爬虫，甚至是人工智能，但却觉得那些东西比较遥远，会担心孩子学Python为时过早。
其实Python并不只是能做一些很专业、高端的应用，它在生活中也有很多实用而有趣的用途。在生活中应用Python，既能让初学者对编程产生浓厚的兴趣，还能够更清楚的知道：为什么要学编程，学编程能做些什么。
今天，小编就来给大家介绍一下Python在生活中的奇妙用途，希望对大家有所启发。
自制文字云
什么是文字云(Word Cloud)?顾名思义，它就像是由文字组成的云，相信你对这类的图一点都不陌生。
大家也许都知道文字云是什么，但可能不知道的是，用Python来自制文字云是一件很简单的事！基本上只要学会Python基本语法，再用几个好用的模组，你就能做出属于你自己的文字云。你还可以分析自己的文本，调成你想要的色调，让文字云长成你想要的图案。
为什么我们会需要文字云呢？文字云存在的目的，在于能让阅读者在不阅读所有文章的前提下，快速聚焦在大批文章中的主要内容，了解总体的趋势。
OCR(光学字符识别)
在我们的生活中，经常会看到图片中的文字，想提取出来分享，又或是需要填写网站的验证码。这就需要用到OCR ( Optical Character Recognition) ——光学字符识别。
可能很多人没有听过这个专业名词，但识别图像中的文字、自动填写验证码这类的应用在生活中已经非常普遍。在Python中，实现光学字符识别的相关模组便是Google所资助的Tesseract。Tesseract 是一个OCR 库， 是目前公认最优秀、最精确的开源OCR系统。
除了极高的精确度，Tesseract 也具有很高的灵活性。它可以通过训练识别出任何字体（只要这些字体的风格保持不变就可以），也可以识别出任何Unicode 字符。
自己做简易外挂
如果你曾经花费好长时间处理文件的重新命名，或是对几百份Word文档进行一样的修改工作，那么使用Python中的PyAutoGui模组，就可以大大减轻负担。几行代码就可以搞定，让电脑自动运行这些操作。
PyAutoGui模组可以模拟移动鼠标，单击鼠标，拖动鼠标以及键盘热键组合，因此经常用于制作各类外挂程序，替代人们完成各种自动化操作。
类似PyAutoGui这样的模组，你可以不懂其中的原理，但只要你知道如何使用这些工具，就可以实现事半功倍的效率！
自动发送Email
说到用Python发送Email，内行人一定都会想到Python的SMTP模组「Smtplib」，它是Python内建的函数库模组，所以不需要另外下载安装。
这个模组好用在哪呢？如果你是一个健忘的人，你就可以结合smtplib 模组和time模组，为自已量身定做一个小秘书程序，能够在特定的时间发送Email给你，提醒你重要的相关事宜，是不是很方便呢？
整理电脑文件
如果你经常下载东西，又没有好好整理文件夹的习惯，久而久之，电脑就会有很多重复文件，排列复杂。这时候你就可以用到Python的os 模组了。这个模组可以处理几乎所有与文件夹相关的操作，例如分类、移动、删除、复制和重新命名等。
除了这些，Python还可以实现：
★ 爬取网页上的资讯和下载网络上的图文内容。
★ 处理大大小小的Excel表格，内容合并、更新以及格式美化等。
★ 处理PDF档的分割与合并，加入水印和密码等操作。
★ 自动覆盖内容，填写线上表单。
★ 为自己量身定做抢高铁票的程序。
★ 以及更多…
关于Python技术储备
学好 Python 不论是就业还是做副业赚钱都不错，但要学会 Python 还是要有一个学习规划。最后大家分享一份全套的 Python 学习资料，给那些想学习 Python 的小伙伴们一点帮助！
一、Python所有方向的学习路线
Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。（文末获取！）
温馨提示：篇幅有限，已打包文件夹，获取方式在“文末”！！！
二、Python必备开发工具
三、Python视频合集
观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。
四、实战案例
光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。
五、Python练习题
检查学习结果。
六、面试资料
我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。
这份完整版的Python全套学习资料已经上传CSDN，朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】
你所不知道的堆外缓存
在互联网项目中，一般以堆内缓存的使用居多，无论是Guava，Memcache，还是JDK自带的HashMap，ConcurrentHashMap等，都是在堆内内存中做数据计算操作。这样做的好处显而易见，用户完全不必在意数据的分配，溢出，回收等操作，全部交由JVM来进行处理。由于JVM提供了诸多的垃圾回收算法，可以保证在不影响甚至微影响系统的前提下，做到堆内内存接近完美的管控。君不见，小如图书管理这样的系统，大如整个电商交易平台，都在JVM的加持下，服务于几个，十几个，乃至于上亿用户，而在这些系统中，堆内缓存组件所带来的收益可是居功至伟。在自下而上的互联网架构中，堆内缓存就像把卫这宫廷入口的剑士，神圣而庄严，真可谓谁敢横刀立马，唯我堆内缓存将军。
但是，事物都是有两面性的，堆内缓存在JVM的管理下，纵然无可挑剔，但是在GC过程中产生的程序小停顿和程序大停顿，则像一把利剑一样，斩断了对构造出完美高并发系统的念想。简单的以HashMap这个JDK自带的缓存组件为例，benchmark结果如下：
Benchmark Mode Cnt Score Error Units
localCacheBenchmark.testlocalCacheSet thrpt 20 85056.759 ± 126702.544 ops/s
其插入速度最快为85056.759+126702.544=211759.303ops，最慢为0，也就是每秒插入速度最快为20w，最慢为0。之所以为0，是因为HashMap中的数据在快速的增长过程中，引起了频繁的GC操作，为了给当前HashMap腾出足够的空间进行插入操作，不得不释放一些对象。频繁的GC，势必对插入速度有不小的影响，造成应用的偶尔性暂停。所以这也能解释为啥最慢的时候，ops为0了。 同时从benchmark数据，我们可以看到误差率为126702.544ops，比正常操作的85056.756要大很多，说明GC的影响，对HashMap的插入操作影响特别的大。
由于GC的存在，堆内缓存操作的ops会受到不小的影响，会造成原本小流量下10ms能够完成的内存计算，大流量下500ms还未完成。如果内存计算过于庞杂，则造成整体流程的ops吞吐量降低，也是极有可能的事儿。所以从这里可以看出，堆内缓存组件，在高并发的压力下，如果计算量巨大，尤其是写操作巨大，使其不会成为护城的利剑，反而成了性能的帮凶，何其可惧。
为了缓解在高并发，高写入操作下，堆内缓存组件造成的频繁GC问题，堆外缓存应运而生。从前面的描述我们知道，堆内缓存是受JVM管控的，所以我们不必担心垃圾回收的问题。但是堆外缓存是不受JVM管控的，所以也不受GC的影响导致的应用暂停问题。但是由于堆外缓存的使用，是以byte数组来进行的，所以需要自己进行序列化反序列化操作。目前已知的知名开源项目中，netty4的buffer pool采用了堆外缓存实现，具体的比对信息可以参考此处，具体的比对信息截图如下：
带有Direct字眼的即为offheap堆外Buffer，x轴为分配的内存大小，Y轴为耗时。从上面可以看出，小块内存分配，JVM要稍微优秀一点；但是大块内存分配，明显的堆外缓存要优秀一些。由于堆外Buffer操作不受GC影响，实际上性能更好一些。但是需要的垃圾回收管控也需要自己去做，要麻烦很多。
说到堆外缓存实现原理，不可不提到sun.misc.Unsafe这个package包。此包提供了底层的Unsafe操作方法，让我们可以直接在堆外内存做数据分配操作。由于是底层包，所以用户层面很少用到，只是一些jdk里面的核心类库会用到。其实例的初始化方式如下：
public static Unsafe getUnsafe() {
Class cc = sun.reflect.Reflection.getCallerClass(2);
if (cc.getClassLoader() != null)
throw new SecurityException("Unsafe");
return theUnsafe;
}
long address = unsafe.allocateMemory(100);
unsafe.putLong(address,1);
System.out.println(unsafe.getLong(address));
但是在运行的过程中，我们却遇到了如下的错误：
java.lang.SecurityException: Unsafe
at sun.misc.Unsafe.getUnsafe(Unsafe.java:90)
at UnsafeTest.testUnsafe(UnsafeTest.java:18)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:498)
.......
Process finished with exit code -1
可以看出，由于安全性的原因，我们是无法直接使用Unsafe的实例来进行数据操作的，主要原因是因为cc.getClassLoader()对theUnsafe实例做了过滤限制。但是我们可以直接用theUnsafe来实现，由于是private修饰，我们可以用反射来将private修饰改成public修饰，让其暴露出来供我们使用：
Field f = Unsafe.class.getDeclaredField("theUnsafe");
f.setAccessible(true);
Unsafe unsafe = (Unsafe) f.get(null);
long address = unsafe.allocateMemory(100);
unsafe.putLong(address,1);
System.out.println(unsafe.getLong(address));
上面的代码展示，其实已经说明了Unsafe方法的基本使用方式。如果想查看更多的Unsafe实现方式，个人推荐可以看看Cassandra源码中的中的Object mapper - Caffinitas里面关于Unsafe的实现。此类的名称为Uns.java，由于类精简，个人认为很值得一看，我贴出部分代码来：
static
{
try
{
Field field = Unsafe.class.getDeclaredField("theUnsafe");
field.setAccessible(true);
unsafe = (Unsafe) field.get(null);
if (unsafe.addressSize() > 8)
throw new RuntimeException("Address size " + unsafe.addressSize() + " not supported yet (max 8 bytes)");
if (__DEBUG_OFF_HEAP_MEMORY_ACCESS)
LOGGER.warn("Degraded performance due to off-heap memory allocations and access guarded by debug code enabled via system property " + OHCacheBuilder.SYSTEM_PROPERTY_PREFIX + "debugOffHeapAccess=true");
IAllocator alloc;
String allocType = __ALLOCATOR != null ? __ALLOCATOR : "jna";
switch (allocType)
{
case "unsafe":
alloc = new UnsafeAllocator();
LOGGER.info("OHC using sun.misc.Unsafe memory allocation");
break;
case "jna":
default:
alloc = new JNANativeAllocator();
LOGGER.info("OHC using JNA OS native malloc/free");
}
allocator = alloc;
}
catch (Exception e)
{
throw new AssertionError(e);
}
}
。。。。。。
static long getLongFromByteArray(byte[] array, int offset)
{
if (offset < 0 || offset + 8 > array.length)
throw new ArrayIndexOutOfBoundsException();
return unsafe.getLong(array, (long) Unsafe.ARRAY_BYTE_BASE_OFFSET + offset);
}
static int getIntFromByteArray(byte[] array, int offset)
{
if (offset < 0 || offset + 4 > array.length)
throw new ArrayIndexOutOfBoundsException();
return unsafe.getInt(array, (long) Unsafe.ARRAY_BYTE_BASE_OFFSET + offset);
}
static short getShortFromByteArray(byte[] array, int offset)
{
if (offset < 0 || offset + 2 > array.length)
throw new ArrayIndexOutOfBoundsException();
return unsafe.getShort(array, (long) Unsafe.ARRAY_BYTE_BASE_OFFSET + offset);
}
写到这里，原理什么的大概都懂了，我们准备进阶一下，写个基于Off-heap堆外缓存的Int数组，由于On-heap Array的空间请求分配到了堆上，所以这里自然而然的就把空间分配到了堆外。代码如下：
public class OffheapIntArray {
/**
* 此list分配的地址
*/
private long address;
/**
* 默认分配空间大小
*/
private static final int defaultSize = 1024;
/**
* 带参构造
* 由于Integer类型在java中占用4个字节，所以在分配地址的时候，一个integer，需要分配 4*8 = 32 bytes的空间
* @param size
* @throws NoSuchFieldException
* @throws IllegalAccessException
*/
public OffheapIntArray(Integer size) throws NoSuchFieldException, IllegalAccessException {
if (size == null) {
address = alloc(defaultSize * 4 * 8);
} else {
address = alloc(size * 4 * 8);
}
}
public int get(int index) throws NoSuchFieldException, IllegalAccessException {
return getUnsafe().getInt(address + index * 4 * 8);
}
public void set(int index, int value) throws NoSuchFieldException, IllegalAccessException {
getUnsafe().putInt(address + index * 4 * 8, value);
}
private Unsafe getUnsafe() throws IllegalAccessException, NoSuchFieldException {
Field f = Unsafe.class.getDeclaredField("theUnsafe");
f.setAccessible(true);
return (Unsafe) f.get(null);
}
private long alloc(int size) throws NoSuchFieldException, IllegalAccessException {
long address = getUnsafe().allocateMemory(size);
return address;
}
public void free() throws NoSuchFieldException, IllegalAccessException {
if (address == 0) {
return;
}
getUnsafe().freeMemory(address);
}
}
我们来简单的测试一下：
@Test
public void testOffheap() throws NoSuchFieldException, IllegalAccessException {
OffheapIntArray offheapArray = new OffheapIntArray(10);
offheapArray.set(0,11111);
offheapArray.set(1,1112);
offheapArray.set(2,1113);
offheapArray.set(3,1114);
System.out.println(offheapArray.get(0));
System.out.println(offheapArray.get(1));
System.out.println(offheapArray.get(2));
System.out.println(offheapArray.get(3));
offheapArray.free();
}
输出结果如下：
11111
1112
1113
1114
可以看到得到了正确的输出结果。当然我这里只是简单的模拟使用。具体的使用方式，推荐如下两篇文章，可以对堆外内存的使用有更近一步的认识：
https://www.baeldung.com/java-unsafe
http://mishadoff.com/blog/java-magic-part-4-sun-dot-misc-dot-unsafe/
知道了堆外缓存的简单使用后，这里我们要更近一步，使用现有的堆外缓存组件到项目中。
目前在市面上，有诸多的缓存组件，比如mapdb，ohc，ehcache3等，但是由于ehcache3收费，所以这里不做讨论，主要讨论mapdb和ohc这两个。我们先通过benchmark来筛选一下二者的性能差异，由于这两个缓存组件提供的都是基于key-value模型的数据存储，所以benchmark的指标有9个，分别是get，set方法，hget，hset方法（value存储的是hashmap），sadd，smember方法（value存储的是set），zadd，zrange方法（value存储的是treeset）。
benchmark结果如下：
Benchmark Mode Cnt Score Error Units
OffheapCacheBenchmark.testMapdbGet thrpt 20 69699.610 ± 4578.888 ops/s
OffheapCacheBenchmark.testMapdbHGet thrpt 20 63663.523 ± 3595.413 ops/s
OffheapCacheBenchmark.testMapdbHGetAll thrpt 20 64235.582 ± 4009.039 ops/s
OffheapCacheBenchmark.testMapdbHSet thrpt 20 25777.077 ± 480.461 ops/s
OffheapCacheBenchmark.testMapdbSAdd thrpt 20 335.973 ± 39.353 ops/s
OffheapCacheBenchmark.testMapdbSet thrpt 20 39417.070 ± 830.689 ops/s
OffheapCacheBenchmark.testMapdbSmember thrpt 20 67432.314 ± 2799.983 ops/s
OffheapCacheBenchmark.testMapdbZAdd thrpt 20 21220.595 ± 1128.103 ops/s
OffheapCacheBenchmark.testMapdbZRange thrpt 20 45425.162 ± 4533.071 ops/s
Benchmark Mode Cnt Score Error Units
OhcheapOHCBenchmark.testOhcGet thrpt 20 1196976.452 ± 27291.669 ops/s
OhcheapOHCBenchmark.testOhcHGet thrpt 20 348383.355 ± 23304.696 ops/s
OhcheapOHCBenchmark.testOhcHGetAll thrpt 20 350798.417 ± 11870.685 ops/s
OhcheapOHCBenchmark.testOhcHSet thrpt 20 349370.322 ± 8619.813 ops/s
OhcheapOHCBenchmark.testOhcSAdd thrpt 20 11700.160 ± 611.794 ops/s
OhcheapOHCBenchmark.testOhcSet thrpt 20 538314.544 ± 132111.037 ops/s
OhcheapOHCBenchmark.testOhcSmember thrpt 20 458817.772 ± 15817.159 ops/s
OhcheapOHCBenchmark.testOhcZAdd thrpt 20 323979.906 ± 9842.344 ops/s
OhcheapOHCBenchmark.testOhcZRange thrpt 20 192776.479 ± 12988.484 ops/s
从上面的结果可以看出，ohc属于性能怪兽类型，性能十倍于mapdb。而且由于ohc本身支持entry过期，但是mapdb不支持。所以这里综合一下，选择ohc作为我们的堆外缓存组件。需要说明一下的是，在我进行benchmark测试过程中，堆外缓存中会进行大量的数据读写操作，但是这些读写ops整体非常平稳，从error和score的对比就可以看出。不会出现应用暂停的情况。说明GC对堆外缓存的影响是非常小的。
整体类结构图如下（考虑到扩展性，暂时将mapdb加入到了结构图中）：
从整体的类组织结构图看来，使用了策略模式+模板模式组合的方式来进行。 屏蔽不同cache底层接口的不一致性，用的是策略模式；为不同的堆外缓存组件提供一致的操作方法用的是模板模式。组合起来使用就使得开发和扩展显得非常容易。
部分类的封装方式如下：
public class OhcCacheStrategy implements CacheStrategy {
/**
* 日志
*/
private static Logger logger = LoggerFactory.getLogger(OhcCacheStrategy.class);
/**
* 缓存组件
*/
public OHCache<byte[], byte[]> dataCache;
/**
* 过期时间组件
*/
public OHCache<byte[], byte[]> expireCache;
/**
* 缓存table最大容量
*/
private long level2cacheMax = 1024000L;
/**
* 锁
*/
private final Object lock = new Object();
/**
* 键过期回调
*/
public ExpirekeyAction expirekeyAction;
/**
* db引擎初始化
*/
@PostConstruct
public void initOhcEngine() {
try {
dataCache = OHCacheBuilder.<byte[], byte[]>newBuilder()
.keySerializer(new OhcSerializer())
.valueSerializer(new OhcSerializer())
.segmentCount(2 * 4)
.hashTableSize((int) level2cacheMax / 102400)
.capacity(2 * 1024 * 1024 * 1024L)
.defaultTTLmillis(OffheapCacheConst.EXPIRE_DEFAULT_SECONDS * 1000)
.timeouts(true)
.timeoutsSlots(64)
.timeoutsPrecision(512)
.eviction(Eviction.LRU)
.build();
logger.error("ohc data cache init ok...");
expireCache = OHCacheBuilder.<byte[], byte[]>newBuilder()
.keySerializer(new OhcSerializer())
.valueSerializer(new OhcSerializer())
.segmentCount(1)
.hashTableSize((int) level2cacheMax / 102400)
.capacity(2 * 1024 * 1024 * 1024L)
.defaultTTLmillis(OffheapCacheConst.EXPIRE_DEFAULT_SECONDS * 1000)
.timeouts(true)
.timeoutsSlots(64)
.timeoutsPrecision(512)
.eviction(Eviction.NONE)
.build();
logger.error("ohc expire cache init ok...");
} catch (Exception ex) {
logger.error(OffheapCacheConst.PACKAGE_CONTAINER_OHC + OffheapCacheConst.ENGINE_INIT_FAIL, ex);
AlarmUtil.alarm(OffheapCacheConst.PACKAGE_CONTAINER_OHC + OffheapCacheConst.ENGINE_INIT_FAIL, ex.getMessage());
throw ex;
}
}
@Override
public <T> boolean putEntry(String key, T entry, long expireAt) {
synchronized (lock) {
byte[] entryKey = SerializationUtils.serialize(key);
byte[] entryVal = SerializationUtils.serialize((Serializable) entry);
//缓存数据入库
if (dataCache.put(entryKey, entryVal, expireAt)) {
//过期时间入库
putExpire(key, expireAt);
//返回执行结果
return true;
}
return false;
}
}
@Override
public <T> T queryEntry(String key) {
byte[] result = dataCache.get(SerializationUtils.serialize(key));
if (result == null) {
return null;
}
return SerializationUtils.deserialize(result);
}
@Override
public long queryExpireTime(String key) {
byte[] entryKey = SerializationUtils.serialize(key);
return expireCache.get(entryKey) == null ? 0 : SerializationUtils.deserialize(expireCache.get(entryKey));
}
@Override
public boolean removeEntry(String key) {
byte[] entryKey = SerializationUtils.serialize(key);
if (dataCache.remove(entryKey)) {
removeExpire(key);
return true;
}
return false;
}
@Override
public boolean removeAll() {
Iterable<byte[]> dataKey = () -> dataCache.keyIterator();
dataCache.removeAll(dataKey);
Iterable<byte[]> expireKey = () -> expireCache.keyIterator();
expireCache.removeAll(expireKey);
return true;
}
@Override
public List<String> queryKeys() {
List<String> list = new ArrayList<>();
Iterator<byte[]> iterator = expireCache.keyIterator();
while (iterator.hasNext()) {
list.add(SerializationUtils.deserialize(iterator.next()));
}
return list;
}
/**
* key过期时间同步入库
*
* @param key
* @param expireAt
*/
private void putExpire(String key, long expireAt) {
try {
expireCache.put(SerializationUtils.serialize(key), SerializationUtils.serialize(expireAt));
} catch (Exception ex) {
logger.error("key[" + key + "]过期时间入库失败...");
}
}
/**
* 同步清理过期键
*
* @param key
*/
private void removeExpire(String key) {
try {
if (expireCache.remove(SerializationUtils.serialize(key))) {
if (expirekeyAction != null) {
expirekeyAction.keyExpiredNotification(key);
}
}
} catch (Exception ex) {
logger.error("key[" + key + "]过期时间清除失败...");
}
}
}
上面这个类是堆外缓存的核心策略类。所有其他的数据模型读写操作都可以依据此类来扩展，比如类似redis的sortedset，value可以存储一个Treeset即可。需要说明一下，上面代码中，dataCache主要用于存储数据部分，expireCache主要用于存储键过期时间。以便于可以实现键主动过期和被动过期功能。用户添加删除键的时候，会同步删除expireCache中的键，以便于二者能够统一。由于ohc本身并未实现keyExpireCallback，所以这里我实现了这个功能，只要有键被移除（主动删除还是被动删除，都会触发通知），就会通知用户，用户可以按照如下方式使用：
@PostConstruct
public void Init() {
ohcCacheTemplate.registerExpireKeyAction(key -> {
logger.error("key " + key + " expired...");
});
}
键被动过期功能，模仿了redis的键被动驱逐方式，实现如下：
public class OffheapCacheWorker {
/**
* 带参注入
*
* @param cacheStrategy
*/
public OffheapCacheWorker(CacheStrategy cacheStrategy) {
this.cacheStrategy = cacheStrategy;
this.offheapCacheHelper = new OffheapCacheHelper();
}
/**
* 日志
*/
private static Logger logger = LoggerFactory.getLogger(OffheapCacheWorker.class);
/**
* 缓存帮助类
*/
private OffheapCacheHelper offheapCacheHelper;
/**
* 缓存构建器
*/
private CacheStrategy cacheStrategy;
/**
* 过期key检测线程
*/
private Thread expireCheckThread;
/**
* 线程状态
*/
private volatile boolean started;
/**
* 线程开启
*
* @throws IOException
*/
public synchronized void start() {
if (started) {
return;
}
expireCheckThread = new Thread("expire key check thread") {
@Override
public void run() {
logger.error("expire key check thread start...");
while (!Thread.currentThread().isInterrupted()) {
try {
processLoop();
} catch (RuntimeException suppress) {
logger.error("Thread `" + getName() + "` occured a error, suppressed.", suppress);
throw suppress;
} catch (Exception exception) {
logger.error("Thread `" + getName() + "` occured a error, exception.", exception);
}
}
logger.info("Thread `{}` was stopped normally.", getName());
}
};
expireCheckThread.start();
started = true;
}
/**
* 线程停止
*
* @throws IOException
*/
public synchronized void stop() throws IOException {
started = false;
if (expireCheckThread != null) {
expireCheckThread.interrupt();
}
}
/**
* 过期键驱逐
* 模仿的redis键过期机制
*/
private void processLoop() throws InterruptedException {
//每次采集样本数
int sampleCheckNumber = 20;
//过期key计数
int sampleExpiredCount = 0;
//抽样次数迭代
int sampleCheckIteration = 0;
//缓存的key
List<String> keys = cacheStrategy.queryKeys();
//抽样开始时间
long start = System.currentTimeMillis();
//循环开始
do {
//键数量
long expireContainerSize = keys.size();
//默认为键数量
long loopCheckNumber = expireContainerSize;
//每次检查的键数量，如果超过样本数，则以样本数为准
if (loopCheckNumber > sampleCheckNumber) {
loopCheckNumber = sampleCheckNumber;
}
//开始检测
while (loopCheckNumber-- > 0) {
//取随机下标
int rndNum = offheapCacheHelper.getRandomNumber(toIntExact(expireContainerSize) + 1);
//取随机键
String rndKey = keys.get(rndNum);
//获取过期时间
long expireTime = cacheStrategy.queryExpireTime(rndKey);
//过期时间比对
if (expireTime <= System.currentTimeMillis()) {
//键驱逐
boolean result = cacheStrategy.removeEntry(rndKey);
if (result) {
expireContainerSize--;
sampleExpiredCount++;
}
}
}
//抽样次数递增
sampleCheckIteration++;
//抽样达到16次（16的倍数，&0xf都为0）且本批次耗时超过0.5秒，将退出，避免阻塞正常业务操作
if ((sampleCheckIteration % 16) == 0 && (System.currentTimeMillis() - start) > 300) {
logger.error("清理数据库过期键操作耗时过长，退出，预备重新开始...");
return;
}
} while (sampleExpiredCount > sampleCheckNumber / 4);
Thread.sleep(1500);
}
}
键被动驱逐，会随机抽取20个key检测，如果过期键小于5个，则直接进行下一次抽样。否则将进行键驱逐操作。一旦抽样次数达到限定次数且键驱逐耗时过长，为了不影响业务，将会退出本次循环，继续下一次循环操作。此worker在后台运行，实测6W个过期key一起过期，cpu占用控制在10%，60w个过期key基本上一起过期，cpu占用控制在60%左右。达到预期效果。在大量的读写操作过程中，可以看到堆内内存几乎没有变化。
写到最后，上面就是这次我要介绍的堆外缓存的整体内容了，从Unsafe讲到原理，从实现讲到ohc，希望大家能够提出更好的东西来，多谢。
来源：https://www.cnblogs.com/
scy251147/p/9634766.html
以上是关于Python可以做什么？你所不知道的Python——生活中的奇妙用途的主要内容，如果未能解决你的问题，请参考以下文章