캐 시 란 무엇 입 니까?

  • 하드웨어 캐 시?cpu 캐 시: cpu 와 메모리 사이 에 있 는 임시 메모리
  • 소프트웨어 캐 시?소프트웨어 캐 시 는 3 급 으로 나 뉜 다.
  • 메모리 캐 시 (용기 (list, map, set) 등 데이터 저장 장치 에 미리 데 이 터 를 기록 하 는 것 이 소프트웨어 메모리 캐 시)
  • 데이터베이스 캐 시
  • 네트워크 캐 시
  • 메모리 캐 시 도태 체 제 는 세 가지 로 나 뉜 다.
  • FIFO (First In, First Out) 의 선진 적 인 장점 은 선진 적 으로 먼저 나 온 데이터 버퍼 이다. 그 는 일반 메모리 와 다른 점 은 외부 읽 기와 쓰기 주소 선 이 없다 는 것 이다. 이렇게 사용 하면 매우 간단 하 다.단점: 데 이 터 를 순서대로 쓸 수 있 고 순서대로 데 이 터 를 읽 을 수 있 습 니 다. 그 데이터 주 소 는 내부 읽 기와 쓰기 지침 에 의 해 자동 으로 1 을 추가 하여 완성 되 며 일반 메모리 처럼 주소 선 에 의 해 지정 한 주 소 를 읽 거나 쓸 수 없습니다
  • .
  • LFU (Least Freauently Used) 는 페이지 교체 알고리즘 을 가장 자주 사용 하지 않 고 자주 사용 하 는 것 을 지 웁 니 다
  • LRU (Least Recently Used) 는 오래된 메모리 관 리 를 좋아 하 는 페이지 교체 알고리즘 으로 새로 추 가 된 데 이 터 를 링크 의 머리 에 넣 고 캐 시 명중 (접근) 데이터 가 링크 의 머리 로 이동 하면 링크 가 가득 찼 을 때 링크 끝의 데 이 터 를 버 립 니 다.
        //   
      public class LinkedList {
      
          public LinkedList() {
              size = 0;
          }
      
          Node list;
          //        
          int size;
      
          //    
          //       
          public void add(T data) {
              Node head = list;
              Node curNode = new Node(data, list);
              list = curNode;
              size++;
      
          }
      
          //    index         
          public void add(int index, T data) {
              checkPositionIndex(index);
              Node cur = list;
              Node hrad = list;
              for (int i = 0; i < index; i++) {
                  hrad = cur;
                  cur = cur.next;
              }
              Node node = new Node(data, cur);
              hrad.next = node;
              size++;
      
          }
      
          //   index          
          public void checkPositionIndex(int index) {
              if (!(index >= 0 && index <= size)) {
                  throw new IndexOutOfBoundsException("index:" + index + ",size" + size);
              }
          }
      
          //    
          public T remove() {
              if (list != null) {
                  Node node = list;
                  list = list.next;
                  //gc
                  node.next = null;
                  size--;
                  return node.data;
              }
      
              return null;
          }
      
          public T remove(int index) {
              checkPositionIndex(index);
              Node cur = list;
              Node hrad = list;
              for (int i = 0; i < index; i++) {
                  hrad = cur;
                  cur = cur.next;
              }
              hrad.next = cur.next;
              //gc
              cur.next = null;
              size--;
              return null;
      
          }
      
          public T removeLast() {
              if (list != null) {
                  Node node = list;
                  Node cur = list;
                  while (cur.next != null) {
                      node = cur;
                      cur = cur.next;
                  }
                  //gc
                  node.next = null;
                  size--;
                  return cur.data;
              }
              return null;
          }
      
          //    
      
          public void updata(int index, T newData) {
              checkPositionIndex(index);
              Node head = list;
              for (int i = 0; i < index; i++) {
                  head = head.next;
              }
              head.data = newData;
          }
      
          //    
          public T get() {
              Node node = list;
              if (node != null) {
                  return node.data;
      
              } else {
                  return null;
              }
          }
      
          public T get(int index) {
              checkPositionIndex(index);
              Node node = list;
              for (int i = 0; i < index; i++) {
                  node = node.next;
              }
              return node.data;
          }
      
      
          class Node {
              T data;
              Node next;
      
              public Node(T data,
                          Node next) {
                  this.data = data;
                  this.next = next;
              }
          }
      
          @Override
          public String toString() {
              Node node = list;
              for (int i = 0; i < size; i++) {
                  System.out.println("" + node.data);
      
                  node = node.next;
              }
              return super.toString();
          }
      }
    
    public class LruLinhedList extends LinkedList {
    
        //            
        int memorySize;
        static final int DEFAULT_CAP = 6;
    
        public LruLinhedList() {
            this(DEFAULT_CAP);
        }
    
        public LruLinhedList(int memorySize) {
            this.memorySize = memorySize;
        }
    
        //    LRU     
        public void lruAdd(T data) {
            if (size >= memorySize) {
                removeLast();
                add(data);
            } else {
                add(data);
            }
        }
    
        //     
        public T lruRmove() {
            return removeLast();
        }
    
        public T lruGet(int index) {
            checkPositionIndex(index);
            Node node = list;
            Node pro = list;
            for (int i = 0; i < index; i++) {
                pro = node;
                node = node.next;
            }
            T reData = node.data;
            //       
            pro.next = node.next;
            Node head = list;
            node.next = head;
            list = node;
            return reData;
    
        }
    
        public static void main(String[] args) {
            LruLinhedList LinkedList = new LruLinhedList<>(6);
            for (int i = 0; i < 6; i++) {
                LinkedList.lruAdd("" + i);
            }
            LinkedList.toString();
            System.out.println("" + LinkedList.lruGet(4));
    
            LinkedList.toString();
            LinkedList.lruAdd(90+"");
            LinkedList.toString();
    //        LinkedList.lruGet(23);
    //        LinkedList.toString();
        }
    
    }
    
    

  • 좋은 웹페이지 즐겨찾기