tạo bộ nhớ cache của mảng byte

Question

Trong mã của tôi, thường chạy trên máy chủ, tôi không kiểm soát cấu hình, tôi có bộ sưu tập người dùng và mỗi người dùng có một mảng byte[].

Đôi khi các mảng byte[] này là duy nhất cho người dùng. Thông thường, mặc dù, sẽ có số lượng người dùng lớn với cùng một mảng byte[].

Tôi đang cố giảm mức tiêu thụ RAM của máy chủ.

Tôi đã thử biến các mảng byte[] thành chuỗi và thực hiện chúng, nhưng sau đó tôi thường gặp phải lỗi ngoài bộ nhớ PERM-GEN. Tôi cũng thấy một sự suy giảm hiệu suất đáng kể với mã hóa/giải mã khi tôi muốn truy cập mảng byte[] cho người dùng và tôi thấy việc sử dụng bộ nhớ có mức độ tệ hơn nhiều - các chuỗi presuambly lớn hơn nhiều so với mảng.

Làm cách nào tôi có thể tra cứu Set<SoftReference<byte[]>> khi mảng Java không được băm và SoftReferences không bao hàm giá trị băm của đối tượng tại một trong hai điểm. Một Map<byte[],SoftReference<byte[]>> rõ ràng là cũng đánh bại chính nó bởi vì chính là chính nó và ngăn cản việc thu thập; và Set được triển khai nội bộ theo số Map.

Vậy làm cách nào tôi có thể thực tậpbyte[] mảng?

Answer 1

Nếu bạn có nhiều mảng giống hệt nhau, hãy sử dụng một bộ nhớ cache HashSet<ByteBuffer>. Bạn có thể nhận mảng ByteBuffer với phương thức array() và lớp ByteBuffer có các phương thức hashCode và equals. Tất nhiên nó là tốt hơn nếu mảng của bạn là không thay đổi.

EDIT2 Các bình luận từ @ Will là chính xác, để có thể trở lại mảng, sử dụng một WeakHashMap<ByteBuffer,WeakReference<ByteBuffer>> và làm điều gì đó như thế:

public byte[] internalize(byte[] bytes) { 
ByteBuffer wrapped = ByteBuffer.wrap(bytes); 
if(cache.containsKey(wrapped)) { 
    wrapped = cache.get(wrapped).get(); 
} 
else { 
    cache.put(wrapped, new WeakReference<ByteBuffer>(wrapped); 
} 
return wrapped.array(); 
} 

Answer 2

Tôi đã thử chuyển byte của tôi [ ] mảng thành chuỗi và thực hiện chúng, nhưng sau đó tôi thường chạy vào các lỗi ngoài bộ nhớ PERM-GEN.

Tôi đồng ý rằng bạn cần một cái gì đó như String.intern(), nhưng việc triển khai chuẩn là native, vì vậy không có nhiều niềm vui.

Bạn có thể có một Map<Integer,Collection<SoftReference<byte[]>>>, sử dụng mã băm của mảng byte làm khóa Map. Phương pháp intern của bạn sau đó có thể tra cứu tập hợp các mảng byte hiện có với cùng một mã có các mảng byte đã cho. Với một mã băm tốt nên cung cấp cho một bộ nhỏ của mảng để kiểm tra cho một trận đấu.

---

Chỉnh sửa: Để làm rõ:

Something như thế này:

class ByteArrayCache 
{ 
     private final Map<Integer,Collection<SoftReference<byte[]>> map = new ...; 

     public final byte[] intern(byte[] byteArray) 
     { 
      final int hash = Arrays.hashCode(byteArray); 
      final Collection<SoftReference<byte[]>> arrays = map.get(hash); 
      if (arrays != null) { 
       // Search through arrays for a match, and return the match. 
       // If no match found, add byteArray to the collection and return it 
      } else { 
       // create a new map entry, add byteArray to it, and return byte array 
      } 
     } 
} 

Answer 3

tôi sẽ thực hiện một bộ nhớ cache dựa trên Ổi bản đồ giá trị yếu. Nó đảm bảo rằng nếu không có tham chiếu mạnh mẽ hơn đến mảng byte, mục nhập sẽ tự động bị xóa.

class Cache { 
    private final ConcurrentMap<Key, byte[]> map = new MapMaker().weakValues().makeMap(); 

    private static class Key { 
     byte[] a; 
     int hash; 

     Key(byte[] a) { 
      this.a = a; 
      hash = Arrays.hashCode(a); 
     } 

     @Override 
     public int hashCode() { 
      return hash; 
     } 

     @Override 
     public boolean equals(Object obj) { 
      if (obj instanceof Key) { 
       return Arrays.equals(a, ((Key) obj).a); 
      } 
      return false; 
     } 
    } 

    public byte[] intern(byte[] a) { 
     byte[] a1 = map.putIfAbsent(new Key(a), a); 
     if (a1 != null) { 
      return a1; 
     } 
     return a; 
    } 
}