利用Redis實現應用程式主備

阿新 • • 發佈：2018-12-12

需要實現主備的每個任務都先進行爭奪主機，通過爭奪redis中的key值。Rredis需要搭建主備高可用。

搶到key值的程式為主機，可以開始任務，備機執行緒開始等待，過段時間再進行爭奪主機。一般情況下首先搶到key值的主機會一直執行任務直到主機異常，程式崩潰等錯誤發生時，備機才有可能搶到key值，變為主機。

Main:

import java.util.Date;
import java.util.UUID;

public class Test {

    private static final String CODE = UUID.randomUUID().toString();
    private static final Integer TIMEOUT = 10;

	public static void main(String[] args) throws InterruptedException {
		while (true) {
			execute();
		}
	}

	private static void execute() throws InterruptedException {
		String threadKey = "MainScanThread";
		String threadTimeKey = "MainScanTime";
		String oldUuid = RedisOpr.get(threadKey);
		String oldTime = RedisOpr.get(threadTimeKey);
		System.out.println("開始爭奪主機。。。");
		// 如果有其他程序在進行
		if (oldUuid != null && !oldUuid.equals(CODE)) {
			// 如果程序剛進行結束，並且其他執行緒一直在持續執行，那麼返回
			// 表示主機資訊失效時長
			if (oldTime != null && (new Date().getTime() - Long.parseLong(oldTime)) < TIMEOUT*10) {
				System.out.println("RecodeScanServiceJob 未奪取主機執行權");
				// 表示不是主機則睡眠兩倍時間再爭奪主機
				Thread.sleep(TIMEOUT * 2);
				return;
			}
		}
		RedisOpr.set(threadKey, CODE);
		// 儲存當前時間
		RedisOpr.set(threadTimeKey, String.valueOf(new Date().getTime()));
		System.out.println("奪取成功。。。");
		//開始執行任務

	}
}

RedisOpr :Redis基本操作工具類

import java.util.List;
import java.util.Set;

import org.apache.log4j.Logger;

import redis.clients.jedis.Jedis;

/**
 * 
 * @ClassName: RedisOpr
 * @Description: TODO(redis基本操作類)
 * @author zoe 
 * @date 2018年3月12日 上午11:31:55
 *
 */
public class RedisOpr {

	private static Logger log = Logger.getLogger(RedisOpr.class);

	/**
	 * @Title: saveObject @Description: 儲存物件 @param key @param object @return
	 *         void @throws
	 */
	public static void saveObject(String key, Object object) {
		Jedis jedis = RedisUtil.getJedis();
		try {
			jedis.set(key.getBytes(), SerializeUtil.serialize(object));
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			RedisUtil.returnResource(jedis);
		}
	}

	/**
	 * @Title: set @Description: 儲存key值 @param key @param value @return void @throws
	 */
	public static void set(String key, String value) {
		Jedis jedis = RedisUtil.getJedis();
		try {
			jedis.set(key, value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			RedisUtil.returnResource(jedis);
		}
	}

	/**
	 * @Title: @Description: 獲取key值 @param key @return void @throws
	 */
	public static String get(String key) {
		Jedis jedis = RedisUtil.getJedis();
		try {
			return jedis.get(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			RedisUtil.returnResource(jedis);
		}
		return null;
	}

	/**
	 * @Title: getObject @Description: 獲取物件 @param key @param object @return
	 *         void @throws
	 */
	public static Object getObject(String key) {
		Jedis jedis = RedisUtil.getJedis();
		try {
			byte[] object = jedis.get(key.getBytes());
			if (object == null) {
				return null;
			}
			return SerializeUtil.unserialize(object);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			RedisUtil.returnResource(jedis);
		}
		return null;
	}

	/**
	 * @Title: lpush @Description: 向連結串列末尾新增資料 @param key @param value @return
	 *         void @throws
	 */
	public static void lpush(String key, String value) {
		Jedis jedis = RedisUtil.getJedis();
		try {
			jedis.lpush(key, value);
		} catch (Exception e) {
			log.error(e.getMessage());
		} finally {
			RedisUtil.returnResource(jedis);
		}
	}

	/**
	 * @Title: rpush @Description: 向連結串列末位新增資料 @param key @param value @return
	 *         void @throws
	 */
	public static void rpushObject(String key, Object object) {
		Jedis jedis = RedisUtil.getJedis();
		try {
			jedis.rpush(key.getBytes(), SerializeUtil.serialize(object));
		} catch (Exception e) {
			log.error(e.getMessage());
		} finally {
			RedisUtil.returnResource(jedis);
		}
	}

	/**
	 * @Title: rpush @Description: 向連結串列末位新增資料 @param key @param value @return
	 *         void @throws
	 */
	public static void rpush(String key, String value) {
		Jedis jedis = RedisUtil.getJedis();
		try {
			jedis.rpush(key, value);
		} catch (Exception e) {
			log.error(e.getMessage());
		} finally {
			RedisUtil.returnResource(jedis);
		}
	}

	/**
	 * @Title: llen @Description: 獲得連結串列長度 @param key @return long @throws
	 */
	public static long llen(String key) {
		Jedis jedis = RedisUtil.getJedis();
		try {
			return jedis.llen(key.getBytes());
		} catch (Exception e) {
			log.error(e.getMessage());
		} finally {
			RedisUtil.returnResource(jedis);
		}
		return 0;
	}

	/**
	 * @Title: removeObject @Description: 刪除key @param key @return void @throws
	 */
	public static void removeObject(String key) {
		Jedis jedis = RedisUtil.getJedis();
		try {
			jedis.del(key.getBytes());
		} catch (Exception e) {
			log.error("error:" + e.getMessage());
		} finally {
			RedisUtil.returnResource(jedis);
		}
	}

	/**
	 * @Title: rPop @Description: 取出並刪除List最後一個元素 @param key @return String @throws
	 */
	public static String rPop(String key) {
		Jedis jedis = RedisUtil.getJedis();
		try {
			String object = jedis.rpop(key);
			if (object == null) {
				return null;
			}
			return object;
		} catch (Exception e) {
			log.error("error:" + e.getMessage());
		} finally {
			RedisUtil.returnResource(jedis);
		}
		return null;
	}

	/**
	 * @Title: lPop @Description: 取出並刪除List第一個元素 @param key @return String @throws
	 */
	public static String lPop(String key) {
		Jedis jedis = RedisUtil.getJedis();
		try {
			String object = jedis.lpop(key);
			if (object == null) {
				return null;
			}
			return object;
		} catch (Exception e) {
			log.error("error:" + e.getMessage());
		} finally {
			RedisUtil.returnResource(jedis);
		}
		return null;
	}

	/**
	 * @Title: isExistsKey @Description: 判斷key是否存在 @param key @return
	 *         boolean @throws
	 */
	public static boolean isExistsKey(String key) {
		Jedis jedis = RedisUtil.getJedis();
		try {
			return jedis.exists(key);
		} catch (Exception e) {
			log.error("error:" + e.getMessage());
		} finally {
			RedisUtil.returnResource(jedis);
		}
		return false;
	}

	public static void hset(String key, String field, String value) {
		Jedis jedis = RedisUtil.getJedis();
		try {
			jedis.hset(key, field, value);
		} catch (Exception e) {
			log.error("error:" + e.getMessage());
		} finally {
			RedisUtil.returnResource(jedis);
		}
	}

	/**
	 * @Title: getRedisQueueObject @Description: 獲得告警佇列物件 @param key @return
	 *         List<Integer> @throws
	 */
	@SuppressWarnings("unchecked")
	public static List<Integer> getRedisQueueObject(String key) {
		Jedis jedis = RedisUtil.getJedis();
		try {
			byte[] object = jedis.get(key.getBytes());
			if (object == null) {
				return null;
			}
			return (List<Integer>) SerializeUtil.unserialize(object);
		} catch (Exception e) {
			log.error("error:" + e.getMessage());
		} finally {
			RedisUtil.returnResource(jedis);
		}
		return null;
	}

	/**
	 * @Title: getRedisWarnState @Description: TODO(這裡用一句話描述這個方法的作用) @param
	 *         key @param 獲得告警佇列狀態 @return Integer @throws
	 */
	public static Integer getRedisWarnState(String key) {
		Jedis jedis = RedisUtil.getJedis();
		try {
			byte[] object = jedis.get(key.getBytes());
			if (object == null) {
				return null;
			}
			return (Integer) SerializeUtil.unserialize(object);
		} catch (Exception e) {
			log.error("error:" + e.getMessage());
		} finally {
			RedisUtil.returnResource(jedis);
		}
		return null;
	}

	/**
	 * @Title: getAllKeyByPattern @Description: 通過正則表示式獲得key @param pattern @return
	 *         List<String> @throws
	 */
	public static Set<String> getAllKeyByPattern(String pattern) {
		Jedis jedis = RedisUtil.getJedis();
		try {
			return jedis.keys(pattern);
		} catch (Exception e) {
			log.error("error:" + e.getMessage());
		} finally {
			RedisUtil.returnResource(jedis);
		}
		return null;
	}

	/**
	 * @Title: getString @Description: redis獲得string @param key @return
	 *         String @throws
	 */
	public static String getString(String key) {
		Jedis jedis = RedisUtil.getJedis();
		try {
			byte[] object = jedis.get(key.getBytes());
			if (object == null) {
				return null;
			}
			return (String) SerializeUtil.unserialize(object);
		} catch (Exception e) {
			log.error("error:" + e.getMessage());
		} finally {
			RedisUtil.returnResource(jedis);
		}
		return null;
	}

	/**
	 * @Title: lrange @Description: 獲得連結串列指定範圍內的資料 @param key @param start @param
	 *         end @return List<byte[]> @throws
	 */
	public static List<byte[]> lrange(String key, long start, long end) {
		Jedis jedis = RedisUtil.getJedis();
		try {
			return jedis.lrange(key.getBytes(), start, end);
		} catch (Exception e) {
			log.error("error:" + e.getMessage());
		} finally {
			RedisUtil.returnResource(jedis);
		}
		return null;
	}

	/**
	 * @Title: lindex @Description: 根據索引獲得list資料 @param @param key @param @param
	 *         index @return byte[] @throws
	 */
	public static byte[] lindex(String key, long index) {
		Jedis jedis = RedisUtil.getJedis();
		try {
			return jedis.lindex(key.getBytes(), index);
		} catch (Exception e) {
			log.error("error:" + e.getMessage());
		} finally {
			RedisUtil.returnResource(jedis);
		}
		return null;
	}

}

RedisUtil:Redis初始化工具類

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
 * 
 * @ClassName: RedisUtil
 * @Description: TODO(redis初始化類)
 * @author zoe 
 * @date 2018年3月12日 上午11:32:17
 *
 */
public class RedisUtil {
	private static String ADDR = SystemProperties.getString("redis-ip");
	private static int PORT = SystemProperties.getInteger("redis-port");
	private static String PASSWORD = SystemProperties.getString("redis-pwd");
	private static String REDISPASSWORD = PASSWORD;
	private static int MAX_ACTIVE = 50;
	private static int MAX_IDLE = 10;
	private static int MAX_WAIT = 10000;
	private static int TIMEOUT = 10000;
	private static boolean TEST_ON_BORROW = true;
	private static JedisPool jedisPool = null;
	static {
		try {
			JedisPoolConfig config = new JedisPoolConfig();
			config.setMaxTotal(MAX_ACTIVE);
			config.setMaxIdle(MAX_IDLE);
			config.setMaxWaitMillis(MAX_WAIT);
			config.setTestOnBorrow(TEST_ON_BORROW);
			if (REDISPASSWORD == null || "".equals(REDISPASSWORD)) {
				jedisPool = new JedisPool(config, ADDR, PORT, TIMEOUT);
			} else {
				jedisPool = new JedisPool(config, ADDR, PORT, TIMEOUT, REDISPASSWORD);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public synchronized static Jedis getJedis() {
		try {
			if (jedisPool != null) {
				Jedis resource = jedisPool.getResource();
				return resource;
			} else {
				return null;
			}
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 釋放jedis資源
	 * 
	 * @param jedis
	 */
	public static void returnResource(final Jedis jedis) {
		if (jedis != null) {
			jedisPool.returnResource(jedis);
		}
	}
}

SerializeUtil :序列化工具類

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 * 
 * @ClassName: SerializeUtil
 * @Description: TODO(序列化和反序列化)
 * @author zoe 
 * @date 2018年3月12日 上午11:35:26
 *
 */
public class SerializeUtil {
	public static byte[] serialize(Object object) {
		ObjectOutputStream oos = null;
		ByteArrayOutputStream baos = null;
		try {
			// 序列化
			baos = new ByteArrayOutputStream();
			oos = new ObjectOutputStream(baos);
			oos.writeObject(object);
			byte[] bytes = baos.toByteArray();
			return bytes;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	public static Object unserialize(byte[] bytes) {
		ByteArrayInputStream bais = null;
		try {
			// 反序列化
			bais = new ByteArrayInputStream(bytes);
			ObjectInputStream ois = new ObjectInputStream(bais);
			return ois.readObject();
		} catch (Exception e) {

		}
		return null;
	}
}

利用Redis實現應用程式主備

需要實現主備的每個任務都先進行爭奪主機，通過爭奪redis中的key值。Rredis需要搭建主備高可用。搶到key值的程式為主機，可以開始任務，備機執行緒開始等待，過段時間再進行爭奪主機。一般情況下首先搶到key值的主機會一直執行任務直到主機異常，程式崩潰等錯誤發生時，備

利用Redis實現非同步訊息佇列優化系統性能（Redis高階應用）

寫在前面今天把之前在專案中使用 Redis 做非同步訊息佇列的使用經驗總結一下。首先明確使用目的，因為專案中，我們進行某個操作後可能後續會有一系列的其他耗時操作，但是我們不希望將主執行緒阻塞在此過程中，這時便可將其他操作非同步化。舉個栗子，當你給這篇部落格點贊或評論的時候

Java利用Redis實現消息隊列

.get keys rpo throws max del 鍵值先進先出 instance 應用場景為什麽要用redis?二進制存儲、java序列化傳輸、IO連接數高、連接頻繁一、序列化　　這裏編寫了一個java序列化的工具,主要是將對象轉化為byte數組,和根

C# FrameworkAPI之Mutex實現應用程式單例

using System; using System.Collections.Generic; using System.Linq; using System.Threading.Tasks; using System.Windows.Forms; namespace DemoCSDN {

Oracle Database 12c DBA文官手冊（第8版）——第5章開發和實現應用程式（續）

5.2、資源管理5.2.1、實現資料庫資源管理需要建立資源計劃、資源消費者組和資源計劃指令。使用資源管理器命令前須建立“未決區域”。針對會話啟用ADMINISTRATOR_RESOURCE_MAANAGER系統許可權將使用者賦給資源消費者組建立資源計劃指令分配相關資源1 切換消費者組2 使用SQL配置檔案5.

Oracle Database 12c DBA文官手冊（第8版）——第5章開發和實現應用程式

1 調整設計：最佳實踐 1.1做盡可能少的工作應該簡化應用

利用Redis實現分散式鎖使用mysql樂觀鎖解決併發問題

寫在最前面我在之前總結冪等性的時候，寫過一種分散式鎖的實現，可惜當時沒有真正應用過，著實的心虛啊。正好這段時間對這部分實踐了一下，也算是對之前填坑了。分散式鎖按照網上的結論，大致分為三種：1、資料庫樂觀鎖； 2、基於Redis的分散式鎖；3.、基於ZooKeeper的分散式鎖；關於樂觀鎖的實現其實

利用Redis實現分散式鎖

為什麼需要分散式鎖？在傳統單體應用單機部署的情況下，可以使用Java併發相關的鎖，如ReentrantLcok或synchronized進行互斥控制。但是，隨著業務發展的需要，原單體單機部署的系統，漸漸的被部署在多機器多JVM上同時提供服務，這使得原單機部署情況下的併發控制鎖策略失效了，為了解決這個問

nginx叢集負責均衡利用redis實現共享session會話狀態,針對tomcat8

當前是隻針對tomcat8的部署，如果你們的伺服器是tomcat7.x或7以下的版本，請看這個帖子：https://blog.csdn.net/hua1586981/article/details/78132710 目的搭建好nginx負載均衡後，實現反向代理的叢集功能，當用戶訪問網

利用redis實現使用者簽到

很多網站都提供了簽到功能(這裡不考慮資料落地事宜)，並且需要展示最近一個月的簽到情況，如果使用bitmap我們怎麼做？一言不合亮程式碼！ <?php $redis = new Redis(); $redis->connect('127.0.0.1'); //使用者uid $u

利用redis實現分布式鎖

Coding urn isp equals beans redis host ini ng- 一、背景　　在分布式項目中，由於一個服務會有多個實例運行，有些特定的場景需要我們用到分布式鎖。　　例如：最近我正在做的交易所項目，其中一個服務是錢包模塊，需要每半個小時就去歸集

ZooKeeper分散式鎖簡單實踐利用Redis實現分散式鎖

寫在最前面前幾周寫了篇利用Redis實現分散式鎖，今天簡單總結下ZooKeeper實現分散式鎖的過程。其實生產上我只用過Redis或者資料庫的方式，之前還真沒了解過ZooKeeper怎麼實現分散式鎖。這周簡單寫了個小Demo，更堅定了我繼續使用Redis的信心了。 ZooKeep

QtCreator 應用程式主視窗——選單欄(QMenuBar)和工具欄(QToolBar)

1.選單欄(QMenuBar)和工具欄(QToolBar) 1.1 將選單項放在工具欄上面：將Action編輯器中的相應動作直接拖到工具欄上面 1.2 使用資源：新增資原始檔->Qt資原始檔-&g

利用Redis實現高併發計數器

業務需求中經常有需要用到計數器的場景：譬如一個手機號一天限制傳送5條簡訊、一個介面一分鐘限制多少請求、一個介面一天限制呼叫多少次等等。使用Redis的Incr自增命令可以輕鬆實現以上需求。以一個介面一天限制呼叫次數為例： /** * 是否拒絕服務 * @return */ private boolea

高併發場景系列(一) 利用redis實現分散式事務鎖,解決高併發環境下減庫存

問題描述:某電商平臺,首發一款新品手機,每人限購2臺,預計會有10W的併發,在該情況下,如果扣減庫存,保證不會超賣方案一利用資料庫鎖機制,對記錄進行鎖定,再進行操作 SELECT * from goods where ID =1 for updat

redis 主從備份及其主備切換

首先原文是用了3 個伺服器，我是用了一個伺服器；然後再原文的基礎上，稍加了自己的整理。前提：redis中，主從切換場景中，沒有絕對的主和從，只有初始化的主和從，然後當主down後，從就變成主了，而主即使連線上，也是從，不會變為主1.redis-server的主備關係：

如何利用kubernetes實現應用的水平擴充套件(HPA)

雲端計算具有水平彈性的特性，這個是雲端計算區別於傳統IT技術架構的主要特性。對於Kubernetes中的POD叢集來說，HPA就是實現這種水平伸縮的控制器, 它能在當POD中業務負載上升的時候，建立新的POD來保證業務系統穩定執行，當POD中業務負載下降的時候，

使用LogMaster4Net實現應用程式日誌的集中管理

日誌在軟體系統中的重要性我在此也不贅述了，幾乎所有程式設計師每天都會更日誌打交道。那麼你是否曾今為這樣的一些事情而困擾過： - 遠端登入到不同的伺服器，找到應用程式目然後檢視應用日誌； - 來回切換於不同伺服器並使用tail來實時監控日誌輸出資訊; - 解決在各個伺服器上各個應用日積月累生成的大量日誌

用dg_broker實現 oracle rac主備切換

dg_broker其實就是dgmgrl工具,直接輸入dgmgrl可以進入dgmgrl命令列。前提條件：已安裝Oracle DB和Oracle DG ,已經配置dg_broker 1.登入Oracle主庫所在節點 2.在主庫所在節點執行 su - oracle ，切

PHP中利用redis實現訊息佇列處理高併發請求

將請求存入redis 為了模擬多個使用者的請求,使用一個for迴圈替代 //redis資料入隊操作 $redis = new Redis(); $redis->connect('127.0.0.1',6379); for($i=0;$i<50;$i++){

利用Redis實現應用程式主備

相關推薦