Redisson延迟队列执行流程源码解析

引言

在实际分布式项目中延迟任务一般不会使用JDK自带的延迟队列，因为它是基于JVM内存存储，没有持久化操作，所以当服务重启后就会丢失任务。

在项目中可以使用MQ死信队列或redisson延迟队列进行处理延迟任务，本篇文章将讲述redisson延迟队列的使用demo和其执行源码。

demo示例

通过脚手架创建一个简易springboot项目，引入redisson的maven依赖，并简单配置redisson连接属性。

    
    
        org.redisson
        redisson
        3.16.6
    
@Configuration
public class RedissonConfig {
    @Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.port}")
    private String port;
    /**
     * 获取redissonClient实例
     *
     * @return
     * @throws Exception
     */
    @Bean
    public RedissonClient getRedisson() {
        Config config = new Config();
        String address = "redis://" + host + ":" + port;
        config.useSingleServer().setAddress(address);
        return Redisson.create(config);
    }
}

定义一个redisson延迟队列插入和获取任务处理类RedissonQueueHandle，通过控制spring的bean加载周期开启独立线程获取延迟任务。这里获取延迟任务使用了三种方法，除了第一种阻塞式获取任务方法外，其他两种方法都不是百分比按照延迟参数获取到任务，因为是时间间隔定时循环获取延迟任务。

/**
 * redisson延迟队列处理器
 *
 * @author zrh
 */
@Slf4j
@Component
public class RedissonQueueHandle implements InitializingBean {
    private final RBlockingQueue> queue;
    private final RDelayedQueue> delayedQueue;
    public RedissonQueueHandle (RedissonClient client) {
        this.queue = client.getBlockingQueue("redisson:queue");
        this.delayedQueue = client.getDelayedQueue(queue);
    }
    @Override
    public void afterPropertiesSet () {
        // 开一个线程阻塞式获取任务
        thread();
        // 使用netty时间轮循环获取任务
//        watchDog(new HashedWheelTimer());
        // 使用线程池定时获取任务
//        schedule();
    }
    private void thread () {
        new Thread(() -> {
            while (true) {
                try {
                    RedisDataEntity entity = queue.take();
                    log.info("本次获取数据：{}，耗时：{}", entity, System.currentTimeMillis() - entity.getTime());
                } catch (Exception e) {
                }
            }
        }, "zrh").start();
    }
    private void watchDog (final HashedWheelTimer timer) {
        timer.newTimeout(timeout -> {
            RedisDataEntity entity = queue.poll();
            if (null != entity) {
                log.info("本次获取数据：{}，耗时：{}", entity, System.currentTimeMillis() - entity.getTime());
            }
            watchDog(timer);
        }, 3, TimeUnit.SECONDS);
    }
    private void schedule () {
        Executors.newScheduledThreadPool(1).scheduleWithFixedDelay(() -> {
            RedisDataEntity entity = queue.poll();
            if (null != entity) {
                log.info("本次获取数据：{}，耗时：{}", entity, System.currentTimeMillis() - entity.getTime());
            }
        }, 5, 5, TimeUnit.SECONDS);
    }
    /**
     * 放入redis，定时过期
     *
     * @param entity
     */
    public void offer (RedisDataEntity entity) {
        try {
            delayedQueue.offer(entity, entity.getExpire(), TimeUnit.MILLISECONDS);
        } catch (Exception e) {
            log.error("放入redis延迟队列异常", e);
        }
    }
}

放入redisson延迟队列可以是字符串也可以是对象RedisDataEntity，因为有进行IO磁盘存储操作，所以必须实现Serializable序列化接口。

/**
 * @Author: ZRH
 * @Date: 2022/1/10 11:54
 */
@Data
public class RedisDataEntity implements Serializable {
    /**
     * 数据
     */
    private final T data;
    /**
     * 过期时间（单位：毫秒）
     */
    private final Long expire;
    /**
     * 添加时间
     */
    private final Long time;
    public RedisDataEntity (T data, Long expire, Long time) {
        this.data = data;
        this.expire = expire;
        this.time = time;
    }
}

然后开一个插入数据接口：

/**
 * @Author: ZRH
 * @Date: 2022/1/10 11:45
 */
@Slf4j
@RestController
public class IndexController {
    private final RedissonQueueHandle redisHandle;
    public IndexController (RedissonQueueHandle redisHandle) {
        this.redisHandle = redisHandle;
    }
    @PostMapping("redissonQueue")
    public String redissonQueue (@RequestParam String data, @RequestParam Long expire) {
        RedisDataEntity entity = new RedisDataEntity(data, expire, System.currentTimeMillis());
        log.info("本次添加数据：{}", entity);
        redisHandle.offer(entity);
        return "ok";
    }
}
访问接口设置延迟30秒：http://localhost:8802/redissonQueue?data=a&expire=30000，打印结果如下
2022-01-14 14:21:52.140  INFO 10808 --- [nio-8802-exec-1] c.r.web.controller.IndexController       : 本次添加数据：RedisDataEntity(data=a, expire=30000, time=1642141312135)
2022-01-14 14:21:52.887  INFO 10808 --- [nio-8802-exec-2] c.r.web.controller.IndexController       : 本次添加数据：RedisDataEntity(data=a, expire=30000, time=1642141312887)
2022-01-14 14:22:22.240  INFO 10808 --- [            zrh] c.r.web.redis.RedissonQueueHandle        : 本次获取数据：RedisDataEntity(data=a, expire=30000, time=1642141312135)，耗时：30105
2022-01-14 14:22:22.914  INFO 10808 --- [            zrh] c.r.web.redis.RedissonQueueHandle        : 本次获取数据：RedisDataEntity(data=a, expire=30000, time=1642141312887)，耗时：30027

初始执行流程源码解析 redisson延迟队列最终都是和redis服务进行交互的，那可以使用monitor命令查看redis中执行了哪些命令，这样对了解其执行流程有很大帮助。

Redisson延迟队列执行流程源码解析_第1张图片

上图是项目启动时，对redis发送的几个指令

"SUBSCRIBE"：订阅队列"redisson_delay_queue_channel:{redisson:queue}"，里面有个定时任务通过该队列获取数据

"zrangebyscore"：获取"redisson_delay_queue_timeout:{redisson:queue}"集合中排序score值在0到1642148406748（当前时间戳）内的前100元素

"zrange"：获取"redisson_delay_queue_timeout:{redisson:queue}"集合中第一个元素，用于获取下一个元素的到期时间

"BLPOP"：取出并移除"redisson:queue"列表里的第一个元素，如果没有元素就一直等待阻塞。所以这里会阻塞着

"rpush"：如果指令"zrangebyscore"获取到了元素，那就将元素推送到队列redisson:queue内

"lrem"：如果指令"zrangebyscore"获取到了元素，那就删除队列"redisson_delay_queue:{redisson:queue}内元素为v的第一个元素

SUBSCRIBE指令

进入RedissonDelayedQueue延迟队列的构造函数，里面就有上述执行指令的lua脚本命令（为了不影响篇幅删了一部分代码，下同）：

    ......
    protected RedissonDelayedQueue(QueueTransferService queueTransferService, Codec codec, final CommandAsyncExecutor commandExecutor, String name) {
        super(codec, commandExecutor, name);
        // list结构，用于延迟队列的订阅发布
        channelName = prefixName("redisson_delay_queue_channel", getRawName());
        // list结构，存放元素原始顺序
        queueName = prefixName("redisson_delay_queue", getRawName());
        // zset结构，存放未到期元素，并按照过期时间进行排好序
        timeoutSetName = prefixName("redisson_delay_queue_timeout", getRawName());
        QueueTransferTask task = new QueueTransferTask(commandExecutor.getConnectionManager()) {
            @Override
            protected RFuture pushTaskAsync() {
                return commandExecutor.evalWriteAsync(getRawName(), LongCodec.INSTANCE, RedisCommands.EVAL_LONG,
                        "local expiredValues = redis.call('zrangebyscore', KEYS[2], 0, ARGV[1], 'limit', 0, ARGV[2]); "
                      + "if #expiredValues > 0 then "
                          + "for i, v in ipairs(expiredValues) do "
                              + "local randomId, value = struct.unpack('dLc0', v);"
                              + "redis.call('rpush', KEYS[1], value);"
                              + "redis.call('lrem', KEYS[3], 1, v);"
                          + "end; "
                          + "redis.call('zrem', KEYS[2], unpack(expiredValues));"
                      + "end; "
                        // get startTime from scheduler queue head task
                      + "local v = redis.call('zrange', KEYS[2], 0, 0, 'WITHSCORES'); "
                      + "if v[1] ~= nil then "
                         + "return v[2]; "
                      + "end "
                      + "return nil;",
                      Arrays.asList(getRawName(), timeoutSetName, queueName),
                      System.currentTimeMillis(), 100);
            }
            @Override
            protected RTopic getTopic() {
                return RedissonTopic.createRaw(LongCodec.INSTANCE, commandExecutor, channelName);
            }
        };
        queueTransferService.schedule(queueName, task);        
        this.queueTransferService = queueTransferService;
    }
 
  
 
继续跟进queueTransferService.schedule(queueName, task)方法，因为第一次进入tasks集合，所以最后执行start()方法：
 
 
 
  
    ......
    private final ConcurrentMap tasks = new ConcurrentHashMap<>();
    public synchronized void schedule(String name, QueueTransferTask task) {
        QueueTransferTask oldTask = tasks.putIfAbsent(name, task);
        if (oldTask == null) {
            task.start();
        } else {
            oldTask.incUsage();
        }
    }

 
 
 
 
进入QueueTransferTask，继续跟进schedulerTopic.addListener(...)方法：
 
 
 
  
    ......
    private int messageListenerId;
    private int statusListenerId;
    public void start() {
        RTopic schedulerTopic = getTopic();
        statusListenerId = schedulerTopic.addListener(new BaseStatusListener() {
            @Override
            public void onSubscribe(String channel) {
                pushTask();
            }
        });
        messageListenerId = schedulerTopic.addListener(Long.class, new MessageListener() {
            @Override
            public void onMessage(CharSequence channel, Long startTime) {
                scheduleTask(startTime);
            }
        });
    }

 
 
 
 
然后会进入PublishSubscribeService.subscribe(...)方法：
 
 
注意：这里继续调用重载方法subscribe(...)时设置了参数：PubSubType.SUBSCRIBE
 
 
 
  
    ......
    public RFuture subscribe(Codec codec, ChannelName channelName, RedisPubSubListener... listeners) {
        return subscribe(PubSubType.SUBSCRIBE, codec, channelName, getEntry(channelName), listeners);
    }
    private RFuture subscribe(PubSubType type, Codec codec, ChannelName channelName, MasterSlaveEntry entry, RedisPubSubListener... listeners) {
        RPromise promise = new RedissonPromise<>();
        AsyncSemaphore lock = getSemaphore(channelName);
        // 创建一个线程任务放入lock对象
        lock.acquire(() -> {
            if (promise.isDone()) {
                lock.release();
                return;
            }
            subscribe(codec, channelName, entry, promise, type, lock, listeners);
        });
        return promise;
    }

 
 
 
 
AsyncSemaphore对象的acquire(...)方法会把线程任务放入自身队列listeners里，然后依次读取执行线程任务；
 
 
 
  
public class AsyncSemaphore {
    private final AtomicInteger counter;
    private final Queue listeners = new ConcurrentLinkedQueue<>();
    public void acquire(Runnable listener) {
        listeners.add(listener);
        tryRun();
    }
    private void tryRun() {
        if (counter.decrementAndGet() >= 0) {
            Runnable listener = listeners.poll();
            if (listener == null) {
                counter.incrementAndGet();
                return;
            }
            listener.run();
        } else {
            if (counter.incrementAndGet() > 0) {
                tryRun();
            }
        }
    }   
}

 
 
 
 
然后继续跟进方法subscribe(codec, channelName, entry, promise, type, lock, listeners):
 
 
 
  
    .....
    private void subscribe(Codec codec, ChannelName channelName, MasterSlaveEntry entry,
                            RPromise promise, PubSubType type,
                            AsyncSemaphore lock, RedisPubSubListener... listeners) {
        PubSubConnectionEntry connEntry = name2PubSubConnection.get(new PubSubKey(channelName, entry));
        if (connEntry != null) {
            addListeners(channelName, promise, type, lock, connEntry, listeners);
            return;
        }
        freePubSubLock.acquire(() -> {
            if (promise.isDone()) {
                lock.release();
                freePubSubLock.release();
                return;
            }
            MasterSlaveEntry msEntry = Optional.ofNullable(connectionManager.getEntry(entry.getClient())).orElse(entry);
            // 第一次进入entry2PubSubConnection集合为null，所以使用默认值，最后 freeEntry == null
            PubSubEntry freePubSubConnections = entry2PubSubConnection.getOrDefault(msEntry, new PubSubEntry());
            PubSubConnectionEntry freeEntry = freePubSubConnections.getEntries().peek();
            if (freeEntry == null) {
                freePubSubLock.release();
                connect(codec, channelName, msEntry, promise, type, lock, listeners);
                return;
            }
            ......
        });
    }

 
 
 
 
继续跟进方法connect(codec, channelName, msEntry, promise, type, lock, listeners)：
 
 
 
  
    ......
    private void connect(Codec codec, ChannelName channelName,
                         MasterSlaveEntry msEntry, RPromise promise, PubSubType type, AsyncSemaphore lock, RedisPubSubListener... listeners) {
        RFuture connFuture = nextPubSubConnection(msEntry, channelName);
        promise.onComplete((res, e) -> {...});
        connFuture.onComplete((conn, ex) -> {
            if (ex != null) {...}
            freePubSubLock.acquire(() -> {
                PubSubConnectionEntry entry = new PubSubConnectionEntry(conn, config.getSubscriptionsPerConnection());
                int remainFreeAmount = entry.tryAcquire();
                PubSubKey key = new PubSubKey(channelName, msEntry);
                PubSubConnectionEntry oldEntry = name2PubSubConnection.putIfAbsent(key, entry);
                if (oldEntry != null) {...}
                if (remainFreeAmount > 0) {
                    addFreeConnectionEntry(channelName, entry);
                }
                freePubSubLock.release();
                RFuture subscribeFuture = addListeners(channelName, promise, type, lock, entry, listeners);
                ChannelFuture future;
                // 这里通过上述重载方法传递的参数可知，最后走else逻辑
                if (PubSubType.PSUBSCRIBE == type) {
                    future = entry.psubscribe(codec, channelName);
                } else {
                    future = entry.subscribe(codec, channelName);
                }
                future.addListener((ChannelFutureListener) future1 -> {
                    if (!future1.isSuccess()) {...}
                    connectionManager.newTimeout(timeout ->
                            subscribeFuture.cancel(false),
                            config.getTimeout(), TimeUnit.MILLISECONDS);
                });
            });
        });
    }

 
 
 
 
该方法中支线内容不表述，主要看方法 entry.subscribe(codec, channelName)，最后进入RedisPubSubConnection.async(...)方法，就是发送SUBSCRIBE指令的流程：
 
 
Redisson延迟队列执行流程源码解析_第2张图片
 
 
 
 
zrangebyscore和zrange指令
 
 
订阅指令SUBSCRIBE发出后，在QueueTransferTask.start()方法里添加的监听器触发了，就会执行pushTask()
 
 
pushTaskAsync()方法执行完（lua脚本执行完），就会开启一个定时任务scheduleTask()
 
 
 
  
    ......
    protected abstract RTopic getTopic();
    protected abstract RFuture pushTaskAsync();
    private void pushTask() {
        // 这个抽象方法在之前构建RedissonDelayedQueue对象的构造函数里有实现，最后返回元素过期时间
        RFuture startTimeFuture = pushTaskAsync();
        startTimeFuture.onComplete((res, e) -> {
            if (e != null) {
                if (e instanceof RedissonShutdownException) {
                    return;
                }
                log.error(e.getMessage(), e);
                scheduleTask(System.currentTimeMillis() + 5 * 1000L);
                return;
            }
            if (res != null) {
                scheduleTask(res);
            }
        });
    }

 
 
 
 
 
 
BLPOP指令
 
 
当RedissonDelayedQueue延迟队列构造完成后，会调用延迟队列的take()方法获取延迟任务，然后会进入RedissonBlockingQueue.takeAsync()方法:
 
 
 
  
    ......
    @Override
    public RFuture takeAsync() {
        return commandExecutor.writeAsync(getRawName(), codec, RedisCommands.BLPOP_VALUE, getRawName(), 0);
    }
    /*
     * (non-Javadoc)
     * @see java.util.concurrent.BlockingQueue#take()
     */
    @Override
    public V take() throws InterruptedException {
        return commandExecutor.getInterrupted(takeAsync());
    }
    ......

 
 
 
 
注意这里的参数其值为 BLPOP，很明显这里就是和我们要找的BLPOP指令有关，所以这里其实就是客户端通过BLPOP指令阻塞式获取值。在客户端开个线程一直循环阻塞获取元素即可；
 
 
看下源码继续向下进入CommandAsyncService.writeAsync(...)方法，然后继续向下进入RedisExecutor.execute()方法：
 
 
 
  
    ......
    public void execute() {
        if (mainPromise.isCancelled()) {...}
        if (!connectionManager.getShutdownLatch().acquire()) {...}
        codec = getCodec(codec);
        // 获取连接
        RFuture connectionFuture = getConnection();
        RPromise attemptPromise = new RedissonPromise<>();
        mainPromiseListener = (r, e) -> {...};
        if (attempt == 0) {...}
        scheduleRetryTimeout(connectionFuture, attemptPromise);
        connectionFuture.onComplete((connection, e) -> {
            if (connectionFuture.isCancelled()) {...}
            if (!connectionFuture.isSuccess()) {...}
            // 连接获取成功就执行当前方法
            sendCommand(attemptPromise, connection);
            writeFuture.addListener(new ChannelFutureListener() {
                @Override
                public void operationComplete(ChannelFuture future) throws Exception {
                    checkWriteFuture(writeFuture, attemptPromise, connection);
                }
            });
        });
        attemptPromise.onComplete((r, e) -> {...});
    }

 
 
 
 
该方法里一些支线方法按下不表。中间有个超时重试机制，使用netty的时间轮，不是重点也就不表述了。
 
 
先获取写入操作连接对象任务，然后进入方法sendCommand(attemptPromise, connection)发送
 
 
指令指令："BLPOP"，参数："redisson:queue" "0"
 
 
Redisson延迟队列执行流程源码解析_第3张图片
 
 
offer添加任务流程源码解析 项目启动完成后，添加一个延迟任务到redis中，查看redis中所执行的指令：
 
 
 
 
然后跟进插入元素offer方法，进入RedissonDelayedQueue.offerAsync()方法内，如下所示：
 
 
 
  
    ......
    @Override
    public void offer(V e, long delay, TimeUnit timeUnit) {
        get(offerAsync(e, delay, timeUnit));
    }
    @Override
    public RFuture offerAsync(V e, long delay, TimeUnit timeUnit) {
        if (delay < 0) {
            throw new IllegalArgumentException("Delay can't be negative");
        }
        long delayInMs = timeUnit.toMillis(delay);
        long timeout = System.currentTimeMillis() + delayInMs;
        long randomId = ThreadLocalRandom.current().nextLong();
        return commandExecutor.evalWriteNoRetryAsync(getRawName(), codec, RedisCommands.EVAL_VOID,
                "local value = struct.pack('dLc0', tonumber(ARGV[2]), string.len(ARGV[3]), ARGV[3]);" 
              + "redis.call('zadd', KEYS[2], ARGV[1], value);"
              + "redis.call('rpush', KEYS[3], value);"
              // if new object added to queue head when publish its startTime 
              // to all scheduler workers 
              + "local v = redis.call('zrange', KEYS[2], 0, 0); "
              + "if v[1] == value then "
                 + "redis.call('publish', KEYS[4], ARGV[1]); "
              + "end;",
              Arrays.asList(getRawName(), timeoutSetName, queueName, channelName),
              timeout, randomId, encode(e));
    }
 
  
 
其中很明显一长串的脚本命令就是在redis中执行的指令，基本流程比较简单：
 
 
"zadd"：这是向zset集合"redisson_delay_queue_timeout:{redisson:queue}"里添加元素数据（此数据被处理过，不用管其结构），排序值为当前时间戳+延迟时间
 
 
"rpush"：把元素数据推送到list队列"redisson:queue"
 
 
"zrange"：获取zset集合"redisson_delay_queue_timeout:{redisson:queue}"中排好序的第一个元素
 
 
"publish"：如果上述获取的元素是本次插入的元素，那就发布通知队列"redisson_delay_queue_channel:{redisson:queue}"，内容为当前元素的过期时间，这样做是为了减少本次元素到期的时间差。
 
 
 
 
最后定时器源码解析
 
 
定时器任务主要是通过监听器监听到了有新的客户端订阅或元素通知发布出来时，就会执行pushTask()和scheduleTask(...)方法：
 
 
 
  
    ......
    private int messageListenerId;
    private int statusListenerId;
    public void start() {
        RTopic schedulerTopic = getTopic();
        // 当有新的客户端订阅schedulerTopic，就是触发执行pushTask()方法
        statusListenerId = schedulerTopic.addListener(new BaseStatusListener() {
            @Override
            public void onSubscribe(String channel) {
                pushTask();
            }
        });
        // 当redis有新的消息通知，就会触发scheduleTask(...)方法，startTime为上述中publish通知的元素过期时间
        messageListenerId = schedulerTopic.addListener(Long.class, new MessageListener() {
            @Override
            public void onMessage(CharSequence channel, Long startTime) {
                scheduleTask(startTime);
            }
        });
    }

 
 
 
 
pushTask()方法是对redis延迟队列进行操作的方法，scheduleTask(...)是netty时间轮来控制调用pushTask()方法，所以pushTask()和scheduleTask()互相调用。
 
 
 
  
    ......
    private void scheduleTask(final Long startTime) {
        TimeoutTask oldTimeout = lastTimeout.get();
        if (startTime == null) {...}
        if (oldTimeout != null) {...}
        long delay = startTime - System.currentTimeMillis();
        if (delay > 10) {
            Timeout timeout = connectionManager.newTimeout(new TimerTask() {                    
                @Override
                public void run(Timeout timeout) throws Exception {
                    pushTask();
                    TimeoutTask currentTimeout = lastTimeout.get();
                    if (currentTimeout.getTask() == timeout) {
                        lastTimeout.compareAndSet(currentTimeout, null);
                    }
                }
            }, delay, TimeUnit.MILLISECONDS);
            if (!lastTimeout.compareAndSet(oldTimeout, new TimeoutTask(startTime, timeout))) {
                timeout.cancel();
            }
        } else {
            pushTask();
        }
    }
    protected abstract RTopic getTopic();
    protected abstract RFuture pushTaskAsync();
    private void pushTask() {
        RFuture startTimeFuture = pushTaskAsync();
        startTimeFuture.onComplete((res, e) -> {
            if (e != null) {
                if (e instanceof RedissonShutdownException) {
                    return;
                }
                log.error(e.getMessage(), e);
                scheduleTask(System.currentTimeMillis() + 5 * 1000L);
                return;
            }
            if (res != null) {
                scheduleTask(res);
            }
        });
    }

 
 
 
 
 
 
总结：
 
 
当有新的客户端进行订阅，就调用pushTask()方法拉取数据放入阻塞队列。当有信的消息进行发布，就调用scheduleTask(...)方法，并根据其过期时间判断是通过时间轮延迟调用还是立即调用pushTask()方法。最后 redisson延迟队列的源码相对而言其实是比较抽象复杂的，感觉没有其分布式锁这块源码容易解析。但仔细用心去看，跟着主要方法走还是可以了解其执行流程。
 
 
以上就是Redisson延迟队列执行流程源码解析的详细内容，更多关于Redisson延迟队列执行流程的资料请关注脚本之家其它相关文章！
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Redisson延迟队列执行流程源码解析)

        

            

                
    
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Istio pilot-discovery服务发现源码解析（1.13版本）
                        xidianjiapei001
#Istioistio云原生服务发现
                        
    Istiopilot-discovery服务发现介绍工作机制初始化初始化Config控制器初始化Service控制器controller初始化NamespaceServiceNodePodPilotDiscovery各组件启动流程DiscoveryServer接收Envoy的gRPC连接请求流程Config变化后向Envoy推送更新的流程总结参考介绍IstioPilot的代码分为Pilot-Dis
    
                    
    • 
                    
  • Rides实现分布式锁，保障数据一致性,Redisson分布式事务处理
                        朱杰jjj
缓存分布式
                        
    分布式环境下分布式锁有三种方式：基于数据库分布式锁基于Redis分布式锁基于zk分布式锁本帖只介绍Redis分布式锁为什么需要用到分布式锁？在单机环境下一个服务中多个线程对同一个事物或数据资源进行操作时，可以通过添加加锁方式（synchronized和lock）来解决数据一致性的问题。但是如果出现多个服务的情况下，这时候我们在通过synchronized和lock的方式来加锁会出现问题，因为多个服
    
                    
    • 
                    
  • Java集合类框架源码分析 之 RoleList源码解析 【6】
                        yunzhonghefei
Java集合类源码分析RoleList源码解析
                        
    该类继承于ArrayList，针对Role进行了一些扩展。其他方法和ArrayList中基本相同，源码不做针对性分析：看一下类简介：/***代表了一个roles的列表，作为方法setRoles()的参数，去创建一个关联关系，并且尝试在同一个关系中设置多个角色。*ARoleListrepresentsalistofroles(Roleobjects).Itisusedas*parameterwhen
    
                    
    • 
                    
  • VITS 源码解析2-模型概述
                        迪三
#NN_Audio音频人工智能
                        
    VITs是文本到语音(Text-to-Speech,TTS)任务中最流行的技术之一，其实现思路是将文本语音信息融合到了HiFiGAN潜空间内,通过文本控制HiFiGAN的生成器，输出含文本语义的声音。VITs主要以GAN的方式训练,其生成器G是SynthesizerTrn，判别器D是MPD。VITS的判别器几乎和HiFiGAN一样，生成器则融合了文本、时序、声音三大类模型1.文件概述模型部分包含三
    
                    
    • 
                    
  • Mybatis实现员工管理系统
                        wu1113_
mybatisjavamaven
                        
    文章目录1.案例需求2.编程思路3.案例源码4.小结1.案例需求在上次做的父子模块的maven以及Ajax实现人工管理系统的基础上使用Mybatis实现员工管理系统的增删改查，具体运行效果如下：2.编程思路Mybatis框架的一般执行流程：创建MyBatis配置文件mybatis-config.xml在里面加载数据源、事务等，管理映射文件创建需要的映射文件mapper.xml，用于映射表中列和实体
    
                    
    • 
                    
  • Redisson分布式锁实现原理和使用
                        牧竹子
springboot#redisRedissonredis
                        
    常见的锁内存锁lock,synchronize分布式锁redis，zookeeper实现Redisson基于redis实现了Lock接口的分布式集群锁，是可重入锁，功能强大，源码复杂，比redis单机模式分布式锁可靠，稳定性更高，支持集群模式，支持锁根据业务时长自动延迟释放redis普通分布式锁存在一定的缺陷——它加锁只作用在一个Redis节点上，如果通过sentinel和cluster保证高可用
    
                    
    • 
                    
  • 一条sql是如何执行的详解
                        听忆.
轻松拿捏【面试干货】sql数据库
                        
    一条sql是如何执行的详解1.SQL解析（Parsing）2.查询重写（QueryRewrite）3.查询规划（QueryPlanning）4.查询执行（QueryExecution）5.结果返回示例：查询执行流程总结边走、边悟迟早会好一条SQL查询在PostgreSQL（以及大多数关系型数据库）中的执行过程可以分为多个阶段。每个阶段都对应特定的任务，从SQL解析到最终获取查询结果。以下是SQL查
    
                    
    • 
                    
  • Linux 调试器 GDB 使用指南
                        方歧
LInuxlinux运维服务器
                        
    在Linux环境下开发和调试程序时，GNU调试器（GDB）是一个强大的工具。它支持多种编程语言（如C、C++、Fortran等），并且可以帮助开发人员检测、排除和修复程序中的错误。GDB能够让你在程序运行时暂停，查看内存和变量的状态，甚至修改程序的执行流程，是开发人员不可或缺的调试工具之一。在本篇博客中，我们将详细介绍如何使用GDB进行调试，帮助你快速上手并掌握这款工具的基本功能。一、GDB简介G
    
                    
    • 
                    
  • 判断语句有几种写法
                        饭九钦vlog
面试题笔记笔记经验分享
                        
    在编程中，判断语句用于基于特定条件来控制程序的执行流程。以下是一些常见编程语言中判断语句的几种基本写法：###1.`if`语句`if`语句是最基本的条件判断结构，用于在条件为真时执行一段代码。**示例**:```cif(condition){//条件为真时执行的代码}```###2.`if-else`语句`if-else`结构允许你在条件为假时执行另一段代码。**示例**:```cif(condi
    
                    
    • 
                    
  • Koa2 的洋葱模型是什么？它是如何实现的？
                        极客李华
Koakoa
                        
    Koa2的洋葱模型是什么？它是如何实现的？Koa2的洋葱模型是一种中间件执行流程的设计模式，它允许开发者在请求的处理过程中，按照特定的顺序依次执行一系列中间件函数。洋葱模型的实现基于Koa2框架的特性和原理。下面我将通过一个具体的案例来解释洋葱模型的概念和实现。假设我们有一个简单的Koa2应用，用于处理用户的HTTP请求。首先，我们需要创建一个Koa应用实例：constKoa=require('k
    
                    
    • 
                    
  • golang学习笔记02——gin框架及基本原理
                        GoppViper
golang学习笔记golang学习笔记ginhttp
                        
    目录1.前言2.必要的知识3.路由注册流程3.1核心数据结构3.2执行流程3.3创建并初始化gin.Engine3.4注册middleware3.5注册路由及处理函数（1）拼接完整的路径参数（2）组合处理函数链（3）注册完成路径及处理函数链到路由树3.6服务端口监听4.请求处理5.请求绑定和响应渲染5.1.请求绑定5.2响应渲染结束语1.前言gin框架是golang中比较常见的web框架，截止到目
    
                    
    • 
                    
  • RBtree
                        努力的小带土
侯捷老师STLc++蓝桥杯
                        
    终结B站没人能讲清楚红黑树的历史，不服等你来踢馆！-【码炫课堂收费课节选之-红黑树源码解析及手写红黑树】_哔哩哔哩_bilibiliB站的听课记录，并写下如下红黑树c++版本代码，该课程真的史诗级推荐！/*RBtreeNode.h*****/#pragmaonceenum{RED=false,BLACK=true};templateclassRBtreeNode{public://红黑树的左右节点
    
                    
    • 
                    
  • 深入理解Kubernetes：kube-scheduler源码解析
                        mujingluo
kubernetes容器云原生
                        
    Kubernetes的调度器（kube-scheduler）是整个系统中至关重要的组件，它负责将待调度的Pods分配到合适的节点上。本文将深入分析kube-scheduler的源码，揭示其内部工作机制。kube-scheduler的核心功能kube-scheduler的核心功能包括：监听Pod变化：通过KubernetesAPI监听所有未调度的Pods。过滤（Filtering）：根据一系列规则（
    
                    
    • 
                    
  • 【Vesta发号器源码】PropertyMachineIdsProvider
                        DeanChangDM

                        
    Vesta发号器源码解析——PropertyMachineIdsProvider属性配置文件持有Id的模式,没啥东西，比单个的多了一个获取下一个的方法封装实现上略有一点点区别privatelong[]machineIds;privateintcurrentIndex;publiclonggetNextMachineId(){returngetMachineId();}publiclonggetMa
    
                    
    • 
                    
  • StarRocks分布式元数据源码解析
                        不甚了然
Iceberg知识集StarRocksIceberg数据湖湖仓一体大数据
                        
    1.支持元数据表https://github.com/StarRocks/starrocks/pull/44276/files核心类：LogicalIcebergMetadataTable，Iceberg元数据表，将元数据的各个字段做成表的列，后期可以通过sql操作从元数据获取字段，这个表的组成字段是DataFile相关的字段public static LogicalIcebergMetadata
    
                    
    • 
                    
  • 【Starrocks】建表篇Fe源码解析
                        数算七弦
Starrocks大数据
                        
    Starrocks系统架构简述现在市面上主流的OLAP存算一体架构主要有两类进程：Frontend（FE）和Backend（BE）Frontend一般是用Java写的。主要职责有：接收用户连接请求（MySQL协议层）元数据存储与管理查询语句的解析与查询计划的生成集群管控Backend一般是用C++写的，主要职责有：数据存储与管理查询计划的执行建表语句的执行过程与Mysql协议层交互词法解析语法解析
    
                    
    • 
                    
  • 智能农业设备软件工程师如何集成和管理农业物联网（IoT）平台
                        openwin_top
智能农业设备软件工程师物联网python开发语言深度学习大数据智能农业
                        
    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位集成和管理农业物联网（IoT）平台涉及多个步骤，包括设备连接、数据收集、数据传输、数据存储、数据分析和展示。以下是详细分析和示例代码展示。1.设备连接和数据收集首先，智能农业设备需要能够与传感器和执
    
                    
    • 
                    
  • 智能农业设备软件工程师如何集成和管理农业设备的远程更新系统
                        openwin_top
智能农业设备软件工程师深度学习大数据物联网人工智能网络智能农业
                        
    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位集成和管理农业设备的远程更新系统涉及多个技术层面，包括设备固件的安全更新、版本控制、网络通信，以及设备管理平台的开发。下面我们详细分析这些步骤，并提供一个基本的示例代码来展示如何实现这个系统。1.系
    
                    
    • 
                    
  • 智能农业设备软件工程师如何处理设备的远程诊断和修复
                        openwin_top
智能农业设备软件工程师网络智能农业物联网人工智能大数据深度学习
                        
    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位处理智能农业设备的远程诊断和修复涉及几个关键步骤，包括设备的数据采集、数据传输、远程诊断、远程控制和修复。以下是详细分析和示例代码：1.数据采集智能农业设备通常配备传感器和控制器，这些设备不断采集环
    
                    
    • 
                    
  • android10 按键音量调节源码解析
                        @OuYang
android
                        
    /frameworks/base/services/core/java/com/android/server/policy/PhoneWindowManager.javastaticIAudioServicegetAudioService(){IAudioServiceaudioService=IAudioService.Stub.asInterface(ServiceManager.checkS
    
                    
    • 
                    
  • android10 Settings源码解析
                        @OuYang
android
                        
    /packages/apps/Settings/AndroidManifest.xml.................................................................................activity-alias是Android里为了重复使用Activity而设计的。对于activity-alias标签，它有一个属性叫android:
    
                    
    • 
                    
  • Redis高可用
                        確定饿的猫
redis数据库linux
                        
    目录持久化主从复制哨兵Cluster集群RDB持久化手动触发自动触发RDB执行流程RDB载入AOF持久化执行流程命令追加文件写入和文件同步appendfsyncalwaysappendfsyncnoappendfsynceverysecond文件重写文件重写流程载入对比nginx、tomcat、mysql等服务都具有预防单点故障、提高整体性能和安全性的功能，当然，Redis也不例外在Redis中，
    
                    
    • 
                    
  • MyBatis 源码解析：XMLScriptBuilder 工作机制
                        捕风捉你
MyBatis源码解读mybatisjava
                        
    摘要MyBatis提供了强大的动态SQL功能，它通过解析XML配置文件中的动态SQL标签（如、、等），来实现灵活的SQL生成。而XMLScriptBuilder类则负责解析这些XML配置并生成最终的SQL语句。本文将详细解析XMLScriptBuilder的工作机制，并通过自定义实现来帮助您深入理解该类的功能。前言MyBatis中的动态SQL功能是通过解析XML配置文件实现的。XML文件中包含了动
    
                    
    • 
                    
  • Spring MVC 执行流程详解
                        胡耀超
Springjava面试常见问题springmvcjavaSpringMVC
                        
    SpringMVC是一个典型的基于MVC设计模式的框架，它用于开发JavaWeb应用程序。在SpringMVC中，每个请求都要经历一系列的步骤，从客户端请求到服务器返回响应。下面的执行流程图很好地描述了SpringMVC的执行流程，从请求发起到最后返回数据。接下来，我将全面、深入地讲解SpringMVC的执行流程。SpringMVC执行流程图：+---------++---------------
    
                    
    • 
                    
  • 第二十一章 结构化命令case和for，while 循环
                        西南蔡徐坤

                        
    本节所讲内容21，1case-流程控制语句21.2循环循环语句21.3循环语句嵌套21.4实战-3个shell脚本实战21.1流程控制语句控制语句：case变量值in变量或者表达式1）命令序列1；；变量或者表达式1）命令序列2；；.........*）默认命令序列esaccase语句执行流程控制例1编写一个操作文件的脚本#######################################
    
                    
    • 
                    
  • Spark运行时架构
                        tooolik
spark架构大数据
                        
    目录一，Spark运行时架构二，YARN集群架构（一）YARN集群主要组件1、ResourceManager-资源管理器2、NodeManager-节点管理器3、Task-任务4、Container-容器5、ApplicationMaster-应用程序管理器6，总结（二）YARN集群中应用程序的执行流程三、SparkStandalone架构（一）client提交方式（二）cluster提交方式四、
    
                    
    • 
                    
  • C语言教学：程序流程简述和语句
                        析木不会编程
c语言开发语言
                        
    在C语言编程中，理解程序的流程和各种语句的用法是编写高效代码的基础。本文将简要概述程序的执行流程，并详细介绍常见的语句类型，包括基本赋值语句、表达式语句、基本输入输出语句、控制语句、空语句和复合语句。1.程序流程概述程序的执行流程指的是程序运行时指令的执行顺序。C语言程序通常按照从上到下的顺序逐行执行，直到遇到函数结束或程序终止。程序流程控制可以通过各种控制语句来改变执行顺序，如条件判断和循环控制
    
                    
    • 
                    
  • Spring Boot 集成 Redisson 实现消息队列
                        入秋的大橘
SpringBootspringboot后端java
                        
    包含组件内容RedisQueue：消息队列监听标识RedisQueueInit：Redis队列监听器RedisQueueListener：Redis消息队列监听实现RedisQueueService：Redis消息队列服务工具代码实现RedisQueueimportjava.lang.annotation.ElementType;importjava.lang.annotation.Retenti
    
                    
    • 
                    
  • Spark底层逻辑
                        傲雪凌霜，松柏长青
大数据后端spark大数据
                        
    ApacheSpark的底层逻辑可以从其核心概念、组件和执行流程等方面来理解。Spark提供了一个分布式数据处理框架，其底层逻辑基于批处理架构，能够在大规模集群中高效地处理数据。以下是Spark的底层逻辑的详细介绍：1.核心概念Spark的底层基于几个核心概念来实现分布式计算，包括：RDD（ResilientDistributedDataset，弹性分布式数据集）：RDD是Spark最基础的数据抽
    
                    
    • 
                                
  • 统一思想认识
                                    永夜-极光
思想
                                    
    1.统一思想认识的基础,才能有的放矢 
 原因: 
   总有一种描述事物的方式最贴近本质,最容易让人理解. 
   如何让教育更轻松,在于找到最适合学生的方式. 
         难点在于,如何模拟对方的思维基础选择合适的方式.   &
    
                                
    • 
                                
  • Joda Time使用笔记
                                    bylijinnan
javajoda time
                                    
    Joda Time的介绍可以参考这篇文章： 
 
http://www.ibm.com/developerworks/cn/java/j-jodatime.html 
 
工作中也常常用到Joda Time，为了避免每次使用都查API，记录一下常用的用法： 
    
 
   /**
     * DateTime变化（增减）
     */
    @Tes
    
                                
    • 
                                
  • FileUtils API
                                    eksliang
FileUtilsFileUtils API
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2217374 一、概述 
这是一个Java操作文件的常用库，是Apache对java的IO包的封装，这里面有两个非常核心的类FilenameUtils跟FileUtils，其中FilenameUtils是对文件名操作的封装;FileUtils是文件封装，开发中对文件的操作，几乎都可以在这个框架里面找到。 非常的好用。 
    
                                
    • 
                                
  • 各种新兴技术
                                    不懂事的小屁孩
技术
                                    
    1:gradle Gradle 是以 Groovy 语言为基础，面向Java应用为主。基于DSL（领域特定语言）语法的自动化构建工具。 
 
现在构建系统常用到maven工具，现在有更容易上手的gradle， 
搭建java环境:
http://www.ibm.com/developerworks/cn/opensource/os-cn-gradle/ 
搭建android环境：
http://m
    
                                
    • 
                                
  • tomcat6的https双向认证
                                    酷的飞上天空
tomcat6
                                    
    1.生成服务器端证书 
  
keytool -genkey -keyalg RSA -dname "cn=localhost,ou=sango,o=none,l=china,st=beijing,c=cn" -alias server -keypass password -keystore server.jks -storepass password -validity 36
    
                                
    • 
                                
  • 托管虚拟桌面市场势不可挡
                                    蓝儿唯美

                                    
    用户还需要冗余的数据中心，dinCloud的高级副总裁兼首席营销官Ali Din指出。该公司转售一个MSP可以让用户登录并管理和提供服务的用于DaaS的云自动化控制台，提供服务或者MSP也可以自己来控制。 
在某些情况下，MSP会在dinCloud的云服务上进行服务分层，如监控和补丁管理。 
MSP的利润空间将根据其参与的程度而有所不同，Din说。 
“我们有一些合作伙伴负责将我们推荐给客户作为个
    
                                
    • 
                                
  • spring学习——xml文件的配置
                                    a-john
spring
                                    
    在Spring的学习中，对于其xml文件的配置是必不可少的。在Spring的多种装配Bean的方式中，采用XML配置也是最常见的。以下是一个简单的XML配置文件： 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.or
    
                                
    • 
                                
  • HDU 4342 History repeat itself 模拟
                                    aijuans
模拟
                                    
    来源：http://acm.hdu.edu.cn/showproblem.php?pid=4342 
题意：首先让求第几个非平方数，然后求从1到该数之间的每个sqrt(i)的下取整的和。 
思路：一个简单的模拟题目，但是由于数据范围大，需要用__int64。我们可以首先把平方数筛选出来，假如让求第n个非平方数的话，看n前面有多少个平方数，假设有x个，则第n个非平方数就是n+x。注意两种特殊情况，即
    
                                
    • 
                                
  • java中最常用jar包的用途
                                    asia007
java
                                    
    java中最常用jar包的用途 
jar包用途axis.jarSOAP引擎包commons-discovery-0.2.jar用来发现、查找和实现可插入式接口，提供一些一般类实例化、单件的生命周期管理的常用方法.jaxrpc.jarAxis运行所需要的组件包saaj.jar创建到端点的点到点连接的方法、创建并处理SOAP消息和附件的方法，以及接收和处理SOAP错误的方法.  w
    
                                
    • 
                                
  • ajax获取Struts框架中的json编码异常和Struts中的主控制器异常的解决办法
                                    百合不是茶
jsjson编码返回异常
                                    
    一:ajax获取自定义Struts框架中的json编码  出现以下 问题:     
  
1,强制flush输出  json编码打印在首页 
2, 不强制flush js会解析json 打印出来的是错误的jsp页面   却没有跳转到错误页面 
3,  ajax中的dataType的json 改为text 会
    
                                
    • 
                                
  • JUnit使用的设计模式
                                    bijian1013
java设计模式JUnit
                                    
    JUnit源代码涉及使用了大量设计模式 
1、模板方法模式（Template Method） 
        定义一个操作中的算法骨架，而将一些步骤延伸到子类中去，使得子类可以不改变一个算法的结构，即可重新定义该算法的某些特定步骤。这里需要复用的是算法的结构，也就是步骤，而步骤的实现可以在子类中完成。 
  
    
                                
    • 
                                
  • Linux常用命令（摘录）
                                    sunjing
crondchkconfig
                                    
    chkconfig --list   查看linux所有服务 
chkconfig --add servicename 添加linux服务 
netstat -apn | grep 8080  查看端口占用 
env 查看所有环境变量 
echo $JAVA_HOME 查看JAVA_HOME环境变量 
  
安装编译器 
yum install -y gcc
    
                                
    • 
                                
  • 【Hadoop一】Hadoop伪集群环境搭建
                                    bit1129
hadoop
                                    
     结合网上多份文档，不断反复的修正hadoop启动和运行过程中出现的问题，终于把Hadoop2.5.2伪分布式安装起来，跑通了wordcount例子。Hadoop的安装复杂性的体现之一是，Hadoop的安装文档非常多，但是能一个文档走下来的少之又少，尤其是Hadoop不同版本的配置差异非常的大。Hadoop2.5.2于前两天发布，但是它的配置跟2.5.0，2.5.1没有分别。   &nb
    
                                
    • 
                                
  • Anychart图表系列五之事件监听
                                    白糖_
chart
                                    
    创建图表事件监听非常简单：首先是通过addEventListener('监听类型',js监听方法)添加事件监听，然后在js监听方法中定义具体监听逻辑。 
以钻取操作为例，当用户点击图表某一个point的时候弹出point的name和value，代码如下： 
<script>
//创建AnyChart
var chart = new AnyChart();
//添加钻取操作&quo
    
                                
    • 
                                
  • Web前端相关段子
                                    braveCS
web前端
                                    
    Web标准：结构、样式和行为分离 
  
使用语义化标签 
0）标签的语义：使用有良好语义的标签，能够很好地实现自我解释，方便搜索引擎理解网页结构，抓取重要内容。去样式后也会根据浏览器的默认样式很好的组织网页内容，具有很好的可读性，从而实现对特殊终端的兼容。 
1）div和span是没有语义的：只是分别用作块级元素和行内元素的区域分隔符。当页面内标签无法满足设计需求时，才会适当添加div
    
                                
    • 
                                
  • 编程之美-24点游戏
                                    bylijinnan
编程之美
                                    
    

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.Set;


public class PointGame {

	/**编程之美 
    
                                
    • 
                                
  • 主页面子页面传值总结
                                    chengxuyuancsdn
总结
                                    
    1、showModalDialog
returnValue是javascript中html的window对象的属性,目的是返回窗口值,当用window.showModalDialog函数打开一个IE的模式窗口时,用于返回窗口的值
主界面
 var sonValue=window.showModalDialog("son.jsp");
子界面
  window.retu
    
                                
    • 
                                
  • [网络与经济]互联网+的含义
                                    comsci
互联网+
                                    
     
      互联网+后面是一个人的名字 = 网络控制系统 
 
      互联网+你的名字 =  网络个人数据库 
 
      每日提示:如果人觉得不舒服,千万不要外出到处走动,就呆在床上,玩玩手游,更不能够去开车,现在交通状况不
    
                                
    • 
                                
  • oracle 创建视图 with check option
                                    daizj
视图vieworalce
                                    
    我们来看下面的例子： 
create or replace view testview 
as 
select empno,ename from emp where ename like ‘M%’ 
with check option; 
 
这里我们创建了一个视图，并使用了with check option来限制了视图。 然后我们来看一下视图包含的结果： 
select * from testv
    
                                
    • 
                                
  • ToastPlugin插件在cordova3.3下使用
                                    dibov
Cordova
                                    
        自己开发的Todos应用，想实现“ 
再按一次返回键退出程序 ”的功能，采用网上的ToastPlugins插件，发现代码或文章基本都是老版本，运行问题比较多。折腾了好久才弄好。下面吧基于cordova3.3下的ToastPlugins相关代码共享。      
    ToastPlugin.java        
package&nbs
    
                                
    • 
                                
  • C语言22个系统函数
                                    dcj3sjt126com
cfunction
                                    
    C语言系统函数一、数学函数下列函数存放在math.h头文件中Double floor(double num) 求出不大于num的最大数。Double fmod(x, y) 求整数x/y的余数。Double frexp(num, exp); double num; int *exp; 将num分为数字部分（尾数）x和 以2位的指数部分n，即num=x*2n，指数n存放在exp指向的变量中，返回x。D
    
                                
    • 
                                
  • 开发一个类的流程
                                    dcj3sjt126com
开发
                                    
    本人近日根据自己的开发经验总结了一个类的开发流程。这个流程适用于单独开发的构件，并不适用于对一个项目中的系统对象开发。开发出的类可以存入私人类库，供以后复用。 
  
以下是开发流程： 
1. 明确类的功能，抽象出类的大概结构 
2. 初步设想类的接口 
3. 类名设计（驼峰式命名） 
4. 属性设置(权限设置) 
判断某些变量是否有必要作为成员属
    
                                
    • 
                                
  • java 并发
                                    shuizhaosi888
java 并发
                                    
    能够写出高伸缩性的并发是一门艺术 
  
在JAVA SE5中新增了3个包  
 
 java.util.concurrent 
 java.util.concurrent.atomic 
 java.util.concurrent.locks 
  
在java的内存模型中，类的实例字段、静态字段和构成数组的对象元素都会被多个线程所共享，局部变量与方法参数都是线程私有的，不会被共享。 
    
                                
    • 
                                
  • Spring Security（11）——匿名认证
                                    234390216
Spring SecurityROLE_ANNOYMOUS匿名
                                    
    匿名认证 
目录 
1.1     配置 
1.2     AuthenticationTrustResolver 
  
       对于匿名访问的用户，Spring Security支持为其建立一个匿名的AnonymousAuthenticat
    
                                
    • 
                                
  • NODEJS项目实践0.2[ express,ajax通信...]
                                    逐行分析JS源代码
Ajaxnodejsexpress
                                    
      
一、前言 
        通过上节学习，我们已经        ubuntu系统搭建了一个可以访问的nodejs系统，并做了nginx转发。本节原要做web端服务 及 mongodb的存取，但写着写着，web端就
    
                                
    • 
                                
  • 在Struts2 的Action中怎样获取表单提交上来的多个checkbox的值
                                    lhbthanks
javahtmlstrutscheckbox
                                    
    第一种方法：获取结果String类型 
在 Action 中获得的是一个 String 型数据，每一个被选中的 checkbox 的 value 被拼接在一起，每个值之间以逗号隔开(,)。 
 
所以在 Action 中定义一个跟 checkbox 的 name 同名的属性来接收这些被选中的 checkbox 的 value 即可。 
以下是实现的代码： 
 前台 HTML 代码： 
 
 
 
    
                                
    • 
                                
  • 003.Kafka基本概念
                                    nweiren
hadoopkafka
                                    
    Kafka基本概念：Topic、Partition、Message、Producer、Broker、Consumer。   Topic：               消息源（Message）的分类。   Partition：               Topic物理上的分组，一
    
                                
    • 
                                
  • Linux环境下安装JDK
                                    roadrunners
jdklinux
                                    
    1、准备工作 
创建JDK的安装目录： 
mkdir -p /usr/java/ 
  
下载JDK，找到适合自己系统的JDK版本进行下载： 
http://www.oracle.com/technetwork/java/javase/downloads/index.html 
  
把JDK安装包下载到/usr/java/目录，然后进行解压： 
tar -zxvf jre-7
    
                                
    • 
                                
  • Linux忘记root密码的解决思路
                                    tomcat_oracle
linux
                                    
    1：使用同版本的linux启动系统，chroot到忘记密码的根分区passwd改密码   　　2：grub启动菜单中加入init=/bin/bash进入系统，不过这时挂载的是只读分区。根据系统的分区情况进一步判断.   　　3: grub启动菜单中加入 single以单用户进入系统.   　　4:用以上方法mount到根分区把/etc/passwd中的root密码去除   　　例如:   　　ro
    
                                
    • 
                                
  • 跨浏览器 HTML5 postMessage 方法以及 message 事件模拟实现
                                    xueyou
jsonpjquery框架UIhtml5
                                    
    postMessage 是 HTML5 新方法，它可以实现跨域窗口之间通讯。到目前为止，只有 IE8+, Firefox 3, Opera 9, Chrome 3和 Safari 4 支持，而本篇文章主要讲述 postMessage 方法与 message 事件跨浏览器实现。postMessage 方法 JSONP 技术不一样，前者是前端擅长跨域文档数据即时通讯，后者擅长针对跨域服务端数据通讯，p
    
                                
    •