131 lines
3.1 KiB
Java
131 lines
3.1 KiB
Java
package DataStructures.Buffers;
|
|
|
|
import java.util.Random;
|
|
import java.util.concurrent.atomic.AtomicInteger;
|
|
|
|
public class CircularBuffer {
|
|
private char[] _buffer;
|
|
public final int _buffer_size;
|
|
private int _write_index = 0;
|
|
private int _read_index = 0;
|
|
private AtomicInteger _readable_data = new AtomicInteger(0);
|
|
|
|
public CircularBuffer(int buffer_size) {
|
|
if (!IsPowerOfTwo(buffer_size)) {
|
|
throw new IllegalArgumentException();
|
|
}
|
|
this._buffer_size = buffer_size;
|
|
_buffer = new char[buffer_size];
|
|
}
|
|
|
|
private boolean IsPowerOfTwo(int i) {
|
|
return (i & (i - 1)) == 0;
|
|
}
|
|
|
|
private int getTrueIndex(int i) {
|
|
return i % _buffer_size;
|
|
}
|
|
|
|
public Character readOutChar() {
|
|
Character result = null;
|
|
|
|
// if we have data to read
|
|
if (_readable_data.get() > 0) {
|
|
|
|
result = Character.valueOf(_buffer[getTrueIndex(_read_index)]);
|
|
_readable_data.decrementAndGet();
|
|
_read_index++;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public boolean writeToCharBuffer(char c) {
|
|
boolean result = false;
|
|
|
|
// if we can write to the buffer
|
|
if (_readable_data.get() < _buffer_size) {
|
|
// write to buffer
|
|
_buffer[getTrueIndex(_write_index)] = c;
|
|
_readable_data.incrementAndGet();
|
|
_write_index++;
|
|
result = true;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static class TestWriteWorker implements Runnable {
|
|
String _alphabet = "abcdefghijklmnopqrstuvwxyz0123456789";
|
|
Random _random = new Random();
|
|
CircularBuffer _buffer;
|
|
|
|
public TestWriteWorker(CircularBuffer cb) {
|
|
this._buffer = cb;
|
|
}
|
|
|
|
private char getRandomChar() {
|
|
return _alphabet.charAt(_random.nextInt(_alphabet.length()));
|
|
}
|
|
|
|
public void run() {
|
|
while (!Thread.interrupted()) {
|
|
if (!_buffer.writeToCharBuffer(getRandomChar())) {
|
|
Thread.yield();
|
|
try {
|
|
Thread.sleep(10);
|
|
} catch (InterruptedException e) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static class TestReadWorker implements Runnable {
|
|
CircularBuffer _buffer;
|
|
|
|
public TestReadWorker(CircularBuffer cb) {
|
|
this._buffer = cb;
|
|
}
|
|
|
|
@Override
|
|
public void run() {
|
|
System.out.println("Printing Buffer:");
|
|
while (!Thread.interrupted()) {
|
|
Character c = _buffer.readOutChar();
|
|
if (c != null) {
|
|
System.out.print(c.charValue());
|
|
} else {
|
|
Thread.yield();
|
|
try {
|
|
Thread.sleep(10);
|
|
} catch (InterruptedException e) {
|
|
System.out.println();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void main(String[] args) throws InterruptedException {
|
|
int buffer_size = 1024;
|
|
// create circular buffer
|
|
CircularBuffer cb = new CircularBuffer(buffer_size);
|
|
|
|
// create threads that read and write the buffer.
|
|
Thread write_thread = new Thread(new TestWriteWorker(cb));
|
|
Thread read_thread = new Thread(new TestReadWorker(cb));
|
|
read_thread.start();
|
|
write_thread.start();
|
|
|
|
// wait some amount of time
|
|
Thread.sleep(10000);
|
|
|
|
// interrupt threads and exit
|
|
write_thread.interrupt();
|
|
read_thread.interrupt();
|
|
}
|
|
}
|