《環形佇列》遊戲高《TPS》模式下減少cpu執行緒切換

序言

什麼高TPS？QPS，其實很多人都知道，還有人說大資料，大流量這些關鍵詞夜以繼日的出現在我們眼前；

針對高TPS，QPS這些詞彙還有一個次可能比較陌生那就是CCU，tps，qps接受滿天飛，CCU在遊戲服務端出現比較多，

一個運營（SP）如果問研發（CP）你們遊戲承載是多少？通常他們想知道，你們能承載多少玩家線上，並且能承載每個玩家在一秒內有多少個操作；

通常，MMO的RPG類遊戲，FPS類遊戲，對玩家同時操作要求都相對較高，比如團戰，這時候玩家的操作是極具頻繁的；

在遊戲界很多人都知道傳統的頁遊，或者備份手遊，在伺服器端，設計是就是以不同的地圖切換來做整個世界場景，

每一個場景通過傳送門切換到下一章地圖；在傳統遊戲做法就是每一張地圖就是一個執行緒，這個在遊戲界廣為流傳的程式碼《秦美人》模式；

這樣做的好處就是每一個地圖都是單獨的執行緒，自己管理自己範圍的事情，不會衝突，但是理論終究是理論，

實際線上運營情況就是，某些地圖比如《主城》《副本入口》《活動入口》這些地方聚集了大量的玩家，在某些低等級地圖或者沒什麼任務和裝逼產出的地圖玩家少的可憐甚至沒有；

在傳統遊戲，比如最早的盛大代理的《冒險島》業內家喻戶曉的《秦美人》程式碼都有分線這麼一說就是為了解決在一張地圖人太多，一個執行緒處理不了的問題；

這種傳統模式就是一句話，忙得忙死，閒的閒死，一句套用現在皮友的一句話，澇的澇死，旱的旱死；

 那麼應運而生的是什麼

沒錯就是我們今天要講的環形排隊佇列；可能聽起來有點繞口，

其目的是什麼呢？通過佇列模型，達到執行緒恭喜，不再有專有執行緒，減少執行緒數量，執行緒做什麼事情由佇列說了算；

 

我們通常佇列是這樣的，先進先出，

排隊佇列是什麼情況呢？

就是佇列裡面的某一項，當從佇列裡面獲取到這一項的時候，發現這一項本身不是一個任務而是一個佇列；

然後取出這一項佇列裡面的第一項來執行，

一般來講我們需要的佇列基本也就是兩層就夠了，

當然你們如果需要三層，或者更多，你們可以稍加改動我們後面的程式碼；

翠花上程式碼

 

佇列列舉

package com.ty.test.queue;

/**
 * 佇列key值
 *
 * @author: Troy.Chen(失足程式設計師, 15388152619)
 * @create: 2021-04-06 11:19
 **/
public enum QueueKey {
    /**
     * 預設佇列是不區分，順序執行
     */
    Default,
    /**
     * 登入任務處理
     */
    Login,
    /**
     * 聯盟，工會處理
     */
    Union,
    /**
     * 商店處理
     */
    Shop,
    ;

}

 

 佇列任務

package com.ty.test.queue;

import java.io.Serializable;

/**
 * @author: Troy.Chen(失足程式設計師, 15388152619)
 * @create: 2021-04-06 11:35
 **/
public abstract class TyEvent implements Serializable {

    private static final long serialVersionUID = 1L;

    private QueueKey queueKey;

    public abstract void run();

    public TyEvent(QueueKey queueKey) {
        this.queueKey = queueKey;
    }

    public QueueKey getQueueKey() {
        return queueKey;
    }
}

最關鍵的程式碼來了，這個是主佇列，

package com.ty.test.queue;

import java.io.Serializable;
import java.util.HashMap;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 佇列
 *
 * @author: Troy.Chen(失足程式設計師, 15388152619)
 * @create: 2021-04-06 11:14
 **/
public class TyQueue implements Serializable {

    private static final long serialVersionUID = 1L;
    /*同步鎖保證佇列資料的準確性*/
    protected ReentrantLock reentrantLock = new ReentrantLock();
    /*子佇列容器*/
    protected HashMap<QueueKey, TySubQueue> subQueueMap = new HashMap<>();

    /*佇列容器*/
    protected LinkedBlockingQueue<Object> queue = new LinkedBlockingQueue<>();
    /*佇列裡面包括子佇列任務項*/
    protected final AtomicInteger queueSize = new AtomicInteger();

    /**
     * 新增任務
     *
     * @param obj
     */
    public void add(TyEvent obj) {
        reentrantLock.lock();
        try {
            if (obj.getQueueKey() == QueueKey.Default) {
                /*預設模式直接加入佇列*/
                queue.add(obj);
            } else {
                TySubQueue subQueue = subQueueMap.get(obj.getQueueKey());
                if (subQueue == null) {
                    subQueue = new TySubQueue(obj.getQueueKey());
                    subQueueMap.put(obj.getQueueKey(), subQueue);
                }
                /*有排隊情況的，需要加入到排隊子佇列*/
                subQueue.add(obj);
                /*這裡是關鍵，*/
                if (!subQueue.isAddQueue()) {
                    subQueue.setAddQueue(true);
                    /*如果當前子佇列不在佇列項裡面，需要加入到佇列項裡面去*/
                    queue.add(subQueue);
                }
            }
            /*佇列的資料加一*/
            queueSize.incrementAndGet();
        } finally {
            reentrantLock.unlock();
        }
    }


    /**
     * 獲取任務
     *
     * @return
     * @throws InterruptedException
     */
    public TyEvent poll() throws InterruptedException {
        Object poll = this.queue.poll(500, TimeUnit.MILLISECONDS);
        if (poll instanceof TySubQueue) {
            try {
                reentrantLock.lock();
                TySubQueue subQueue = (TySubQueue) poll;
                poll = subQueue.poll();
            } finally {
                reentrantLock.unlock();
            }
        }
        if (poll != null) {
            /*執行減一操作*/
            this.queueSize.decrementAndGet();
            return (TyEvent) poll;
        }
        return null;
    }

    /**
     * 當任務執行完成後操作
     *
     * @param obj
     */
    public void runEnd(TyEvent obj) {
        reentrantLock.lock();
        try {
            if (obj.getQueueKey() != QueueKey.Default) {
                TySubQueue subQueue = subQueueMap.get(obj.getQueueKey());
                if (subQueue != null) {
                    if (subQueue.size() > 0) {
                        /*這個時候需要把佇列重新新增到主佇列*/
                        queue.add(subQueue);
                    } else {
                        /*當子佇列空的時候，標識佇列已經不在主佇列裡面，等待下次加入新任務*/
                        subQueue.setAddQueue(false);
                    }
                }
            }
        } finally {
            reentrantLock.unlock();
        }
    }
}

 

子佇列，也就是排隊佇列的關鍵所在

package com.ty.test.queue;

import java.io.Serializable;
import java.util.LinkedList;

/**
 * 下級佇列
 *
 * @author: Troy.Chen(失足程式設計師, 15388152619)
 * @create: 2021-04-06 11:14
 **/
public class TySubQueue extends LinkedList<TyEvent> implements Serializable {

    private static final long serialVersionUID = 1L;

    private final QueueKey queueKey;
    private boolean addQueue = false;

    public TySubQueue(QueueKey queueKey) {
        this.queueKey = queueKey;
    }

    public QueueKey getQueueKey() {
        return queueKey;
    }

    public boolean isAddQueue() {
        return addQueue;
    }

    public TySubQueue setAddQueue(boolean addQueue) {
        this.addQueue = addQueue;
        return this;
    }

    @Override
    public String toString() {
        return "{" + "queueKey=" + queueKey + ", size=" + size() + '}';
    }
}

 

 測試一下結果

package com.ty.test.queue;

/**
 * @author: Troy.Chen(失足程式設計師, 15388152619)
 * @create: 2021-04-06 11:46
 **/
public class Test {

    public static final TyQueue queue = new TyQueue();

    public static void main(String[] args) {
        queue.add(new TyEvent(QueueKey.Default) {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getId() + ", 1");
            }
        });
        queue.add(new TyEvent(QueueKey.Default) {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getId() + ", 2");
            }
        });
        queue.add(new TyEvent(QueueKey.Default) {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getId() + ", 3");
            }
        });

        T t1 = new T();
        T t2 = new T();
        T t3 = new T();
        t1.start();
        t2.start();
        t3.start();
    }

    public static class T extends Thread {

        @Override
        public void run() {
            while (!Thread.currentThread().isInterrupted()) {
                TyEvent poll = null;
                try {
                    poll = queue.poll();
                    if (poll != null) {
                        /*執行任務*/
                        poll.run();
                    }
                } catch (InterruptedException interruptedException) {
                    Thread.currentThread().interrupt();
                } catch (Throwable throwable) {
                    throwable.printStackTrace(System.out);
                } finally {
                    if (poll != null) {
                        /*當然任務執行完成後*/
                        queue.runEnd(poll);
                    }
                }
            }
        }

    }

}

 

我們用三個執行緒測試一下，在沒有排隊情況下執行輸出

 我們可以看到三個任務分別有三個執行緒執行了；

接下來我們在佇列裡面再額外加入三個登入排隊佇列

        queue.add(new TyEvent(QueueKey.Login) {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getId() + ", Login 1");
            }
        });
        queue.add(new TyEvent(QueueKey.Login) {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getId() + ", Login 2");
            }
        });
        queue.add(new TyEvent(QueueKey.Login) {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getId() + ", Login 3");
            }
        });

 

再看看輸出情況，

很明顯的可以看到我們加入到登入佇列的任務，又同一個執行緒順序執行的；

總結

排隊佇列就是為了讓同一型別任務順序執行或者叫多工操作同一個物件的時候減少加鎖 帶來的額外開銷，減少執行緒等待的時間；

更合理的利用的執行緒。避免澇的澇死，旱的旱死；

我要訂一個小目標