Limit Order Exchange

Overview

A high-performance limit order exchange implementation that processes buy and sell orders with price-time priority matching. This project demonstrates core concepts of building trading systems used in stock exchanges and cryptocurrency platforms.

Key Features

• Order Matching Engine: Implements efficient price-time priority algorithm
• Order Book Management: Maintains separate buy and sell order books
• Real-time Processing: Low-latency order execution
• Order Types: Supports limit orders with potential for market orders

Technical Implementation

Order Book Structure

The order book uses a sorted data structure to maintain orders at each price level:

public class OrderBook {
    private final TreeMap<BigDecimal, Queue<Order>> buyOrders;
    private final TreeMap<BigDecimal, Queue<Order>> sellOrders;

    public OrderBook() {
        this.buyOrders = new TreeMap<>(Comparator.reverseOrder());
        this.sellOrders = new TreeMap<>();
    }
}

Matching Algorithm

Orders are matched using price-time priority:

1. Best price gets matched first
2. At the same price, earlier orders get priority
3. Partial fills are supported

Architecture

The system follows a clean architecture pattern:

• Domain Layer: Core order and trade entities
• Service Layer: Order matching and book management
• API Layer: REST endpoints for order submission

Performance Considerations

• Lock-free data structures where possible
• Efficient memory allocation
• Minimal garbage collection pressure

Lessons Learned

Building this exchange taught me the importance of:

• Precise decimal handling for financial calculations
• Atomic operations for concurrent order processing
• Comprehensive testing for edge cases in matching logic