肯尼思布赖恩埃德蒙
肯尼思布赖恩埃德蒙

redisson 随笔 0-入门

0. 虽说时运不佳，仍欲提桶跑路

分布式锁的常见实现方案

常用锁的用例

runoob Lua教程

  • 对于分布式锁的实现方案，本文如标题所言，简单梳理了redisson的实现方案

  • redisson 也是基于redis的多个命令组合来实现的，为保证执行多个命令时的原子性，redisson借助了lua脚本实现，这个脚本算是其核心科技，也是本章节所关注的。

  • 本文大概可以给出常用锁的源码解读、状态图

0.1通过UML简单鸟瞰redisson提供的众多组件

可以看到

  • 分布式锁是基于 j.u.c.Lock 来实现的
  • 除了分布式锁，还提供了一些分布式缓存组件(数组、队列、映射)等等
    redisson 随笔 0-入门_第1张图片
    并且也基于 j.u.c.Semaphore 实现了分布式的信号量
    redisson 随笔 0-入门_第2张图片

1. 可重入锁

1.1 获取锁

redisson 随笔 0-入门_第3张图片

// org.redisson.RedissonLock#tryLockInnerAsync
// RFuture evalWriteAsync(String key, Codec codec, RedisCommand evalCommandType, String script, List keys, Object... params)
evalWriteAsync(getName(), LongCodec.INSTANCE, command,
	// 当前申请的资源未被占用，
	// 于是 创建被申请资源的hash，并put lockName:1(重入次数)
	// 被申请的资源的hash，设置租赁时间
	"if (redis.call('exists', KEYS[1]) == 0) then " +
			"redis.call('hincrby', 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]);",
	
	// KEYS
	Collections.singletonList(getName()), 	// 被申请的资源key(hash)
	
	// ARGV
	internalLockLeaseTime, 					// 租赁时间
	getLockName(threadId));					// 客户端线程的标识


1.2 释放锁


redisson 随笔 0-入门_第4张图片


// org.redisson.RedissonLock#unlockInnerAsync
// RFuture evalWriteAsync(String key, Codec codec, RedisCommand evalCommandType, String script, List keys, Object... params)
evalWriteAsync(getName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,

	// 被申请的资源未被占用，直接返回即可
	"if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then " +
			"return nil;" +
			"end; " +
			
	// 被申请的资源存在占用，递减其重入次数
	"local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1); " +
	
	// 重入次数大于0，说明该客户端线程(lockName)后续重入了，那么再续上一波租赁时间，并退出
	"if (counter > 0) then " +
	"redis.call('pexpire', KEYS[1], ARGV[2]); " +
	"return 0; " +
	
	// 此时当前客户端线程不再需要锁定该资源了，删除资源的key,通知其他线程
	"else " +
	"redis.call('del', KEYS[1]); " +
	"redis.call('publish', KEYS[2], ARGV[1]); " +
	"return 1; " +
	"end; " +
	"return nil;",
			
	// KEYS
	Arrays.asList(getName(), getChannelName()),

	// ARGV
	LockPubSub.UNLOCK_MESSAGE, internalLockLeaseTime, getLockName(threadId));


2. 公平锁


应用常用通常是锁定并发量较高的资源


2.1 获取锁


redisson 随笔 0-入门_第5张图片


// org.redisson.RedissonFairLock#tryLockInnerAsync
evalWriteAsync(
	getName(), 
	LongCodec.INSTANCE, 
	command,
	
	// 循环删除过期的线程，直至找到1个未过期的线程
	// remove stale threads
	"while true do " +
		// 从队列中获取1个存在的线程名lockName
		// threadsQueueName[0] == false,不存在则直接退出
		"local firstThreadId2 = redis.call('lindex', KEYS[2], 0);" +
		"if firstThreadId2 == false then " +
			"break;" +
		"end;" +
		
		// zSet通过lockName，获取优先级较高的timeout(最快要过期的)
		// 这里使用时延作为排序的依据
		"local timeout = tonumber(redis.call('zscore', KEYS[3], firstThreadId2));" +
		
		// 这里线程过期
		"if timeout <= tonumber(ARGV[3]) then " +
			// 从Zset中删除这个过期的线程
			"redis.call('zrem', KEYS[3], firstThreadId2);" +
			// 将过期的lockName从队列中移出
			"redis.call('lpop', KEYS[2]);" +
		"else " +
			"break;" +
		"end;" +
	"end;" +

	// 两种情况:第一次?还是说重入了？
	// 当前资源没有被占用(或已释放)
	"if (redis.call('exists', KEYS[1]) == 0) " +
		// 队列为空，没有排队的客户端了
		"and ((redis.call('exists', KEYS[2]) == 0) " +
		// 或 刚好排到了当前客户端的线程
			"or (redis.call('lindex', KEYS[2], 0) == ARGV[2])) then " +
			
		// 将这个lockName从线程队列中移出
		"redis.call('lpop', KEYS[2]);" +
		// 将这个lockName从zset中移除
		"redis.call('zrem', KEYS[3], ARGV[2]);" +

		// 查询所有timeoutSetName线程名
		// decrease timeouts for all waiting in the queue
		"local keys = redis.call('zrange', KEYS[3], 0, -1);" +
		// 迭代查询到的线程名全集
		"for i = 1, #keys, 1 do " +
			// 更新其他排队中的线程的超时时间
			"redis.call('zincrby', KEYS[3], -tonumber(ARGV[4]), keys[i]);" +
		"end;" +

		// 当前资源(锁)的hash中，新增1条key:value=当前客户端线程标识:1(自增以支持可重入)
		"redis.call('hset', KEYS[1], ARGV[2], 1);" +
		// 将锁的租赁时间作为key的超时时间
		"redis.call('pexpire', KEYS[1], ARGV[1]);" +
		// 退出
		"return nil;" +
	"end;" +
	
	// 此时，当前客户端线程已经持有过该资源了，这次即重入
	"if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
		// 重入，即自增 resource.clientId（hash）
		"redis.call('hincrby', KEYS[1], ARGV[2], 1);" +
		// 重新设置租赁时间
		"redis.call('pexpire', KEYS[1], ARGV[1]);" +
		// 退出
		"return nil;" +
	"end;" +
	"return 1;",
	
	// KEYS
	// getName():资源名、锁的key(hash=lockName:重入次数=RedissonObject.name)
	// threadsQueueName:客户端线程标识的队列(list)，lockName
	// timeoutSetName:维护lockName的zSet(优先级依据超时时间),lockName:timeout
	Arrays.asList(getName(), threadsQueueName, timeoutSetName),
	
	// ARGV
	internalLockLeaseTime,	// 锁的租赁时间
	getLockName(threadId), 	// 持有锁的客户端线程标识: 客户端UUID:线程ID
	currentTime, 			// 系统时钟
	wait					// 排队的等待时间
);



2.2 释放锁


redisson 随笔 0-入门_第6张图片


evalWriteAsync(
	getName(), 
	LongCodec.INSTANCE, 
	RedisCommands.EVAL_BOOLEAN,
	
	// 如出一辙:清理超时的lockName的zset、list
	// remove stale threads
	"while true do "
	+ "local firstThreadId2 = redis.call('lindex', KEYS[2], 0);"
	+ "if firstThreadId2 == false then "
		+ "break;"
	+ "end; "
	+ "local timeout = tonumber(redis.call('zscore', KEYS[3], firstThreadId2));"
	+ "if timeout <= tonumber(ARGV[4]) then "
		+ "redis.call('zrem', KEYS[3], firstThreadId2); "
		+ "redis.call('lpop', KEYS[2]); "
	+ "else "
		+ "break;"
	+ "end; "
  + "end;"
	
	// 锁未被占用
	// 但list中存在当前客户端线程
	// 依旧发布解锁事件，唤醒其他线程，并退出
  + "if (redis.call('exists', KEYS[1]) == 0) then " +
		"local nextThreadId = redis.call('lindex', KEYS[2], 0); " + 
		"if nextThreadId ~= false then " +
			"redis.call('publish', KEYS[4] .. ':' .. nextThreadId, ARGV[1]); " +
		"end; " +
		"return 1; " +
	"end;" +
	
	// hash中不存在该lockName:当前客户端线程并没有占用该资源，即退出
	"if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then " +
		"return nil;" +
	"end; " +
	
	// hash递减重入次数
	"local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1); " +
	// 如果重入，更新资源的过期时间，并退出
	"if (counter > 0) then " +
		"redis.call('pexpire', KEYS[1], ARGV[2]); " +
		"return 0; " +
	"end; " +
		
	// 如果不再占用任务资源了，发布解锁事件，唤醒其他线程
	"redis.call('del', KEYS[1]); " +
	"local nextThreadId = redis.call('lindex', KEYS[2], 0); " + 
	"if nextThreadId ~= false then " +
		"redis.call('publish', KEYS[4] .. ':' .. nextThreadId, ARGV[1]); " +
	"end; " +
	"return 1; ",
	
	Arrays.asList(
		getName(), 				// hash=lockName:重入次数
		threadsQueueName, 		// list=lockName
		timeoutSetName, 		// zset=lockName(排序依据timeout)
		getChannelName()		// 解锁消息的发布通道(监听这个key，以了解解锁的消息)
	),
	
	LockPubSub.UNLOCK_MESSAGE,  // 解锁的消息
	internalLockLeaseTime, 		// 锁的租赁时间
	getLockName(threadId), 		// lockName，即持锁的客户端线程标识
	System.currentTimeMillis());// 系统时钟



3. 联锁、红锁


3.1 获取锁


redisson 随笔 0-入门_第7张图片


// 从 lock.lock() 一路步进
// org.redisson.RedissonMultiLock#lockInterruptibly(long, java.util.concurrent.TimeUnit)
@Override
public void lockInterruptibly(long leaseTime, TimeUnit unit) throws InterruptedException {

	// 这一坨just 通过租赁时间 计算 等待时间
	long baseWaitTime = locks.size() * 1500;
	long waitTime = -1;
	if (leaseTime == -1) {
		waitTime = baseWaitTime;
	} else {
		leaseTime = unit.toMillis(leaseTime);
		waitTime = leaseTime;
		if (waitTime <= 2000) {
			waitTime = 2000;
		} else if (waitTime <= baseWaitTime) {
			waitTime = ThreadLocalRandom.current().nextLong(waitTime/2, waitTime);
		} else {
			waitTime = ThreadLocalRandom.current().nextLong(baseWaitTime, waitTime);
		}
	}
	
	// 获取锁失败，则反复重试
	while (true) {
		// step into ...
		if (tryLock(waitTime, leaseTime, TimeUnit.MILLISECONDS)) {
			return;
		}
	}
}

// org.redisson.RedissonMultiLock#tryLock(long, long, java.util.concurrent.TimeUnit)
@Override
public boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException {
//        try {
//            return tryLockAsync(waitTime, leaseTime, unit).get();
//        } catch (ExecutionException e) {
//            throw new IllegalStateException(e);
//        }

	// 租赁时间 做个转换而已
	long newLeaseTime = -1;
	if (leaseTime != -1) {
		if (waitTime == -1) {
			newLeaseTime = unit.toMillis(leaseTime);
		} else {
			newLeaseTime = unit.toMillis(waitTime)*2;
		}
	}
	
	// 计算等待时间
	long time = System.currentTimeMillis();
	long remainTime = -1;
	if (waitTime != -1) {
		remainTime = unit.toMillis(waitTime);
	}
	// long lockWaitTime = remainTime
	long lockWaitTime = calcLockWaitTime(remainTime);
	
	// return 0
	// 表示获取锁失败了的redis节点数，0表示必须获取到所有节点的锁才算成功
	int failedLocksLimit = failedLocksLimit();
	List<RLock> acquiredLocks = new ArrayList<>(locks.size());
	for (ListIterator<RLock> iterator = locks.listIterator(); iterator.hasNext();) {
		RLock lock = iterator.next();
		boolean lockAcquired;
		try {
			// 遍历每个锁，tryLock
			// lockAcquired=true 表示当前锁获取成功
			if (waitTime == -1 && leaseTime == -1) {
				lockAcquired = lock.tryLock();
			} else {
				long awaitTime = Math.min(lockWaitTime, remainTime);
				lockAcquired = lock.tryLock(awaitTime, newLeaseTime, TimeUnit.MILLISECONDS);
			}
		} catch (RedisResponseTimeoutException e) {
			unlockInner(Arrays.asList(lock));
			lockAcquired = false;
		} catch (Exception e) {
			lockAcquired = false;
		}
		
		// 当前锁获取成功，即放入集合中
		if (lockAcquired) {
			acquiredLocks.add(lock);
		} else {
			// 如果获取失败的节点个数 == 所容忍的个数，即失败，退出
			if (locks.size() - acquiredLocks.size() == failedLocksLimit()) {
				break;
			}

			// 如果之前有成功获取到的锁，这里不会释放，只是重置迭代器的索引
			// 接踵而来的就是，从头重试获取
			if (failedLocksLimit == 0) {
				unlockInner(acquiredLocks);
				if (waitTime == -1) {
					return false;
				}
				failedLocksLimit = failedLocksLimit();
				// list.clear()
				acquiredLocks.clear();
				// reset iterator
				while (iterator.hasPrevious()) {
					iterator.previous();
				}
			} else {
				failedLocksLimit--;
			}
		}
		
		if (remainTime != -1) {
			remainTime -= System.currentTimeMillis() - time;
			time = System.currentTimeMillis();
			if (remainTime <= 0) {
				unlockInner(acquiredLocks);
				return false;
			}
		}
	}

	if (leaseTime != -1) {
		List<RFuture<Boolean>> futures = new ArrayList<>(acquiredLocks.size());
		for (RLock rLock : acquiredLocks) {
			RFuture<Boolean> future = ((RedissonLock) rLock).expireAsync(unit.toMillis(leaseTime), TimeUnit.MILLISECONDS);
			futures.add(future);
		}
		
		for (RFuture<Boolean> rFuture : futures) {
			rFuture.syncUninterruptibly();
		}
	}
	
	return true;
}



3.2 释放锁


redisson 随笔 0-入门_第8张图片


// org.redisson.RedissonMultiLock#unlock
// 简直不要太朴实
@Override
public void unlock() {
	List<RFuture<Void>> futures = new ArrayList<>(locks.size());

	for (RLock lock : locks) {
		futures.add(lock.unlockAsync());
	}

	for (RFuture<Void> future : futures) {
		future.syncUninterruptibly();
	}
}



3.3 红锁实现


redisson 将联锁视为一种特殊的红锁(最少许获取的锁的数量，为锁的总数)


package org.redisson;

public class RedissonRedLock extends RedissonMultiLock {

    /**
     * Creates instance with multiple {@link RLock} objects.
     * Each RLock object could be created by own Redisson instance.
     *
     * @param locks - array of locks
     */
    public RedissonRedLock(RLock... locks) {
        super(locks);
    }

    @Override
    protected int failedLocksLimit() {
		// redis节点总数 - 成功获取的最小容忍的节点个数
        return locks.size() - minLocksAmount(locks);
    }
    
    protected int minLocksAmount(final List<RLock> locks) {
        return locks.size()/2 + 1;
    }

    @Override
    protected long calcLockWaitTime(long remainTime) {
        return Math.max(remainTime / locks.size(), 1);
    }
    
    @Override
    public void unlock() {
        unlockInner(locks);
    }

}



4. 读写锁


4.1 读锁


4.1.1 获取锁


redisson 随笔 0-入门_第9张图片


// org.redisson.RedissonReadLock#tryLockInnerAsync
evalWriteAsync(getName(), LongCodec.INSTANCE, command,
	
	// 获取 资源.模式
	"local mode = redis.call('hget', KEYS[1], 'mode'); " +
	
	// 资源.模式 还未被占用
	"if (mode == false) then " +
	
	  // 添加 资源.模式=read
	  "redis.call('hset', KEYS[1], 'mode', 'read'); " +
	  
	  // 添加 资源.客户端=1(重入次数)
	  "redis.call('hset', KEYS[1], ARGV[2], 1); " 
	  // 添加 '{资源}:客户端:rwlock_timeout:重入次数'=1
	  "redis.call('set', KEYS[2] .. ':1', 1); " +
	  
	  // 设置  '{资源}:客户端:rwlock_timeout:重入次数' 的租赁时间
	  "redis.call('pexpire', KEYS[2] .. ':1', ARGV[1]); " +
	  // 设置 资源的租赁时间
	  "redis.call('pexpire', KEYS[1], ARGV[1]); " +
	  "return nil; " +
	"end; " +
	
	// 资源.模式=read || (资源.模式=write && 资源.写端=1)
	"if (mode == 'read') or (mode == 'write' and redis.call('hexists', KEYS[1], ARGV[3]) == 1) then " +
	  // 资源.客户端=重入次数 ++
	  "local ind = redis.call('hincrby', KEYS[1], ARGV[2], 1); " + 
	  // key='{资源}:客户端:rwlock_timeout:ind'
	  "local key = KEYS[2] .. ':' .. ind;" +
	  // 添加 '{资源}:客户端:rwlock_timeout:ind'=1
	  "redis.call('set', key, 1); " +
	  // 设置 '{资源}:客户端:rwlock_timeout:ind' 的租赁时间
	  "redis.call('pexpire', key, ARGV[1]); " +
	  // 获取 资源 的剩余租赁时间
	  "local remainTime = redis.call('pttl', KEYS[1]); " +
	  // 更新 资源 的租赁时间
	  "redis.call('pexpire', KEYS[1], math.max(remainTime, ARGV[1])); " +
	  "return nil; " +
	"end;" +
	
	// 返回 资源 的剩余租赁时间
	"return redis.call('pttl', KEYS[1]);",
	
	Arrays.<Object>asList(
		// 资源
		// 资源.模式=是否被占用
		// 资源.客户端=重入次数
		// 租赁时间的更新逻辑:当前申请的锁的租赁时间
		getName(), 
		// 写端name '{资源}:客户端:rwlock_timeout:重入次数'=1
		// 该key为读、写之前协作使用的
		// 租赁时间的更新：max(剩余的租赁时间，当前申请的锁的租赁时间)
		// 因为读锁可以同时被多个客户端线程所持有，因此这里区分一下客户端线程
		getReadWriteTimeoutNamePrefix(threadId)
	), 
	
	internalLockLeaseTime, 
	getLockName(threadId), 
	// lockName:write
	getWriteLockName(threadId));



4.1.2 释放锁


redisson 随笔 0-入门_第10张图片


// org.redisson.RedissonReadLock#unlockInnerAsync
evalWriteAsync(getName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,

	// 获取 资源.模式
	"local mode = redis.call('hget', KEYS[1], 'mode'); " +
	// 如果 资源.模式 不被占用的话，即发布解锁事件，退出
	"if (mode == false) then " +
		"redis.call('publish', KEYS[2], ARGV[1]); " +
		"return 1; " +
	"end; " +
	
	// 如果 资源.客户端 不存在，即退出
	"local lockExists = redis.call('hexists', KEYS[1], ARGV[2]); " +
	"if (lockExists == 0) then " +
		"return nil;" +
	"end; " +
	
	// 资源.客户端=重入次数 --
	"local counter = redis.call('hincrby', KEYS[1], ARGV[2], -1); " + 
	// 如果 重入次数=0,删除 资源.客户端
	"if (counter == 0) then " +
		"redis.call('hdel', KEYS[1], ARGV[2]); " + 
	"end;" +
	// 删除 '{资源}:客户端:rwlock_timeout:重入次数'，这是用于保存 租赁时间的
	"redis.call('del', KEYS[3] .. ':' .. (counter+1)); " +
	
	// 如果 资源 的key(value即客户端) 尚有客户端
	"if (redis.call('hlen', KEYS[1]) > 1) then " +
		"local maxRemainTime = -3; " + 
		"local keys = redis.call('hkeys', KEYS[1]); " + 
		"for n, key in ipairs(keys) do " + 
			"counter = tonumber(redis.call('hget', KEYS[1], key)); " + 
			"if type(counter) == 'number' then " + 
				"for i=counter, 1, -1 do " + 
					// 取出其剩余的租赁时间
					"local remainTime = redis.call('pttl', KEYS[4] .. ':' .. key .. ':rwlock_timeout:' .. i); " + 
					"maxRemainTime = math.max(remainTime, maxRemainTime);" + 
				"end; " + 
			"end; " + 
		"end; " +
				
		// 若存在大于0的剩余租赁时间，说明还有客户端在等待占用
		// 更新该客户端的租赁时间，然后返回
		"if maxRemainTime > 0 then " +
			"redis.call('pexpire', KEYS[1], maxRemainTime); " +
			"return 0; " +
		"end;" + 
			 
		// 如果说 资源.模式=write(加锁事件由写触发) 那没事了
		"if mode == 'write' then " + 
			"return 0;" + 
		"end; " +
	"end; " +
		
	// 如果 资源.模式=read 释放资源，发布解锁事件
	"redis.call('del', KEYS[1]); " +
	"redis.call('publish', KEYS[2], ARGV[1]); " +
	"return 1; ",
	
	Arrays.<Object>asList(
		getName(), 
		getChannelName(), 
		timeoutPrefix, 
		keyPrefix
	), 
	
	LockPubSub.UNLOCK_MESSAGE, 
	getLockName(threadId)
);



4.2 写锁


4.2.1 获取锁


redisson 随笔 0-入门_第11张图片


// org.redisson.RedissonWriteLock#tryLockInnerAsync
evalWriteAsync(getName(), LongCodec.INSTANCE, command,

	// 资源.模式 若不存在，则:
		// 设置 资源.模式=写入模式
		// 设置 资源.客户端线程=1
		// 设置 资源 对应的租赁时间
		// 直接退出
	"local mode = redis.call('hget', KEYS[1], 'mode'); " +
	"if (mode == false) then " +
	  "redis.call('hset', KEYS[1], 'mode', 'write'); " +
	  "redis.call('hset', KEYS[1], ARGV[2], 1); " +
	  "redis.call('pexpire', KEYS[1], ARGV[1]); " +
	  "return nil; " +
    "end; " +
	
	// 如果 资源.模式=写入，则：
		// 如果 资源.'资源.客户端线程'=重入次数，也存在，则:
			// 资源.'资源.客户端线程' 对应的 重入次数 ++
			// 资源 对应的租赁时间 更新为 剩余租赁时间 + 当前申请的时间
			// 退出
    "if (mode == 'write') then " +
	  "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
		  "redis.call('hincrby', KEYS[1], ARGV[2], 1); " + 
		  "local currentExpire = redis.call('pttl', KEYS[1]); " +
		  "redis.call('pexpire', KEYS[1], currentExpire + ARGV[1]); " +
		  "return nil; " +
	  "end; " +
	"end;" +
	
	// 默认分治，则直接输入其 剩余租赁时间
	"return redis.call('pttl', KEYS[1]);",
		
	// 资源
	Arrays.<Object>asList(getName()), 
	
	// 写入锁的租赁时间
	internalLockLeaseTime,
	// '资源:客户端线程'
	// 注意: 写入客户端线程 的命名规则，资源:客户端线程id:write
	getLockName(threadId)

);



4.2.2 释放锁


redisson 随笔 0-入门_第12张图片


// org.redisson.RedissonWriteLock#unlockInnerAsync
evalWriteAsync(getName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,

	// 资源.模式 不存在，则：
		// 直接发布解锁事件
		// 随即，退出即可
	"local mode = redis.call('hget', KEYS[1], 'mode'); " +
	"if (mode == false) then " +
		"redis.call('publish', KEYS[2], ARGV[1]); " +
		"return 1; " +
	"end;" +
	
	// 如果 资源.模式=写入，则：
	"if (mode == 'write') then " +
		"local lockExists = redis.call('hexists', KEYS[1], ARGV[3]); " +
		
		// 如果 资源.客户端 却不存在,则:
			// 直接退出
		"if (lockExists == 0) then " +
			"return nil;" +
			
		// 如果 资源.客户端 同时存在，则：
			// 如果 资源.'资源.客户端线程' 对应的 重入次数 > 0
				// 设置 资源 的租赁时间 为当前申请的时间
				// 直接返回0
			// 如果 资源.'资源.客户端线程' 对应的 重入次数 <= 0
				// 删除 资源.'资源.客户端线程'
				// 如果 删除后的 资源 下的key 还有1个(即 资源.模式)
					//  删除 这仅存的 资源.模式
					// 发布解锁事件
				// 如果 删除后的 资源 下还存在 无锁的读端
					// 将当前的 资源.模式 改成 读
				// 整个函数，返回1
		"else " +
			"local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1); " +
			"if (counter > 0) then " +
				"redis.call('pexpire', KEYS[1], ARGV[2]); " +
				"return 0; " +
			"else " +
				"redis.call('hdel', KEYS[1], ARGV[3]); " +
				"if (redis.call('hlen', KEYS[1]) == 1) then " +
					"redis.call('del', KEYS[1]); " +
					"redis.call('publish', KEYS[2], ARGV[1]); " + 
				"else " +
					// has unlocked read-locks
					"redis.call('hset', KEYS[1], 'mode', 'read'); " +
				"end; " +
				"return 1; "+
			"end; " +
		"end; " +
	"end; "
	
	// 保底给个nil
	+ "return nil;",
	
	Arrays.<Object>asList(
		getName(), 
		getChannelName()
	), 
	
	LockPubSub.READ_UNLOCK_MESSAGE, 
	internalLockLeaseTime, 
	getLockName(threadId)
	
);


























你可能感兴趣的:(分布式,lua,开发语言)






    

  • Redis 进阶知识：看完绝对可以提升你的Redis技能
Java爱好狂.
java后端redis

    提到Redis，也许大家第一印象是：高性能的K-V缓存。其除了缓存业务上的热点数据还能做队列以及分布式锁。可大部分的我们在使用的时候也许都是公司封装好的Redis，对于整个Redis的集群以及内部核心实现一知半解。只专注业务开发，那久而久之，在个人成长上变得帮组甚少。最明显的就是当业务量级上来后，在极端情况下，许多问题暴露出来，如果没有对Redis的底层有深入的了解，很难快速定位并解决问题Redi
    

    • 

  • 【系统分析师】-安全体系
宣晨光
系统分析师软考真题标签安全软考系统分析

    考点综述(1)综合知识:包括加密密钥和公开密钥算法:计算机病毒及防治技术计算机犯罪基本概念与防范措施、入侵检测与防范、系统访问控制技术;信息删除、修改、插入和丢失;伪造与重放攻击的防止;SHA、MD5;私有信息保护。(2)案例:根据具体案例，说明在网络与分布式环境下的分布式应用系统在安全性方面需要考虑的因素。(3)论文:包括入侵检测、VPN、安全协议(IPSec、SSL、PGP、HTTPSSSL)
    

    • 

  • 速盾高防cdn是怎么解决网站攻击的？
速盾cdn
web安全安全ddos

    速盾高防CDN是一种基于云计算技术的网络安全解决方案，可以有效地保护网站免受各种网络攻击的威胁。它通过在全球多个节点部署服务器，将网站内容缓存到这些服务器上，并通过智能路由技术将用户的请求引导到最近的服务器上，以提供更快的访问速度和更好的网络性能。速盾高防CDN主要采用以下几种方式来解决网站攻击：分布式拒绝服务攻击(DDoS)防护：DDoS攻击是一种常见的网络攻击手段，攻击者通过向目标网站发送大量
    

    • 

  • 速盾：高防CDN是怎样防御的?
速盾cdn
网络web安全安全

    随着互联网的快速发展，网站安全问题也日益突出。为了保护网站避免遭受恶意攻击，高防CDN（ContentDeliveryNetwork）应运而生。高防CDN通过一系列的安全防护措施来保护网站免受DDoS（分布式拒绝服务）和其他恶意攻击的影响。首先，高防CDN提供了分布式架构，将网站的内容和流量分散到全球各地的节点服务器中。这样做的目的是为了分散攻击者对网站的恶意访问，并避免单点故障。当攻击发生时，高
    

    • 

  • 速盾：全面分析高防 CDN 和 CDN 对比？
速盾cdn
网络运维web安全

    在当今数字化时代，网站的性能和安全性对于企业和个人来说至关重要。为了提高网站的访问速度和安全性，许多人会选择使用CDN（ContentDeliveryNetwork，内容分发网络）或高防CDN。那么，高防CDN和普通CDN有什么区别呢？下面我们来进行全面分析。一、CDN的基本概念和作用CDN的定义CDN是一种分布式的网络架构，它通过在全球各地部署服务器节点，将网站的内容缓存到这些节点上。当用户访问
    

    • 

  • 弹性资源组件集成系列(一)datax集成弹性资源设计解释
中间件XL
弹性资源组件k8s分布式dataX弹性资源分布式dataxk8s

    简介弹性组件集成有弹性需求的组件，为组件增加高弹性容量，规划集成datax，elastic-job，xxl-job，sentineldashboard，dolphinscheduer，eventbridgedatax基于社区版，此前已对datax进行重构，增加其metricsexporter，分布式特性，分布式模型是基于启动的worker分配，固定的worker数量，如果分片少，浪费资源；分片多，
    

    • 

  • 基于Java毕业设计新锐台球厅管理系统源码+系统+mysql+lw文档+部署软件
练练科技
java课程设计mysql

    基于Java毕业设计新锐台球厅管理系统源码+系统+mysql+lw文档+部署软件基于Java毕业设计新锐台球厅管理系统源码+系统+mysql+lw文档+部署软件本源码技术栈：项目架构：B/S架构开发语言：Java语言开发软件：ideaeclipse前端技术：Layui、HTML、CSS、JS、JQuery等技术后端技术：JAVA运行环境：Win10、JDK1.8数据库：MySQL5.7/8.0源码
    

    • 

  • mysql雪花算法主键_分布式主键 SNOWFLAKE (雪花算法)
ag獭
mysql雪花算法主键

    SNOWFLAKE雪花算法是由Twitter公布的分布式主键生成算法，它能够保证不同进程主键的不重复性，以及相同进程主键的有序性。在同一个进程中，它首先是通过时间位保证不重复，如果时间相同则是通过序列位保证。同时由于时间位是单调递增的，且各个服务器如果大体做了时间同步，那么生成的主键在分布式环境可以认为是总体有序的，这就保证了对索引字段的插入的高效性。例如MySQL的Innodb存储引擎的主键。使
    

    • 

  • java计算机毕业设计高校学生资助管理信息系统源码+mysql数据库+系统+lw文档+部署
鸿源网络
数据库mysqljava

    java计算机毕业设计高校学生资助管理信息系统源码+mysql数据库+系统+lw文档+部署java计算机毕业设计高校学生资助管理信息系统源码+mysql数据库+系统+lw文档+部署本源码技术栈：项目架构：B/S架构开发语言：Java语言开发软件：ideaeclipse前端技术：Layui、HTML、CSS、JS、JQuery等技术后端技术：JAVA运行环境：Win10、JDK1.8数据库：MySQ
    

    • 

  • 基于JAVA高校毕业就业管理系统计算机毕业设计源码+数据库+lw文档+系统+部署
源新网络
java开发语言

    基于JAVA高校毕业就业管理系统计算机毕业设计源码+数据库+lw文档+系统+部署基于JAVA高校毕业就业管理系统计算机毕业设计源码+数据库+lw文档+系统+部署本源码技术栈：项目架构：B/S架构开发语言：Java语言开发软件：ideaeclipse前端技术：Layui、HTML、CSS、JS、JQuery等技术后端技术：JAVA运行环境：Win10、JDK1.8数据库：MySQL5.7/8.0源码
    

    • 

  • 面试频繁被问Java中的各种锁，今天就给大伙来梳理梳理外加视频教学
java涛仔

    大伙在面试的时候应该会经常碰到线程并发方面的问题，而且也会问到你各种分布式锁的概念，本文就给大家整理了下各种锁的分类，希望对你有所帮助。视频获取方式：私信【锁】即可领取锁的分类我们先总体的来看看有哪些具体的分类一、乐观锁/悲观锁  注意，乐观锁与悲观锁并不是具体的两种锁的实现，而一种设计思想。乐观锁  顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断
    

    • 

  • 【架构设计模式-1】代理模式
W Y
代理模式系统安全安全

    什么情况下用上代理模式？远程对象访问当需要访问位于不同地址空间的远程对象时，比如在分布式系统中。代理可以隐藏网络通信的复杂性，让客户端感觉就像在本地访问对象一样。例如，一个企业级应用中，不同部门的系统可能分布在不同的服务器上。当部门A的系统需要调用部门B系统中的某个服务时，可以使用代理模式。代理对象负责与远程服务进行通信，将请求发送到远程服务器并接收响应，然后将结果返回给本地客户端。这样，部门A的
    

    • 

  • Spark底层逻辑
傲雪凌霜，松柏长青
大数据后端spark大数据

    ApacheSpark的底层逻辑可以从其核心概念、组件和执行流程等方面来理解。Spark提供了一个分布式数据处理框架，其底层逻辑基于批处理架构，能够在大规模集群中高效地处理数据。以下是Spark的底层逻辑的详细介绍：1.核心概念Spark的底层基于几个核心概念来实现分布式计算，包括：RDD（ResilientDistributedDataset，弹性分布式数据集）：RDD是Spark最基础的数据抽
    

    • 

  • 大数据分析与安全分析
Zh&&Li
网络安全运维数据分析安全数据挖掘运维数据库

    大数据分析一、大数据安全威胁与需求分析1.1大数据相关概念发展大数据：是指非传统的数据处理工具的数据集大数据特征：海量的数据规模、快速的数据流转、多样的数据类型和价值密度低等大数据的种类和来源非常多，包括结构化、半结构化和非结构化数据有关大数据的新兴网络信息技术应用不断出现，主要包括大规模数据分析处理、数据挖掘、分布式文件系统、分布式数据库、云计算平台、互联网和存储系统1.2大数据安全威胁分析“数
    

    • 

  • 分布式跟踪服务实战应用指南
CRMEB系统商城
分布式

    已成为了决解复杂系统运行效率问题的关键手段之一，随着企业向微服务化与分布式系统的转变，应用复杂度不断提升，监控技术的挑战更为严峻。此项服务不仅能协助开发与运维团队更直观地理解系统运作状况，还可增强系统稳定性及提升用户满意度。接下来，文章将详细剖析分布式追踪服务的优点、适用场景、可能存在的风险以及安全性，同时还会介绍如何在Python项目中进行集成操作，并对比其他可用选项，为您推荐合适的服务提供商。
    

    • 

  • 【脚手架 第一篇章】介绍一下若依微服务版框架
蜗牛 | ICU
脚手架专栏微服务架构云原生

    若依框架（RuoYi）是一个广泛使用的开源框架，它提供了多种版本以满足不同开发需求。以下是关于若依框架微服务版（RuoYi-Cloud）的详细介绍：一、概述RuoYi-Cloud是基于SpringCloud和SpringBoot的分布式微服务架构平台，专为构建大型分布式系统提供完整的解决方案。它集成了众多微服务特性，如服务发现、配置管理、负载均衡等，适合需要高可扩展性和高可用性的企业级应用。二、技
    

    • 

  • PHP与出库单打印预览，包含下载与打印功能
assasinSteven
PHP框架PHP打印预览

    咱们的开发语言还是用框架：laravel5。应用场景出库单打印出三色单，这个很普遍，以下用PHP来实现出库单的打印预览，主要用到tcpdf插件，整合到laravel项目中。tcpdf插件可以到官网下载最新的版本。我这里用的是最新版本，这里提供下载插件链接：链接：https://pan.baidu.com/s/1Mn8ho_AxyJfWR7YUa0wzhQ提取码：9doa三色单截图：插件截图：开发功
    

    • 

  • PHP使用rabbitMQ
每天瞎忙的农民工
php实战rabbitMQphprabbitmq

    在PHP中使用RabbitMQ通常是为了处理异步任务、队列、消息推送等场景，特别是在高并发、分布式系统中，RabbitMQ提供了可靠的消息队列服务。RabbitMQ是基于AMQP协议的消息中间件，具有高效、可靠、可扩展的特点。下面将介绍如何在PHP中使用RabbitMQ，并结合场景给出实现方法。一、RabbitMQ基础概念Producer（生产者）：发送消息的客户端，负责将消息发送到消息队列。Co
    

    • 

  • 淘宝海量数据库OceanBase:系统架构详解
weixin_34356555
数据库系统架构大数据

    无论从数据量还是访问量，OceanBase不再能够是一个单机系统，即使一台单机能服务高达几个TB的数据、提供几万QPS的服务能力，因此，分布式系统不可避免，然而，内部如何实现拆表(拆库)以及如何实现数据库的事务，成为了一个很大的挑战和十分艰难的抉择：相关文章：淘宝海量数据库之一：来自业务的挑战淘宝海量数据库之二：一致性选择淘宝海量数据库之三：事务的ACID一种选择是当前数据库的常用的水平拆库，淘宝
    

    • 

  • 应用基本期末
渔jy
Android系统及应用应用物联网

    选以下哪些属于Java的三大特性：a.抽象b.封装c.面向对象d.分布式e.安全性f.平台独立以下哪些是Object的公用方法？a.equals()b.getContext()c.notify()d.toString()e.clone()int和integer两个谁更占用内存？a.Intb.integer“a==b”和“a.equals(b)”是否有区别？a.Yesb.No以下关于ArrayLis
    

    • 

  • 千万级规模高性能、高并发的网络架构经验分享
搬砖养女人
网络架构经验分享

    主题：INTO100沙龙时间：2015年11月21日下午地点：梦想加联合办公空间分享人：卫向军（毕业于北京邮电大学，现任微博平台架构师，先后在微软、金山云、新浪微博从事技术研发工作，专注于系统架构设计、音视频通讯系统、分布式文件系统和数据挖掘等领域。）架构以及我理解中架构的本质在开始谈我对架构本质的理解之前，先谈谈对今天技术沙龙主题的个人见解，千万级规模的网站感觉数量级是非常大的，对这个数量级我们
    

    • 

  • 两阶段事务提交
码农小伙
事务java

    简介分布式事务是指会涉及到操作多个数据库的事务,在分布式系统中，各个节点之间在物理上相互独立，通过网络进行沟通和协调。XA就是X/OpenDTP定义的交易中间件与数据库之间的接口规范（即接口函数），交易中间件用它来通知数据库事务的开始、结束以及提交、回滚等。XA接口函数由数据库厂商提供。二阶段提交(Two-phaseCommit)是指，在计算机网络以及数据库领域内，为了使基于分布式系统架构下的所有
    

    • 

  • 01 Web基础与HTTP协议
子非鱼　　　
前端http网络协议

    1.1Web基础本章将介绍Web基础知识，包括域名的概念、DNS原理、静态网页和动态网页的相关知识。1.1.1.域名概述1.域名的概念ip地址不易记忆2.早期使用host文件解析域名主机名重复主机维护困难3.DNS分布式层次式4.域名空间结构根域顶级域组织域国家域二级域名FQDN=主机名.DNS后缀1.2网页的概念1.2.1网页纯文本格式文件编写语言为HTNL在用户的浏览器中被‘翻译’成网页形成显
    

    • 

  • 2022年最新Kubernetes常见面试题汇总
云小七
kubernetes容器云原生java

    常规题1.简述etcd及其特点答∶etcd是CoreOS团队发起的开源项目，是一个管理配置信息和服务发现（servicediscovery）的项目，它的目标是构建一个高可用的分布式键值（key-value）数据库，基于Go语言实现。特点∶●简单∶支持REST风格的HTTP+JSONAPI●安全∶支持HTTPS方式的访问●快速：支持并发1k/s的写操作●可靠∶支持分布式结构，基于Raft的一致性算法
    

    • 

  • Redisson与Redis分布式锁
Lill_bin
javaredis分布式数据库开发语言云原生架构微服务

    Redis分布式锁Redis分布式锁是一种在分布式系统中用于确保多个进程对共享资源互斥访问的机制。它通常通过Redis的原子指令来实现，比如使用SETNX（SetifNoteXists）指令来设置键，如果键不存在则操作成功，可以认为获取了锁；如果键已存在，则操作失败，表示锁被其他进程持有。但是，这种基本的实现可能会遇到各种问题，如锁无法自动释放导致的死锁问题，或者在高并发情况下的锁安全性问题。为了
    

    • 

  • Deepspeed 结合huggingface Trainer实现多机分布式训练
ningzhao
分布式

    目前工作中只使用了单机多卡做微调训练，为了提升训练效率，特实验多机多卡分布式训练。一、环境准备本试验使用两台机器（manager，worker），操作系统ubuntu22.4，每台机器有4个GPU为了使安装配置统一，使用docker容器，docker的安装这里不做介绍。1.网络配置-创建overlay共享网络初始化集群，在manager机器上运行:dockerswarminit#输出结果:Swar
    

    • 

  • Java中的分布式计算：如何在多节点环境中实现高效计算
省赚客app开发者
java开发语言

    Java中的分布式计算：如何在多节点环境中实现高效计算大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！在现代计算中，分布式计算已成为处理大量数据和复杂计算任务的标准解决方案。通过将计算任务分散到多个节点上，可以显著提升计算性能和系统的可扩展性。本文将探讨如何在Java环境中实现高效的分布式计算，涵盖从基本概念到具体的技术实现和最佳实践。一、分布式计算基础分布式计算指的
    

    • 

  • 分布式计算任务调度算法总结
一条鱼2017
分布式计算任务调度算法总结分布式计算任务调度算法总结

    一、影响分布式系统性能的因素主要有这些因素影响着分布式系统的性能：网络延迟、数据通信效能、计算节点处理能力、任务的分割、无法预算处理时间、任务的颠簸等等。我们在寻求分布式计算调度算法时，就是有针对性的以解决这些问题为目的，从各个角度，不同侧面，利用一种或者集中方法结合起来的形式，从而达到最优解，使得系统效率相对最高。二、几种基本的调度算法获得网络负载均衡有几个基本的方法。这些方法可以结合使用，形成
    

    • 

  • node中间件是什么意思？
zhangyubababa
web前端

    node中间件是什么意思？2020-09-1116:11:17分类：常见问题/Node.js答疑阅读(1757)评论(0)中间件是一种独立的系统软件或服务程序，分布式应用软件借助这种软件在不同的技术之间共享资源。中间件位于客户机/服务器的操作系统之上，管理计算机资源和网络通讯。node中间件：1、中间件就是一种功能的封装方式，就是封装在程序中处理http请求的功能，2、中间件是在管道中执行3、中间
    

    • 

  • ray.tune文档总结
AI大司马
python人工智能深度学习

    ray.tune文档总结tune.runconfig指定超参数的搜索方法ConcurrencyLimiter搜索算法scheduler试验调度程序分析资源（并行、GPU、分布式）原文档请看这里https://docs.ray.io/en/latest/tune/key-concepts.htmltune.run执行超参数调整、用于管理实验，例如日志检查、提前停止tune.run(trainable
    

    • 

  • Algorithm
香水浓
javaAlgorithm

    冒泡排序
public static void sort(Integer[] param) {
for (int i = param.length - 1; i > 0; i--) {
for (int j = 0; j < i; j++) {
int current = param[j];
int next = param[j + 1];
    

    • 

  • mongoDB 复杂查询表达式
开窍的石头
mongodb

    1:count
   Pg: db.user.find().count();
   统计多少条数据
2:不等于$ne
   Pg: db.user.find({_id:{$ne:3}},{name:1,sex:1,_id:0});
   查询id不等于3的数据。
3：大于$gt $gte(大于等于)
&n
    

    • 

  • Jboss Java heap space异常解决方法, jboss OutOfMemoryError : PermGen space
0624chenhong
jvmjboss

    转自
http://blog.csdn.net/zou274/article/details/5552630
解决办法：
window->preferences->java->installed jres->edit jre
把default vm arguments 的参数设为-Xms64m -Xmx512m
----------------
    

    • 

  • 文件上传 下载 解析 相对路径
不懂事的小屁孩
文件上传

    有点坑吧，弄这么一个简单的东西弄了一天多，身边还有大神指导着，网上各种百度着。
下面总结一下遇到的问题：
文件上传，在页面上传的时候，不要想着去操作绝对路径，浏览器会对客户端的信息进行保护，避免用户信息收到攻击。
在上传图片，或者文件时，使用form表单来操作。
前台通过form表单传输一个流到后台，而不是ajax传递参数到后台，代码如下:
<form action=&
    

    • 

  • 怎么实现qq空间批量点赞
换个号韩国红果果
qq

    纯粹为了好玩！！
逻辑很简单
1 打开浏览器console；输入以下代码。
先上添加赞的代码
var tools={};
//添加所有赞
function init(){
document.body.scrollTop=10000;
setTimeout(function(){document.body.scrollTop=0;},2000);//加
    

    • 

  • 判断是否为中文
灵静志远
中文

    方法一：
public class Zhidao {
public static void main(String args[]) {
String s = "sdf灭礌 kjl d{';\fdsjlk是";
int n=0;
for(int i=0; i<s.length(); i++) {
n = (int)s.charAt(i);
if((
    

    • 

  • 一个电话面试后总结
a-john
面试

    今天，接了一个电话面试，对于还是初学者的我来说，紧张了半天。
面试的问题分了层次，对于一类问题，由简到难。自己觉得回答不好的地方作了一下总结：
 
在谈到集合类的时候，举几个常用的集合类，想都没想，直接说了list,map。
 
然后对list和map分别举几个类型：
 
list方面：ArrayList,LinkedList。在谈到他们的区别时，愣住了
    

    • 

  • MSSQL中Escape转义的使用
aijuans
MSSQL

    IF OBJECT_ID('tempdb..#ABC') is not null
drop table tempdb..#ABC
create table #ABC
(
PATHNAME NVARCHAR(50)
)
insert into #ABC
SELECT N'/ABCDEFGHI'
UNION ALL SELECT N'/ABCDGAFGASASSDFA'
UNION ALL
    

    • 

  • 一个简单的存储过程
asialee
mysql存储过程构造数据批量插入

               今天要批量的生成一批测试数据，其中中间有部分数据是变化的，本来想写个程序来生成的，后来想到存储过程就可以搞定，所以随手写了一个，记录在此：
 
        
DELIMITER $$
DROP PROCEDURE IF EXISTS inse
    

    • 

  • annot convert from HomeFragment_1 to Fragment
百合不是茶
android导包错误

    创建了几个类继承Fragment, 需要将创建的类存储在ArrayList<Fragment>中; 出现不能将new 出来的对象放到队列中,原因很简单;
    创建类时引入包是:import android.app.Fragment;
 
   创建队列和对象时使用的包是:import android.support.v4.ap
    

    • 

  • Weblogic10两种修改端口的方法
bijian1013
weblogic端口号配置管理config.xml

    一.进入控制台进行修改    1.进入控制台:  http://127.0.0.1:7001/console     2.展开左边树菜单         域结构->环境->服务器-->点击AdminServer(管理) &
    

    • 

  • mysql 操作指令
征客丶
mysql

    一、连接mysql
进入 mysql 的安装目录；
$ bin/mysql -p [host IP 如果是登录本地的mysql 可以不写 -p 直接 -u] -u [userName] -p
输入密码，回车，接连；
二、权限操作［如果你很了解mysql数据库后，你可以直接去修改系统表，然后用 mysql> flush privileges; 指令让权限生效］
1、赋权
mys
    

    • 

  • 【Hive一】Hive入门
bit1129
hive

    Hive安装与配置
Hive的运行需要依赖于Hadoop，因此需要首先安装Hadoop2.5.2，并且Hive的启动前需要首先启动Hadoop。
  Hive安装和配置的步骤
 
1. 从如下地址下载Hive0.14.0
 
http://mirror.bit.edu.cn/apache/hive/
 
 2.解压hive，在系统变
    

    • 

  • ajax 三种提交请求的方法
BlueSkator
Ajaxjqery

    1、ajax 提交请求
$.ajax({
type:"post",
url : "${ctx}/front/Hotel/getAllHotelByAjax.do",
dataType : "json",
success : function(result) {
try {
for(v
    

    • 

  • mongodb开发环境下的搭建入门
braveCS
运维

     
linux下安装mongodb
1）官网下载mongodb-linux-x86_64-rhel62-3.0.4.gz
2）linux 解压 
gzip -d mongodb-linux-x86_64-rhel62-3.0.4.gz;
mv mongodb-linux-x86_64-rhel62-3.0.4 mongodb-linux-x86_64-rhel62-
    

    • 

  • 编程之美-最短摘要的生成
bylijinnan
java数据结构算法编程之美

    
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
public class ShortestAbstract {
/**
* 编程之美 最短摘要的生成
* 扫描过程始终保持一个[pBegin,pEnd]的range,初始化确保[pBegin,pEnd]的ran
    

    • 

  • json数据解析及typeof
chengxuyuancsdn
jstypeofjson解析

    
// json格式
var people='{"authors": [{"firstName": "AAA","lastName": "BBB"},'
+' {"firstName": "CCC&
    

    • 

  • 流程系统设计的层次和目标
comsci
设计模式数据结构sql框架脚本

    
                              流程系统设计的层次和目标
 
    

    • 

  • RMAN List和report 命令
daizj
oraclelistreportrman

    LIST 命令
使用RMAN LIST 命令显示有关资料档案库中记录的备份集、代理副本和映像副本的
信息。使用此命令可列出：
• RMAN 资料档案库中状态不是AVAILABLE 的备份和副本
• 可用的且可以用于还原操作的数据文件备份和副本
• 备份集和副本，其中包含指定数据文件列表或指定表空间的备份
• 包含指定名称或范围的所有归档日志备份的备份集和副本
• 由标记、完成时间、可
    

    • 

  • 二叉树:红黑树
dieslrae
二叉树

        红黑树是一种自平衡的二叉树,它的查找,插入,删除操作时间复杂度皆为O(logN),不会出现普通二叉搜索树在最差情况时时间复杂度会变为O(N)的问题.
    红黑树必须遵循红黑规则,规则如下
   
1、每个节点不是红就是黑。     2、根总是黑的  &
    

    • 

  • C语言homework3，7个小题目的代码
dcj3sjt126com
c

    1、打印100以内的所有奇数。
# include <stdio.h>
int main(void)
{
int i;
for (i=1; i<=100; i++)
{
if (i%2 != 0)
printf("%d ", i);
}
return 0;
}
 2、从键盘上输入10个整数，
    

    • 

  • 自定义按钮, 图片在上, 文字在下, 居中显示
dcj3sjt126com
自定义

    #import <UIKit/UIKit.h>
@interface MyButton : UIButton
-(void)setFrame:(CGRect)frame ImageName:(NSString*)imageName Target:(id)target Action:(SEL)action Title:(NSString*)title Font:(CGFloa
    

    • 

  • MySQL查询语句练习题，测试足够用了
flyvszhb
sqlmysql

    http://blog.sina.com.cn/s/blog_767d65530101861c.html
1.创建student和score表
CREATE  TABLE  student (
id  INT(10)  NOT NULL  UNIQUE  PRIMARY KEY  ,
name  VARCHAR
    

    • 

  • 转：MyBatis Generator 详解
happyqing
mybatis

     
MyBatis Generator 详解
http://blog.csdn.net/isea533/article/details/42102297
 
MyBatis Generator详解
http://git.oschina.net/free/Mybatis_Utils/blob/master/MybatisGeneator/MybatisGeneator.
    

    • 

  • 让程序员少走弯路的14个忠告
jingjing0907
工作计划学习

     
无论是谁，在刚进入某个领域之时，有再大的雄心壮志也敌不过眼前的迷茫：不知道应该怎么做，不知道应该做什么。下面是一名软件开发人员所学到的经验，希望能对大家有所帮助
 
1.不要害怕在工作中学习。
只要有电脑，就可以通过电子阅读器阅读报纸和大多数书籍。如果你只是做好自己的本职工作以及分配的任务，那是学不到很多东西的。如果你盲目地要求更多的工作，也是不可能提升自己的。放
    

    • 

  • nginx和NetScaler区别
流浪鱼
nginx

    NetScaler是一个完整的包含操作系统和应用交付功能的产品，Nginx并不包含操作系统，在处理连接方面，需要依赖于操作系统，所以在并发连接数方面和防DoS攻击方面，Nginx不具备优势。
2.易用性方面差别也比较大。Nginx对管理员的水平要求比较高，参数比较多，不确定性给运营带来隐患。在NetScaler常见的配置如健康检查，HA等，在Nginx上的配置的实现相对复杂。
3.策略灵活度方
    

    • 

  • 第11章 动画效果（下）
onestopweb
动画

    index.html
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    

    • 

  • FAQ - SAP BW BO roadmap
blueoxygen
BOBW

    http://www.sdn.sap.com/irj/boc/business-objects-for-sap-faq
 
Besides, I care that how to integrate tightly.
 
By the way, for BW consultants, please just focus on Query Designer which i
    

    • 

  • 关于java堆内存溢出的几种情况
tomcat_oracle
javajvmjdkthread

    【情况一】： 　　
java.lang.OutOfMemoryError: Java heap space：这种是java堆内存不够，一个原因是真不够，另一个原因是程序中有死循环； 　　如果是java堆内存不够的话，可以通过调整JVM下面的配置来解决： 　　<jvm-arg>-Xms3062m</jvm-arg> 　　<jvm-arg>-Xmx
    

    • 

  • Manifest.permission_group权限组
阿尔萨斯
Permission

    结构
继承关系
public static final class Manifest.permission_group extends Object
java.lang.Object
android. Manifest.permission_group 常量
ACCOUNTS 直接通过统计管理器访问管理的统计
COST_MONEY可以用来让用户花钱但不需要通过与他们直接牵涉的权限
D
    

    •