"Turbo-Charging Java for Real-Time Applications"
Vol. 9, Issue 7, p. 32

	



Listing 1

PoolContext.enter(); // Allows for „stack‰ allocations.
try {
    ...
    ConcurrentContext.enter();
    try {
        // Concurrent executions have access to
        // the „stack‰ objects of the outer pool context.
        ConcurrentContext.execute(logic, ...);
        ConcurrentContext.execute(logic, ...);
    } finally {
        // Waits for concurrent executions to complete.
        ConcurrentContext.exit();
    }
    ...
} finally {
    // Recycles all stack objects including
    // objects allocated by concurrent threads.
    PoolContext.exit();
}

Listing 2

Matrix[] inputs = ...;
Matrix[] results = new Matrix[inputs.length];
for (int i=0; i < inputs.length; i++) {
    PoolContext.enter() {
    try {
        Matrix tmp = inputs[i].inverse();
        ... // Some function of inputs/results
        results[i] = (Matrix) tmp.export();
    } finally {
        // Recycles all temporary objects allocated.
        PoolContext.exit();
    }
}

Listing 3

// Defines UDP message internal fields.
class Message extends Struct { ... }

class MulticastConnection extends Thread {
    MulticastSocket socket;
    public void run() {
        byte[] bytes = new byte[1024];
        DatagramPacket packet
            = new DatagramPacket(bytes, bytes.length);
        Message msg = new Message(bytes);
        while (!socket.isClosed()) {
            PoolContext.enter();
            try {
                socket.receive(packet);
                ... // Process msg (real-time).
                packet.setLength(bytes.length);
            } catch (IOException ioError) {
                ... // Process error.
            } finally {
                PoolContext.exit();
            }
        }
    }
}