我们在Redis中存储了大量数据。实际上，我们存储了大量密钥，我们存储在Redis中，以及与每个密钥关联的 tiny 数据量。密钥长度为8个字节，数据长度为8个字节（长值）。 10亿键（是的，十亿）。
鉴于Redis存储的结构，据我所知（https://redislabs.com/blog/redis-ram-ramifications-part-i/和https://github.com/antirez/sds/blob/master/README.md），给定8个字节的密钥，头部的开销为8字节，空的为1字节在钥匙的最后。那是17个字节。假设这个向上舍入到至少24个字节，添加8个字节的长值会产生32个字节。
十亿个密钥是32GB。测得的使用量为158GB。当然，有开销，但5：1的比例似乎很大。任何人都可以解释这一点或指出减少内存使用的方法。
我已将我的测试程序包含在Jedis中。
import java.security.SecureRandom;
import java.text.DecimalFormat;
import java.util.Date;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.exceptions.JedisClusterMaxRedirectionsException;
public class Test8byteKeys {
protected static JedisCluster cluster = null;
protected static final ExecutorService executor;
protected static volatile boolean shuttingDown = false;
private static final int AVAILABLE_PROCESSORS = Runtime.getRuntime().availableProcessors();
static {
final int cores = Math.max(4, (AVAILABLE_PROCESSORS * 3) / 4);
executor = new ThreadPoolExecutor(cores, cores, //
15, TimeUnit.SECONDS, //
new LinkedBlockingQueue<>(cores), //
new ThreadPoolExecutor.CallerRunsPolicy());
System.out.println("Running with " + cores + " threads");
}
static private GenericObjectPoolConfig getPoolConfiguration() {
GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
poolConfig.setLifo(true);
poolConfig.setTestOnBorrow(true);
poolConfig.setTestOnReturn(false);
poolConfig.setBlockWhenExhausted(true);
poolConfig.setMinIdle(1);
poolConfig.setMaxTotal(101);
poolConfig.setTestWhileIdle(false);
poolConfig.setSoftMinEvictableIdleTimeMillis(3000L);
poolConfig.setNumTestsPerEvictionRun(5);
poolConfig.setTimeBetweenEvictionRunsMillis(5000L);
poolConfig.setJmxEnabled(true);
return poolConfig;
}
private static void connectToCluster() {
try {
Set<HostAndPort> nodes = new HashSet<>();
String hap /* host and port */ = System.getProperty("hap", null);
if (hap == null) {
System.err.println("You must supply the host and port of a master in the cluster on the command line");
System.err.println("java -Dhap=<host:port> -jar <jar> ");
System.exit(1);
}
String[] parts = hap.split(":"); // assume ipv4 address
nodes.add(new HostAndPort(parts[0].trim(), Integer.valueOf(parts[1].trim())));
System.out.println("Connecting to " + hap);
cluster = new JedisCluster(nodes, getPoolConfiguration());
}
catch (Exception e) {
System.err.println("Could not connect to redis -- " + e.getMessage());
System.exit(1);
}
}
private static final Thread shutdown = new Thread(new Runnable() {
// Clean up at exit
@Override
public void run() {
shuttingDown = true;
System.out.println((new Date()).toString() + "\t" + "Executor shutdown in progress");
try {
executor.shutdown();
executor.awaitTermination(10L, TimeUnit.SECONDS);
}
catch (Exception e) {
// ignore
}
finally {
try {
if (!executor.isShutdown()) {
executor.shutdownNow();
}
}
catch (Exception e) {
//ignore
}
}
try {
cluster.close();
}
catch (Exception e) {
System.err.println("cluster disconnection failure: " + e);
}
finally {
//
}
System.out.println((new Date()).toString() + "\t" + "shutdown complete.");
}
});
final static char[] CHARACTERS = { //
'0', '1', '2', '3', '4', '5', //
'6', '7', '8', '9', 'a', 'b', //
'c', 'd', 'e', 'f', 'g', 'h', //
'i', 'j', 'k', 'l', 'm', 'n', //
'o', 'p', 'q', 'r', 's', 't', //
'u', 'v', 'w', 'x', 'y', 'z', //
'A', 'B', 'C', 'D', 'E', 'F', //
'G', 'H', 'I', 'J', 'K', 'L', //
'M', 'N', 'O', 'P', 'Q', 'R', //
'S', 'T', 'U', 'V', 'W', 'X', //
'Y', 'Z', '#', '@' //
};
protected final static byte[] KEY_EXISTS_MARKER = { '1' };
static class Runner implements Runnable {
private byte[] key = null;
public Runner(byte[] key) {
this.key = key;
}
@Override
public void run() {
if (!shuttingDown) {
try {
cluster.set(key, KEY_EXISTS_MARKER);
cluster.expire(key, 60 * 60 * 48); // for test purposes, only keep around for 2 days
}
catch (JedisClusterMaxRedirectionsException e) {
System.err.println(
(new Date()).toString() + "\tIGNORING\t" + e + "\t" + "For key " + new String(key));
}
catch (Exception e) {
System.err.println((new Date()).toString() + "\t" + e + "\t" + "For key " + new String(key));
e.printStackTrace();
System.exit(1);
}
}
}
}
public static void main(String[] args) {
SecureRandom random = new SecureRandom();
DecimalFormat decimal = new DecimalFormat("#,##0");
final byte[] randomBytes = new byte[8];
connectToCluster();
Runtime.getRuntime().addShutdownHook(shutdown);
System.out.println((new Date()) + " Starting test");
for (int i = 0; i < 1000000000; i++) {
random.nextBytes(randomBytes);
final byte[] key = new byte[8];
for (int j = 0; j < randomBytes.length; j++)
key[j] = (byte) (CHARACTERS[((randomBytes[j] & 0xFF)) % CHARACTERS.length] & 0xFF);
try {
if (shuttingDown) {
System.err.println((new Date()).toString() + "\t" + "Main loop terminating due to shutdown");
break;
}
if (i % 1000000 == 0)
System.out.println((new Date()).toString() + "\t" + decimal.format(i));
try {
executor.submit(new Runner(key));
}
catch (Exception e) {
System.err.println((new Date()).toString() + "\t" + e);
}
}
catch (Exception e) {
System.err.println("Failed to set key " + new String(key) + " -- " + e);
}
}
if (!shuttingDown) {
System.out.println((new Date()) + " Done");
System.exit(0);
}
}
}
答案 0 :(得分：1)
实际上，每个内存管理器都会为您分配的每个对象提供内部开销，只需跟踪对象即可。例如：当你调用free（）时，内存管理器可能需要有关该对象的一些信息来确定它所属的内存池/页面。小对象可能属于一个池，并使用与较大对象不同的分配机制。
与Redis sds.c / sds.h的工作方式非常相似，堆管理器通常也会将自己的结构添加到每个malloc（）对象中。
如果你的堆每个对象有16个字节的开销，那么将它添加到每个10KB malloc（）将是一个难以察觉的开销。但是，如果您在Redis中讨论8字节密钥，那么为每个8字节密钥添加16字节的开销将超出密钥本身的内存。
您可以在此处找到有关malloc chunk和fastbins的更多信息： http://iarchsys.com/?p=764
对这种开销进行快速而脏的检查是将密钥从8个字节增加到16个。虽然密钥使用的内存大小加倍，但可能看不到内存消耗的内存加倍。 Redis流程。
答案 1 :(得分：0)
这需要更深入的分析，但有一件事显而易见的是，开销计算是错误的（可能是因为我没有完成博客系列的错误 - 抱歉;）。
Redis中的每个密钥，无论其类型/名称/值如何，都会产生开销。对于v3.2.10，开销IIRC约为70字节。但是，这个开销是在较小的数据集上测量的（远小于1B键），如果我没有弄错，一个更大的全局字典会导致每个键的开销更多。将值本身及其字符串开销添加到该值，您可以轻松地获得80个字节，并且最多可以达到80GB。
那就是说，我不能解释x2因素，而不是在实验室中重新实现这一点。可能是集群有额外的开销需要考虑。我建议您从较小的数据集开始，并将独立与集群内存使用情况进行比较，作为调查此问题的下一步。此外，您可能希望测试最新版本的Redis（4），因为它包含几个与内存使用相关的优化。
答案 2 :(得分：-1)
您应该考虑将Ur redis实例分区为多个实例