diff --git a/lophine-server/src/main/java/fun/bm/lophine/utils/concurrent/AbstractConcurrentTable.java b/lophine-server/src/main/java/fun/bm/lophine/utils/concurrent/AbstractConcurrentTable.java
new file mode 100644
index 0000000..ee3c40f
--- /dev/null
+++ b/lophine-server/src/main/java/fun/bm/lophine/utils/concurrent/AbstractConcurrentTable.java
@@ -0,0 +1,36 @@
+package fun.bm.lophine.utils.concurrent;
+
+import java.util.List;
+import java.util.Map;
+
+public abstract class AbstractConcurrentTable<X, Y, Z> {
+    public abstract void put(X x, Y y, Z z);
+
+    public abstract void remove(X x, Y y, Z z);
+
+    public abstract List<Z> getZ(X x, Y y);
+
+    public abstract List<Y> getY(X x, Z z);
+
+    public abstract List<X> getX(Y y, Z z);
+
+    public abstract Map<X, Y> getXY(Z z);
+
+    public abstract Map<Y, Z> getYZ(X x);
+
+    public abstract Map<X, Z> getXZ(Y y);
+
+    public abstract List<X> getAllX();
+
+    public abstract List<Y> getAllY();
+
+    public abstract List<Z> getAllZ();
+
+    public abstract void clearXY(Z z);
+
+    public abstract void clearYZ(X x);
+
+    public abstract void clearXZ(Y y);
+
+    public abstract void clearAll();
+}
diff --git a/lophine-server/src/main/java/fun/bm/lophine/utils/concurrent/ConcurrentTable.java b/lophine-server/src/main/java/fun/bm/lophine/utils/concurrent/ConcurrentTable.java
new file mode 100644
index 0000000..0b350e1
--- /dev/null
+++ b/lophine-server/src/main/java/fun/bm/lophine/utils/concurrent/ConcurrentTable.java
@@ -0,0 +1,182 @@
+package fun.bm.lophine.utils.concurrent;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentLinkedDeque;
+import java.util.function.Predicate;
+
+public class ConcurrentTable<X, Y, Z> extends AbstractConcurrentTable<X, Y, Z> {
+    protected final ConcurrentLinkedDeque<TableEntry<X, Y, Z>> data = new ConcurrentLinkedDeque<>();
+    protected final boolean flagX;
+    protected final boolean flagY;
+    protected final boolean flagZ;
+
+    public ConcurrentTable() {
+        this(false, false, false);
+    }
+
+    public ConcurrentTable(boolean flagX, boolean flagY, boolean flagZ) {
+        this.flagX = flagX;
+        this.flagY = flagY;
+        this.flagZ = flagZ;
+    }
+
+    @Override
+    public void put(X x, Y y, Z z) {
+        put(x, y, z, false);
+    }
+
+    public void put(X x, Y y, Z z, boolean flag) {
+        if (!flag) {
+            if (flagX) {
+                List<X> datas = getX(y, z);
+                for (X x1 : datas) {
+                    if (!x1.equals(x)) {
+                        remove(x1, y, z);
+                    }
+                }
+            }
+            if (flagY) {
+                List<Y> datas = getY(x, z);
+                for (Y y1 : datas) {
+                    if (!y1.equals(y)) {
+                        remove(x, y1, z);
+                    }
+                }
+            }
+            if (flagZ) {
+                List<Z> datas = getZ(x, y);
+                for (Z z1 : datas) {
+                    if (!z1.equals(z)) {
+                        remove(x, y, z1);
+                    }
+                }
+            }
+        }
+        data.add(new TableEntry<>(x, y, z));
+    }
+
+    @Override
+    public void remove(X x, Y y, Z z) {
+        data.removeIf(entry -> entry.getX().equals(x) && entry.getY().equals(y) && entry.getZ().equals(z));
+    }
+
+    @Override
+    public List<Z> getZ(X x, Y y) {
+        return filterAndCollect(
+                entry -> entry.getX().equals(x) && entry.getY().equals(y),
+                TableEntry::getZ
+        );
+    }
+
+    @Override
+    public List<Y> getY(X x, Z z) {
+        return filterAndCollect(
+                entry -> entry.getX().equals(x) && entry.getZ().equals(z),
+                TableEntry::getY
+        );
+    }
+
+    @Override
+    public List<X> getX(Y y, Z z) {
+        return filterAndCollect(
+                entry -> entry.getY().equals(y) && entry.getZ().equals(z),
+                TableEntry::getX
+        );
+    }
+
+    @Override
+    public Map<X, Y> getXY(Z z) {
+        return filterAndMap(
+                entry -> entry.getZ().equals(z),
+                TableEntry::getX,
+                TableEntry::getY
+        );
+    }
+
+    @Override
+    public Map<Y, Z> getYZ(X x) {
+        return filterAndMap(
+                entry -> entry.getX().equals(x),
+                TableEntry::getY,
+                TableEntry::getZ
+        );
+    }
+
+    @Override
+    public Map<X, Z> getXZ(Y y) {
+        return filterAndMap(
+                entry -> entry.getY().equals(y),
+                TableEntry::getX,
+                TableEntry::getZ
+        );
+    }
+
+    @Override
+    public List<X> getAllX() {
+        return collectAll(TableEntry::getX);
+    }
+
+    @Override
+    public List<Y> getAllY() {
+        return collectAll(TableEntry::getY);
+    }
+
+    @Override
+    public List<Z> getAllZ() {
+        return collectAll(TableEntry::getZ);
+    }
+
+    @Override
+    public void clearXY(Z z) {
+        data.removeIf(entry -> entry.getZ().equals(z));
+    }
+
+    @Override
+    public void clearYZ(X x) {
+        data.removeIf(entry -> entry.getX().equals(x));
+    }
+
+    @Override
+    public void clearXZ(Y y) {
+        data.removeIf(entry -> entry.getY().equals(y));
+    }
+
+    @Override
+    public void clearAll() {
+        data.clear();
+    }
+
+    private <T> List<T> filterAndCollect(Predicate<TableEntry<X, Y, Z>> filter,
+                                         java.util.function.Function<TableEntry<X, Y, Z>, T> mapper) {
+        List<T> result = new ArrayList<>();
+        for (TableEntry<X, Y, Z> entry : data) {
+            if (filter.test(entry)) {
+                result.add(mapper.apply(entry));
+            }
+        }
+        return result;
+    }
+
+    private <K, V> Map<K, V> filterAndMap(Predicate<TableEntry<X, Y, Z>> filter,
+                                          java.util.function.Function<TableEntry<X, Y, Z>, K> keyMapper,
+                                          java.util.function.Function<TableEntry<X, Y, Z>, V> valueMapper) {
+        Map<K, V> map = new HashMap<>();
+        for (TableEntry<X, Y, Z> entry : data) {
+            if (filter.test(entry)) {
+                map.put(keyMapper.apply(entry), valueMapper.apply(entry));
+            }
+        }
+        return map;
+    }
+
+    private <T> List<T> collectAll(java.util.function.Function<TableEntry<X, Y, Z>, T> mapper) {
+        List<T> result = new ArrayList<>();
+        for (TableEntry<X, Y, Z> entry : data) {
+            result.add(mapper.apply(entry));
+        }
+        return result;
+    }
+}
diff --git a/lophine-server/src/main/java/fun/bm/lophine/utils/concurrent/OptimizedConcurrentTable.java b/lophine-server/src/main/java/fun/bm/lophine/utils/concurrent/OptimizedConcurrentTable.java
new file mode 100644
index 0000000..2b701fa
--- /dev/null
+++ b/lophine-server/src/main/java/fun/bm/lophine/utils/concurrent/OptimizedConcurrentTable.java
@@ -0,0 +1,207 @@
+package fun.bm.lophine.utils.concurrent;
+
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+public class OptimizedConcurrentTable<X, Y, Z> extends ConcurrentTable<X, Y, Z> {
+    private final ConcurrentHashMap<X, ConcurrentHashMap<Y, Set<Z>>> xyIndex = new ConcurrentHashMap<>();
+    private final ConcurrentHashMap<Y, ConcurrentHashMap<Z, Set<X>>> yzIndex = new ConcurrentHashMap<>();
+    private final ConcurrentHashMap<Z, ConcurrentHashMap<X, Set<Y>>> zxIndex = new ConcurrentHashMap<>();
+
+    public OptimizedConcurrentTable() {
+        super();
+    }
+
+    public OptimizedConcurrentTable(boolean flagX, boolean flagY, boolean flagZ) {
+        super(flagX, flagY, flagZ);
+    }
+
+    @Override
+    public void put(X x, Y y, Z z) {
+        if (flagX) {
+            List<X> datas = getX(y, z);
+            for (X x1 : datas) {
+                if (!x1.equals(x)) {
+                    remove(x1, y, z);
+                }
+            }
+        }
+        if (flagY) {
+            List<Y> datas = getY(x, z);
+            for (Y y1 : datas) {
+                if (!y1.equals(y)) {
+                    remove(x, y1, z);
+                }
+            }
+        }
+        if (flagZ) {
+            List<Z> datas = getZ(x, y);
+            for (Z z1 : datas) {
+                if (!z1.equals(z)) {
+                    remove(x, y, z1);
+                }
+            }
+        }
+        super.put(x, y, z, true);
+        xyIndex.computeIfAbsent(x, k -> new ConcurrentHashMap<>())
+                .computeIfAbsent(y, k -> ConcurrentHashMap.newKeySet()).add(z);
+        yzIndex.computeIfAbsent(y, k -> new ConcurrentHashMap<>())
+                .computeIfAbsent(z, k -> ConcurrentHashMap.newKeySet()).add(x);
+        zxIndex.computeIfAbsent(z, k -> new ConcurrentHashMap<>())
+                .computeIfAbsent(x, k -> ConcurrentHashMap.newKeySet()).add(y);
+    }
+
+    @Override
+    public void remove(X x, Y y, Z z) {
+        super.remove(x, y, z);
+        removeFromIndex(xyIndex, x, y, z);
+        removeFromIndex(yzIndex, y, z, x);
+        removeFromIndex(zxIndex, z, x, y);
+    }
+
+    private <K, V, T> void removeFromIndex(ConcurrentHashMap<K, ConcurrentHashMap<V, Set<T>>> index,
+                                           K key1, V key2, T value) {
+        index.computeIfPresent(key1, (k, map) -> {
+            map.computeIfPresent(key2, (k2, set) -> {
+                set.remove(value);
+                return set.isEmpty() ? null : set;
+            });
+            return map.isEmpty() ? null : map;
+        });
+    }
+
+    public void removeAll(Predicate<TableEntry<X, Y, Z>> predicate) {
+        data.removeIf(entry -> {
+            boolean shouldRemove = predicate.test(entry);
+            if (shouldRemove) {
+                removeFromIndex(xyIndex, entry.getX(), entry.getY(), entry.getZ());
+                removeFromIndex(yzIndex, entry.getY(), entry.getZ(), entry.getX());
+                removeFromIndex(zxIndex, entry.getZ(), entry.getX(), entry.getY());
+            }
+            return shouldRemove;
+        });
+    }
+
+    public boolean putIfAbsent(X x, Y y, Z z) {
+        if (data.stream().anyMatch(entry ->
+                Objects.equals(entry.getX(), x) &&
+                        Objects.equals(entry.getY(), y) &&
+                        Objects.equals(entry.getZ(), z))) {
+            return false;
+        }
+        put(x, y, z);
+        return true;
+    }
+
+    @Override
+    public List<Z> getZ(X x, Y y) {
+        Set<Z> result = xyIndex.getOrDefault(x, new ConcurrentHashMap<>()).get(y);
+        return result != null ? new ArrayList<>(result) : new ArrayList<>();
+    }
+
+    @Override
+    public List<Y> getY(X x, Z z) {
+        Set<Y> result = zxIndex.getOrDefault(z, new ConcurrentHashMap<>()).get(x);
+        return result != null ? new ArrayList<>(result) : new ArrayList<>();
+    }
+
+    public List<X> getX(Y y, Z z) {
+        Set<X> result = yzIndex.getOrDefault(y, new ConcurrentHashMap<>()).get(z);
+        return result != null ? new ArrayList<>(result) : new ArrayList<>();
+    }
+
+    @Override
+    public Map<X, Y> getXY(Z z) {
+        return buildMapFromIndex(zxIndex.get(z), Function.identity(), Function.identity());
+    }
+
+    @Override
+    public Map<Y, Z> getYZ(X x) {
+        return buildMapFromIndex(xyIndex.get(x), Function.identity(), Function.identity());
+    }
+
+    @Override
+    public Map<X, Z> getXZ(Y y) {
+        return reverseMapFromIndex(yzIndex.get(y));
+    }
+
+    @Override
+    public List<X> getAllX() {
+        Set<X> resultSet = new HashSet<>(xyIndex.keySet());
+        return new ArrayList<>(resultSet);
+    }
+
+    @Override
+    public List<Y> getAllY() {
+        Set<Y> resultSet = new HashSet<>(yzIndex.keySet());
+        return new ArrayList<>(resultSet);
+    }
+
+    @Override
+    public List<Z> getAllZ() {
+        Set<Z> resultSet = new HashSet<>(zxIndex.keySet());
+        return new ArrayList<>(resultSet);
+    }
+
+
+    @Override
+    public void clearXY(Z z) {
+        super.clearXY(z);
+        zxIndex.remove(z);
+    }
+
+    @Override
+    public void clearYZ(X x) {
+        super.clearYZ(x);
+        xyIndex.remove(x);
+    }
+
+    @Override
+    public void clearXZ(Y y) {
+        super.clearXZ(y);
+        yzIndex.remove(y);
+    }
+
+    @Override
+    public void clearAll() {
+        super.clearAll();
+        xyIndex.clear();
+        yzIndex.clear();
+        zxIndex.clear();
+    }
+
+
+    private <K, V, R, S> Map<R, S> buildMapFromIndex(ConcurrentHashMap<K, Set<V>> indexMap, java.util.function.Function<K, R> keyMapper, java.util.function.Function<V, S> valueMapper) {
+        Map<R, S> result = new HashMap<>();
+        if (indexMap != null) {
+            for (Map.Entry<K, Set<V>> entry : indexMap.entrySet()) {
+                K key = entry.getKey();
+                Set<V> valueSet = entry.getValue();
+                if (valueSet != null && !valueSet.isEmpty()) {
+                    for (V value : valueSet) {
+                        result.put(keyMapper.apply(key), valueMapper.apply(value));
+                    }
+                }
+            }
+        }
+        return result;
+    }
+
+    private <K, V> Map<V, K> reverseMapFromIndex(ConcurrentHashMap<K, Set<V>> indexMap) {
+        Map<V, K> result = new HashMap<>();
+        if (indexMap != null) {
+            for (Map.Entry<K, Set<V>> entry : indexMap.entrySet()) {
+                K key = entry.getKey();
+                Set<V> valueSet = entry.getValue();
+                if (valueSet != null && !valueSet.isEmpty()) {
+                    for (V value : valueSet) {
+                        result.put(value, key);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+}
diff --git a/lophine-server/src/main/java/fun/bm/lophine/utils/concurrent/TableEntry.java b/lophine-server/src/main/java/fun/bm/lophine/utils/concurrent/TableEntry.java
new file mode 100644
index 0000000..391ee37
--- /dev/null
+++ b/lophine-server/src/main/java/fun/bm/lophine/utils/concurrent/TableEntry.java
@@ -0,0 +1,25 @@
+package fun.bm.lophine.utils.concurrent;
+
+public class TableEntry<X, Y, Z> {
+    private final X x;
+    private final Y y;
+    private final Z z;
+
+    public TableEntry(X x, Y y, Z z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+
+    public X getX() {
+        return x;
+    }
+
+    public Y getY() {
+        return y;
+    }
+
+    public Z getZ() {
+        return z;
+    }
+}
diff --git a/lophine-server/src/main/java/org/leavesmc/leaves/protocol/servux/ServuxHudDataProtocol.java b/lophine-server/src/main/java/org/leavesmc/leaves/protocol/servux/ServuxHudDataProtocol.java
index 68aa759..bd25228 100644
--- a/lophine-server/src/main/java/org/leavesmc/leaves/protocol/servux/ServuxHudDataProtocol.java
+++ b/lophine-server/src/main/java/org/leavesmc/leaves/protocol/servux/ServuxHudDataProtocol.java
@@ -17,11 +17,10 @@
 
 package org.leavesmc.leaves.protocol.servux;
 
-import com.google.common.collect.HashBasedTable;
-import com.google.common.collect.Table;
-import com.google.common.collect.Tables;
 import com.mojang.serialization.DataResult;
 import fun.bm.lophine.config.modules.function.protocol.ServuxProtocolConfig;
+import fun.bm.lophine.utils.concurrent.AbstractConcurrentTable;
+import fun.bm.lophine.utils.concurrent.OptimizedConcurrentTable;
 import io.netty.buffer.Unpooled;
 import net.minecraft.core.BlockPos;
 import net.minecraft.nbt.CompoundTag;
@@ -59,7 +58,7 @@ public class ServuxHudDataProtocol implements LeavesProtocol {
 
     private static final Map<ServerPlayer, List<DataLogger.Type>> loggerPlayers = new ConcurrentHashMap<>();
     private static final Map<DataLogger.Type, DataLogger<?>> LOGGERS = new ConcurrentHashMap<>();
-    private static final Table<DataLogger.Type, ServerPlayer, Tag> DATA = Tables.synchronizedTable(HashBasedTable.create());
+    private static final AbstractConcurrentTable<DataLogger.Type, ServerPlayer, Tag> DATA = new OptimizedConcurrentTable<>(false, false, true);
 
     public static boolean refreshSpawnMetadata = false;
 
@@ -85,7 +84,7 @@ public class ServuxHudDataProtocol implements LeavesProtocol {
     private static void onPlayerLeave(ServerPlayer player) {
         players.remove(player);
         loggerPlayers.remove(player);
-        DATA.rowMap().values().forEach(row -> row.remove(player));
+        DATA.clearXZ(player);
     }
 
     @ProtocolHandler.PayloadReceiver(payload = HudDataPayload.class)
@@ -260,10 +259,12 @@ public class ServuxHudDataProtocol implements LeavesProtocol {
         loggerPlayers.forEach((player, list) -> {
             CompoundTag nbt = new CompoundTag();
             for (DataLogger.Type type : list) {
-                Tag data = DATA.get(type, player);
+                List<Tag> data0 = DATA.getZ(type, player);
+                if (data0.isEmpty()) continue;
+                Tag data = data0.getFirst();
                 if (data != null) {
                     nbt.put(type.getSerializedName(), data);
-                    DATA.remove(type, player);
+                    DATA.remove(type, player, data);
                 }
             }
             if (!nbt.isEmpty()) {