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

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,开发语言)

        

            

                
    
                    
  • GitHub上克隆项目
                        bigbig猩猩
github
                        
    从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
    
                    
    • 
                    
  • 01-Git初识
                        Meereen
Gitgit
                        
    01-Git初识概念：一个免费开源，分布式的代码版本控制系统，帮助开发团队维护代码作用：记录代码内容。切换代码版本，多人开发时高效合并代码内容如何学：个人本机使用：Git基础命令和概念多人共享使用：团队开发同一个项目的代码版本管理Git配置用户信息配置：用户名和邮箱，应用在每次提交代码版本时表明自己的身份命令：查看git版本号git-v配置用户名gitconfig--globaluser.name
    
                    
    • 
                    
  • Kafka是如何保证数据的安全性、可靠性和分区的
                        喜欢猪猪
kafka分布式
                        
    Kafka作为一个高性能、可扩展的分布式流处理平台，通过多种机制来确保数据的安全性、可靠性和分区的有效管理。以下是关于Kafka如何保证数据安全性、可靠性和分区的详细解析：一、数据安全性SSL/TLS加密：Kafka支持SSL/TLS协议，通过配置SSL证书和密钥来加密数据传输，确保数据在传输过程中不会被窃取或篡改。这一机制有效防止了中间人攻击，保护了数据的安全性。SASL认证：Kafka支持多种
    
                    
    • 
                    
  • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • 华为云分布式缓存服务DCS 8月新特性发布
                        华为云PaaS服务小智
华为云分布式缓存
                        
    分布式缓存服务（DistributedCacheService，简称DCS）是华为云提供的一款兼容Redis的高速内存数据处理引擎，为您提供即开即用、安全可靠、弹性扩容、便捷管理的在线分布式缓存能力，满足用户高并发及数据快速访问的业务诉求。此次为大家带来DCS8月的特性更新内容，一起来看看吧！
    
                    
    • 
                    
  • 浅谈MapReduce
                        Android路上的人
Hadoop分布式计算mapreduce分布式框架hadoop
                        
    从今天开始，本人将会开始对另一项技术的学习，就是当下炙手可热的Hadoop分布式就算技术。目前国内外的诸多公司因为业务发展的需要，都纷纷用了此平台。国内的比如BAT啦，国外的在这方面走的更加的前面，就不一一列举了。但是Hadoop作为Apache的一个开源项目，在下面有非常多的子项目，比如HDFS，HBase,Hive，Pig,等等，要先彻底学习整个Hadoop，仅仅凭借一个的力量，是远远不够的。
    
                    
    • 
                    
  • spring security中几大组件的作用和执行顺序
                        阿信在这里
javaspring
                        
    springsecurity中几大组件的作用和执行顺序在SpringSecurity中，AuthenticationProvider、GroupPermissionEvaluator、PermissionEvaluator、AbstractAuthenticationProcessingFilter、DefaultMethodSecurityExpressionHandler和ManageSecu
    
                    
    • 
                    
  • KVM+GFS分布式存储系统构建KVM高可用
                        henan程序媛
分布式GFS高可用KVM
                        
    一、案列分析1.1案列概述本章案例主要使用之前章节所学的KVM及GlusterFs技术,结合起来从而实现KVM高可用。利用GlusterFs分布式复制卷，对KVM虚拟机文件进行分布存储和冗余。分布式复制卷主要用于需要冗余的情况下把一个文件存放在两个或两个以上的节点,当其中一个节点数据丢失或者损坏之后，KVM仍然能够通过卷组找到另一节点上存储的虚拟机文件，以保证虚拟机正常运行。当节点修复之后，Glu
    
                    
    • 
                    
  • Hadoop
                        傲雪凌霜，松柏长青
后端大数据hadoop大数据分布式
                        
    ApacheHadoop是一个开源的分布式计算框架，主要用于处理海量数据集。它具有高度的可扩展性、容错性和高效的分布式存储与计算能力。Hadoop核心由四个主要模块组成，分别是HDFS（分布式文件系统）、MapReduce（分布式计算框架）、YARN（资源管理）和HadoopCommon（公共工具和库）。1.HDFS（HadoopDistributedFileSystem）HDFS是Hadoop生
    
                    
    • 
                    
  • 大模型训练数据库Common Crawl
                        WindyChanChan
数据集语言模型数据库
                        
    CommonCrawl介绍‌‌CommonCrawl是一个非营利组织，致力于通过大规模分布式爬虫系统定期抓取整个Web并将其存储在一个可公开访问的数据库中。CommonCrawl的数据收集和处理过程包括使用Python开源爬虫工具收集全球范围内的网站数据，并将其上传到‌CommonCrawl基金会的数据仓库中。该项目从2008年开始，至今已经积累了大量的原始网页数据、元数据和文本提取数据。这些数据
    
                    
    • 
                    
  • 慢速连接攻击是什么？慢速连接攻击怎么防护？
                        快快小毛毛
网络ddos服务器
                        
    慢速连接攻击（SlowConnectionAttack），又称慢速攻击（SlowlorisAttack），是一种网络攻击技术，旨在通过占用服务器上的所有可用连接资源来使其无法响应正常请求。与传统的拒绝服务（DoS）和分布式拒绝服务（DDoS）攻击不同，慢速攻击并不依赖于发送大量数据包来消耗带宽，而是利用HTTP、TCP或SSL等协议的特性，通过发送大量不完整的请求或缓慢发送数据来占用服务器资源，使
    
                    
    • 
                    
  • 分布式锁和spring事务管理
                        暴躁的鱼
锁及事务分布式springjava
                        
    最近开发一个小程序遇到一个需求需要实现分布式事务管理业务需求用户在使用小程序的过程中可以查看景点，对景点地区或者城市标记是否想去，那么需要统计一个地点被标记的人数，以及记录某个用户对某个地点是否标记为想去，用两个表存储数据，一个地点表记录改地点被标记的次数，一个用户意向表记录某个用户对某个地点是否标记为想去。由于可能有多个用户同时标记一个地点，每个用户在前端点击想去按钮之后，后台接收到请求，从数据
    
                    
    • 
                    
  • Gobelieve 架构
                        weixin_34099526
数据库golangjson
                        
    Gobelievegithub地址声明:转简书JackieF的文章,为了自己方便copy了一份,加一些自己的东西.链接：https://www.jianshu.com/p/8121d6e85282IMCore主要分三大块:im客户连接服务器（可分布式部署，暂无负载均衡模块)imr路由查询服务器（主要解决im分布式部署的问题）ims存储服务器(主从部署)基础模块1.数据包协议包：header(12)
    
                    
    • 
                    
  • Lua 与 C#交互
                        z2014z
luac#开发语言
                        
    Lua与C#交互前提Lua是一种嵌入式脚本语言，Lua的解释器是用C编写的，因此可以方便的与C/C++进行相互调用。轻量级Lua语言的官方版本只包括一个精简的核心和最基本的库，这使得Lua体积小、启动速度快，也适合嵌入在别的程序里。交互过程C#调用Lua:由C#文件调用Lua解析器底层dll库（由C语言编写），再由dll文件执行相应的Lua文件。Lua调用C#：1、Wrap方式：首先生成C#源文件
    
                    
    • 
                    
  • Github 2024-09-12 Go开源项目日报Top10
                        老孙正经胡说
githubgolang开源Github趋势分析开源项目PythonGolang
                        
    根据GithubTrendings的统计，今日(2024-09-12统计)共有10个项目上榜。根据开发语言中项目的数量，汇总情况如下：开发语言项目数量Go项目10C项目1Terraform：基础设施即代码的开源工具创建周期：3626天开发语言：Go协议类型：OtherStar数量：40393个Fork数量：9397次关注人数：40393人贡献人数：358人OpenIssues数量：1943个Git
    
                    
    • 
                    
  • Kafka详细解析与应用分析
                        芊言芊语
kafka分布式
                        
    Kafka是一个开源的分布式事件流平台（EventStreamingPlatform），由LinkedIn公司最初采用Scala语言开发，并基于ZooKeeper协调管理。如今，Kafka已经被Apache基金会纳入其项目体系，广泛应用于大数据实时处理领域。Kafka凭借其高吞吐量、持久化、分布式和可靠性的特点，成为构建实时流数据管道和流处理应用程序的重要工具。Kafka架构Kafka的架构主要由
    
                    
    • 
                    
  • linux挂载文件夹
                        小码快撩
linux
                        
    1.使用NFS（NetworkFileSystem）NFS是一种分布式文件系统协议，允许一个系统将其文件系统的一部分共享给其他系统。检查是否安装NFSrpm-qa|grepnfs2.启动和启用NFS服务假设服务名称为nfs-server.service，你可以使用以下命令启动和启用它：sudosystemctlstartnfs-server.servicesudosystemctlenablenf
    
                    
    • 
                    
  • Kafka 基础与架构理解
                        StaticKing
KAFKAkafka
                        
    目录前言Kafka基础概念消息队列简介：Kafka与传统消息队列（如RabbitMQ、ActiveMQ）的对比Kafka的组件Kafka的工作原理：消息的生产、分发、消费流程Kafka系统架构Kafka的分布式架构设计Leader-Follower机制与数据复制Log-basedStorage和持久化Broker间通信协议Zookeeper在Kafka中的角色总结前言Kafka是一个分布式的消息系
    
                    
    • 
                    
  • Rides实现分布式锁，保障数据一致性,Redisson分布式事务处理
                        朱杰jjj
缓存分布式
                        
    分布式环境下分布式锁有三种方式：基于数据库分布式锁基于Redis分布式锁基于zk分布式锁本帖只介绍Redis分布式锁为什么需要用到分布式锁？在单机环境下一个服务中多个线程对同一个事物或数据资源进行操作时，可以通过添加加锁方式（synchronized和lock）来解决数据一致性的问题。但是如果出现多个服务的情况下，这时候我们在通过synchronized和lock的方式来加锁会出现问题，因为多个服
    
                    
    • 
                    
  • 基于Python执行lua脚本
                        xu-jssy
Python自动化脚本pythonlua自动化rpa
                        
    一、依赖安装pipinstalllupa二、源码将lua文件存放在base_path路径，将lua文件名称（不包含后缀名）传递给lua_runner函数即可importmultiprocessingimportlupa#lua文件存放位置base_path='D:\\test\\lua'classLuaFuncion:#创建Lua运行时环境lua=lupa.LuaRuntime(unpack_re
    
                    
    • 
                    
  • 机电综合管理系统架构
                        小熊coder
机载系统系统架构
                        
    文章目录一、机电综合管理系统架构1.系统概述2.架构层次3.核心组件二、余度管理1.余度概述2.硬件冗余3.软件冗余4.通信冗余三、总线架构1.MIL-STD-1553B总线2.ARINC429总线3.ARINC629总线4.AFDX/ARINC664总线四、未来发展趋势1.分布式架构2.高速网络3.智能化与自动化结语机电综合管理系统（ElectromechanicalManagementSyst
    
                    
    • 
                    
  • 华为云分布式缓存服务DCS与开源服务差异对比
                        hcinfo_18
redis使用华为云Redis5.0分布式缓存服务Redis客户端
                        
    分布式缓存服务DCS提供单机、主备、集群等丰富的实例类型，满足用户高读写性能及快速数据访问的业务诉求。支持丰富的实例管理操作，帮助用户省去运维烦恼。用户可以聚焦于业务逻辑本身，而无需过多考虑部署、监控、扩容、安全、故障恢复等方面的问题。DCS基于开源Redis、Memcached向用户提供一定程度定制化的缓存服务，因此，除了拥有开源服务缓存数据库的优秀特性，DCS提供更多实用功能。一、与开源Red
    
                    
    • 
                    
  • Dubbo架构概览：服务注册与发现、远程调用、监控与管理
                        木南曌
dubbo架构
                        
    Dubbo是一个成熟的、高性能的、基于Java的微服务开发框架，它主要用于解决分布式系统中的服务治理问题，包括服务的注册与发现、远程过程调用（RPC）、服务监控与管理等多个关键环节。以下是Dubbo架构概览的详细介绍：服务注册与发现Dubbo的服务注册与发现机制是其核心功能之一，它依赖于注册中心来管理服务的生命周期和定位服务提供者。1.服务提供者（Provider）服务提供者是实际提供服务的节点，
    
                    
    • 
                    
  • 数据仓库介绍
                        阿龙的代码在报错
数据分析数据仓库数据库
                        
    数据仓库数据仓库的概念数据仓库的主要特征数据仓库的主流开发语言-sql结构化数据sql语句数据仓库的概念数据仓库（英语：DataWarehouse，简称数仓、DW）,是一个用于存储、分析、报告的数据系统。数据仓库的目的是构建面向分析的集成化数据环境，分析结果为企业提供决策支持（DecisionSupport）。就是数据仓库只分析数据并不产生数据数据仓库的主要特征1、面向主题主题是一个抽象的概念，是
    
                    
    • 
                    
  • 外卖霸王餐返利外卖会员卡小程序开发
                        闹小艾
good506070微信小程序小程序
                        
    外卖霸王餐返利外卖会员卡小程序开发"社交电商赋能下的外卖返利小程序"是专为商家与用户双赢而设计的创新平台。以下是其开发方案的详细步骤：一、需求梳理：首先，我们需要明确小程序的核心功能和特色。包括设定活动类型、返利策略，以及用户体验友好的界面设计。二、技术决策：技术选型是关键。我们采用小程序的开发框架，利用JavaScript作为前端开发语言，并结合微信提供的API进行后端接口调用与数据处理。三、账
    
                    
    • 
                    
  • nfs服务搭建
                        GHope

                        
    nfs是什么？基哥度娘网络文件系统(NFS)是sun微系统最初开发的分布式文件系统协议,[1]允许客户端计算机上的用户通过计算机网络访问文件很像本地存储被访问。NFS与许多其他协议一样,在开放网络计算远程过程调用(很久以前RPC)系统上建立。NFS是在请求注释(RFC)中定义的开放标准,允许任何人实现协议。NFSNFS优势：节省本地存储空间，将常用的数据存放在一台NFS服务器上且可以通过网络访问，
    
                    
    • 
                    
  • hbase介绍
                        CrazyL-
云计算+大数据hbase
                        
    hbase是一个分布式的、多版本的、面向列的开源数据库hbase利用hadoophdfs作为其文件存储系统，提供高可靠性、高性能、列存储、可伸缩、实时读写、适用于非结构化数据存储的数据库系统hbase利用hadoopmapreduce来处理hbase、中的海量数据hbase利用zookeeper作为分布式系统服务特点：数据量大：一个表可以有上亿行，上百万列（列多时，插入变慢）面向列：面向列（族）的
    
                    
    • 
                    
  • Flume：大规模日志收集与数据传输的利器
                        傲雪凌霜，松柏长青
后端大数据flume大数据
                        
    Flume：大规模日志收集与数据传输的利器在大数据时代，随着各类应用的不断增长，产生了海量的日志和数据。这些数据不仅对业务的健康监控至关重要，还可以通过深入分析，帮助企业做出更好的决策。那么，如何高效地收集、传输和存储这些海量数据，成为了一项重要的挑战。今天我们将深入探讨ApacheFlume，它是如何帮助我们应对这些挑战的。一、Flume概述ApacheFlume是一个分布式、可靠、可扩展的日志
    
                    
    • 
                    
  • 【免费】springboot项目申报管理系统|毕业设计|Javaweb项目
                        计算机学姐来啦
springbootssmjavaspringboot课程设计后端毕设毕业设计java-ee
                        
    收藏点赞不迷路关注作者有好处编号：springboot375springboot项目申报管理系统开发语言：Java数据库：MySQL技术：Spring+SpringMVC+MyBatis工具：IDEA/Ecilpse、Navicat、Maven1.万字文档展示(部分)2.系统图片展示第5章系统详细设计5.1管理员功能模块的实现5.1.1项目列表如图5.1显示的就是项目列表页面，此页面提供给管理员的
    
                    
    • 
                    
  • 探索未来，大规模分布式深度强化学习——深入解析IMPALA架构
                        汤萌妮Margaret

                        
    探索未来，大规模分布式深度强化学习——深入解析IMPALA架构scalable_agent项目地址:https://gitcode.com/gh_mirrors/sc/scalable_agent在当今的人工智能研究前沿，深度强化学习（DRL）因其在复杂任务中的卓越表现而备受瞩目。本文要介绍的是一个开源于GitHub的重量级项目：“ScalableDistributedDeep-RLwithImp
    
                    
    • 
                                
  • 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
    
                                
    •