Menggunakan Redis untuk melaksanakan penyelesaian penembusan cache yang diedarkan

Menggunakan Redis untuk melaksanakan penyelesaian penembusan cache yang diedarkan

Dengan perkembangan berterusan perniagaan Internet, jumlah akses data juga semakin meningkat Untuk meningkatkan prestasi sistem dan pengalaman pengguna, teknologi caching secara beransur-ansur menjadi sebahagian daripadanya , Redis, sebagai penyelesaian middleware caching yang cekap dan berskala, digemari oleh pembangun. Apabila menggunakan Redis sebagai cache teragih, untuk mengelakkan masalah prestasi yang disebabkan oleh penembusan cache, kita perlu melaksanakan penyelesaian yang boleh dipercayai.

Artikel ini akan memperkenalkan cara menggunakan Redis untuk melaksanakan penyelesaian penembusan cache yang diedarkan dan memberikan contoh kod khusus untuk dijelaskan.

1. Apakah itu penembusan cache?

Apabila menggunakan teknologi caching, jika kawalan keberkesanan yang ketat tidak dilaksanakan pada cache, masalah penembusan cache mungkin berlaku, iaitu apabila data yang diperlukan dalam permintaan tidak wujud dalam cache, setiap permintaan akan diakses terus Pangkalan Data, menyebabkan sumber pangkalan data akan dibebankan, dengan itu mengurangkan prestasi keseluruhan sistem atau bahkan menyebabkan masa henti.

Sebab utama penembusan cache ialah semua data tidak boleh disimpan dalam cache, dan data dalam permintaan mungkin tidak disimpan dalam cache Jika tiada kawalan yang berkesan, maka setiap permintaan akan terus mengakses pangkalan data, menyebabkan Sumber sistem amat membazir.

2. Bagaimana untuk menyelesaikan masalah penembusan cache

Untuk menyelesaikan masalah penembusan cache, kita boleh menggunakan dua kaedah berikut:

1 Algoritma Penapis Bloom

Algoritma Penapis Bloom adalah struktur data yang cekap berdasarkan vektor bit . Ia boleh digunakan untuk menentukan dengan cepat sama ada sesuatu elemen tergolong dalam set, dan mempunyai ciri kerumitan ruang dan masa yang sangat rendah. Apabila menggunakan algoritma Penapis Bloom, kita boleh menyimpan nilai cincang data yang diminta dalam vektor bit Penapis Bloom Jika nilai cincang permintaan data tidak wujud dalam Penapis Bloom, maka permintaan itu boleh ditolak secara langsung masalah penembusan cache.

2. Pemanasan awal cache

Pemanasan awal cache merujuk kepada memuatkan data yang perlu digunakan ke dalam cache terlebih dahulu apabila sistem dimulakan, untuk memastikan permintaan itu sudah wujud dalam cache sebelum memasuki sistem latar belakang, dengan itu mengelakkan caching Isu Penembusan.

3. Gunakan Redis untuk melaksanakan penyelesaian penembusan cache yang diedarkan

Apabila menggunakan Redis untuk melaksanakan cache yang diedarkan, kami boleh menggunakan dua kaedah berikut:

1 Gunakan kunci yang diedarkan

Apabila melakukan pertanyaan cache, kami boleh menggunakan kunci yang diedarkan. untuk memastikan bahawa hanya satu utas boleh mengakses pangkalan data dan mengemas kini cache. Jika berbilang utas mengakses data yang sama pada masa yang sama, hanya satu utas boleh mengambil kunci, sekali gus mengelakkan masalah penembusan cache.

Berikut ialah contoh kod yang dilaksanakan menggunakan kunci yang diedarkan:

def query_data(key):
    #先尝试从缓存中读取数据
    data = cache.get(key)
    #如果缓存中没有该数据，则获取分布式锁
    if not data:
        lock_key = 'lock:' + key
        #尝试获取锁
        if cache.setnx(lock_key, 1):
            #若获取到锁，则从数据库中读取数据，并更新到缓存中
            data = db.query(key)
            cache.set(key, data)
            #释放锁
            cache.delete(lock_key)
        else:
            #如果未获取到锁，则等待一段时间后重试
            time.sleep(0.1)
            data = query_data(key)
    return data

2 Gunakan penapis Bloom

Sebelum cache pertanyaan, kita boleh menyimpan nilai cincang data dalam penapis Bloom Jika nilai cincang adalah data yang sepadan dengan nilai hash tidak wujud, permintaan boleh ditolak secara langsung, dengan itu mengelakkan masalah penembusan cache.

Berikut ialah contoh kod yang dilaksanakan menggunakan penapis Bloom:

import redis
from pybloom_live import BloomFilter

#初始化布隆过滤器
bf = BloomFilter(capacity=1000000, error_rate=0.001)
#初始化Redis连接池
pool = redis.ConnectionPool(host='127.0.0.1', port=6379)
cache = redis.Redis(connection_pool=pool)

def query_data(key):
    #先尝试从缓存中读取数据
    data = cache.get(key)
    #如果缓存中没有该数据，则检查布隆过滤器，如果布隆过滤器中不存在该数据，则直接返回None
    if not data and (key not in bf):
        return None
    #如果缓存中没有该数据，但是存在于布隆过滤器中，则获取分布式锁
    if not data:
        lock_key = 'lock:' + key
        #尝试获取锁
        if cache.setnx(lock_key, 1):
            #若获取到锁，则从数据库中读取数据，并更新到缓存中
            data = db.query(key)
            cache.set(key, data)
            #将哈希值添加到布隆过滤器中
            bf.add(key)
            #释放锁
            cache.delete(lock_key)
        else:
            #如果未获取到锁，则等待一段时间后重试
            time.sleep(0.1)
            data = query_data(key)
    return data

Di atas ialah contoh kod pelaksanaan khusus menggunakan Redis untuk melaksanakan penyelesaian penembusan cache yang diedarkan.

Ringkasan:

Apabila menggunakan Redis sebagai penyelesaian perisian tengah cache yang diedarkan, untuk mengelakkan masalah prestasi yang disebabkan oleh penembusan cache, kami boleh menyelesaikannya dengan menggunakan kunci teragih atau penapis Bloom. Semasa menggunakan penapis Bloom, kami juga boleh menggabungkan kaedah prapemanasan cache untuk memuatkan data yang akan digunakan ke dalam cache Redis terlebih dahulu untuk memastikan permintaan itu sudah wujud dalam cache sebelum memasuki sistem latar belakang, dengan itu mengelakkan masalah penembusan Cache.

Atas ialah kandungan terperinci Menggunakan Redis untuk melaksanakan penyelesaian penembusan cache yang diedarkan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!