So verwenden Sie die Redis-Cache-Eliminierungsstrategie und -Transaktionen, um optimistisches Sperren zu implementieren

Cache-Eliminierungsstrategie

Titel-LRU-Prinzip

Der LRU-Algorithmus (Least Latest Used, Least Latest Used) eliminiert Daten basierend auf den historischen Zugriffsdatensätzen der Daten. Die Kernidee lautet: „Wenn auf die Daten kürzlich zugegriffen wurde.“ , dann sind auch die Chancen, in Zukunft besucht zu werden, höher.“

Die häufigste Implementierung besteht darin, eine verknüpfte Liste zum Speichern zwischengespeicherter Daten zu verwenden. Der detaillierte Algorithmus wird wie folgt implementiert:

• Neue Daten werden in den Kopf der verknüpften Liste eingefügt Verschieben Sie die Daten bei jedem Cache-Treffer (d. h. beim Zugriff auf die zwischengespeicherten Daten) an den Kopf der verknüpften Liste.

• Wenn die verknüpfte Liste voll ist, werden die Daten am Ende der verknüpften Liste verworfen.

• Sie können LinkHashMap in Java verwenden, um LRU mithilfe der Hash-Linked-List-Implementierung zu implementieren:

Title Redis-Cache-Eliminierungsstrategie

Legen Sie den maximalen Cache fest.

In Redis dürfen Benutzer das Maximum festlegen Die verwendete Speichergröße ist maxmemory, der Standardwert ist 0 und der maximale Cache ist nicht angegeben. Wenn neue Daten hinzugefügt werden und den maximalen Speicher überschreiten, stürzt Redis ab und muss daher festgelegt werden.

redis Wenn die Größe des Speicherdatensatzes eine bestimmte Größe erreicht, wird die Dateneliminierungsstrategie implementiert.

Eliminierungsstrategie

Redis-Eliminierungsstrategiekonfiguration: maxmemory-policy voltile-lru, unterstützt Hot-Konfiguration

redis bietet 6 Dateneliminierungsstrategien:

volatile-lru:

Aus der eingestellten Ablaufzeit auswählen die zuletzt verwendeten Daten aus dem Datensatz (server.db[i].expires), um

• volatile-ttl:
Aus dem Datensatz (server.db[i].expires) mit festgelegter Ablaufzeit zu entfernen Wählen Sie die Daten aus, die ablaufen, und löschen Sie sie

• volatile-random:
Wählen Sie zufällig die Daten aus, die aus dem Datensatz (server.db[i].expires) gelöscht werden sollen, für den die Ablaufzeit festgelegt ist

• allkeys -lru:
From Wählen Sie die zuletzt verwendeten Daten aus dem Datensatz (server.db[i].dict) aus, um sie zu eliminieren.

• allkeys-random:
Wählen Sie beliebige Daten aus dem Datensatz (server.db[i). .dict) zur Beseitigung von

• no-enviction (Räumung):
Keine Ausweisung von Daten

• Redis-Transaktion

Einführung in Redis-Transaktionen

Redis-Transaktionen werden über die fünf Befehle MULTI, EXEC abgeschlossen , DISCARD und WATCH und UNWATCH .

• Ein einzelner Befehl von Redis ist atomar, daher müssen Sie hier sicherstellen, dass das Transaktionsobjekt ein Befehlssatz ist.

• Redis serialisiert den Befehlssatz und stellt die kontinuierliche und ununterbrochene Ausführung des Befehlssatzes in derselben Transaktion sicher.

• Redis unterstützt keine Rollback-Vorgänge. Der Transaktionsbefehl

• MULTI

wird verwendet, um den Beginn eines Transaktionsblocks zu markieren. Redis stellt nachfolgende Befehle nacheinander in die Warteschlange und verwendet dann den atomaren EXEC-Befehl, um diese Befehlssequenz auszuführen. ... Stellen Sie den Befehl in die Warteschlange und nehmen Sie dann den normalen Verbindungsstatus wieder auf.

Syntax:

multi

WATCHWenn eine [Transaktion bedingt ausgeführt werden muss], verwenden Sie diesen Befehl, um den angegebenen [Schlüssel auf überwacht]-Status festzulegen.

Syntax:

exec

Hinweise: Verwenden Sie diesen Befehl, um die optimistische Sperre von Redis zu implementieren.

UNWATCH

Alle zuvor für eine Transaktion überwachten Schlüssel löschen

Syntax:

discard

Befehlsdarstellung:

Transaktionsdemo:

watch key [key…]

Redis unterstützt kein Transaktions-Rollback (warum schon)

Die meisten Transaktionsfehler sind auf Syntaxfehler oder Typfehler zurückzuführen. Beide Fehler sind während der Entwicklungsphase vorhersehbar.

Redis Optimistic Lock

Optimistic Lock basiert auf der CAS-Idee (Vergleichen und Ersetzen). Es schließt sich nicht gegenseitig aus und verursacht keine Sperrwartezeiten und verbraucht keine Ressourcen Dies liegt auch daran, dass der Testmechanismus schneller reagieren kann. Daher können wir Redis verwenden, um optimistisches Sperren zu implementieren. Die konkrete Idee lautet wie folgt:

Verwenden Sie die Überwachungsfunktion von Redis, um den Statuswert dieses RedisKey zu überwachen.

Erhalten Sie den Wert von RedisKey.

Erstellen Sie eine Redis-Transaktion dieses Schlüssels +1

然后去执行这个事务，如果key的值被修改过则回滚，key不加1

public void watch() {
	try {
		String watchKeys = "watchKeys";
		//初始值 value=1
		jedis.set(watchKeys, 1);
		//监听key为watchKeys的值
		jedis.watch(watchkeys);
		//开启事务
		Transaction tx = jedis.multi();
		//watchKeys自增加一
		tx.incr(watchKeys);
		//执行事务，如果其他线程对watchKeys中的value进行修改，则该事务将不会执行
		//通过redis事务以及watch命令实现乐观锁
		List<Object> exec = tx.exec();
		if (exec == null) {
			System.out.println("事务未执行");
		} else {
			System.out.println("事务成功执行，watchKeys的value成功修改");
		}
	} catch (Exception e) {
		e.printStackTrace();
	} finally {
		jedis.close();
	}
}

Redis乐观锁实现秒杀

public class RedisLock {
    public static void main(String[] arg) {
        //库存key 
        String redisKey = "stock";
        ExecutorService executorService = Executors.newFixedThreadPool(20);
        try {
            Jedis jedis = new RedisProperties.Jedis("127.0.0.1", 6378);
            // 可以被秒杀的库存的初始值，库存总共20个
            jedis.set(redisKey, "0");
            jedis.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        for (int i = 0; i < 1000; i++) {
            executorService.execute(() -> {
                Jedis jedis1 = new Jedis("127.0.0.1", 6378);
                try {
                    jedis1.watch(redisKey);
                    String redisValue = jedis1.get(redisKey);
                    int valInteger = Integer.valueOf(redisValue);
                    String userInfo = UUID.randomUUID().toString();
                    // 没有秒完
                    if (valInteger < 20) {
                        Transaction tx = jedis1.multi();
                        tx.incr(redisKey);
                        List list = tx.exec();
                        // 秒成功 失败返回空list而不是空
                        if (list != null && list.size() > 0) {
                            System.out.println("用户：" + userInfo + "，秒杀成 功！当前成功人数：" + (valInteger + 1));
                        }
                        // 版本变化，被别人抢了。
                        else {
                            System.out.println("用户：" + userInfo + "，秒杀失 败");
                        }
                    }
                    // 秒完了
                    else {
                        System.out.println("已经有20人秒杀成功，秒杀结束");
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    jedis1.close();
                }
            });
        }
        executorService.shutdown();
    }
}

Das obige ist der detaillierte Inhalt vonSo verwenden Sie die Redis-Cache-Eliminierungsstrategie und -Transaktionen, um optimistisches Sperren zu implementieren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!