BlogJava-少年阿宾-随笔分类-Redis

Redis的三种启动方式

abin — Thu, 10 Sep 2015 13:02:00 GMT

第一种：直接启动
安装：

tar zxvf redis-2.8.9.tar.gz

cd redis-2.8.9

#直接make 编译

make

#可使用root用户执行`make install`，将可执行文件拷贝到/usr/local/bin目录下。这样就可以直接敲名字运行程序了。

make install

启动：

#加上`&`号使redis以后台程序方式运行

./redis-server &

检测：

#检测后台进程是否存在

ps -ef |grep redis

#检测6379端口是否在监听

netstat -lntp | grep 6379

#使用`redis-cli`客户端检测连接是否正常

./redis-cli

127.0.0.1:6379> keys *

(empty list or set)

127.0.0.1:6379> set key "hello world"

127.0.0.1:6379> get key

"hello world"

停止：

#使用客户端

redis-cli shutdown

#因为Redis可以妥善处理SIGTERM信号，所以直接kill -9也是可以的

kill -9 PID

第二种：通过指定配置文件启动

配置文件

可为redis服务启动指定配置文件，配置文件 redis.conf 在Redis根目录下。

#修改daemonize为yes，即默认以后台程序方式运行（还记得前面手动使用&号强制后台运行吗）。

daemonize no

#可修改默认监听端口

port 6379

#修改生成默认日志文件位置

logfile "/home/futeng/logs/redis.log"

#配置持久化文件存放位置

dir /home/futeng/data/redisData

启动时指定配置文件

redis-server ./redis.conf

#如果更改了端口，使用`redis-cli`客户端连接时，也需要指定端口，例如：

redis-cli -p 6380

其他启停同直接启动方式。配置文件是非常重要的配置工具，随着使用的逐渐深入将显得尤为重要，推荐在一开始就使用配置文件。

第三种：

使用Redis启动脚本设置开机自启动

启动脚本

推荐在生产环境中使用启动脚本方式启动redis服务。启动脚本 redis_init_script 位于位于Redis的 /utils/ 目录下。

#大致浏览下该启动脚本，发现redis习惯性用监听的端口名作为配置文件等命名，我们后面也遵循这个约定。

#redis服务器监听的端口

REDISPORT=6379

#服务端所处位置，在make install后默认存放与`/usr/local/bin/redis-server`，如果未make install则需要修改该路径，下同。

EXEC=/usr/local/bin/redis-server

#客户端位置

CLIEXEC=/usr/local/bin/redis-cli

#Redis的PID文件位置

PIDFILE=/var/run/redis_${REDISPORT}.pid

#配置文件位置，需要修改

CONF="/etc/redis/${REDISPORT}.conf"

配置环境

1. 根据启动脚本要求，将修改好的配置文件以端口为名复制一份到指定目录。需使用root用户。

mkdir /etc/redis

cp redis.conf /etc/redis/6379.conf

2. 将启动脚本复制到/etc/init.d目录下，本例将启动脚本命名为redisd（通常都以d结尾表示是后台自启动服务）。

cp redis_init_script /etc/init.d/redisd

3. 设置为开机自启动

此处直接配置开启自启动 chkconfig redisd on 将报错误： service redisd does not support chkconfig

参照此篇文章，在启动脚本开头添加如下两行注释以修改其运行级别：

#!/bin/sh

# chkconfig: 2345 90 10

# description: Redis is a persistent key-value database

再设置即可成功。

#设置为开机自启动服务器

chkconfig redisd on

#打开服务

service redisd start

#关闭服务

service redisd stop

http://www.tuicool.com/articles/aQbQ3u

abin 2015-09-10 21:02 发表评论

redis和memcached比较

abin — Sat, 04 Apr 2015 21:45:00 GMT

1、线程问题

由于Redis只使用单核，而Memcached可以使用多核，所以平均每一个核上Redis在存储小数据时比Memcached性能更高。而在100k以上的数据中，Memcached性能要高于Redis，虽然Redis最近也在存储大数据的性能上进行优化，但是比起 Memcached，还是稍有逊色。

因为 Redis 的操作都非常快速——它的数据全部在内存里，完全不需要访问磁盘。至于并发，Redis 使用多路 I/O 复用技术，本身的并发效率不成问题。

当然，单个 Redis 进程没办法使用多核（任一时刻只能跑在一个 CPU 核心上），但是它本来就不是非常计算密集型的服务。如果单核性能不够用，可以多开几个进程。

Redis 单线程-多路复用io模型

、

2、内存使用效率对比：

使用简单的key-value存储的话，Memcached的内存利用率更高，而如果Redis采用hash结构来做key-value存储，由于其组合式的压缩，其内存利用率会高于Memcached。

3、数据类型：

Redis相比Memcached来说，拥有更多的数据结构和并支持更丰富的数据操作，通常在Memcached 里，你需要将数据拿到客户端来进行类似的修改再set回去。这大大增加了网络IO的次数和数据体积。在Redis中，这些复杂的操作通常和一般的 GET/SET一样高效。所以，如果需要缓存能够支持更复杂的结构和操作，那么Redis会是不错的选择。

4、安全机制
memcached采用cas机制，而redis有事务机制。
5、事件模型
memcached采用了libevent事件模型，多线程模型可以发挥多核作用，Redis实现了自己的一套和libevent类似的事件驱动机制，两者都采用了epoll通信模型和非阻塞机制。

epoll是在2.6内核中提出的，是之前的select和poll的增强版本。相对于select和poll来说，epoll更加灵活，没有描述符限制。epoll使用一个文件描述符管理多个描述符，将用户关系的文件描述符的事件存放到内核的一个事件表中，这样在用户空间和内核空间的copy只需一次。

最后讲讲 为什么epoll会比select高效，主要从三方面来进行论述。

（1）elect对描述符状态的改变是通过轮询来进行查找的；而epoll是当描述符状态发生改变时主动进行通知内核，这就是所谓的Reactor事件处理机制。可以用“好莱坞原则”进行描述：不要打电话给我们，我们会打电话通知你。相比之下，select的机制就好比面试结束后不停给面试官打电话询问面试结果。效率孰高孰低，可见一斑。

（2）select的文件描述符是使用链表进行组织的；而epoll是使用红黑树这一高效数据结构组织的。

（3）select从内核到用户空间传递文件描述符上发送的信息是使用内存复制的方式进行的；而epoll是采用共享内存的方式。
6、内存管理方面

　　Memcached使用预分配的内存池的方式，使用slab和大小不同的chunk来管理内存，Item根据大小选择合适的chunk存储，内存池的方式可以省去申请/释放内存的开销，并且能减小内存碎片产生，但这种方式也会带来一定程度上的空间浪费，并且在内存仍然有很大空间时，新的数据也可能会被剔除，原因可以参考Timyang的文章：http://timyang.net/data/Memcached-lru-evictions/

　　Redis使用现场申请内存的方式来存储数据，并且很少使用free-list等方式来优化内存分配，会在一定程度上存在内存碎片，Redis跟据存储命令参数，会把带过期时间的数据单独存放在一起，并把它们称为临时数据，非临时数据是永远不会被剔除的，即便物理内存不够，导致swap也不会剔除任何非临时数据(但会尝试剔除部分临时数据)，这点上Redis更适合作为存储而不是cache。
7、redis并发

Redis 是一个高性能的key-value数据库。 redis的出现，很大程度补偿了memcached这类keyvalue存储的不足，在部分场合可以对关系数据库起到很好的补充作用。它提供了Python，Ruby，Erlang，PHP客户端，使用很方便。

性能测试结果：

SET操作每秒钟 110000 次，GET操作每秒钟 81000 次，服务器配置如下：

Linux 2.6, Xeon X3320 2.5Ghz.

stackoverflow 网站使用 Redis 做为缓存服务器。

abin 2015-04-05 05:45 发表评论

spring redis整合(一)

abin — Wed, 14 Nov 2012 15:17:00 GMT

spring-data-redis下载地址：

http://www.springsource.org/download/community?project=Spring%2520Data%2520Redis&version=1.0.1.RELEASE

//spring-redis.xml

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"

xmlns:cache="http://www.springframework.org/schema/cache"

xmlns:context="http://www.springframework.org/schema/context"

xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:oxm="http://www.springframework.org/schema/oxm"

xmlns:p="http://www.springframework.org/schema/p" xmlns:util="http://www.springframework.org/schema/util"

xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd

http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd

http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd

http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.1.xsd">

id="jedisPoolConfig"

class="redis.clients.jedis.JedisPoolConfig">

name="maxActive"

value="${redis.pool.maxActive}" />

name="maxIdle"

value="${redis.pool.maxIdle}" />

name="maxWait"

value="${redis.pool.maxWait}" />

name="testOnBorrow"

value="${redis.pool.testOnBorrow}" />

id="jedisConnectionFactory"

class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">

name="hostName"

value="${redis.ip}" />

name="port"

value="${redis.port}" />

name="poolConfig"

ref="jedisPoolConfig" />

class="org.springframework.data.redis.core.RedisTemplate"

p:connection-factory-ref="jedisConnectionFactory" />

//User.java

package com.abin.lee.spring.redis.pojo;

import java.io.Serializable;

public class User implements Serializable {

/**

private static final long serialVersionUID = 2668307865623183776L;

private String uid;

private String address;

public User() {

super();

}

public User(String uid, String address) {

super();

this.uid = uid;

this.address = address;

}

public String getUid() {

return uid;

}

public void setUid(String uid) {

this.uid = uid;

}

public String getAddress() {

return address;

}

public void setAddress(String address) {

this.address = address;

}

@Override

public String toString() {

return "User [uid=" + uid + ", address=" + address + "]";

}

@Override

public int hashCode() {

final int prime = 31;

int result = 1;

result = prime * result + ((address == null) ? 0 : address.hashCode());

result = prime * result + ((uid == null) ? 0 : uid.hashCode());

return result;

}

@Override

public boolean equals(Object obj) {

if (this == obj)

return true;

if (obj == null)

return false;

if (getClass() != obj.getClass())

return false;

User other = (User) obj;

if (address == null) {

if (other.address != null)

return false;

} else if (!address.equals(other.address))

return false;

if (uid == null) {

if (other.uid != null)

return false;

} else if (!uid.equals(other.uid))

return false;

return true;

}

//UserDao.java

package com.abin.lee.spring.redis.dao;

import com.abin.lee.spring.redis.pojo.User;

public interface UserDao {

/**

* @param uid

* @param address

void save(User user);

/**

* @param uid

* @return

User read(String uid);

/**

* @param uid

void delete(String uid);

}

//UserDaoImpl.java

package com.abin.lee.spring.redis.dao.impl;

import java.io.Serializable;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.dao.DataAccessException;

import org.springframework.data.redis.connection.RedisConnection;

import org.springframework.data.redis.core.RedisCallback;

import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.stereotype.Repository;

import com.abin.lee.spring.redis.dao.UserDao;

import com.abin.lee.spring.redis.pojo.User;

@Repository("userDao")

public class UserDaoImpl implements UserDao{

@Autowired

private RedisTemplate redisTemplate;

@Override

public void save(final User user) {

redisTemplate.execute(new RedisCallback() {

@Override

public Object doInRedis(RedisConnection connection)

throws DataAccessException {

connection.set(

redisTemplate.getStringSerializer().serialize(

"user.uid." + user.getUid()),

redisTemplate.getStringSerializer().serialize(

user.getAddress()));

return null;

}

});

}

@Override

public User read(final String uid) {

return redisTemplate.execute(new RedisCallback() {

@Override

public User doInRedis(RedisConnection connection)

throws DataAccessException {

byte[] key = redisTemplate.getStringSerializer().serialize(

"user.uid." + uid);

if (connection.exists(key)) {

byte[] value = connection.get(key);

String address = redisTemplate.getStringSerializer()

.deserialize(value);

User user = new User();

user.setAddress(address);

user.setUid(uid);

return user;

}

return null;

}

});

}

@Override

public void delete(final String uid) {

redisTemplate.execute(new RedisCallback() {

public Object doInRedis(RedisConnection connection) {

connection.del(redisTemplate.getStringSerializer().serialize(

"user.uid." + uid));

return null;

}

});

}

//UserDaoTest.java

package com.abin.lee.spring.redis.dao.test;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertNull;

import org.junit.Before;

import org.junit.Test;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.abin.lee.spring.redis.dao.UserDao;

import com.abin.lee.spring.redis.pojo.User;

public class UserDaoTest {

private ApplicationContext app;

private UserDao userDao;

@Before

public void before() throws Exception {

app = new ClassPathXmlApplicationContext("com/abin/lee/spring/redis/spring-redis.xml");

userDao = (UserDao) app.getBean("userDao");

}

@Test

public void crud() {

// -------------- Create ---------------

String uid = "u123456";

String address1 = "上海";

User user = new User();

user.setAddress(address1);

user.setUid(uid);

userDao.save(user);

// ---------------Read ---------------

user = userDao.read(uid);

System.out.println("address1="+user.getAddress());

assertEquals(address1, user.getAddress());

// --------------Update ------------

String address2 = "北京";

user.setAddress(address2);

userDao.save(user);

user = userDao.read(uid);

System.out.println("address2Save="+user.getAddress());

assertEquals(address2, user.getAddress());

// --------------Delete ------------

userDao.delete(uid);

user = userDao.read(uid);

System.out.println("addressdel="+user.getAddress());

assertNull(user);

}

abin 2012-11-14 23:17 发表评论

Redis在windows下的安装使用

abin — Mon, 12 Nov 2012 12:45:00 GMT

下载的windows版本是redis-2.0.2，解压到D盘下：

D:\redis-2.0.2

进到该目录下，有下列文件：

　redis-server.exe：服务程序

redis-check-dump.exe：本地数据库检查

redis-check-aof.exe：更新日志检查

redis-benchmark.exe：性能测试，用以模拟同时由N个客户端发送M个 SETs/GETs 查询 (类似于 Apache 的ab 工具).

启动Redis服务（conf文件指定配置文件，若不指定则默认）：

D:\redis-2.0.2>redis-server.exe redis.conf

启动cmd窗口要一直开着，关闭后则Redis服务关闭。

这时服务开启着，另外开一个窗口进行，设置客户端：

D:\redis-2.0.2>redis-cli.exe -h 202.117.16.133 -p 6379

然后可以开始玩了：

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

Redis提供了多种语言的客户端，包括Java，C++，python。

Redis官网上推荐的Java包是Jedis，去下载Jedis，在Java项目中导入Jedis包，开始发现有错误，是因为缺少org.apache.commons这个包，

去网上找此包，下载导入后，Jedis就没有错误了。

可以开始了，用Jedis来操作Redis：

package test;

import redis.clients.jedis.Jedis;

public class Client {

/**

* @param args

public static void main(String[] args) {

// TODO Auto-generated method stub

Jedis jj = new Jedis("localhost");

jj.set("key1", "I am value 1");

String ss = jj.get("key1");

System.out.println(ss);

}

abin 2012-11-12 20:45 发表评论

windows下redis安装(一)

abin — Mon, 12 Nov 2012 12:44:00 GMT

首先下载一个redis的安装包:

windows:http://code.google.com/p/servicestack/wiki/RedisWindowsDownload

linux:http://code.google.com/p/redis/downloads/list

redis-2.0.0版本: redis-2.0.0 (302)

redis-2.4.5版本: redis-2.4.5-win32-win64.zip (506)
解压后,得到一个redis的文件夹,打开文件夹得到如下图的一些文件:

安装包中是不提供redis.conf的,关于配置可以到网上搜索一下,或者从这里直接下载:redis.conf (643)

下载后可以将redis.conf放到上图所示位置!

用命令行,切换到redis的根目录,然后启动redis服务端即redis-server.exe,如下图:

启动后的效果图如下:

当前服务端没有1个客户端连接,因此显示0 clients,

现在分别启动两个客户端,如下图:

这里值得注意的是:当你登录redis-cli.exe的时候,服务端并没有检测到客户端的存在,也就是在客户端执行了第一次操作以后,服务端才检测到这个状态.

abin 2012-11-12 20:44 发表评论