mybati缓存了解

title: “mybati缓存了解”
createTime: 2021-12-08T12:19:57+08:00
updateTime: 2021-12-08T12:19:57+08:00
draft: false
author: “ggball”
tags: [“mybatis”]
categories: [“java”]
description: “mybati缓存了解”

mybatis的缓存

首先来看下mybatis对缓存的规范，规范嘛就是定义的接口啦。

缓存接口

​ Cache接口 定义了缓存的方法

public interface Cache {/**获取缓存的id* @return The identifier of this cache*/String getId();/**添加缓存* @param key Can be any object but usually it is a {@link CacheKey}* @param value The result of a select.*/void putObject(Object key, Object value);/**根据缓存键获取缓存* @param key The key* @return The object stored in the cache.*/Object getObject(Object key);/**移除缓存* As of 3.3.0 this method is only called during a rollback * for any previous value that was missing in the cache.* This lets any blocking cache to release the lock that * may have previously put on the key.* A blocking cache puts a lock when a value is null * and releases it when the value is back again.* This way other threads will wait for the value to be * available instead of hitting the database.** * @param key The key* @return Not used*/Object removeObject(Object key);/*** Clears this cache instance*/  void clear();/*** Optional. This method is not called by the core.* * @return The number of elements stored in the cache (not its capacity).*/int getSize();/** * Optional. As of 3.2.6 this method is no longer called by the core.*  * Any locking needed by the cache must be provided internally by the cache provider.* * @return A ReadWriteLock */ReadWriteLock getReadWriteLock();}

实现

image-20211116203147375

mybatis实现了多种缓存，比如perpetualCache 是Cache接口的默认实现，通过hashMap来操作缓存，logginCache，在具有缓存的功能下，添加了打印日志的功能。

  • BlockingCache：阻塞版本的缓存装饰器，能够保证同一时间只有一个线程到缓存中查找指定的Key对应的数据。

  • FifoCache：先入先出缓存装饰器，FifoCache内部有一个维护具有长度限制的Key键值链表（LinkedList实例）和一个被装饰的缓存对象，Key值链表主要是维护Key的FIFO顺序，而缓存存储和获取则交给被装饰的缓存对象来完成。

  • LoggingCache：为缓存增加日志输出功能，记录缓存的请求次数和命中次数，通过日志输出缓存命中率。LruCache：最近最少使用的缓存装饰器，当缓存容量满了之后，使用LRU算法淘汰最近最少使用的Key和Value。

  • LruCache中通过重写LinkedHashMap类的removeEldestEntry()方法获取最近最少使用的Key值，将Key值保存在LruCache类的eldestKey属性中，然后在缓存中添加对象时，淘汰eldestKey对应的Value值。具体实现细节读者可参考LruCache类的源码。

  • ScheduledCache：自动刷新缓存装饰器，当操作缓存对象时，如果当前时间与上次清空缓存的时间间隔大于指定的时间间隔，则清空缓存。清空缓存的动作由getObject()、putObject()、removeObject()等方法触发。

  • SerializedCache：序列化缓存装饰器，向缓存中添加对象时，对添加的对象进行序列化处理，从缓存中取出对象时，进行反序列化处理。

  • SoftCache：软引用缓存装饰器，SoftCache内部维护了一个缓存对象的强引用队列和软引用队列，缓存以软引用的方式添加到缓存中，并将软引用添加到队列中，获取缓存对象时，如果对象已经被回收，则移除Key，如果未被回收，则将对象添加到强引用队列中，避免被回收，如果强引用队列已经满了，则移除最早入队列的对象的引用。

  • SynchronizedCache：线程安全缓存装饰器，SynchronizedCache的实现比较简单，为了保证线程安全，对操作缓存的方法使用synchronized关键字修饰。

  • TransactionalCache：事务缓存装饰器，该缓存与其他缓存的不同之处在于，TransactionalCache增加了两个方法，即commit()和rollback()。当写入缓存时，只有调用commit()方法后，缓存对象才会真正添加到TransactionalCache对象中，如果调用了rollback()方法，写入操作将被回滚。WeakCache：弱引用缓存装饰器，功能和SoftCache类似，只是使用不同的引用类型。

mybatis一级缓存

概念:

会话（session）级别的缓存称为一级缓存，默认开启的。

为什么使用一级缓存？

mybatis毕竟是查询数据库的一个半orm框架，查询数据库势必要消耗服务器的性能，为了减少服务器的性能，使用了缓存。将每次查询到的结果结果缓存起来，当下次查询的时候，如果判断先前有个完全一样的查询，会直接从缓存中直接将结果取出，返回给用户，不需要再进行一次数据库查询了。

实现原理自己的概括

当程序与数据库建立了一次会话，中间开始查询数据，每次查询会根据mapper的id、命名空间、sql等等创建缓存key,先去查询本地缓存是否有值，如果有值，则获取解析值，返回，如果没有值，则去查询数据库，再把结果缓存到本地缓存。

一级缓存实现原理

image-20211116205926071

首先来看下缓存实例是存在哪里的，在BaseExecutor中有本地缓存localCache，所以继承BaseExecutor的执行器都有localCache,包括但不限于

SimpleExecutor、BatchExecutor,ReuseExecutor。

接下来大概介绍查询流程，具体介绍用到一级缓存的地方

  @Testpublic  void testMybatisCache () throws IOException {// 获取配置文件输入流InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");// 通过SqlSessionFactoryBuilder的build()方法创建SqlSessionFactory实例SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);// 调用openSession()方法创建SqlSession实例SqlSession sqlSession = sqlSessionFactory.openSession();// 获取UserMapper代理对象UserMapper userMapper = sqlSession.getMapper(UserMapper.class);// 执行Mapper方法，获取执行结果List<UserEntity> userList = userMapper.listAllUser();UserMapper userMapper1 = sqlSession.getMapper(UserMapper.class);// 执行Mapper方法，获取执行结果List<UserEntity> userList1 = userMapper.listAllUser();System.out.println(JSON.toJSONString(userList));}@Overridepublic SqlSession openSession() {return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);}private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {Transaction tx = null;try {// 获取Mybatis主配置文件配置的环境信息final Environment environment = configuration.getEnvironment();// 创建事务管理器工厂final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);// 创建事务管理器tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);// 根据Mybatis主配置文件中指定的Executor类型创建对应的Executor实例final Executor executor = configuration.newExecutor(tx, execType);// 创建DefaultSqlSession实例return new DefaultSqlSession(configuration, executor, autoCommit);} catch (Exception e) {closeTransaction(tx); // may have fetched a connection so lets call close()throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);} finally {ErrorContext.instance().reset();}}
  1. 从mybatis配置文件获取配置信息输入流，然后利用SqlSessionFactoryBuilder的build的方法创建SqlSession工厂
  2. openSession方法创建默认SqlSession(获取mybatis环境信息，创建事务管理器,创建执行器，构造默认SqlSession)
  3. 调用sqlSession的getMapper方法，利用动态代理（实现InvocationHadler）创建代理对象
  4. 调用Mapper的方法，实际上就是调用代理对象的invoke方法，而且调用查询方法（不管是默认还是自己写的），最后都会调用sqlSession的select相关方法。

根据上面的流程可以知道，SqlSession,Executor,localcache之间的关系

image-20211116211707062

接下来主要看SqlSession的select方法

  @Overridepublic void select(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler) {try {MappedStatement ms = configuration.getMappedStatement(statement);executor.query(ms, wrapCollection(parameter), rowBounds, handler);} catch (Exception e) {throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);} finally {ErrorContext.instance().reset();}}@Overridepublic <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {// 获取BoundSql对象，BoundSql是对动态SQL解析生成的SQL语句和参数映射信息的封装BoundSql boundSql = ms.getBoundSql(parameter);// 创建CacheKey，用于缓存KeyCacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);// 调用重载的query（）方法return query(ms, parameter, rowBounds, resultHandler, key, boundSql);}@Overridepublic <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());if (closed) {throw new ExecutorException("Executor was closed.");}if (queryStack == 0 && ms.isFlushCacheRequired()) {clearLocalCache();}List<E> list;try {queryStack++;// 从缓存中获取结果list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;if (list != null) {handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);} else {// 缓存中获取不到，则调用queryFromDatabase（）方法从数据库中查询list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);}} finally {queryStack--;}if (queryStack == 0) {for (DeferredLoad deferredLoad : deferredLoads) {deferredLoad.load();}// issue #601deferredLoads.clear();if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {// issue #482clearLocalCache();}}return list;}@Overridepublic CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {if (closed) {throw new ExecutorException("Executor was closed.");}CacheKey cacheKey = new CacheKey();
createTime: 2021-12-08T12:19:57+08:00
updateTime: 2021-12-08T12:19:57+08:00
createTime: 2021-12-08T12:19:57+08:00
updateTime: 2021-12-08T12:19:57+08:00
createTime: 2021-12-08T12:19:57+08:00
updateTime: 2021-12-08T12:19:57+08:00
createTime: 2021-12-08T12:19:57+08:00
updateTime: 2021-12-08T12:19:57+08:00List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();// 所有参数值for (ParameterMapping parameterMapping : parameterMappings) {if (parameterMapping.getMode() != ParameterMode.OUT) {Object value;String propertyName = parameterMapping.getProperty();if (boundSql.hasAdditionalParameter(propertyName)) {value = boundSql.getAdditionalParameter(propertyName);} else if (parameterObject == null) {value = null;} else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {value = parameterObject;} else {MetaObject metaObject = configuration.newMetaObject(parameterObject);value = metaObject.getValue(propertyName);}
createTime: 2021-12-08T12:19:57+08:00
updateTime: 2021-12-08T12:19:57+08:00}}// Environment Idif (configuration.getEnvironment() != null) {
createTime: 2021-12-08T12:19:57+08:00
updateTime: 2021-12-08T12:19:57+08:00}return cacheKey;}
  1. 调用SqlSession的select方法，从configuration拿出mappedSatement（里面封装了mapper的属性），调用内置的执行器的query方法
  2. 执行器的query方法，先获取BoundSql对象，创建cacheKey(利用MapperId,偏移量,SQL语句…)，调用重载的query
  3. 先根据cacheKey去执行器的localCache查询是否有值，如果没有再调用queryFromDatabase查询数据库，缓存结果到localCache。注意：LocalCacheScope=SATATEMENT时，每次查询都会清空缓存。

注意：在分布式环境下，务必将MyBatis的localCacheScope属性设置为STATEMENT，避免其他应用节点执行SQL更新语句后，本节点缓存得不到刷新而导致的数据一致性问题。

在MyBatis中，关于缓存设置的参数一共有2个：localCacheScope，cacheEnabled。

<!-- 二级缓存开关 有效值: true|false，默认值为true -->
<settingname="cacheEnabled"value="true"/>
<!-- 是否清除一级缓存 SESSION不清除，STATEMENT清除  有效值：SESSION|STATEMENT，默认值为SESSION -->
<settingname="localCacheScope"value="SESSION"/>

mybatis二级缓存

概念

二级缓存是全局的缓存，即使不同会话之间也能共享二级缓存，默认是不开启的；

二级缓存实现原理

首先说下如何开启他，在mybatis配置文件添加<settingname="cacheEnabled"value="true"/> 和在对应的mapper.xml添加cache实例

image-20211116213954482

image-20211116213939859

其次看下二级缓存是如何生效的

  public Executor newExecutor(Transaction transaction, ExecutorType executorType) {executorType = executorType == null ? defaultExecutorType : executorType;executorType = executorType == null ? ExecutorType.SIMPLE : executorType;Executor executor;// 根据executor类型创建对象的Executor对象if (ExecutorType.BATCH == executorType) {executor = new BatchExecutor(this, transaction);} else if (ExecutorType.REUSE == executorType) {executor = new ReuseExecutor(this, transaction);} else {executor = new SimpleExecutor(this, transaction);}// 如果cacheEnabled属性为ture，这使用CachingExecutor对上面创建的Executor进行装饰if (cacheEnabled) {executor = new CachingExecutor(executor);}// 执行拦截器链的拦截逻辑executor = (Executor) interceptorChain.pluginAll(executor);return executor;}public class CachingExecutor implements Executor {private final Executor delegate;private final TransactionalCacheManager tcm = new TransactionalCacheManager();public CachingExecutor(Executor delegate) {this.delegate = delegate;delegate.setExecutorWrapper(this);}@Overridepublic Transaction getTransaction() {return delegate.getTransaction();}@Overridepublic void close(boolean forceRollback) {try {//issues #499, #524 and #573if (forceRollback) { tcm.rollback();} else {tcm.commit();}} finally {delegate.close(forceRollback);}}@Overridepublic <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {BoundSql boundSql = ms.getBoundSql(parameterObject);// 调用createCacheKey（）方法创建缓存KeyCacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);}@Overridepublic <E> Cursor<E> queryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds) throws SQLException {flushCacheIfRequired(ms);return delegate.queryCursor(ms, parameter, rowBounds);}@Overridepublic <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)throws SQLException {// 获取MappedStatement对象中维护的二级缓存对象Cache cache = ms.getCache();if (cache != null) {// 判断是否需要刷新二级缓存flushCacheIfRequired(ms);if (ms.isUseCache() && resultHandler == null) {ensureNoOutParams(ms, boundSql);// 从MappedStatement对象对应的二级缓存中获取数据@SuppressWarnings("unchecked")List<E> list = (List<E>) tcm.getObject(cache, key);if (list == null) {// 如果缓存数据不存在，则从数据库中查询数据list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);// 將数据存放到MappedStatement对象对应的二级缓存中tcm.putObject(cache, key, list); // issue #578 and #116}return list;}}return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);}}public class TransactionalCacheManager {// 通过HashMap对象维护二级缓存对应的TransactionalCache实例private final Map<Cache, TransactionalCache> transactionalCaches = new HashMap<Cache, TransactionalCache>();public void clear(Cache cache) {getTransactionalCache(cache).clear();}public Object getObject(Cache cache, CacheKey key) {// 获取二级缓存对应的TransactionalCache对象，然后根据缓存Key获取缓存对象return getTransactionalCache(cache).getObject(key);}public void putObject(Cache cache, CacheKey key, Object value) {getTransactionalCache(cache).putObject(key, value);}public void commit() {for (TransactionalCache txCache : transactionalCaches.values()) {txCache.commit();}}public void rollback() {for (TransactionalCache txCache : transactionalCaches.values()) {txCache.rollback();}}private TransactionalCache getTransactionalCache(Cache cache) {// 获取二级缓存对应的TransactionalCache对象TransactionalCache txCache = transactionalCaches.get(cache);if (txCache == null) {// 如果获取不到则创建，然后添加到Map中txCache = new TransactionalCache(cache);transactionalCaches.put(cache, txCache);}return txCache;}}

  1. 还是在sqlSessionFactory.openSession(); 时，会创建执行器，当cacheEnabled属性为ture，会创建CachingExecutor缓存执行器。

  2. 看下CachingExecutor的结构，它包含了一个委托执行器(使用了委托模式)，用来真正执行的sql,而自己主要的作用是放在了建立和使用二级缓存

  3. 当执行sql，最后会进入到执行器，如果执行器是CachingExecutor时,会调用他的query方法，进入方法后，首先会从MappedStatement拿出二级缓存实例（你以为这就是二级缓存？不，你错了），然后判断是否要刷新缓存，再根据二级缓存实例从缓存管理器(CacheExecutor维护了TransactionalCacheManager缓存管理器，缓存管理器里面维护了二级缓存实例和TransactionalCache的关系)中得到TransactionalCache，再利用cacheKey获取TransactionalCache中对应的二级缓存，如果缓存不存在，则使用委托执行器去数据库查询数据，再缓存结果，如果存在，则直接返回。

    再回过头看，当时的MappedStatement是如何get二级缓存实例的;

      private void configurationElement(XNode context) {try {// 获取命名空间String namespace = context.getStringAttribute("namespace");if (namespace == null || namespace.equals("")) {throw new BuilderException("Mapper's namespace cannot be empty");}// 设置当前正在解析的Mapper配置的命名空间builderAssistant.setCurrentNamespace(namespace);// 解析<cache-ref>标签cacheRefElement(context.evalNode("cache-ref"));// 解析<cache>标签cacheElement(context.evalNode("cache"));// 解析所有的<parameterMap>标签parameterMapElement(context.evalNodes("/mapper/parameterMap"));// 解析所有的<resultMap>标签resultMapElements(context.evalNodes("/mapper/resultMap"));// 解析所有的<sql>标签sqlElement(context.evalNodes("/mapper/sql"));

createTime: 2021-12-08T12:19:57+08:00
updateTime: 2021-12-08T12:19:57+08:00
createTime: 2021-12-08T12:19:57+08:00
updateTime: 2021-12-08T12:19:57+08:00
} catch (Exception e) {
throw new BuilderException(“Error parsing Mapper XML. The XML location is '” + resource + "'. Cause: " + e, e);
}
}

 private void cacheElement(XNode context) throws Exception {if (context != null) {String type = context.getStringAttribute("type", "PERPETUAL");Class<? extends Cache> typeClass = typeAliasRegistry.resolveAlias(type);String eviction = context.getStringAttribute("eviction", "LRU");Class<? extends Cache> evictionClass = typeAliasRegistry.resolveAlias(eviction);Long flushInterval = context.getLongAttribute("flushInterval");Integer size = context.getIntAttribute("size");boolean readWrite = !context.getBooleanAttribute("readOnly", false);boolean blocking = context.getBooleanAttribute("blocking", false);Properties props = context.getChildrenAsProperties();builderAssistant.useNewCache(typeClass, evictionClass, flushInterval, size, readWrite, blocking, props);}}MappedStatement.Builder statementBuilder = new MappedStatement.Builder(configuration, id, sqlSource, sqlCommandType).resource(resource).fetchSize(fetchSize).timeout(timeout).statementType(statementType).keyGenerator(keyGenerator).keyProperty(keyProperty).keyColumn(keyColumn).databaseId(databaseId).lang(lang).resultOrdered(resultOrdered).resultSets(resultSets).resultMaps(getStatementResultMaps(resultMap, resultType, id)).resultSetType(resultSetType).flushCacheRequired(valueOrDefault(flushCache, !isSelect)).useCache(valueOrDefault(useCache, isSelect)).cache(currentCache);


如上面的代码所示，在获取<cache>标签的所有属性信息后，调用MapperBuilderAssistant对象的userNewCache()方法创建二级缓存实例，然后通过MapperBuilderAssistant的currentCache属性保存二级缓存对象的引用。在调用MapperBuilderAssistant对象的addMappedStatement()方法创建MappedStatement对象时会将当前命名空间对应的二级缓存对象的引用添加到MappedStatement对象中,所以这就是需要配置<cache>的原因。流程![image-20211116235954488](https://img-blog.csdnimg.cn/img_convert/8ad5873a6586eb7912f170272d6da1c2.png)### mybatis二级缓存解决了什么问题解决了一级缓存在不同session存在脏读的问题，但是分布式二级缓存也存在脏读。![image-20211117000030143](https://img-blog.csdnimg.cn/img_convert/cca57efae1991272139c4998773fe8e7.png)### 总结MyBatis一级缓存是SqlSession级别的缓存，默认就是开启的，而且无法关闭；二级缓存需要在MyBatis主配置文件中通过设置cacheEnabled参数值来开启。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/88394.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Ingress Controller

Ingress Controller

什么是 Ingress Controller &#xff1f; 在云原生生态中&#xff0c;通常来讲&#xff0c;入口控制器( Ingress Controller )是 Kubernetes 中的一个关键组件&#xff0c;用于管理入口资源对象。 Ingress 资源对象用于定义来自外网的 HTTP 和 HTTPS 规则&#xff0c;以控制进…
阅读更多...
el-image 和 el-table冲突层级冲突问题

el-image 和 el-table冲突层级冲突问题

其中原理&#xff0c;很多博客已经所过了&#xff0c;table组件中使用图片&#xff0c;会出现层级过低问题&#xff0c; 网上大部分解决方式是 使用穿透 // 单元格样式 ::v-deep(.el-table__cell) {position: static !important; }我在此不推荐这种解决方式&#xff0c;原因&a…
阅读更多...
Leetcode228. 汇总区间

Leetcode228. 汇总区间

力扣&#xff08;LeetCode&#xff09;官网 - 全球极客挚爱的技术成长平台 给定一个 无重复元素 的 有序 整数数组 nums 。 返回 恰好覆盖数组中所有数字 的 最小有序 区间范围列表 。也就是说&#xff0c;nums 的每个元素都恰好被某个区间范围所覆盖&#xff0c;并且不存在属…
阅读更多...
二、VXLAN BGP EVPN基本原理

二、VXLAN BGP EVPN基本原理

VXLAN BGP EVPN基本原理 1、BGP EVPN2、BGP EVPN路由2.1、Type2路由——MAC/IP路由2.2、Type3路由——Inclusive Multicast路由2.3、Type5路由——Inclusive Multicast路由 ————————————————————————————————————————————————…
阅读更多...
聚焦云原生安全|如何为5G边缘云和工业互联网应用筑牢安全防线

聚焦云原生安全|如何为5G边缘云和工业互联网应用筑牢安全防线

9月22日&#xff0c;2023年中国信息通信业发展高层论坛5G工业互联网分论坛在北京顺利举办。 作为国内云原生安全领导厂商&#xff0c;安全狗受邀出席此次活动。 据悉&#xff0c;中国信息通信业发展高层论坛是致力于研究信息通信业发展新问题、新趋势&#xff0c;推动信息通信…
阅读更多...
uniapp项目实践总结(二十三)网页和小程序应用打包教程

uniapp项目实践总结(二十三)网页和小程序应用打包教程

导语&#xff1a;当你的应用程序开发完成后&#xff0c;在发布到互联网之前&#xff0c;需要进行打包操作&#xff0c;包括网页端、小程序端的打包。 目录 准备工作网页打包小程序打包 准备工作 在打包之前&#xff0c;请保证你的 uniapp 应用程序编译到网页、小程序是可以正…
阅读更多...
标准化、逻辑回归、随机梯度参数估计

标准化、逻辑回归、随机梯度参数估计

机器学习入门 数据预处理&#xff1a; 将&#xff1f;替换为缺失值 data data.replace(to_replace"?",valuenp.nan)丢掉缺失值 data.dropna(how"any) #howall删除全是缺失值的行和列 #haowany删除有缺失值的行和列将数据集划分成测试集和训练集 data[colu…
阅读更多...
tensor数学运算

tensor数学运算

运算函数加add减sub乘mul除div矩阵相乘matmul次方pow平方根及其倒数sqrt 和 rsqrt向下/向上取整floor / ceil分离出整数/小数trunc / frac近似解四舍五入round裁剪clamp 1、矩阵元素的加减乘除 注意是矩阵间对应位置元素进行加减乘除 add 和 a torch.rand(3,4) b torch.…
阅读更多...
ceph分布式存储部署

ceph分布式存储部署

一、概述 是一个统一的分布式存储系统&#xff0c;设计初衷是提供较好的性能、可靠性和可扩展性。 特点 1、统一存储 虽然 ceph 底层是一个分布式文件系统&#xff0c;但由于在上层开发了支持对象和块的接口。所以在开源存储软件中&#xff0c;能够一统江湖。至于能不能千秋万…
阅读更多...
面试打底稿④ 专业技能的第四部分

面试打底稿④ 专业技能的第四部分

简历原文 抽查部分 了解Python的使用&#xff08;第一篇关于Python升级版本bug解决的文章斩获6W阅读&#xff09;&#xff0c;用python实现了几篇图像信息隐藏领 域论文的复现&#xff08;博客中有提及&#xff09;&#xff1b; 了解Django基本框架&#xff0c;写过Django框架的…
阅读更多...
【深度学习实验】卷积神经网络（二）：自定义简单的二维卷积神经网络

【深度学习实验】卷积神经网络（二）：自定义简单的二维卷积神经网络

目录 一、实验介绍 二、实验环境 1. 配置虚拟环境 2. 库版本介绍 三、实验内容 0. 导入必要的工具包 1. 二维互相关运算&#xff08;corr2d&#xff09; 2. 二维卷积层类&#xff08;Conv2D&#xff09; a. __init__&#xff08;初始化&#xff09; b. forward(前向传…
阅读更多...
第十四届蓝桥杯大赛软件赛决赛 C/C++ 大学 B 组 试题 B: 双子数

第十四届蓝桥杯大赛软件赛决赛 C/C++ 大学 B 组 试题 B: 双子数

[蓝桥杯 2023 国 B] 双子数 试题 B: 双子数 【问题描述】 若一个正整数 x x x 可以被表示为 p 2 q 2 p^2 \times q^2 p2q2&#xff0c;其中 p p p、 q q q 为质数且 p ≠ q p \neq q pq&#xff0c;则 x x x 是 一个 “双子数”。请计算区间 [ 2333 , 233333333333…
阅读更多...
千兆光模块和万兆光模块的差别是什么？

千兆光模块和万兆光模块的差别是什么？

千兆光模块和万兆光模块是目前使用最广泛的光模块之一&#xff0c;它们之间有什么差别呢&#xff1f;下面从传输速率、光纤类型、距离等多个方面详细分析千兆光模块和万兆光模块的差别。 一、传输速率 千兆光模块的传输速率为1.25Gbps&#xff0c;而万兆光模块的传输速率为10…
阅读更多...
记录一下 malloc 是如何分配内存的

记录一下 malloc 是如何分配内存的

系统深入学习笔记-malloc 以 32 位系统为例&#xff0c;&#xff0c;通过这张图你可以看到&#xff0c;用户空间内存从低到高分别是 6 种不同的内存段&#xff1a; 代码段&#xff0c;包括二进制可执行代码&#xff1b;数据段&#xff0c;包括已初始化的静态常量和全局变量B…
阅读更多...
燃气安全如何保障?万宾燃气管网监测系统时刻感知管网运行态势

燃气安全如何保障?万宾燃气管网监测系统时刻感知管网运行态势

近年来随着我国城镇化建设的加快&#xff0c;燃气已经成为每个家庭的必需品。然而&#xff0c;每年夏季频繁发生的燃气爆炸事故&#xff0c;已经严重危害人民生命财产安全危害社会公共安全和公共利益。为了保障燃气安全运行&#xff0c;近日&#xff0c;许多城市都在大力推进燃…
阅读更多...
深入浅出Java的多线程编程——第二篇

深入浅出Java的多线程编程——第二篇

目录 前情回顾 1. 中断一个线程 1.1 中断的API 1.2 小结 2. 等待一个线程 2.1 等待的API 3. 线程的状态 3.1 贯彻线程的所有状态 3.2 线程状态和状态转移的意义 4. 多线程带来的的风险-线程安全 (重点) 4.1 观察线程不安全 4.2 线程安全的概念 4.3 线程不安全的原因…
阅读更多...
代码随想录算法训练营第23期day7| 454.四数相加II 、383. 赎金信 、15. 三数之和、18. 四数之和

代码随想录算法训练营第23期day7| 454.四数相加II 、383. 赎金信 、15. 三数之和、18. 四数之和

目录 一、&#xff08;leetode 454&#xff09;四数相加II 二、&#xff08;leetcode 383&#xff09;赎金信 暴力解法 哈希法 三、&#xff08;leetcode 15&#xff09;三数之和 四、&#xff08;leetcode 18&#xff09;四数之和 一、&#xff08;leetode 454&#xf…
阅读更多...
电涌保护器外部专用脱离器（SCB）后备保护器产品说明

电涌保护器外部专用脱离器（SCB）后备保护器产品说明

为了更好的满足不同应用场景的市场需求&#xff0c;地凯科技经过两年多不断的研发与试验&#xff0c;对电涌保护器外部专用脱离器 SCB 后备保护器产品&#xff08;以下简称 SCB&#xff09;进行了技术升级&#xff0c;升级后的SCB 产品在电气性能、外观尺寸、智能化和可靠性等方…
阅读更多...
springboot+vue智能诊后随访系统 java医院挂号预约诊断系统

springboot+vue智能诊后随访系统 java医院挂号预约诊断系统

本系统是基于java前端架构Vue用java编程语言及javascript、CSS、HTML语言进行编写设计并实现相关功能的。 设计步骤及措施&#xff1a; &#xff08;1&#xff09;确定项目名称、项目研究内容&#xff0c;开题报告提交及修改。 &#xff08;2&#xff09;项目开发准备&#xff…
阅读更多...
全志H616在低温reboot过程中进入休眠解决方法

全志H616在低温reboot过程中进入休眠解决方法

主题 H618在DDR物料适配支持时候&#xff0c;reboot实验异常进休眠&#xff0c;在reboot老化测试中报如下log1 [2023-07-11,16:56:44][ 40.325238][ T1] init: Untracked pid 1888 exited with status 0 [2023-07-11,16:56:44][ 40.325295][ T5] binder: undeliver…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023