奋斗的蛐蛐
奋斗的蛐蛐

Redis经典问题解析

缓存问题

缓存穿透

一般的缓存系统，都是按照key去缓存查询，如果不存在对应的value，就应该去后端系统查找(比如 DB)。缓存穿透是指在高并发下查询key不存在的数据，会穿过缓存查询数据库。导致数据库压力过大而宕机

解决方案:

  • 对查询结果为空的情况也进行缓存，缓存时间(ttl)设置短一点，或者该key对应的数据insert了 之后清理缓存。
    • 问题:缓存太多空值占用了更多的空间
  • 使用布隆过滤器。在缓存之前在加一层布隆过滤器，在查询的时候先去布隆过滤器查询 key 是否存在，如果不存在就直接返回，存在再查缓存和DB。
使用布隆过滤器.png

布隆过滤器(Bloom Filter)是1970年由布隆提出的。它实际上是一个很长的二进制向量和一系列随机hash映射函数。布隆过滤器可以用于检索一个元素是否在一个集合中。它的优点是空间效率和查询时间都远远超过一般的算法。


布隆过滤器工作.png

布隆过滤器的原理是，当一个元素被加入集合时，通过K个Hash函数将这个元素映射成一个数组中的K个点，把它们置为1。检索时，我们只要看看这些点是不是都是1就(大约)知道集合中有没有它了:如 果这些点有任何一个0，则被检元素一定不在;如果都是1，则被检元素很可能在。这就是布隆过滤器的 基本思想。

  • 把字符串------>位 省空间 (1或0)

  • 不用循环------>比较位置 省时间

缓存雪崩

当缓存服务器重启或者大量缓存集中在某一个时间段失效，这样在失效的时候，也会给后端系统(比如 DB)带来很大压力。突然间大量的key失效了或redis重启，大量访问数据库，数据库崩溃解决方案:

  1. key的失效期分散开 不同的key设置不同的有效期
  2. 设置二级缓存(数据不一定一致)
  3. 高可用(脏读)

缓存击穿

对于一些设置了过期时间的key，如果这些key可能会在某些时间点被超高并发地访问，是一种非常“热点”的数据。这个时候，需要考虑一个问题:缓存被“击穿”的问题，这个和缓存雪崩的区别在于这里针对某一key缓存，前者则是很多key。

缓存在某个时间点过期的时候，恰好在这个时间点对这个Key有大量的并发请求过来，这些请求发现缓 存过期一般都会从后端DB加载数据并回设到缓存，这个时候大并发的请求可能会瞬间把后端DB压垮。

解决方案:

  1. 用分布式锁控制访问的线程

    使用redis的setnx互斥锁先进行判断，这样其他线程就处于等待状态，保证不会有大并发操作去操作数据库。

  2. 不设超时时间，volatile-lru 但会造成写一致问题

    当数据库数据发生更新时，缓存中的数据不会及时更新，这样会造成数据库中的数据与缓存中的数据的 不一致，应用会从缓存中读取到脏数据。可采用延时双删策略处理，这个我们后面会详细讲到。

数据不一致

缓存和DB的数据不一致的根源 : 数据源不一样

如何解决：

  • 强一致性很难，追求最终一致性(时间) 互联网业务数据处理的特点
  • 高吞吐量
  • 低延迟
  • 数据敏感性低于金融业
  • 时序控制是否可行?
  • 先更新数据库再更新缓存或者先更新缓存再更新数据库
  • 本质上不是一个原子操作，所以时序控制不可行
  • 高并发情况下会产生不一致
保证数据的最终一致性（延时双删）
  1. 先更新数据库同时删除缓存项(key)，等读的时候再填充缓存
  2. 2秒后再删除一次缓存项(key)
  3. 设置缓存过期时间 Expired Time 比如 10秒 或1小时
  4. 将缓存删除失败记录到日志中，利用脚本提取失败记录再次删除(缓存失效期过长 7*24)

升级方案:

通过数据库的binlog来异步淘汰key，利用工具(canal)将binlog日志采集发送到MQ中，然后通过ACK机 制确认处理删除缓存。

数据并发竞争

这里的并发指的是多个redis的client同时set同一个key引起的并发问题。 多客户端(Jedis)同时并发写一个key，一个key的值是1，本来按顺序修改为2,3,4，最后是4，但是顺序变成了4,3,2，最后变成了2。
第一种方案:分布式锁+时间戳

  1. 整体技术方案

    这种情况，主要是准备一个分布式锁，大家去抢锁，抢到锁就做set操作。加锁的目的实际上就是把并行读写改成串行读写的方式，从而来避免资源竞争。


    数据并发竞争.png

  2. Redis分布式锁的实现

主要用到的redis函数是setnx()。用SETNX实现分布式锁
时间戳

由于上面举的例子，要求key的操作需要顺序执行，所以需要保存一个时间戳判断set顺序。

系统A key 1 {ValueA 7:00}

系统B key 1 { ValueB 7:05

假设系统B先抢到锁，将key1设置为{ValueB 7:05}。接下来系统A抢到锁，发现自己的key1的时间戳早于缓存中的时间戳(7:00<7:05)，那就不做set操作了。

第二种方案:利用消息队列

在并发量过大的情况下,可以通过消息中间件进行处理,把并行读写进行串行化。 把Redis的set操作放在队列中使其串行化,必须的一个一个执行。

Hot Key

当有大量的请求(几十万)访问某个Redis某个key时，由于流量集中达到网络上限，从而导致这个redis的 服务器宕机。造成缓存击穿，接下来对这个key的访问将直接访问数据库造成数据库崩溃，或者访问数据库回填Redis再访问Redis，继续崩溃。


Hot Key.png

如何发现热key

  1. 预估热key，比如秒杀的商品、火爆的新闻等
  2. 在客户端进行统计，实现简单，加一行代码即可
  3. 如果是Proxy，比如Codis，可以在Proxy端收集
  4. 利用Redis自带的命令，monitor、hotkeys。但是执行缓慢(不要用)

  5. 利用基于大数据领域的流式计算技术来进行实时数据访问次数的统计，比如 Storm、Spark Streaming、Flink，这些技术都是可以的。发现热点数据后可以写到zookeeper中


    如何发现热key.png

如何处理热Key:

  1. 变分布式缓存为本地缓存

    发现热key后，把缓存数据取出后，直接加载到本地缓存中。可以采用Ehcache、Guava Cache都可 以，这样系统在访问热key数据时就可以直接访问自己的缓存了。(数据不要求时时一致)

  2. 在每个Redis主节点上备份热key数据，这样在读取时可以采用随机读取的方式，将访问压力负载到 每个Redis上。

  3. 利用对热点数据访问的限流熔断保护措施

    每个系统实例每秒最多请求缓存集群读操作不超过 400 次，一超过就可以熔断掉，不让请求缓存集群，直接返回一个空白信息，然后用户稍后会自行再次重新刷新页面之类的。(首页不行，系统友好性差) 通过系统层自己直接加限流熔断保护措施，可以很好的保护后面的缓存集群。

Big Key

大key指的是存储的值(Value)非常大，常见场景:

  • 热门话题下的讨论
  • 大V的粉丝列表
  • 序列化后的图片
  • 没有及时处理的垃圾数据

大key的影响:

  • 大key会大量占用内存，在集群中无法均衡
  • Redis的性能下降，主从复制异常
  • 在主动删除或过期删除时会操作时间过长而引起服务阻塞

如何发现大key:

  1. redis-cli --bigkeys命令。可以找到某个实例5种数据类型(String、hash、list、set、zset)的最大key。
    但如果Redis 的key比较多，执行该命令会比较慢

  2. 获取生产Redis的rdb文件，通过rdbtools分析rdb生成csv文件，再导入MySQL或其他数据库中进行 分析统计，根据size_in_bytes统计bigkey

大key的处理:

优化big key的原则就是string减少字符串长度，list、hash、set、zset等减少成员数。

  1. String类型的big key，尽量不要存入Redis中，可以使用文档型数据库MongoDB或缓存到CDN上。如果必须用Redis存储，最好单独存储，不要和其他的key一起存储。采用一主一从或多从。

  2. 单个简单的key存储的value很大，可以尝试将对象分拆成几个key-value， 使用mget获取值，这样 分拆的意义在于分拆单次操作的压力，将操作压力平摊到多次操作中，降低对redis的IO影响。

  3. hash， set，zset，list 中存储过多的元素，可以将这些元素分拆。(常见)

    以hash类型举例来说，对于field过多的场景，可以根据field进行hash取模，生成一个新的key，例如原来的
hash_key:{filed1:value, filed2:value, filed3:value ...}，可以hash取模后形成如下 key:value形式
hash_key:1:{filed1:value}
hash_key:2:{filed2:value}
hash_key:3:{filed3:value}
...
取模后，将原先单个key分成多个key，每个key filed个数为原先的1/N

  4. 删除大key时不要使用del,因为del是阻塞命令，删除时会影响性能。

  5. 使用 lazy delete (unlink命令)

删除指定的key(s),若key不存在则该key被跳过。但是，相比DEL会产生阻塞，该命令会在另一个线程中回收内存，因此它是非阻塞的。 这也是该命令名字的由来:仅将keys从key空间中删除，真正的数据删 除会在后续异步操作。

redis> SET key1 "Hello"
"OK"
redis> SET key2 "World"
"OK"
redis> UNLINK key1 key2 key3
(integer) 2

分布式锁

利用Watch实现Redis乐观锁

乐观锁基于CAS(Compare And Swap)思想(比较并替换)，是不具有互斥性，不会产生锁等待而消耗资源，但是需要反复的重试，但也是因为重试的机制，能比较快的响应。因此我们可以利用redis来 实现乐观锁。具体思路如下:

  1. 利用redis的watch功能，监控这个redisKey的状态值
  2. 获取redisKey的值
  3. 创建redis事务
  4. 给这个key的值+1
  5. 然后去执行这个事务，如果key的值被修改过则回滚，key不加1
Redis乐观锁实现秒杀
package com.hhb.redis;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;

import java.util.List;
import java.util.UUID;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @description:
 * @author: huanghongbo
 * @date: 2020-08-09 13:47
 **/
public class SecondKillTest {
    public static void main(String[] args) {
        String redisKey = "redisKey";
        ExecutorService executorService = Executors.newFixedThreadPool(20);
        //设置初始值
        Jedis jedis = new Jedis("59.110.241.53", 6381);
        jedis.set(redisKey, "0");
        jedis.close();
        //并发竞争
        for (int i = 0; i < 1000; i++) {
            executorService.execute(() -> {
                Jedis j1 = new Jedis("59.110.241.53", 6381);
                j1.watch(redisKey);
                String redisValue = j1.get(redisKey);
                int valInteger = Integer.valueOf(redisValue);
                String userInfo = UUID.randomUUID().toString();
                if (valInteger < 20) {
                    Transaction multi = j1.multi();
                    multi.incr(redisKey);
                    List exec = multi.exec();
                    if (exec != null && exec.size() > 0) {
                        System.out.println("用户:" + userInfo + "，秒杀成功! 当前成功人数:" + (valInteger + 1));
                    } else {
                        System.out.println("用户:" + userInfo + "，秒杀失败");
                    }
                } else {
                    System.out.println("已经有20人秒杀成功，秒杀结束");
                }
                j1.close();
            });
        }
        executorService.shutdown();
    }
}


setNX


实现原理


    

  • 共享资源互斥
    • 

  • 共享资源串行化
    • 

  • 单应用中使用锁:(单进程多线程)
    • 

  • synchronized、ReentrantLock
    • 

  • 分布式应用中使用锁:(多进程多线程)
    • 

  • 分布式锁是控制分布式系统之间同步访问共享资源的一种方式。
    • 

  • 利用Redis的单线程特性对共享资源进行串行化处理
    • 



实现方式


    

  • 方式1(使用set命令实现)--推荐
    • 



    /**
     * 原子性操作
     *
     * @return
     */
    public static boolean getLock() {
        Jedis jedis = new Jedis("59.110.241.53", 6381);
        String set = jedis.set("k1", "v1", "NX", "PX", 1000);
        if ("OK".equals(set)) {
            return true;
        }
        return false;
    }




    

  • 方式2 使用setNX命令实现) -- 并发会产生问题
    • 



    /**
     * 非原子性操作，设置过期时间的时候，系统挂了，后面都获取不到锁了
     *
     * @return
     */
    public static boolean getLock2() {
        Jedis jedis = new Jedis("59.110.241.53", 6381);
        Long set = jedis.setnx("k1", "v1");
        if (1 == set) {
            jedis.expire("k1", 1000);
            return true;
        }
        return false;
    }



释放锁


    

  • 方式1(del命令实现) -- 并发
    • 



    /**
     * 释放分布式锁
     *
     * @param lockKey * @param requestId
     */
    public static void releaseLockUnSafe(String lockKey, String requestId) {
        Jedis jedis = new Jedis("59.110.241.53", 6381);
        if (requestId.equals(jedis.get(lockKey))) {
            jedis.del(lockKey);
        }
    }






问题在于如果调用jedis.del()方法的时候，这把锁已经不属于当前客户端的时候会解除他人加的锁。 那么是否真的有这种场景?答案是肯定的，比如客户端A加锁，一段时间之后客户端A解锁，在执行 jedis.del()之前，锁突然过期了，此时客户端B尝试加锁成功，然后客户端A再执行del()方法，则将客户 端B的锁给解除了。




    

  • 方式2(redis+lua脚本实现)--推荐
    • 



    /**
     * 安全的
     *
     * @param lockKey
     * @param requestId
     * @return
     */
    public static boolean releaseLockSafe(String lockKey, String requestId) {
        Jedis jedis = new Jedis("59.110.241.53", 6381);
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end ";
        Object result = jedis.eval(script, Collections.singletonList(lockKey),
                Collections.singletonList(requestId));
        if (result.equals(1L)) {
            return true;
        }
        return false;
    }



存在问题


    

  • 单机：无法保证高可用
    • 

  •  
    主--从：无法保证数据的强一致性，在主机宕机时会造成锁的重复获得。
     
    

    

    

    

    

    

    
分布式锁存在的问题.png

    

     
    • 

  • 无法续租：超过expireTime后，不能继续使用
    • 



本质分析


CAP模型分析：在分布式环境下不可能满足三者共存，只能满足其中的两者共存，在分布式下P不能舍弃(舍弃P就是单机了)。所以只能是CP(强一致性模型)和AP(高可用模型)。分布式锁是CP模型，Redis集群是AP模型。 (base)Redis集群不能保证数据的随时一致性，只能保证数据的最终一致性。


为什么还可以用Redis实现分布式锁?


与业务有关，当业务不需要数据强一致性时，比如:社交场景，就可以使用Redis实现分布式锁，当业务必须要数据的强一致性，即不允许重复获得锁，比如金融场景(重复下单，重复转账)就不要使用，可以使用CP模型实现，比如:zookeeper和etcd。


Redisson分布式锁的使用


Redisson是架设在Redis基础上的一个Java驻内存数据网格(In-Memory Data Grid)。 Redisson在基于NIO的Netty框架上，生产环境使用分布式锁。


pom




  org.redisson
  redisson
  2.7.0




配置Redission


package com.hhb.redis.redission;

import org.redisson.Redisson;
import org.redisson.config.Config;

/**
 * @description:
 * @author: huanghongbo
 * @date: 2020-08-09 14:34
 **/
public class RedissonManager {

    private static Config config = new Config(); //声明redisso对象
    private static Redisson redisson = null;

    //实例化redisson static{
    static {
        config.useClusterServers()
                // 集群状态扫描间隔时间，单位是毫秒
                .setScanInterval(2000)
                //cluster方式至少6个节点(3主3从，3主做sharding，3从用来保证主宕机后可以高可用)
                .addNodeAddress("redis://59.110.241.53:7001")
                .addNodeAddress("redis://59.110.241.53:7002")
                .addNodeAddress("redis://59.110.241.53:7003")
                .addNodeAddress("redis://59.110.241.53:7004")
                .addNodeAddress("redis://59.110.241.53:7005")
                .addNodeAddress("redis://59.110.241.53:7006");
        //得到redisson对象
        redisson = (Redisson) Redisson.create(config);
    }

    //获取redisson对象的方法
    public static Redisson getRedisson() {
        return redisson;
    }
}




加锁、释放及使用


package com.hhb.redis.redission;

import org.redisson.Redisson;
import org.redisson.api.RLock;

import java.io.IOException;
import java.util.concurrent.TimeUnit;

/**
 * @description:
 * @author: huanghongbo
 * @date: 2020-08-09 14:37
 **/
public class DistributedRedisLock {
    //从配置类中获取redisson对象
    private static Redisson redisson = RedissonManager.getRedisson();
    private static final String LOCK_TITLE = "redisLock_"; //加锁

    public static boolean acquire(String lockName) { //声明key对象
        String key = LOCK_TITLE + lockName; //获取锁对象
        RLock mylock = redisson.getLock(key); //加锁，并且设置锁过期时间3秒，防止死锁的产生 uuid+threadId
        mylock.lock(2, TimeUnit.SECONDS); //加锁成功
        return true;
    }

    //锁的释放
    public static void release(String lockName) {
        //必须是和加锁时的同一个key
        String key = LOCK_TITLE + lockName;
        //获取所对象
        RLock mylock = redisson.getLock(key);
        //释放锁(解锁)
        mylock.unlock();
    }


    public String discount() throws IOException {
        String key = "lock001";
        //加锁
        DistributedRedisLock.acquire(key); //执行具体业务逻辑
        //todo:dosoming
        //释放锁
        DistributedRedisLock.release(key);
        //返回结果 return soming;
        return null;
    }
}



Redisson分布式锁的实现原理













Redisson分布式锁的实现原理.png





加锁机制


如果该客户端面对的是一个redis cluster集群，他首先会根据hash节点选择一台机器。 发送lua脚本到redis服务器上，脚本如下:


"if (redis.call('exists',KEYS[1])==0) then "+ --看有没有锁 
"redis.call('hset',KEYS[1],ARGV[2],1) ; "+ --无锁 加锁 
"redis.call('pexpire',KEYS[1],ARGV[1]) ; "+
"return nil; end ;" +
"if (redis.call('hexists',KEYS[1],ARGV[2]) ==1 ) then "+ --我加的锁 
"redis.call('hincrby',KEYS[1],ARGV[2],1) ; "+ --重入锁 
"redis.call('pexpire',KEYS[1],ARGV[1]) ; "+
"return nil; end ;" +
"return redis.call('pttl',KEYS[1]) ;" --不能加锁，返回锁的时间



lua的作用:保证这段复杂业务逻辑执行的原子性。


lua的解释:


KEYS[1]) : 加锁的key


ARGV[1] : key的生存时间，默认为30秒


ARGV[2] : 加锁的客户端ID (UUID.randomUUID() + “:” + threadId)


第一段if判断语句，就是用“exists myLock”命令判断一下，如果你要加锁的那个锁key不存在的话，你 就进行加锁。如何加锁呢?很简单，用下面的命令:


hset myLock 8743c9c0-0795-4907-87fd-6c719a6b4586:1 1



通过这个命令设置一个hash数据结构，这行命令执行后，会出现一个类似下面的数据结构:


myLock :{"8743c9c0-0795-4907-87fd-6c719a6b4586:1":1 }



上述就代表“8743c9c0-0795-4907-87fd-6c719a6b4586:1”这个客户端对“myLock”这个锁key完成了加锁。


接着会执行“pexpire myLock 30000”命令，设置myLock这个锁key的生存时间是30秒。


锁互斥机制


那么在这个时候，如果客户端2来尝试加锁，执行了同样的一段lua脚本，会咋样呢?很简单，第一个if判断会执行“exists myLock”，发现myLock这个锁key已经存在了。接着第二个if判断，判断一下，myLock锁key的hash数据结构中，是否包含客户端2的ID，但是明显不 是的，因为那里包含的是客户端1的ID。所以，客户端2会获取到pttl myLock返回的一个数字，这个数字代表了myLock这个锁key的剩余生存时 间。比如还剩15000毫秒的生存时间。此时客户端2会进入一个while循环，不停的尝试加锁。


自动延时机制


只要客户端1一旦加锁成功，就会启动一个watch dog看门狗，他是一个后台线程，会每隔10秒检查一 下，如果客户端1还持有锁key，那么就会不断的延长锁key的生存时间。


可重入锁机制


第一个if判断肯定不成立，“exists myLock”会显示锁key已经存在了。 第二个if判断会成立，因为myLock的hash数据结构中包含的那个ID，就是客户端1的那个ID，也就是“8743c9c0-0795-4907-87fd-6c719a6b4586:1”此时就会执行可重入加锁的逻辑，他会用


incrby myLock 8743c9c0-0795-4907-87fd-6c71a6b4586:1 1



通过这个命令，对客户端1的加锁次数，累加1。数据结构会变成:


myLock :{"8743c9c0-0795-4907-87fd-6c719a6b4586:1":2 }



释放锁的机制


执行lua脚本如下:


-- 如果key已经不存在，说明已经被解锁，直接发布(publish)redis消息 
"if (redis.call('exists', KEYS[1]) == 0) then " +
"redis.call('publish', KEYS[2], ARGV[1]); " +
                        "return 1; " +
                    "end;" +
-- key和field不匹配，说明当前客户端线程没有持有锁，不能主动解锁。 不是我加的锁 不能解锁
"if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then " +
-- 将value减1
    "return nil;" +
"end; " +
"local counter = redis.call('hincrby', KEYS[1], ARGV[3],-1); " +
-- 如果counter>0说明锁在重入，不能删除key
"if (counter > 0) then " + "redis.call('pexpire', KEYS[1], ARGV[2]); " + "return 0; " +
-- 删除key并且publish 解锁消息 
"else " +
"redis.call('del', KEYS[1]); " + -- 删除锁
"redis.call('publish', KEYS[2], ARGV[1]); " + "return 1; "+
                    "end; " +
                    "return nil;",



– KEYS[1] :需要加锁的key，这里需要是字符串类型。


– KEYS[2] :redis消息的ChannelName,一个分布式锁对应唯一的一个channelName:“redisson_lockchannel{” + getName() + “}”


– ARGV[1] :reids消息体，这里只需要一个字节的标记就可以，主要标记redis的key已经解锁，再结合redis的Subscribe，能唤醒其他订阅解锁消息的客户端线程申请锁。


– ARGV[2] :锁的超时时间，防止死锁


– ARGV[3] :锁的唯一标识，也就是刚才介绍的 id(UUID.randomUUID()) + “:” + threadId


如果执行lock.unlock()，就可以释放分布式锁，此时的业务逻辑也是非常简单的。 其实说白了，就是每次都对myLock数据结构中的那个加锁次数减1。 如果发现加锁次数是0了，说明这个客户端已经不再持有锁了，此时就会用: “del myLock”命令，从redis里删除这个key。 然后呢，另外的客户端2就可以尝试完成加锁了。


分布式锁特性


    

  •  
    互斥性
    

      

    • 任意时刻，只能有一个客户端获取锁，不能同时有两个客户端获取到锁。
      • 

    • Redis : setnx 、set key value NX 如果key存在就不设置
      • 

     
    • 

  •  
    同一性
    

      

    • 锁只能被持有该锁的客户端删除，不能由其它客户端删除。
      • 

    • Redis : lua 实现原子性
      • 

     
    • 

  •  
    可重入性
    

      

    • 持有某个锁的客户端可继续对该锁加锁，实现锁的续租
      • 

     
    • 

  •  
    容错性
    

      

    • 锁失效后(超过生命周期)自动释放锁(key失效)，其他客户端可以继续获得该锁，防止死锁
      • 

    • expire 设置超时时间
      • 

    • set key value NX PX
      • 

     
    • 



分布式锁的实际应用


    

  •  
    数据并发竞争
     
    利用分布式锁+时间戳可以将处理串行化，前面已经讲过了。
     
    • 

  •  
    防止库存超卖
     
    

    

    

    

    

    

    
防止库存超卖.png

    

     
    • 



订单1下单前会先查看库存，库存为10，所以下单5本可以成功; 订单2下单前会先查看库存，库存为10，所以下单8本可以成功;订单1和订单2 同时操作，共下单13本，但库存只有10本，显然库存不够了，这种情况称为库存超卖。 可以采用分布式锁解决这个问题。















超卖解决.png





订单1和订单2都从Redis中获得分布式锁(setnx)，谁能获得锁谁进行下单操作，这样就把订单系统下单 的顺序串行化了，就不会出现超卖的情况了。伪码如下:


    

  • 获得分布式锁
    • 

  • 取得库存
    • 

  • 如果大于下单数
    • 

  • 下单
    • 

  • 更改库存
    • 

  • 释放锁
    • 



//加锁并设置有效期 
if(redis.lock("RDL",200)){
//判断库存
  if (orderNum


注意此种方法会降低处理效率，这样不适合秒杀的场景，秒杀可以使用CAS和Redis队列的方式。
























你可能感兴趣的:(Redis经典问题解析)






    

  • 【iOS】MVC设计模式
Magnetic_h
iosmvc设计模式objective-c学习ui

    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
    

    • 

  • Redis系列：Geo 类型赋能亿级地图位置计算
Ly768768
redisbootstrap数据库

    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
    

    • 

  • 2019-01-19
王小康KK

    姓名:王康公司:扬州市方圆建筑工程有限公司2018年3月16日～3月18日上海361期《六项精进》感谢二组学员【日精进打卡第307天】【知～学习】《六项精进》大纲3遍共862遍《大学》通篇3遍共860遍《六项精进》全书40页【经典名句】思想决定行为，行为决定习惯，习惯决定性格，性格决定命运。【行～实践】一、修身：（对自己个人）1、践行六项精进的理念。二、齐家：（对家庭和家人）1、和女朋友视频聊天。
    

    • 

  • 现代汉语粗糙版 文学史与经典
学习搬运工

    第十六章文学史与经典文学史的兴起在西方,虽然从亚里士多德开始,在人类的著述中已经可以找到文学史概念与写作方式的萌芽,但是,人们一般认为17世纪后期到18世纪是现代文学史写作真正开始的时期。长达百年波及整个欧洲的“古今之争”孕育出文学研究的历史意识,现代意义上的文学史观念在这场影响深远的论争中初见端倪。从18世纪晚期到19世纪初,由于席勒、弗·施莱格尔和赫尔德等人的介入,文学史研究逐渐变得复杂和成熟
    

    • 

  • 语文主题教学学习笔记之87
东哥杂谈

    “语文主题教学”学习笔记之八十七（0125）今天继续学习小学语文主题教学的实践样态。板块三：教学中体现“书艺”味道。作为四大名著之一的《水浒传》，堪称我国文学宝库之经典。对从《水浒传》中摘选的单元，教师就要了解其原生态，即评书体特点。这也要求教师要了解一些常用的评书行话术语，然后在教学时适时地加入一些，让学生体味其文本中原有的特色。学生也要尽可能地通过朗读的方式，而不单是分析讲解的方式进行学习。细
    

    • 

  • 2019-03-24
李飞720

    姓名：李飞企业名称：临沂鑫道食品有限公司组别373期利他1组日精进打卡第338天】【知~学习】1、阿米巴经营一段2、活用人才1段3、活法、一段【行~实践】一、修身：读书、抽烟减量、俯卧撑个跑步3公里二、齐家、劝说老爸与姑姑和好三、建功、业务洽谈【经典名句分享】1、依据原理原则追求事物的本质，以“作为人，何谓正确”进行判断2、经营者必须为员工物质和精神两方面的幸福殚精竭虑，倾尽全力，必须超脱私心，让
    

    • 

  • Python算法L5：贪心算法
小熊同学哦
Python算法算法python贪心算法

    Python贪心算法简介目录Python贪心算法简介贪心算法的基本步骤贪心算法的适用场景经典贪心算法问题1.**零钱兑换问题**2.**区间调度问题**3.**背包问题**贪心算法的优缺点优点：缺点：结语贪心算法（GreedyAlgorithm）是一种在每一步选择中都采取当前最优或最优解的算法。它的核心思想是，在保证每一步局部最优的情况下，希望通过贪心选择达到全局最优解。虽然贪心算法并不总能得到全
    

    • 

  • 2019-04-10
shuaigefeng

    姓名：王林锋企业名称：三亚蔚蓝时代实业有限公司组别：420期努力6组【日精进打卡251天】【知~学习、诵读】《六项精进》2遍，累计256遍《大学》2遍，累计220遍【经典分享】1、想过成功、想过失败、也想过放弃。【行~实践】一、修身：（对自己个人）1.拍打腿部两侧50下，舌顶上颚50下。2.坚持诵读、阅读。3.坚持锻炼、按时睡觉起床。4.控制健康饮食，饭后走动30分钟。5.每天反省自己的思想和行为
    

    • 

  • 妖孽宫廷（四）
安好是佳

    1.“纸糊三阁老，泥塑六尚书”与商辂堂堂文官言官，数年苦读儒家经典，应该是皇帝的智囊团，但是在这个时期的明朝政坛下居然是这样的评价，成为皇帝的后腿子团，成为国家发展的智障团，可见其背后有很强的推动力，让言官们躲避刚正不阿，做出祸国殃民的举措。我想，这个推动力应该是首先保住性命，而后同流而强取豪夺他人财物。在监派出头的环境下，尤其在监派强大的特务机构和惩罚机构，让那些发现问题的言官们不敢言。这可是脑
    

    • 

  • 华为云分布式缓存服务DCS 8月新特性发布
华为云PaaS服务小智
华为云分布式缓存

    分布式缓存服务（DistributedCacheService，简称DCS）是华为云提供的一款兼容Redis的高速内存数据处理引擎，为您提供即开即用、安全可靠、弹性扩容、便捷管理的在线分布式缓存能力，满足用户高并发及数据快速访问的业务诉求。此次为大家带来DCS8月的特性更新内容，一起来看看吧！
    

    • 

  • Python实现关联规则推荐
这孩子谁懂哈
PythonMachineLearningpython关联规则机器学习

    1.什么关联规则关联规则（AssociationRules）是反映一个事物与其他事物之间的相互依存性和关联性，如果两个或多个事物之间存在一定的关联关系，那么，其中一个事物就能通过其他事物预测到。关联规则是数据挖掘的一个重要技术，用于从大量数据中挖掘出有价值的数据项之间的相关关系。关联规则挖掘的最经典的例子就是沃尔玛的啤酒与尿布的故事，通过对超市购物篮数据进行分析，即顾客放入购物篮中不同商品之间的关
    

    • 

  • Redis Key的过期策略
ArchManual
分布式架构分布式Java后端微服务架构redis

    Redis的过期策略主要是指管理和删除那些设定了过期时间的键，以确保内存的有效使用和数据的及时清理。具体来说，Redis有三种主要的过期策略：定期删除（ScheduledDeletion）、惰性删除（LazyDeletion）和内存淘汰策略（EvictionPolicies）。1.定期删除Redis的定期删除策略（ScheduledDeletion）的步骤如下：设置定期任务：Redis会在后台线程
    

    • 

  • Redis:缓存击穿
我的程序快快跑啊
缓存redisjava

    缓存击穿(热点key)：部分key(被高并发访问且缓存重建业务复杂的)失效,无数请求会直接到数据库，造成巨大压力1.互斥锁：可以保证强一致性线程一：未命中之后，获取互斥锁，再查询数据库重建缓存，写入缓存，释放锁线程二：查询未命中，未获得锁(已由线程一获得)，等待一会，缓存命中互斥锁实现方式：redis中setnxkeyvalue:改变对应key的value,仅当value不存在时执行，以此来实现互
    

    • 

  • Redis 有哪些危险命令？如何防范？
花小疯
redis缓存数据库危险命令大数据

    Redis有哪些危险命令？Redis的危险命令主要有以下几个：1.keys客户端可查询出所有存在的键。2.flushdb删除Redis中当前所在数据库中的所有记录，并且此命令从不会执行失败。3.flushall删除Redis中所有数据库中的所有记录，不止是当前所在数据库，并且此命令从不会执行失败。4.config客户端可修改Redis配置。怎么禁用和重命名危险命令？看下redis.conf默认配置
    

    • 

  • 【新教育-教师随笔】读《做最好的英语老师》有感
164c5aca7b79

    伊川县直中学王素平《做最好的英语老师》这本书是作者这些年在他教学中得与失的总结。里面给我们提供了听力，单词，句子，阅读，作文等模块的教学方法，让我受益匪浅，现总结如下：一.语文教学给了我们什么启示？（1）：现有的英语教材内容简单，枯燥，与学生的心智发展水平严重脱节。我们要给学生补中一些贴近学生生活，能感动和影响他们的经典作品。让学生学习知识的同时，有所感悟和思考，同时享受审美的乐趣！如AWiseO
    

    • 

  • 内经简介（上）
骆长珊

    哈喽大家好我是骆长珊今天是2017年1月9日，今天是我每天一篇文章的第四十八篇。最近在重温《黄帝内经》，我在不断记颂原文的过程也不断的找相关资料来看。最终目的，以教为学，写出自己知道的，提神自己的觉悟。黄帝内经》是我国传统医学四大经典著作之一（《黄帝内经》、《伤寒论》、《金匮要略》、《温病条辨》），也是第一部冠以中华民族先祖“黄帝”之名的传世巨著，是我国医学宝库中现存成书最早的一部医学典籍。在理论
    

    • 

  • 【品读国学经典】大学：第一章
冰清九月

    【原文】大学之道，在明明德，在亲民，在止于至善。知止而后有定，定而后能静，静而后能安，安而后能虑，虑而后能得。物有本末，事有终始。知所先后，则近道矣。古之欲明明德于天下者，先治其国;欲治其国者，先齐其家;欲齐其家者，先修其身;欲修其身者，先正其心;欲正其心者，先诚其意;欲诚其意者，先致其知;致知在格物。物格而后知至，知至而后意诚，意诚而后心正，心正而后身修，身修而后家齐，家齐而后国治，国治而后天下
    

    • 

  • 学习| 积极心理学—习得性无助
benignHu

    习得性无助——不知不觉，你居然习得了可怕的无助，从此，它将长久伴随着你，轻易不肯离去。“习得性无助”是积极心理学之父塞利格曼的研究成果，其概念由其提出。也正是因为“习得性无助”的发现，才有后来的积极心理学，所以今天我们来好好聊聊何谓习得性无助，如何走出习得性无助。01、习得性无助一、习得性无助的由来习得性无助源于经典心理学实验：美国著名心理学家、教育心理学的创始人爱德华·李·桑代克是一个科学心理学
    

    • 

  • 尹吭【谦虚组】精进打卡2018.06.12
老黑1983

    内容：【日精进打卡第171天】【知～学习】《六项精进》2遍共330遍《大学》2遍共346遍••••••【经典名句分享】人不知而不愠不亦君子乎【行～实践】一、修身：（对自己个人）俯卧撑20个五组修身：（利他：告知中医的一些治疗项目）修身：（帮扶：帮扶对象离职）二、齐家：（对家庭和家人）1、送女儿上学三、建功：（对工作）1、湿疹和疣案例页调整｛积善｝：发愿从2017年12月25日起1年内365善事。今
    

    • 

  • 增长黑客和最小可复制的内核
爱思考的糖

    五段-增长黑客的三大步骤生活就像逆水行舟，加入你不能加速，现实中最好的情况，你也就处在一种原地打转的状况。增长，就像一辆车里的加速器。围棋爱好者，水平一直没有进步的原因。是因为没有找到提高下棋水平的增长模式有三个办法可以提高：做死活题，练习做关键决策的能力；打谱，复盘经典案例；找AI陪练。增长黑客的三个实战步骤：第一步，假设：建立最小闭环。从笨办法开始，不怕犯错，代价并不高，你可以勇敢尝试。想知道
    

    • 

  • 每日片刻诗情画意之2022-06-28
人生下伴场

    #日诵诗情，画意日趣#人生下伴场-每日诗情画意#日诵之20220628春怨刘方平纱窗日落渐黄昏，金屋无人见泪痕。寂寞空庭春欲晚，梨花满地不开门。1、春怨是古代诗词的经典主题系列，除了民间夫君出远门或者思念意中人之外，宫廷锁春深也是常见的内容。刘方平的这一首我是第一次读到，第二句“金屋无人见泪痕”不知道是金屋藏娇的由来还是引用。2、梨花满地不开门，让我想起李清照《声声慢》词中“满地黄花堆积”、“寻寻
    

    • 

  • Rides实现分布式锁，保障数据一致性,Redisson分布式事务处理
朱杰jjj
缓存分布式

    分布式环境下分布式锁有三种方式：基于数据库分布式锁基于Redis分布式锁基于zk分布式锁本帖只介绍Redis分布式锁为什么需要用到分布式锁？在单机环境下一个服务中多个线程对同一个事物或数据资源进行操作时，可以通过添加加锁方式（synchronized和lock）来解决数据一致性的问题。但是如果出现多个服务的情况下，这时候我们在通过synchronized和lock的方式来加锁会出现问题，因为多个服
    

    • 

  • Cloud Native Weekly | 华为云抢先发布Redis5.0，红帽宣布收购混合云提供商
weixin_34302561
数据库devops大数据

    1——华为云抢先发布Redis5.02——DigitalOceanK8s服务正式上线3——红帽宣布收购混合云提供商NooBaa4——微软发布多项AzureKubernetes服务更新1华为云抢先发布Redis5.012月17日，华为云在DCS2.0的基础上，快人一步，抢先推出了新的Redis5.0产品，这是一个崭新的突破。目前国内在缓存领域的发展普遍停留在Redis4.0阶段，华为云率先发布了Re
    

    • 

  • 华为云分布式缓存服务DCS与开源服务差异对比
hcinfo_18
redis使用华为云Redis5.0分布式缓存服务Redis客户端

    分布式缓存服务DCS提供单机、主备、集群等丰富的实例类型，满足用户高读写性能及快速数据访问的业务诉求。支持丰富的实例管理操作，帮助用户省去运维烦恼。用户可以聚焦于业务逻辑本身，而无需过多考虑部署、监控、扩容、安全、故障恢复等方面的问题。DCS基于开源Redis、Memcached向用户提供一定程度定制化的缓存服务，因此，除了拥有开源服务缓存数据库的优秀特性，DCS提供更多实用功能。一、与开源Red
    

    • 

  • 超越免费
奔向自由的路上

    在这个互联时代，由于社会的进步，我们亨受了很多免费的东西，比如免费的电脑操作软件，免费的杀毒软件，免费的搜索服务，雅虎的杨致远和费罗首创让互联网成为一个开放，免费的工具。后来微软用免费的方式压浏览器市场打败了当时一家独大的网景公司，一时之间，免费成了趋势，互联网传播的本质，起到了一个巨大的复印件的作用。免费带来的一个结果是迅速形成垄断，造就了googlefacebook和阿里巴巴这样的经典掉板，然
    

    • 

  • 传统经典《大学》学习录：28
明道1968

    传统经典《大学》学习录：28“《诗》云：‘殷之未丧师，克配上帝；仪监于殷，峻命不易。’道得众则得国，失众则失国。”这一节是讲天命是因于民心。曾子讲：“百姓的好恶，关系非同小可。《大雅·文王》诗云：当殷代的先王没有失去众人之时，也曾经能面对上天，受上天的眷顾而成为天下之主。等到纣王失掉了人心，天命于是也随之而去。现在我周朝的子孙应以殷为鉴，一定要了知，峻大之天命不易保有，而常怀有敬重之心。”诗人的意
    

    • 

  • 我问时间！（非常经典）
柒月以沫

    我们走在岁月的长河里，随着时间的流逝，一路成长，一路领悟。时间是最好的老师，把生命里所有的道理与感悟，通通教给了我们……1我问时间：怎样才能留住你？时间告诉我：人生是一个哭着走来笑着离去的过程生命是一片树叶绿了枯了，必然青春是一朵鲜花开了谢了，天然人生正如一片叶一绿一枯，便是一生没有谁能永葆青春也没有谁能留住时间你走过的每一段路爱过的每一个人做过的每一件事都深深地留下了时间的烙印安守本心，爱你所爱
    

    • 

  • 2018-11-10
菜菜_d868

    姓名：邢彩颜公司：蔚蓝时代【日精进打卡第101天】【知-学习】1.读0六项精进【经典名句分享】努力不一定成功，但不努力一定不会成功行：今日休息【省-觉悟】躺一整天没有运动。【感谢】感谢420谦虚2组的成员，感恩父母，感谢我的领导、我的团队。感谢身边的朋友，【发愿】愿我身边的朋友健健康康。愿爱我的人每天都快乐，幸福。愿自己能够每天进步一点点。愿我的家人都健康快乐幸福。今日0善,累计103件.
    

    • 

  • 重看《天道》，芸芸众生分为4个层次，看看你属于哪一层?
拂尘记

    听说纯原创的公众号不超过7%，这是拂尘记的第701篇原创文章，字数1676，阅读大概需要3分钟最近用3天时间，重刷一遍《天道》，经典就是经典，每次看都能有不同的收获与感悟。这次最大的感悟是，纵观全剧，有以下4类人：1、俗人：为了名利面子，贪嗔痴，不停地追求索取。比如刘冰，退了股还想呆在格律诗，就为了那辆宝马以及北京的繁华，然而看着肖亚文忙里忙外，开始心态失衡：我们打下的江山，凭什么给你？殊不知，是
    

    • 

  • 恒信永利：优化行业风气严肃抵制“老赖”行为
叶有司

    最近《中餐厅》屡上热搜，其中中年王子黄晓明可谓是凭借着经典语录又一次火爆了网络，“明学”之盛行，恒信永利想说，：“不要你觉得，只要我觉得！都听我的！恒信永利坚决抵制’老赖’行为！”在如今的“无现金社会”，人们的支付方式发生了巨大的改变，信用经济时代也已经随着“信用医疗”、“信用金融”等的出现而到来，信用借贷也应运而生了。谈及信用借贷，近年来兴起的消费分期借贷正是平台基于每个人的信用基础而提供的贷款
    

    • 

  • java Illegal overloaded getter method with ambiguous type for propert的解决
zwllxs
javajdk

    好久不来iteye,今天又来看看，哈哈,今天碰到在编码时，反射中会抛出
Illegal overloaded getter method with ambiguous type for propert这么个东东，从字面意思看，是反射在获取getter时迷惑了，然后回想起java在boolean值在生成getter时，分别有is和getter，也许我们的反射对象中就有is开头的方法迷惑了jdk，
    

    • 

  • IT人应当知道的10个行业小内幕
beijingjava
工作互联网

    10. 虽然IT业的薪酬比其他很多行业要好，但有公司因此视你为其“佣人”。
　　尽管IT人士的薪水没有互联网泡沫之前要好，但和其他行业人士比较，IT人的薪资还算好点。在接下的几十年中，科技在商业和社会发展中所占分量会一直增加，所以我们完全有理由相信，IT专业人才的需求量也不会减少。
　　然而，正因为IT人士的薪水普遍较高，所以有些公司认为给了你这么多钱，就把你看成是公司的“佣人”，拥有你的支配
    

    • 

  • java 实现自定义链表
CrazyMizzz
java数据结构

    1.链表结构
  链表是链式的结构
2.链表的组成
   链表是由头节点，中间节点和尾节点组成
   节点是由两个部分组成：
      1.数据域
      2.引用域
3.链表的实现
&nbs
    

    • 

  • web项目发布到服务器后图片过一会儿消失
麦田的设计者
struts2上传图片永久保存

      作为一名学习了android和j2ee的程序员，我们必须要意识到，客服端和服务器端的交互是很有必要的，比如你用eclipse写了一个web工程，并且发布到了服务器（tomcat）上，这时你在webapps目录下看到了你发布的web工程，你可以打开电脑的浏览器输入http://localhost:8080/工程/路径访问里面的资源。但是，有时你会突然的发现之前用struts2上传的图片
    

    • 

  • CodeIgniter框架Cart类 name 不能设置中文的解决方法
IT独行者
CodeIgniterCart框架　

    今天试用了一下CodeIgniter的Cart类时遇到了个小问题，发现当name的值为中文时，就写入不了session。在这里特别提醒一下。 在CI手册里也有说明，如下：
$data = array(
'id' => 'sku_123ABC',
'qty' => 1,
'
    

    • 

  • linux回收站
_wy_
linux回收站

    今天一不小心在ubuntu下把一个文件移动到了回收站，我并不想删，手误了。我急忙到Nautilus下的回收站中准备恢复它，但是里面居然什么都没有。     后来我发现这是由于我删文件的地方不在HOME所在的分区，而是在另一个独立的Linux分区下，这是我专门用于开发的分区。而我删除的东东在分区根目录下的.Trash-1000/file目录下，相关的删除信息（删除时间和文件所在
    

    • 

  • jquery回到页面顶端
知了ing
htmljquerycss

    html代码：
<h1 id="anchor">页面标题</h1>
<div id="container">页面内容</div>
<p><a href="#anchor" class="topLink">回到顶端</a><
    

    • 

  • B树、B-树、B+树、B*树
矮蛋蛋
B树

    原文地址：
http://www.cnblogs.com/oldhorse/archive/2009/11/16/1604009.html
B树
       即二叉搜索树：
       1.所有非叶子结点至多拥有两个儿子（Left和Right）；
&nb
    

    • 

  • 数据库连接池
alafqq
数据库连接池

    http://www.cnblogs.com/xdp-gacl/p/4002804.html
@Anthor:孤傲苍狼
数据库连接池
用MySQLv5版本的数据库驱动没有问题，使用MySQLv6和Oracle的数据库驱动时候报如下错误：
java.lang.ClassCastException: $Proxy0 cannot be cast to java.sql.Connec
    

    • 

  • java泛型
百合不是茶
java泛型

    泛型
在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，任意化的缺点就是要实行强制转换，这种强制转换可能会带来不安全的隐患
 
泛型的特点：消除强制转换 确保类型安全 向后兼容
 
简单泛型的定义：
     泛型：就是在类中将其模糊化，在创建对象的时候再具体定义
class fan
    

    • 

  • javascript闭包[两个小测试例子]
bijian1013
JavaScriptJavaScript

    一.程序一
<script>
var name = "The Window";
var Object_a = {
　　name : "My Object",
　　getNameFunc : function(){
var that = this;
　　　　return function(){
　　　　
    

    • 

  • 探索JUnit4扩展：假设机制（Assumption）
bijian1013
javaAssumptionJUnit单元测试

    一.假设机制（Assumption）概述        理想情况下，写测试用例的开发人员可以明确的知道所有导致他们所写的测试用例不通过的地方，但是有的时候，这些导致测试用例不通过的地方并不是很容易的被发现，可能隐藏得很深，从而导致开发人员在写测试用例时很难预测到这些因素，而且往往这些因素并不是开发人员当初设计测试用例时真正目的，
    

    • 

  • 【Gson四】范型POJO的反序列化
bit1129
POJO

    在下面这个例子中，POJO(Data类)是一个范型类，在Tests中，指定范型类为PieceData，POJO初始化完成后，通过
String str = new Gson().toJson(data);
得到范型化的POJO序列化得到的JSON串，然后将这个JSON串反序列化为POJO
 
import com.google.gson.Gson;
import java.
    

    • 

  • 【Spark八十五】Spark Streaming分析结果落地到MySQL
bit1129
Stream

    几点总结：
1. DStream.foreachRDD是一个Output Operation，类似于RDD的action，会触发Job的提交。DStream.foreachRDD是数据落地很常用的方法
2. 获取MySQL Connection的操作应该放在foreachRDD的参数（是一个RDD[T]=>Unit的函数类型)，这样，当foreachRDD方法在每个Worker上执行时，
    

    • 

  • NGINX + LUA实现复杂的控制
ronin47
nginx lua

    安装lua_nginx_module 模块
lua_nginx_module 可以一步步的安装，也可以直接用淘宝的OpenResty
Centos和debian的安装就简单了。。
这里说下freebsd的安装：
fetch http://www.lua.org/ftp/lua-5.1.4.tar.gz
tar zxvf lua-5.1.4.tar.gz
cd lua-5.1.4
ma
    

    • 

  • java-递归判断数组是否升序
bylijinnan
java

    
public class IsAccendListRecursive {
/*递归判断数组是否升序
* if a Integer array is ascending,return true
* use recursion
*/
public static void main(String[] args){
IsAccendListRecursiv
    

    • 

  • Netty源码学习-DefaultChannelPipeline2
bylijinnan
javanetty

    Netty3的API
http://docs.jboss.org/netty/3.2/api/org/jboss/netty/channel/ChannelPipeline.html
里面提到ChannelPipeline的一个“pitfall”：
如果ChannelPipeline只有一个handler（假设为handlerA）且希望用另一handler（假设为handlerB）
来
    

    • 

  • Java工具之JPS
chinrui
java

    JPS使用
 
 
熟悉Linux的朋友们都知道，Linux下有一个常用的命令叫做ps（Process Status)，是用来查看Linux环境下进程信息的。同样的，在Java Virtual Machine里面也提供了类似的工具供广大Java开发人员使用，它就是jps（Java Process Status)，它可以用来
    

    • 

  • window.print分页打印
ctrain
window

    
function init() {
var tt = document.getElementById("tt");
var childNodes = tt.childNodes[0].childNodes;
var level = 0;
for (var i = 0; i < childNodes.length; i++) { 
    

    • 

  • 安装hadoop时 执行jps命令Error occurred during initialization of VM
daizj
jdkhadoopjps

    在安装hadoop时，执行JPS出现下面错误
 
[slave16][email protected]:/tmp/hsperfdata_hdfs# jps
Error occurred during initialization of VM
java.lang.Error: Properties init: Could not determine current working
    

    • 

  • PHP开发大型项目的一点经验
dcj3sjt126com
PHP重构

    一、变量 最好是把所有的变量存储在一个数组中，这样在程序的开发中可以带来很多的方便，特别是当程序很大的时候。变量的命名就当适合自己的习惯，不管是用拼音还是英语，至少应当有一定的意义，以便适合记忆。变量的命名尽量规范化，不要与PHP中的关键字相冲突。 二、函数 PHP自带了很多函数，这给我们程序的编写带来了很多的方便。当然，在大型程序中我们往往自己要定义许多个函数，几十
    

    • 

  • android笔记之--向网络发送GET/POST请求参数
dcj3sjt126com
android

    使用GET方法发送请求
private static boolean sendGETRequest (String path,
Map<String, String> params) throws Exception{
//发送地http://192.168.100.91:8080/videoServi
    

    • 

  • linux复习笔记 之bash shell (3) 通配符
eksliang
linux 通配符linux通配符

    转载请出自出处：
http://eksliang.iteye.com/blog/2104387
在bash的操作环境中有一个非常有用的功能，那就是通配符。
下面列出一些常用的通配符，如下表所示 符号 意义 * 万用字符，代表0个到无穷个任意字符 ? 万用字符，代表一定有一个任意字符 [] 代表一定有一个在中括号内的字符。例如：[abcd]代表一定有一个字符，可能是a、b、c
    

    • 

  • Android关于短信加密
gqdy365
android

    关于Android短信加密功能，我初步了解的如下（只在Android应用层试验）：
    1、因为Android有短信收发接口，可以调用接口完成短信收发；
        发送过程：APP（基于短信应用修改）接受用户输入号码、内容——>APP对短信内容加密——>调用短信发送方法Sm
    

    • 

  • asp.net在网站根目录下创建文件夹
hvt
.netC#hovertreeasp.netWeb Forms

    假设要在asp.net网站的根目录下建立文件夹hovertree,C#代码如下：
string m_keleyiFolderName = Server.MapPath("/hovertree");
if (Directory.Exists(m_keleyiFolderName))
{
//文件夹已经存在
return;
}
else
{
try
{
D
    

    • 

  • 一个合格的程序员应该读过哪些书
justjavac
程序员书籍

    编者按：2008年8月4日，StackOverflow 网友 Bert F 发帖提问：哪本最具影响力的书，是每个程序员都应该读的？
“如果能时光倒流，回到过去，作为一个开发人员，你可以告诉自己在职业生涯初期应该读一本， 你会选择哪本书呢？我希望这个书单列表内容丰富，可以涵盖很多东西。”
很多程序员响应，他们在推荐时也写下自己的评语。 以前就有国内网友介绍这个程序员书单，不过都是推荐数
    

    • 

  • 单实例实践
跑龙套_az
单例

     
 1、内部类
public class Singleton {
private static class SingletonHolder {
public static Singleton singleton = new Singleton();
}
public Singleton getRes
    

    • 

  • PO VO BEAN 理解
q137681467
VODTOpo

    PO：
     全称是 persistant object持久对象 最形象的理解就是一个PO就是数据库中的一条记录。 好处是可以把一条记录作为一个对象处理，可以方便的转为其它对象。
 
 
BO：
    全称是 business object:业务对象 主要作用是把业务逻辑封装为一个对象。这个对
    

    • 

  • 战胜惰性，暗自努力
金笛子
努力

    偶然看到一句很贴近生活的话：“别人都在你看不到的地方暗自努力，在你看得到的地方，他们也和你一样显得吊儿郎当，和你一样会抱怨，而只有你自己相信这些都是真的，最后也只有你一人继续不思进取。”很多句子总在不经意中就会戳中一部分人的软肋，我想我们每个人的周围总是有那么些表现得“吊儿郎当”的存在，是否你就真的相信他们如此不思进取，而开始放松了对自己的要求随波逐流呢？
我有个朋友是搞技术的，平时嘻嘻哈哈，以
    

    • 

  • NDK/JNI二维数组多维数组传递
wenzongliang
二维数组jniNDK

    多维数组和对象数组一样处理，例如二维数组里的每个元素还是一个数组 用jArray表示，直到数组变为一维的，且里面元素为基本类型，去获得一维数组指针。给大家提供个例子。已经测试通过。
Java_cn_wzl_FiveChessView_checkWin( JNIEnv* env,jobject thiz,jobjectArray qizidata)
{
jint i,j;
int s
    

    •