laravel+Redis implémente simplement un traitement hautement simultané des files d'attente qui réussissent les tests de résistance

Cet article présente principalement laravel+Redis pour implémenter simplement un traitement à haute concurrence des files d'attente qui réussissent le test de résistance. Il a une certaine valeur de référence. Maintenant, je le partage avec vous. Les amis dans le besoin peuvent s'y référer. 🎜> Activité de vente flash

Dans les centres commerciaux en ligne en général, nous sommes souvent exposés à certaines conditions commerciales à forte concurrence, telles que nos ventes flash courantes et d'autres activités

Dans ces entreprises, nous le faisons souvent. devez gérer certaines demandes de filtrage d’informations et de problèmes d’inventaire de produits.

Une situation courante dans les demandes est que le même utilisateur effectue plusieurs demandes ou contient des attaques malveillantes, ainsi que des achats répétés de certaines commandes.

En termes d'inventaire, les conditions de survente doivent être prises en compte.

Simulons un traitement simultané simple et utilisable.

Accédez directement au code

Processus de code

1 Simulez la demande de l'utilisateur et écrivez l'utilisateur dans la file d'attente Redis

2. l'utilisateur Demande des informations pour le traitement (vous pouvez effectuer plus de traitement dans cette étape, demander un filtrage, un rachat de commande, etc.)

3. L'utilisateur passe une commande (paiement, etc.) et réduit l'inventaire. Deux méthodes sont utilisées pour le traitement ci-dessous.

L'une utilise la fonctionnalité d'opération atomique à thread unique de Redis pour faire fonctionner le programme de manière linéaire et maintenir la cohérence des données

. L'autre est d'utiliser des transactions pour des opérations, qui peuvent être modulées selon les métiers, je ne les décrirai pas une par une ici.

La situation actuelle des affaires est plus compliquée, mais elle est davantage due à l'expansion des idées de base.

Test AB

<?php

namespace App\Http\Controllers\SecKill;

use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Redis;

class SecKillControllers extends Controller {

    public function SecKillTest() {　　　　　///在此之前我们已经将一千过用户写入了redis中了
        $num = Redis::lpop(&#39;user_list&#39;);　　　　　///取出一个用户　　　　　///　　　　　///一些对请求的处理　　　　　///
        if (!is_null($num)) {　　　　　　　///将需要秒杀的商品放入队列中
            $this->AddGoodToRedis(1);　　　　　　　///需要注意的是我们如果写的是秒杀活动的话，需要做进一步的处理，例如设置商品队列的缓存等方式，这里就实现了　　　　　　　///下订单减库存
            $this->GetGood(1,$num);
        }
    }

    public function DoLog($log) {
        file_put_contents("test.txt", $log . &#39;\r\n&#39;, FILE_APPEND);
    }

    /**
     * 重点在于Redis中存储数据的单线程的原子性，！！！无论多少请求同时执行这个方法，依然是依次执行的！！！！！
     * 这种方式性能较高，并且确保了对数据库的单一操作，但容错率极低，一旦出现未可预知的错误会导致数据混乱；
     */
    public function GetGood($id,$user_id) {
        $good = \App\Goods::find($id);
        if (is_null($good)) {
            $this->DoLog("商品不存在");
            return &#39;error&#39;;
        }

        ///去除一个库存
        $num = Redis::lpop(&#39;good_list&#39;);
        ///判断取出库存是否成功
        if (!$num) {
            $this->DoLog("取出库存失败");
            return &#39;error&#39;;
        } else {
            ///创建订单
            $order = new \App\Order();
            $order->good_id = $good->good_id;
            $order->user_id = $user_id;
            $order->save();

            $ok = DB::table(&#39;Goods&#39;)
                    ->where(&#39;good_id&#39;, $good->good_id)
                    ->decrement(&#39;good_left&#39;, $num);
            if (!$ok) {
                $this->DoLog("库存减少失败");
                return;
            }
            echo &#39;下单成功&#39;;
        }
    }

    public function AddUserToRedis() {
        $user_count = 1000;
        for ($i = 0; $i < $user_count; $i++) {
            try {
                Redis::lpush(&#39;user_list&#39;, rand(1, 10000));
            } catch (Exception $e) {
                echo $e->getMessage();
            }
        }
        $user_num = Redis::llen(&#39;user_list&#39;);
        dd($user_num);
    }

    public function AddGoodToRedis($id) {

        $good = \App\Goods::find($id);
        if ($good == null) {
            $this->DoLog("商品不存在");
            return;
        }

        ///获取当前redis中的库存。
        $left = Redis::llen(&#39;good_list&#39;);
        ///获取到当前实际存在的库存，库存减去Redis中剩余的数量。
        $count = $good->good_left - $left;
        //        dd($good->good_left);
        ///将实际库存添加到Redis中
        for ($i = 0; $i < $count; $i++) {
            Redis::lpush(&#39;good_list&#39;, 1);
        }
        echo Redis::llen(&#39;good_list&#39;);
    }

    public function getGood4Mysql($id) {
        DB::beginTransaction();
        ///开启事务对库存以及下单进行处理
        try {
            ///创建订单
            $order = new \App\Order();
            $order->good_id = $good->good_id;
            $order->user_id = rand(1, 1000);
            $order->save();

            $good = DB::table("goods")->where([&#39;goods_id&#39; => $id])->sharedLock()->first();
            //对商品表进行加锁(悲观锁)
            if ($good->good_left) {
                $ok = DB::table(&#39;Goods&#39;)
                        ->where(&#39;good_id&#39;, $good->good_id)
                        ->decrement(&#39;good_left&#39;, $num);
                if ($ok) {
                    // 提交事务
                    DB::commit();
                    echo&#39;下单成功&#39;;
                } else {
                    $this->DoLog("库存减少失败");
                }
            } else {
                $this->DoLog("库存剩余为空");
            }
            DB::rollBack();
            return &#39;error&#39;;
        } catch (Exception $e) {
            // 出错回滚数据
            DB::rollBack();
            return &#39;error&#39;;
            //执行其他操作
        }
    }

}

Ici, j'ai utilisé Apache Bench pour tester le code

Appel du code dans

AddUserToRedis()
方法将一堆请求用户放进redis队列中
先看库存

这里设置了一千个库存
开始压力测试

向我们的程序发起1200个请求，并发量为200

Ici, nous avons complété 1 200 demandes, dont 1 199 ont été marquées comme ayant échoué. En effet, Apache Bench utilisera le contenu de la première réponse à la requête comme référence

Si le contenu de la réponse à la requête suivante est incohérent, il sera marqué comme un échec si vous voyez que le nombre de marqueurs est présent. la longueur n'est pas correcte, elle peut en principe être ignorée. Nous La demande a effectivement été complétée.

Ce qui précède représente l'intégralité du contenu de cet article. J'espère qu'il sera utile à l'étude de chacun. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois !

Recommandations associées :

Solution à l'erreur de configuration de fastcgi_param dans le fichier de configuration nginx

Comment wordpress utilise la fonction wp_head()

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!