Sure thing. The trick is to give each thread a fixed priority band and let the scheduler run only one per band at a time. That way you get determinism—no race on the priority queue. Keep the scheduler logic in a single small module, expose a clear API for the kernel modules, and use lock-free queues for the work items. Then just rely on atomic ops for the counters. It stays clean, and you avoid the usual contention headaches.

A good lock‑free queue for this is a single‑producer single‑consumer ring buffer with atomic head/tail indexes. Use a power‑of‑two size, mask the indices, and make the buffer slots hold a pointer to the work item. The producer just writes the item, bumps the head with a relaxed atomic store, and the consumer reads from tail, bumps tail with a relaxed store. No locks, no CAS loops, just a few atomic ops. If you want multi‑producer, switch to a Michael‑Scott lock‑free queue and use compare‑and‑swap on the tail pointer, but that adds a little overhead. The key is keeping the data structure tiny so it fits in cache lines and avoiding false sharing.