Multiple producer single consumer on the same thread
I took rob.earwaker's advice (thanks!), and I implemented it using a BlockingCollection. The code is much simpler now :)
class ThreadedWorker&lt;T&gt; where T : class
{
    private readonly object locker = new object();
    BlockingCollection&lt;T&gt; queue = new BlockingCollection&lt;T&gt;(new ConcurrentQueue&lt;T&gt;());
    private readonly WorkerLogic&lt;T&gt; logic;
    private readonly Thread actualThread;
    private bool started = false;
    private volatile bool shouldWork = true;

    public ThreadedWorker(WorkerLogic&lt;T&gt; logic)
    {

        this.logic = logic;
        actualThread = new Thread(Spin);
        
    }

    private void Spin()
    {
        while (shouldWork)
        {
            T item;
            var dequeued = queue.TryTake(out item, TimeSpan.FromMilliseconds(100));
            if (!dequeued) continue;
            try
            {
                logic.Work(item);
            }
            catch (Exception ex)
            {
                // log
            }

        }            
    }

    public void Stop()
    {
        Stop(TimeSpan.FromMilliseconds(500));
    }

    public void Stop(TimeSpan timeout)
    {
        shouldWork = false;            
        bool joined = actualThread.Join(timeout);
        if (!joined)
        {
            try
            {
                actualThread.Abort();
            }
            catch (ThreadStateException)
            {
                // swallow
            }
        }
    }


    public void Push(T item)
    {
        if (!started)
        {
            lock (locker)
            {
                if (!started)
                {
                    started = true;
                    actualThread.Start();
                }
            }
        }
        queue.Add(item);
    }
}