精华内容
下载资源
问答
  • 内存做虚拟盘应用

    千次阅读 2018-08-11 13:01:06
    用一些软件将部分内存做一个虚拟硬盘,可以带来一些性能提升体验。我目前主要用它来存放一些临时数据: 一、浏览器临时文件存放地 1、chrome WIN7下,通常chrome的缓存文件夹是 C:\Users\当前登录用户名\App...

    用一些软件将部分内存做一个虚拟硬盘,可以带来一些性能提升的体验。我目前主要用它来存放一些临时数据:

    一、浏览器临时文件存放地
    1、chrome
    WIN7下,通常chrome的缓存文件夹是

    C:\Users\当前登录用户名\AppData\Local\Google\Chrome\User Data\Default\Cache

    可以更改。比如说,虚拟盘为R,可以改到R:\Chrome,方法为:
    1)首先删除现有缓存文件夹

    C:\Users\当前登录用户名\AppData\Local\Google\Chrome\User Data\Default\Cache

    2)命令行方式下,运行

    mklink /D "C:\Users\Administrator\AppData\Local\Google\Chrome\User Data\Default\Cache" "R:\Chrome"

    就在原来cache所在文件夹下建立一个名为“cache”的快捷方式,指向了R:\Chrome,但好像自己在图形界面上建的快捷方式不起作用,可能少了啥设置吧。

    重启谷歌浏览器就可以了。

    2、IE
    简单
    这里写图片描述

    二、下载文件夹
    可以将谷歌浏览器的默认下载文件夹设置到虚拟盘。原因是我们通常会下载很多东西,但不一定都是需要和有用的。所以先下载到这里,发现真的有用,可以转移到真正的硬盘里。剩下的内容,则随着关机而消失。
    方法是 谷歌浏览器的“设置”

    三、发布文件夹
    将visual studio的网站项目发布到虚拟盘。宇宙级开发IDE visual studio,采用文件系统形式发布web项目,每次发布前都要先将上一次的发布结果删掉,然后再将发布结果写上去。发布结果通常也是挪作他用,临时存放而已。

    既然如此,何不发布到虚拟盘?

    我用内存虚拟盘软件是Primo Ramdisk5.5。原本用的是6.1,但没有破解版。30天后就无法使用。网上有个所谓大眼仔的破解版,显示已经激活,但过了30天后就报错。这个5.5版是否已经破解,目前还不知道。网址如下
    https://pan.baidu.com/s/1pJryIpl

    展开全文
  • 而是通过动态缓存的方法来有效提高系统速度, 并矫正大多数不健康的系统行为以及不正当操作[1], 优化过程并没有修改注册表和更改文件等操作,属于比较安全的 有些人说升级硬件才是王道,没错,对于硬件好的朋友用...
  • 软件存在意义:电脑内存小助手,主要功能是分析每个文件夹的内存大小,方便管理电脑内存(这里的内存是指硬盘或者U盘),硬盘空间越来越少,不知道存储空间都分配到哪些文件夹去了;想更直观浏览,管理文件,...

    软件存在的意义:电脑内存小助手,主要功能是分析每个文件夹的内存大小,方便管理电脑内存(这里的内存是指硬盘或者U盘),硬盘空间越来越少,不知道存储空间都分配到哪些文件夹去了;想更直观的浏览,管理文件,删除垃圾文件,不需要的文件,这就是——电脑内存小助手的存在意义。

    软件特殊功能:拥有缓存,再次计算时不需要从头开始,计算文件夹时子文件夹不需要再次计算就可以通过双击直接浏览;如果文件夹的子文件或者子文件夹太多,页面有分页操作;可以过滤显示,方便查看。

    直接下载源码:https://download.csdn.net/download/qiziyiming/10773703

    我的其它资源有兴趣的朋友也可以去看看,都是手动实现+源代码

    其它功能:

    1. 有文件或者文件夹批量重命名,支持指定名过滤;
    2. 文件批量提取(指定名或者指定后缀);
    3. 图片批量提取(开发人员必备:可以提取文件夹中图片)

    源代码简单描述我在后面再说明

     

    初始页面:

    添加了两个任务,计算C盘和D盘的文件夹大小:

    多任务并行,单任务速度快,多任务速度慢

    建议在电脑刚开机后进行各个盘单任务计算,这样每多长时间就结束了(因为java程序和其它软件强占CPU资源相对较弱);

    计算结束后:以我的E盘为例

    1. 总大小:150GB
    2. 剩余大小:86.49GB
    3. 计算大小:63.52GB
    4. 未知占用:277MB
    5. 子文件数:46997个
    6. 子文件夹数:11131个
    7. 计算错误:0个
    8. 时间:1:18 772  (一分钟18秒)

    未知占用:从系统获取的剩余大小计算后的剩余大小它们之间的

    文件夹数少时间越短

    如下,我的E盘的内存主要被前3个文件夹分配了,其中百度云收件箱就占用56GB,整个E盘内存才占用63GB

    文件项的位置是根据内存大小排序的

    文件夹的计算记录(这些文件地址都是文件夹,其中选中地址,Ctrl键就可以打开文件夹,Shift键就可以进行计算了,当然不需要从头开始了)

    文件批量重命名:

    过滤项必填一项,替换项必填一项

    指定文件批量提取

    可以指定文件名,也可以指定后缀(比如说:提取java文件使用后缀就可以了)

    图片批量提取:

    比如做开发、美工朋友,需要图片素材,但是文件夹太复杂,就可以使用此功能快速获取图片素材了

     

    以上是功能的简单描述,源代码太多这里就不包含了

    源代码使用到的框架:

    1. commons-codec-1.11.jar(字符串的摘要)
    2. dom4j-1.6.1.ja  (缓存是使用XML文档,每一个文件夹对应一个节点,文件不产生节点)
    3. jaxen-1.1-beta-6.jar (dom4j的依赖包,使用XPath路径查找节点就需要此包)

    程序为什么需要字符串摘要:因为xml节点名称不能有特殊字符,但是文件夹名可以使用,

    所以有点文件名进行了摘要,有的没有,可以打开缓存,它就是xml文档。

    源代码清晰的代码注释,一个java初学者都看明白;程序实现不难,都是基本语法基本类

    每一个类、每一个方法、声明都有注释,不常出现的代码行也有

    每一个java初学者都可以看懂。

    废话不多说,直接下载源码:https://download.csdn.net/download/qiziyiming/10773703

    我的其它资源有兴趣的朋友也可以去看看,都是手动实现+源代码

    展开全文
  • SpringBoot缓存详解

    2020-04-29 16:33:22
    后端程序开发人员都知道一个程序瓶颈在于数据库,大家也知道内存的速度是大大快于硬盘的速度。 在开发过程中,当我们需要重复获取数据库里面相同数据时候,我们一次又一次请求数据库或者远程数据...

    SpringBoot缓存详解(一)Ehcache

    首先说一下缓存是做什么的,能解决什么问题。做后端程序开发的人员都知道一个程序的瓶颈在于数据库,大家也知道内存的速度是大大快于硬盘的速度的。
    在开发过程中,当我们需要重复的获取数据库里面的相同数据的时候,我们一次又一次的请求数据库或者远程数据服务,导致大量的时间耗费在数据库查询或者远程方法的调用上,致使我们软件的性能低下,大量占用系统的CPU。缓存就是解决这些问题的。
    知道了缓存是干嘛的,下面开始讲解Spring Boot中缓存的使用。

    1、缓存的分类

    在Spring boot中,根据业务场景,缓存大致分为两类,一类是单机版缓存,一类是集中制缓存,单机版以Ehcache为例,集中制缓存以Redis为例,后面第二篇会介绍。
    单机版缓存意思就是只缓存在本机服务器上的缓存,适用于中小型项目。

    准备工作

    这里用到的技术是spring boot +jpa +Ehcache
    新建一个SpringBoot项目,这里不做介绍,修改pom文件,添加一下依赖:

        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter</artifactId>
            </dependency>
    <!--        添加ehcache 依赖-->
             <dependency>
                 <groupId>org.springframework.boot</groupId>
                 <artifactId>spring-boot-starter-cache</artifactId>
             </dependency>
             <dependency>
                 <groupId>net.sf.ehcache</groupId>
                 <artifactId>ehcache</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-devtools</artifactId>
                <scope>runtime</scope>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-jpa</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-aop</artifactId>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <optional>true</optional>
            </dependency>
            <!-- Mysql驱动包 -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <scope>runtime</scope>
            </dependency>
    
            <!-- SpringBoot集成mybatis框架 -->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>${mybatis.spring.boot.starter.version}</version>
            </dependency>
    
            <!-- pagehelper 分页插件 -->
            <dependency>
                <groupId>com.github.pagehelper</groupId>
                <artifactId>pagehelper-spring-boot-starter</artifactId>
                <version>${pagehelper.spring.boot.starter.version}</version>
            </dependency>
    
            <!--阿里数据库连接池 -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid-spring-boot-starter</artifactId>
                <version>${druid.version}</version>
            </dependency>
    
            <!--常用工具类 -->
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-lang3</artifactId>
            </dependency>
    
            <!--io常用工具类 -->
            <dependency>
                <groupId>commons-io</groupId>
                <artifactId>commons-io</artifactId>
                <version>${commons.io.version}</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
                <exclusions>
                    <exclusion>
                        <groupId>org.junit.vintage</groupId>
                        <artifactId>junit-vintage-engine</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
        </dependencies>
    

    对应的版本

        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
            <java.version>1.8</java.version>
            <mybatis.spring.boot.starter.version>1.3.2</mybatis.spring.boot.starter.version>
            <pagehelper.spring.boot.starter.version>1.2.5</pagehelper.spring.boot.starter.version>
            <druid.version>1.1.14</druid.version>
            <commons.io.version>2.5</commons.io.version>
        </properties>
    

    修改application.yml文件,填写自己的数据库名称、用户名和密码

    spring:
      datasource:
        type: com.alibaba.druid.pool.DruidDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        druid:
          url: jdbc:mysql://localhost:3306/cache_test?characterEncoding=utf-8&useSSL=false&serverTimezone=UTC
          username: 
          password: 
          initial-size: 10 
          max-active: 100 
          min-idle: 10
          max-wait: 60000
          pool-prepared-statements: true
          max-pool-prepared-statement-per-connection-size: 20
          time-between-eviction-runs-millis: 60000
          min-evictable-idle-time-millis: 300000
          validation-query: SELECT 1 FROM DUAL
          test-while-idle: true
          test-on-borrow: false
          test-on-return: false
          stat-view-servlet:
            enabled: true
            url-pattern: /druid/*
            login-username: admin
            login-password: admin
          filter: stat,wall,slf4j
          connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
      jpa:
        show-sql: true
        hibernate:
          ddl-auto: update
      cache:
        ehcache:
          config: ehcache.xml
    server:
      port: 9999
    
    

    在resources目录下,新建ehcache.xml,对ehcache进行配置,SpringBoot会自定检测ehcache.xml文件

    <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
             <diskStore path="java.io.tmpdir"/>
          
        <cache name="users"
            maxElementsInMemory="10000"
               eternal="false"
             timeToIdleSeconds="120"
             timeToLiveSeconds="120"
            maxElementsOnDisk="10000000"
             diskExpiryThreadIntervalSeconds="120"
             memoryStoreEvictionPolicy="LRU">
            <persistence strategy="localTempSwap"/>
         </cache>
    </ehcache>
    

    ehcache 有很多属性,可以自己百度搜索查询,平时用的最多的是这四个属性:maxElementsInMemory=“10000” 缓存中元素个数
    eternal=“false” 缓存是否永久有效
    timeToIdleSeconds=“120” 当对象自从被存放到缓存中后,如果处于缓存中的时间超过了 timeToLiveSeconds属性值,这个对象就会过期,EHCache将把它从缓存中清除;即缓存自创建日期起能够存活的最长时间,单位为秒(s)
    timeToLiveSeconds=“120” 当对象自从最近一次被访问后,如果处于空闲状态的时间超过了timeToIdleSeconds属性值,这个对象就会过期,EHCache将把它从缓存中清空;即缓存被创建后,最后一次访问时间到缓存失效之时,两者之间的间隔,单位为秒(s)

    编写对应的实体类,dao层和server层

    /**
     * User 实体.
    
     */
    @Entity // 实体
    public class User implements Serializable {
    
    	@Id // 主键
    	@GeneratedValue(strategy= GenerationType.IDENTITY) // 自增策略
    	private Long id; // 实体一个唯一标识
    
    
    	@Column(nullable = false, length = 20) // 映射为字段,值不能为空
    	private String name;
    
    
    	@Column(nullable = false, length = 50, unique = true)
    	private String email;
    
    
    	@Column(nullable = false, length = 20, unique = true)
    	private String username; // 用户账号,用户登录时的唯一标识
    
    	@Column(length = 100)
    	private String password; // 登录时密码
    
    	@Column(length = 200)
    	private String perms; // 授权码
    
    	public String getPerms() {
    		return perms;
    	}
    
    	public void setPerms(String perms) {
    		this.perms = perms;
    	}
    
    	protected User() { // 无参构造函数;设为 protected 防止直接使用
    	}
    
    	public User(String name, String email, String username, String password, String perms) {
    		this.name = name;
    		this.email = email;
    		this.username = username;
    		this.password = password;
    		this.perms = perms;
    	}
    
    
    	public Long getId() {
    		return id;
    	}
    	public void setId(Long id) {
    		this.id = id;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public String getEmail() {
    		return email;
    	}
    	public void setEmail(String email) {
    		this.email = email;
    	}
    
    	public String getUsername() {
    		return username;
    	}
    
    	public void setUsername(String username) {
    		this.username = username;
    	}
    
    	public String getPassword() {
    		return password;
    	}
    
    	public void setPassword(String password) {
    		this.password = password;
    	}
    
    	@Override
    	public String toString() {
    		return "User{" +
    				"id=" + id +
    				", name='" + name + '\'' +
    				", email='" + email + '\'' +
    				", username='" + username + '\'' +
    				", password='" + password + '\'' +
    				", perms='" + perms + '\'' +
    				'}';
    	}
    }
    

    dao层

    public interface UserRepository extends JpaRepository<User, Long> {
    	
    	/**
    	 * 根据用户姓名分页查询用户列表
    	 * @param name
    	 * @param pageable
    	 * @return
    	 */
    	Page<User> findByNameLike(String name, Pageable pageable);
    	
    	/**
    	 * 根据用户账号查询用户
    	 * @param username
    	 * @return
    	 */
    	User findByUsername(String username);
    }
    

    service层

    ublic interface UserService {
    	 /**
         * 新增、编辑、保存用户
         * @param user
         * @return
         */
        User saveOrUpateUser(User user);
    
        /**
         * 删除用户
         * @param id
         */
        void removeUser(Long id);
    
        /**
         * 根据id获取用户
         * @param id
         * @return
         */
        Optional<User> getUserById(Long id);
        /**
         * 根据用户名进行分页模糊查询
         * @param pageable
         * @return
         */
        Page<User> findAll(Pageable pageable);
        /**
         * 根据用户名进行分页模糊查询
         * @param name
         * @param pageable
         * @return
         */
        Page<User> listUsersByNameLike(String name, Pageable pageable);
    
        /**
         * 根据用户名查询
         * @param username
         * @return
         */
        User getUserByUserName(String username);
    
        List<User> getUserAll();
    }
    

    service的实现类

    @Transactional
    @Service
    @CacheConfig(cacheNames = "users")
    public class UserServiceImpl implements UserService {
    
    	@Autowired
    	private UserRepository userRepository;
    
    	@Override
    	//@CachePut缓存新增的或更新的数据到缓存,其中缓存名字是 uesr 。数据的key是person的id
    	@CachePut
    	public User saveOrUpateUser(User user) {
    		return userRepository.save(user);
    	}
    	@Override
    	//@CacheEvict 从缓存people中删除key为id 的数据 ,只会删除自己id的缓存
    	@CacheEvict
    	public void removeUser(Long id) {
    		userRepository.deleteById(id);
    	}
    	@Override
    	//@Cacheable缓存key为user 的id 数据到缓存users中,如果没有指定key则方法参数作为key保存到缓存中
    	@Cacheable
    	public Optional<User> getUserById(Long id) {
    		return userRepository.findById(id);
    	}
    	@Override
    	public Page<User> findAll(Pageable pageable) {
    		return userRepository.findAll(pageable);
    	}
    	@Override
    	public Page<User> listUsersByNameLike(String name, Pageable pageable) {
    
            // 模糊查询
            name = "%" + name + "%";
            Page<User> users = userRepository.findByNameLike(name, pageable);
            return users;
    	}
    	@Override
    	public User getUserByUserName(String username) {
    		return userRepository.findByUsername(username);
    	}
    	@Override
    	public List<User> getUserAll() {
    		List<User> users =userRepository.findAll();
    		return users;
    	}
    }
    
    

    在启动类上添加缓存注解

    @EnableCaching
    

    测试用例如下:

     @Autowired
        private UserRepository userRepository;
    
        @Autowired
        private UserService userService;
    
        @Autowired
        private CacheManager cacheManager;
    
        @Test
        public void test() throws Exception {
    
            Optional<User> u1 = userService.getUserById(1L);
            System.out.println("第一次查询:" + u1.get().getName());
          //  User u2 = userRepository.findByUsername("username");
            Optional<User> u2 = userService.getUserById(1L);
            System.out.println("第二次查询:" +u2.get().getName());
            u1.get().setName("DDDD");
            userService.saveOrUpateUser(u1.get());
           // User u3 = userRepository.findByUsername("username");
            Optional<User> u3 = userService.getUserById(1L);
            System.out.println("第三次查询:" + u3.get().getName());
            Optional<User> u4 = userService.getUserById(1L);
            System.out.println("第四次查询:" + u4.get().getName());
            Optional<User> u6 = userService.getUserById(2L);
            System.out.println("第一次查询:" + u6.get().getName());
    

    测试结果:

    Hibernate: select user0_.id as id1_0_0_, user0_.email as email2_0_0_, user0_.name as name3_0_0_, user0_.password as password4_0_0_, user0_.perms as perms5_0_0_, user0_.username as username6_0_0_ from user user0_ where user0_.id=?
    第一次查询:DDDD
    第二次查询:DDDD
    Hibernate: select user0_.id as id1_0_0_, user0_.email as email2_0_0_, user0_.name as name3_0_0_, user0_.password as password4_0_0_, user0_.perms as perms5_0_0_, user0_.username as username6_0_0_ from user user0_ where user0_.id=?
    第三次查询:DDDD
    第四次查询:DDDD
    Hibernate: select user0_.id as id1_0_0_, user0_.email as email2_0_0_, user0_.name as name3_0_0_, user0_.password as password4_0_0_, user0_.perms as perms5_0_0_, user0_.username as username6_0_0_ from user user0_ where user0_.id=?
    第一次查询:AAA
    

    可以看出,在第二次查询之后,就不在执行SQl查询语句,说明数据的查询时来自于缓存,这样就可以避免多次查询数据库。

    总结

    Cache注解的主要作用,以及常用的注解:
    @CacheConfig:主要用于配置该类中会用到的一些共用的缓存配置。在这里@CacheConfig(cacheNames = “users”):配置了该数据访问对象中返回的内容将存储于名为users的缓存对象中,我们也可以不使用该注解,直接通过@Cacheable自己配置缓存集的名字来定义。
    @Cacheable:配置了findByName函数的返回值将被加入缓存。同时在查询时,会先从缓存中获取,若不存在才再发起对数据库的访问。
    @CachePut:配置于函数上,能够根据参数定义条件来进行缓存,它与@Cacheable不同的是,它每次都会真是调用函数,所以主要用于数据新增和修改操作上。它的参数与@Cacheable类似,具体功能可参考上面对@Cacheable参数的解析
    @CacheEvict:配置于函数上,通常用在删除方法上,用来从缓存中移除相应数据。
    本章就讲解到这里,下一讲,将介绍SpringBoot+Redis的使用。

    展开全文
  • 用于操作内存的软件。 e.虽然是缓存数据库但是可以持久化的工作  MySQL是一个软件,帮助开发者对一台机器的硬盘进行操作。  redis是一个软件, 帮助开发者对一台机器的内存进行操作。 1.使用redis.那么...

    0.特点:

        a.持久化

        b.单进程、单线程

        c.5大数据类型

          d.用于操作内存的软件。

          e.虽然是缓存数据库但是可以做持久化的工作

      MySQL是一个软件,帮助开发者对一台机器的硬盘进行操作。

      redis是一个软件,  帮助开发者对一台机器的内存进行操作。

     

    1.使用redis.那么现在我的云服务器上安装了redis,并且启动:

    启动以后会看到如下的界面:

    这里服务器已经启动。

    2.redis配置文件初识:

    配置文件路径:cd /etc/redis/redis.conf

    如果出现redis下次无法启动的问题,找到该进程,关闭即可重新使用redis。

     

     

    lsof -i:6379
    kill pid

     

     

     

    root@iZbp17qwke8fau3qzwo15lZ:~# ps -ef |grep redis
    redis     4625     1  0 Oct20 ?        00:01:24 /usr/bin/redis-server 0.0.0.0:6379
    root      5761     1  0 Oct21 ?        00:00:48 redis-server *:6379
    root      6526  6502  0 09:22 pts/1    00:00:00 grep --color=auto redis
    root@iZbp17qwke8fau3qzwo15lZ:~# kill -9 4625

    3.下面就是使用python连接到redis.

    首先

    pip3 install redis

    在文件中:

    import redis
    
    conn=redis.Redis(host="47.99.191.149",port=6379,password='xxxxx')   #链接到redis
    conn.set("x1",'alex')                                               #给redis设置一个值
    
    val=conn.get('x1')  #获取x1对应的值
    print(val)          #alex 

    第二种方式:

    import redis
    #推荐使用连接池,链接不断开,不用长期connect
    pool=redis.ConnectionPool(host="47.99.191.149",port=6379,password='xxxx',max_connections=1000)
    conn=redis.Redis(connection_pool=pool)
    conn.set('foo','Bar')

    这种都不好,最后墙裂推荐使用单例模式来使用链接池!

    1.创建一个单独的文件

    import redis
    pool = redis.ConnectionPool(host="47.99.191.149", port=6379, password='xxxxx', max_connections=1000)

     

    2.在下面文件中导入这个,就是一个天然的单例连接池。(这也是提升redis性能的一个点)

    import redis
    from
    redis_poll import pool # 创建连接池 while True: key=input("请输入key:") val=input("请输入val:") #去连接池中获取链接 conn = redis.Redis(connection_pool=pool) #设置值 conn.set(key, val)

    连接池的源码分析:

    使用连接池。不会夯住,因为使用了IO多路复用
    
    while True:
        r,w,e=select.select([sk,sk,sk])
        一直在监测
        监测到某个sk发来消息,然后处理完返回
        三个都来,因为redis是单线程单进程,一个个的来,不用担心效率,内存操作很快。


    源码中的连接池这么做!
    在set的过程中建立socket对象,发了一个命令过去,发完把这connection从in_use_connection移除,
    然后放到可用列表中 self.avaliable_connections.append()进去。
    等下次有人想用的时候,直接pop一下把这个对象拿出来继续用。
    

    本质:

    本质就是维护一个已经和服务端链接成功的socket.以后再次发送数据直接获取socket,直接send数据,节省了开支,
    这就是为什么使用连接池速度快的原因。

     

    最后补充一个小点:

    mysql端口号:3306
    redis端口 :6379

    接着昨天的内容继续写:

    首先介绍的就是redis的五大数据类型:

            redis ={
                k1:'123',      #字符串
                k2:[1,2,3,4,4,2,1],  #列表
                k3:{1,2,3,4},        #集合
                k4:{name:123,age:666},#字典
                k5:{('alex',60),('eva',80),('yuan',70)} #有序集合    
            }

    操作字典:

    import redis
    pool=redis.ConnectionPool(host='47.99.191.149',port=6379,password="cyy520",max_connections=1000)
    conn=redis.Redis(connection_pool=pool)
    
    #字典操作:
    conn.hset('k4','username','alex')
    conn.hset('k4','age',18)
    '''
    上面的设置相当于下面这种结构
    redis={ k4:{ username:alex, age:18 } } ''' val=conn.hget('k4','username') #获取字典内username的值 print(val) #b'alex'
    vals=conn.hgetall('k4')             #获取字典内所有的键值
    print(vals) #{b'username': b'alex', b'age': b'18'}
     

    第二种多种设置方式:

    conn.hmset('k5',{'username': 'alex', 'age': '19'})     #直接给k5设置键值对,不用像上面一个个的设置
    val2=conn.hmget('k5','username','age')                 #获取多个值。
    print(val2)   #[b'alex', b'19']

    计数器:

    原来的数据都写在数据库,每次做更新压力会大。现在不写在数据库,这一天都在redis里写,每天0点只往数据库更新一次,减少数据库的压力。

    #计数器:
    print(conn.hget('k4','age'))           #b'18'
    conn.hincrby('k4','age',amount=1)      #每次增加1,amount为负时则自减
    print(conn.hget('k4','age'))           #b'19'

     

    现在抛出了一个问题:

    #如果reids的k4对应的字典中假设有1000W条数据,请打印所有的数据
    
    # result=conn.hgetall('k4')
    # print(result)  #不可取,数据太多内存无法承受,爆栈

    如果数据非常的多怎么把呢?通过hgetall取出全部的话,瞬间内存爆栈!

    推荐通过下面方法取:

    ret=conn.hscan_iter('k4',count=100)  #100个100个的取
    for item in ret:
        print(item)

    这个就是做成一个生成器,一个一个的迭代取。

    源码中是这么写的:

        def hscan_iter(self, name, match=None, count=None):
            """
            Make an iterator using the HSCAN command so that the client doesn't
            need to remember the cursor position.
    
            ``match`` allows for filtering the keys by pattern
    
            ``count`` allows for hint the minimum number of returns
            """
            cursor = '0'
            while cursor != 0:
                #起始位置:0
                cursor, data = self.hscan(name, cursor=cursor,
                                          match=match, count=count)
                #corsor=100,data=数据
                for item in data.items():
                    yield item           #在此yield住

    注意事项:
        -拿到的数据是bytes.
        -redis操作时,只有第一层的value支持:list,dict...

                redis={
                    k3:[1,2,3],   #只支持第一层的列表
                    k4:{
                        id:1,
                        title:"xxx",
                        price_list:[
                        {id:1,title:"xx"},
                        {id:2,title:"oo"},
                        {id:3,title:"qq"},
                        {id:4,title:"aa"},
                        ]        
                        #把列表json.dumps一下变成字符串
                        #取回来的时候bytes转成字符串,然后json.loads回来即可
                    }
                }

    Redis操作列表:

    1.列表左插入

    import redis
    conn=redis.Redis(host="47.99.191.149",port=6379,password='cyy520')
    
    #列表左插入
    # conn.lpush('k1',11)
    # conn.lpush('k1',22)

    2.列表右插入

    #列表右插入
    # conn.rpush('k1',33)

    3.左获取

    # 左获取
    # val=conn.lpop('k1')
    # print(val)
    # val=conn.blpop('k1',timeout=3)
    # print(val)  #去取k1的数据,没有数据就夯住,可以加超时时间,过时返回None

    4.右获取

    #右获取
    # val=conn.rpop('k1')
    # print(val)
    # val=conn.brpop('k1',timeout=3)
    # print(val)  #去取k1的数据,没有数据就夯住,可以加超时时间,过时返回None

    这里在以前业务中使用到这里的一个点:

    '''
    在这里把爬虫的URL放到一个队列中,爬虫每次去取URL爬取,我们在这边往里面放地址,
    放到redis,使用分布式爬取,2台机器共享一个队列,然后每次都brpop一下。
    '''

    最后就是redis的其他类型都有上面提到的生成器逐步取数据,只有列表没有提供方法,那么需要我们自己来用生成器配合看过源码来照猫画虎做一个。

    #通过yield创造一个生成器,一点点的获取数据,灵感源于字典生成器源码
    def list_iter(key,count=2):
        index=0
        while True:
            data_list=conn.lrange(key, index, index+count-1)
            if not data_list:
                return
            index+=count
    
            for item in data_list:
                yield item

    利用这个方法就可以通过调用List_iter方法逐步取数据了。

    for item in list_iter('k1',count=3):
        print(item)

    Redis支持事务操作:

    import redis
    '''
    redis={
        k1:[1,2,3,4,5]
    }
    '''
    
    conn=redis.Redis(host="47.99.191.149",port=6379,password='cyy520')
    
    
    
    pipe=conn.pipeline(transaction=True)  #创建一个pipe,事务为True
    pipe.multi()
    
    pipe.set('k2',123)
    pipe.hset('k3','n1',666)
    pipe.lpush('k4','oldboy')
    
    pipe.execute()    #一次发送三个命令,要成功都成功,要失败都失败。

     

    4.Django使用redis

    1.手动操作redis

    想要在django程序中使用redis需要先安装一个模块:

    pip3 install django-redis

    然后在django的配置文件中设置一下。

    #redis配置
    CACHES = {
        "default": {
            "BACKEND": "django_redis.cache.RedisCache",
            "LOCATION": "redis://47.99.191.149:6379",                #redis服务器地址
            "OPTIONS": {   
                "CLIENT_CLASS": "django_redis.client.DefaultClient",
                "CONNECTION_POOL_KWARGS": {"max_connections": 100},  #最大连接池100
                "PASSWORD": "cyy520",
            }
        }
    }

     

    这样在视图中就可以导入使用redis了。

    import redis
    from django.shortcuts import render,HttpResponse
    from django_redis import  get_redis_connection  #导入连接池
    
    def index(request):
        conn=get_redis_connection('default')        #拿到defalut这个redis连接池
        conn.set("name","egon")                     #设置值
        return HttpResponse("设置成功!")
    
    def order(request):
        conn=get_redis_connection('default')        
        name=conn.get("name")                     
        return HttpResponse(name)                   #返回值

    这样访问order就可以拿到这个对应的值,egon.

    2.全站缓存

    'django.middleware.cache.UpdateCacheMiddleware'      #最上面
    ...其他中间件
    'django.middleware.cache.FetchFromCacheMiddleware'   #最下面

    这样全站都缓存上了。

     

    3.视图缓存

    只给单视图缓存,把刚才的中间件注释掉。

    from django.views.decorators.cache import cache_page
    
    @cache_page(60*15)   #60为秒
    def index(request):
        ctime=str(time.time())
        return HttpResponse(ctime)

    4.局部缓存

       应用场景。比如抢购界面的商品简介等等不需要一直加载,可以做缓存,而剩余个数需要实时刷新。

    {% load cache %}
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
        <h1>商品剩余个数</h1>
    
        {% cache 10  缓存key %}
            <div>商品简介</div>
        {% endcache %}
    
    </body>
    </html>v

    1.首先{% load cache %}

    2.然后给需要缓存的地方加上

        {% cache 10  缓存key %}
            <div>商品简介</div>
        {% endcache %}

    这样这部分东西就会缓存,cache后面的是失效时间,10s,  后面是在redis里面放的缓存key,下面div里面的是key对应的值。

     最后补充一点就是rest-framework的访问频率限制就是放在缓存系统中:

    源码:

    from rest_framework.throttling import SimpleRateThrottle

    这里的cache=default_cache

    class SimpleRateThrottle(BaseThrottle):
        """
        A simple cache implementation, that only requires `.get_cache_key()`
        to be overridden.
    
        The rate (requests / seconds) is set by a `rate` attribute on the View
        class.  The attribute is a string of the form 'number_of_requests/period'.
    
        Period should be one of: ('s', 'sec', 'm', 'min', 'h', 'hour', 'd', 'day')
    
        Previous request information used for throttling is stored in the cache.
        """
        cache = default_cache
        timer = time.time
        cache_format = 'throttle_%(scope)s_%(ident)s'
        scope = None
        THROTTLE_RATES = api_settings.DEFAULT_THROTTLE_RATES

    点进来发现

    cache = DefaultCacheProxy()

    这个类就是下面的。

    class DefaultCacheProxy:
        """
        Proxy access to the default Cache object's attributes.
    
        This allows the legacy `cache` object to be thread-safe using the new
        ``caches`` API.
        """
        def __getattr__(self, name):
            return getattr(caches[DEFAULT_CACHE_ALIAS], name)
    
    def __setattr__(self, name, value):
            return setattr(caches[DEFAULT_CACHE_ALIAS], name, value)
    
        def __delattr__(self, name):
            return delattr(caches[DEFAULT_CACHE_ALIAS], name)
    
        def __contains__(self, key):
            return key in caches[DEFAULT_CACHE_ALIAS]
    
        def __eq__(self, other):
            return caches[DEFAULT_CACHE_ALIAS] == other

     

    转载于:https://www.cnblogs.com/geogre123/p/9822665.html

    展开全文
  • django13--redis缓存

    2019-03-06 19:39:01
    缓存: 为什么要使用缓存: ...缓存的技术支撑: 硬件上:内存硬盘 软件上:缓存系统,比如:redis,mongoDB 使用redis缓存: 1)下载中间件:django-redis 2)在settings里面作配置 ...
  • 中,那么操作系统将暂时停止您进程,将其他内存转存到硬盘中,从硬盘上加载被请求的内存,然后再重新启动您进程。这样,每个进程都获得了自己可以使用地址空间,可以访问比您物理上安装的内存更多的内存。 ...
  • 它是下载术语,意思是在你自己下载同时,自己电脑还要继续主机上传,这种下载方式,人越多速度越快但缺点是对硬盘损伤比较大(在写同时还要读),还有对内存占用较多,影响整机速度。  在P2P软件中,每个...
  • 它是术语,意思是在你自己同时,自己电脑还要继续主机上传,这种方式,人越多速度越快但缺点是对硬盘损伤比较大(在写同时还要读),还有对内存占用较多,影响整机速度。  在P2P软件中,每个用户就是一个...
  • 首先,在硬件的角度,存储器的结构分为 寄存器、L1高速缓存、L2高速缓存、L3、主存、硬盘、远程存储等。从左到右,代表了从贵到便宜,从快到慢,从小到大。本文要记录的是主存的软件上的管理。 操作系统 从工作...
  • 操作系统(内存管理)

    热门讨论 2009-09-20 12:55:25
    并且,如果地址在硬盘上而不是在 RAM 中,那么操作系统将暂时停止您进程,将其他内存转存到硬盘中,从硬盘上加载被请求的内存,然后再重新启动您进程。这样,每个进程都获得了自己可以使用地址空间,可以访问...
  • 软件学习基础知识

    2019-10-04 16:04:47
    硬盘:存储资料和软件等数据设备,有容量大,断电数据不丢失特点。也被人们称之为“数据仓库”。 内存:1. 负责硬盘等硬件上数据与CPU之间数据交换处理;2. 缓存系统中临时数据。3. 断电后数据丢失。 ​输入...
  • 为界面美观,汉化时部分控件了一些调整,但最终版权归软件原作者所有。 【更新说明】 V2.01 1.修复相同硬盘模式下无法完成“移动”罕见错误。 V2.00 1.新增“简易比较功能”(Ctrl + “列表”按钮)。 2.如果...
  • 为界面美观,汉化时部分控件了一些调整,但最终版权归软件原作者所有。 【更新说明】 V1.99 r2 1.新增“日志文件”选项(/filelog)。 2.移动模式中启动过滤器。 3.程序启动速度提升。 V1.98 1.添加...
  • 一.Memcache内存缓存 1.mem(内存) cache(缓存),memcache是用内存做缓存,效率高法宝缓存,memcache是开源高效软件,用内存做临时缓存硬盘访问速度快;2.通过内存维护一张统一巨大hash表,来存储各种格式数据...
  • 如果你有足够的内存和CPU,更高级技巧可以帮助,但如果你只是等待硬盘驱动器,因为该文件没有缓存,这将不会有太大不同.BTW:10秒或500 MB /秒500 MB是HDD典型读取速度.尝试运行以下操作以查看系统无法高效缓存...
  • 我们知道内存的存取速度是硬盘的好几倍,所以,如果我们将常用到动态函式库先加载内存当中 (缓存, cache),如此一来,当软件要取用动态函式库时,就不需要从头由硬盘里面读出罗!这样不就可以增进动态函式库
  • 如果您有足够的内存和CPU,可以使用更高级技巧,但是如果由于文件未缓存而仅在硬盘上等待,则不会有太大不同。BTW:10秒内500 MB或50 MB /秒是HDD典型读取速度。尝试运行以下命令以查看系统何时无法有效地缓存...
  • CreateFileFILE_FLAG_NO_BUFFERING 问题

    千次阅读 2013-11-25 19:01:55
    最近在写数据恢复的软件,同时要对24块硬盘的数据进行操作,然后写入一个16T 的存储中。 由于在平常的时候没有考虑到系统缓存的问题,只知道 我每次 重复跑数据的时候 往往第二次的比第一次的快上好多。 情况...
  • memcached 介绍

    2015-10-03 20:56:19
    memcache 是一套数据缓存系统或者软件用于在动态...memcache是通过预先分配指定内存空间来缓存数据,因此它比MYSQL这样数据库直接操作硬盘要快很多,可以提供比直接读取数据库更好性能,另外,memcached也进程作...
  • 进入MZD世界

    2007-09-03 19:12:29
    一、 进入MZD世界1, 硬件环境:P4级CPU(AMDCPU更好),内存512M以上(如果需要开缓存最少1G),硬盘建议使用阵列,并读写分离,30台工作站以内可以使用百兆网络,30以上必须千兆网卡+千兆中心交换机。...
  • 利人利己,Intel 酷睿2双核P7350CPU(45纳米 ),2.0G主频,3M二级缓存,Intel PM45高速芯片组 ,DVD刻录,Intel 5100AGN无线网卡, 2G DDR3内存,130W摄像头 ,人脸识别,250G硬盘,14寸宽屏。迅驰二平台,...
  • 1.memcache应用说明 ...memcache是管理内存软件,负责数据向内存的存取。 为了解决网站访问速度一个缓存用。 2.memcache工作原理 mysql数据库管理系统原理 数据库客户端(sql语句)----(服务
  • 动态库

    2019-06-20 14:14:00
    内存的访问速度是硬盘的好几倍,如果将常用动态函数库加载到内存中(高速缓存,cache),当软件套件要采用动态函数库时,就不需要重新从硬盘里读出,这样就>可以提高动态函数库读取速度。这个时候需要...
  • python笔记(redis)

    2019-04-14 21:06:13
    mysql是一个软件,帮助开发者对一台机器的硬盘进行操作 redis是一个软件,帮助开发者对一台机器的内存进行操作 缓存,命中,优先去redis中获取 特点: 持久化 AOF(快照,定时保存),RDB(把所有记录和命令...
  • Python Day01

    2019-04-11 22:47:00
    计算机组成框架:  :控制器、运算器、存储器、输入、输出(IO)设备。  控制器:统筹规划硬件与软件、硬件与硬件系统协同运行。  运算器:只能加法运算。...内存通过三级缓存与cpu寄存器交换数据。 ...
  • ldconfig与 /etc/ld.so.conf

    2017-10-11 10:27:16
    我们知道,内存的访问速度是硬盘的好几倍,所以,如果将常用动态函数库加载到内存中(高速缓存,cache),当软件套件要采用动态函数库时,就不需要重新从硬盘里读出,这样就可以提高动态函数库读取速度。...
  • 电脑蓝屏对照码

    2019-05-05 14:16:40
    ◆错误分析:有问题的内存(包括屋里内存、二级缓存、显存)、不兼容的软件(主要是远程控制和杀毒软件)、损坏的NTFS卷以及有问题的硬件(比如: PCI插卡本身已损坏)等都会引发这个错误. ◇解决方案:请使用前面介绍的常规...

空空如也

空空如也

1 2 3 4
收藏数 67
精华内容 26
关键字:

内存做硬盘缓存的软件