Сценарій інтерв’ю „Останні 100 байт”

Я отримав це запитання в інтерв’ю днями і хотів би знати найкращі можливі відповіді (я відповів не дуже добре ха-ха):

Сценарій: Існує веб-сторінка, яка контролює байти, надіслані через певну мережу. Щоразу, коли байт надсилається, функція recordByte () називається передачею цього байта, це може відбуватися сотні тисяч разів на день. На цій сторінці є кнопка, яка при натисканні відображає на екрані останні 100 байтів, переданих RecordByte () (це робиться за допомогою методу друку нижче).

Наступний код - це те, що мені дали і попросили заповнити:

public class networkTraffic {
    public void recordByte(Byte b){
    }
    public String print() {
    }
}

Який найкращий спосіб зберігати 100 байт? Список? Цікаво, як краще це зробити.

Щось на зразок цього ( круговий буфер ):

byte[] buffer = new byte[100];
int index = 0;

public void recordByte(Byte b) {
   index = (index + 1) % 100;
   buffer[index] = b; 
}

public void print() {
   for(int i = index; i < index + 100; i++) {
       System.out.print(buffer[i % 100]);
   }
}

Переваги використання кругового буфера:

1. Ви можете зарезервувати простір статично. У мережевій програмі в режимі реального часу (VoIP, потокове передавання тощо) це часто робиться, оскільки вам не потрібно зберігати всі дані передачі, а лише вікно, що містить нові байти, які підлягають обробці.
2. Це швидко: може бути реалізовано з масивом із вартістю читання та запису O (1).

Я не знаю Java, але повинна існувати концепція черги, згідно з якою ви б ставили байти в чергу, поки кількість елементів у черзі не досягла 100, після чого ви виведете з байта один байт, а потім поставте в чергу інший.

public void recordByte(Byte b)
{ 
  if (queue.ItemCount >= 100)
  {
    queue.dequeue();    
  }
  queue.enqueue(b);
}

Ви можете надрукувати, зазирнувши до елементів:

public String print() 
{ 
  foreach (Byte b in queue)
  {
    print("X", b);  // some hexadecimal print function
  }
}  

Круговий буфер з використанням масиву:

1. Масив 100 байт
2. Відстежуйте, де знаходиться головний індекс i
3. Для recordByte()покласти поточний байт в A [i] і i = i + 1% 100;
4. Для print()повернення підмасиву (i + 1, 100) об'єднується з підмасивом (0, i)

Черга за допомогою пов’язаного списку (або Черги Java):

1. Для recordByte()додавання нового байта до кінця
2. Якщо нова довжина більше 100, видаліть перший елемент
3. Для print()просто роздрукувати список

Ось мій код. Це може виглядати трохи неясно, але я впевнений, що це найшвидший спосіб це зробити (принаймні, це було б у C ++, я не дуже впевнений у Java):

public class networkTraffic {
    public networkTraffic() {
      _ary = new byte[100];
      _idx = _ary.length;
    }

    public void recordByte(Byte b){
      _ary[--_idx] = b;
      if (_idx == 0) {
        _idx = _ary.length;
      }   
    }

    private int _idx;
    private byte[] _ary;
}

Деякі зауваження:

• Під час виклику recordByte () дані не виділяються / звільняються.
• Я не використовував%, оскільки це повільніше, ніж пряме порівняння та використання if (прогнозування гілок також може тут допомогти)
• --_idxшвидше, ніж _idx--через відсутність тимчасової змінної.
• Я рахую назад до 0, тому що тоді мені не потрібно отримувати _ary.lengthкожен раз у дзвінку, а лише кожні 100 разів, коли досягається перший запис. Можливо, це не потрібно, компілятор міг про це подбати.
• якщо до recordByte () було менше 100 дзвінків, решта - нулі.

Найпростіше - запихати його в масив. Максимальний розмір, який може вмістити масив, становить 100 байт. Продовжуйте додавати байти, коли вони витікають з Інтернету. Після того, як перші 100 байтів знайдуться в масиві, коли прийде 101-й байт, видаліть байт на початку (тобто 0-й). Продовжуйте це робити. В основному це черга. Концепція FIFO. Після завершення завантаження у вас залишиться останні 100 байт.

Не тільки після завантаження, але в будь-який момент часу цей масив матиме останні 100 байт.

@Yottagray Не знаходишся там, де проблема? Здається, існує низка загальних підходів (масив, круговий масив тощо) та ряд мовних підходів (byteArray тощо). Мені чогось не вистачає?

Багатопотокове рішення з неблокуючим введенням / виведенням:

private static final int N = 100;
private volatile byte[] buffer1 = new byte[N];
private volatile byte[] buffer2 = new byte[N];
private volatile int index = -1;
private volatile int tag;

synchronized public void recordByte(byte b) {
  index++;
  if (index == N * 2) {
    //both buffers are full
    buffer1 = buffer2;
    buffer2 = new byte[N];
    index = N;
  }
  if (index < N) {
    buffer1[index] = b;
  } else { 
    buffer2[index - N] = b;
  }
}

public void print() {
  byte[] localBuffer1, localBuffer2;
  int localIndex, localTag;
  synchronized (this) {
   localBuffer1 = buffer1;
   localBuffer2 = buffer2;
   localIndex = index;
   localTag = tag++;
  }
  int buffer1Start = localIndex - N >= 0 ? localIndex - N + 1 : 0;
  int buffer1End = localIndex < N ? localIndex : N - 1;      
  printSlice(localBuffer1, buffer1Start, buffer1End, localTag);
  if (localIndex >= N) {
    printSlice(localBuffer2, 0, localIndex - N, localTag);
  }
}

private void printSlice(byte[] buffer, int start, int end, int tag) {
  for(int i = start; i <= end; i++) {
    System.out.println(tag + ": "+ buffer[i]);
  }
}

Просто на біс. Як щодо використання ArrayList<Byte>? Скажіть, чому ні?

public class networkTraffic {
    static ArrayList<Byte> networkMonitor;          // ArrayList<Byte> reference
    static { networkMonitor = new ArrayList<Byte>(100); }   // Static Initialization Block
    public void recordByte(Byte b){
        networkMonitor.add(b);
        while(networkMonitor.size() > 100){
            networkMonitor.remove(0);
        }
    }
    public void print() {
        for (int i = 0; i < networkMonitor.size(); i++) {
            System.out.println(networkMonitor.get(i));
        }
        // if(networkMonitor.size() < 100){
        //  for(int i = networkMonitor.size(); i < 100; i++){
        //      System.out.println("Emtpy byte");
        //  }
        // }
    }
}