这就是编写线程安全IComparable的方法吗

我有一个简单的类，我想让它线程安全。该类需要实现IComparer。我知道以线程安全的方式实现int CompareTo(T other)不是直接的。如果我不以正确的方式锁定，很容易出现死锁。我有三个问题：

1. 这个代码线程安全吗？如果没有，我该如何修复
2. 这个代码可以短一点吗？这看起来像是一个简单减法的大量代码
3. 我甚至应该麻烦让int CompareTo(T other)线程安全吗？我应该要求调用者（通常是排序）锁定所有相关的BObjects吗

这是我的代码：

public class BObject : IComparable<BObject>
{
    //Each BObject has a unique object id
    private static int _bObjectId = 0;
    private static int GetNextId()
    {
        return System.Threading.Interlocked.Increment(ref BObject._bObjectId);
    }
    private object _locker = new object();
    private readonly int _id = BObject.GetNextId();
    //Some variable
    private int _sales;
    public int Sales
    {
        get
        {
            lock (this._locker)
                return this._sales;
        }
        set
        {
            lock (this._locker)
                this._sales = value;
        }
    }
    public int CompareTo(BObject other)
    {
        int result;
        //Can I simply do "if (this._id == other._id)"
        if (object.ReferenceEquals(this, other))
            result = 0;
        else
        {
            //get the BObject with the lower id
            BObject lower = this._id < other._id ? this : other;
            //get the BObject with the higher id
            BObject higher = this._id > other._id ? this : other;
            //lock the BObject with the lower id first
            lock (lower._locker)
            {
                //lock the BObject with the higher id last
                lock (higher._locker)
                {
                    //put object with lower Sales first
                    result = this.Sales - other.Sales;
                }
            }
        }
        return result;
    }
}