แบบแผนการตั้งชื่อสำหรับวัตถุล็อคเธรดเฉพาะ [ปิด]

คำถามเล็ก ๆ น้อย ๆ แต่ฉันไม่สามารถหาเอกสารอย่างเป็นทางการหรือแม้กระทั่งบล็อกความคิดเห็น / การอภิปรายเกี่ยวกับมัน

พูดง่ายๆ: เมื่อฉันมีวัตถุส่วนตัวซึ่งมีจุดประสงค์เพียงอย่างเดียวที่จะให้บริการส่วนตัวlockฉันจะตั้งชื่อวัตถุนั้นว่าอะไร

class MyClass
{
    private object LockingObject = new object();

    void DoSomething()
    {
        lock(LockingObject)
        {
            //do something
        }
    }
}

เราควรตั้งชื่อLockingObjectอะไรที่นี่? นอกจากนี้ให้พิจารณาไม่ใช่แค่ชื่อของตัวแปร แต่จะมีลักษณะอย่างไรเมื่ออยู่ในโค้ดเมื่อล็อค

ฉันเคยเห็นตัวอย่างหลายอย่าง แต่ดูเหมือนไม่มีคำแนะนำที่ชัดเจน

1. การใช้งานมากมายSyncRoot(และรูปแบบเช่น_syncRoot)

   • ตัวอย่างโค้ด: lock(SyncRoot) ,lock(_syncRoot)
   • สิ่งนี้ดูเหมือนจะได้รับอิทธิพลจากSyncLockคำสั่งที่เทียบเท่าของ VB SyncRootคุณสมบัติที่มีอยู่ในคลาส ICollection บางส่วนและเป็นส่วนหนึ่งของรูปแบบการออกแบบ SyncRoot บางประเภท(ซึ่งเป็นแนวคิดที่ไม่ดี)
   • อยู่ในบริบท C # ไม่แน่ใจว่าฉันต้องการตั้งชื่อ VBish หรือไม่ ยิ่งแย่ลงใน VB การตั้งชื่อตัวแปรเช่นเดียวกับคำหลัก ไม่แน่ใจว่านี่จะเป็นแหล่งที่มาของความสับสนหรือไม่

2. thisLockและlockThisจากบทความ MSDN: C # lock Statement , VB SyncLock Statement

   • ตัวอย่างโค้ด: lock(thisLock) ,lock(lockThis)
   • ไม่แน่ใจว่าสิ่งเหล่านี้ถูกตั้งชื่ออย่างน้อยที่สุดสำหรับตัวอย่างหรือไม่
   • ค่อนข้างแปลกถ้าเราใช้สิ่งนี้ภายในstaticคลาส / วิธีการ
   • แก้ไข: บทความ Wikipedia ที่ล็อคยังใช้การตั้งชื่อนี้เป็นตัวอย่าง

3. หลายประเพณีของPadLock(จากปลอกที่แตกต่างกัน)

   • ตัวอย่างโค้ด: lock(PadLock) ,lock(padlock)
   • ไม่ดี แต่เนื้อเดียวของฉันมันน่าแปลกใจที่จะเรียกภาพที่ทางกายภาพ "กุญแจ" ซึ่งผมมักจะไม่เชื่อมโยงกับแนวคิดเกลียวนามธรรม

4. การตั้งชื่อล็อคตามสิ่งที่ตั้งใจจะล็อค

   • ตัวอย่างรหัส: lock(messagesLock) , lock(DictionaryLock),lock(commandQueueLock)
   • ในตัวอย่างหน้า VB SyncRoot MSDN นั้นมีsimpleMessageListตัวอย่างที่เป็นแบบส่วนตัวmessagesLockวัตถุ
   • ฉันไม่คิดว่าเป็นความคิดที่ดีที่จะตั้งชื่อการล็อกกับประเภทที่คุณล็อคอยู่ ("DictionaryLock") เนื่องจากเป็นรายละเอียดการนำไปปฏิบัติที่อาจมีการเปลี่ยนแปลง ฉันชอบตั้งชื่อรอบแนวคิด / วัตถุที่คุณกำลังล็อค ("messagesLock" หรือ "commandQueueLock")
   • ที่น่าสนใจคือฉันไม่ค่อยเห็นแบบแผนการตั้งชื่อนี้สำหรับล็อควัตถุในตัวอย่างโค้ดออนไลน์หรือใน StackOverflow

5. (แก้ไข) ข้อมูลจำเพาะ C # ภายใต้หัวข้อ "8.12 คำแถลงการล็อค" มีตัวอย่างของรูปแบบนี้และตั้งชื่อ synchronizationObject

   • ตัวอย่างโค้ด: lock(SynchronizationObject) ,lock(synchronizationObject)

คำถาม: อะไรคือความคิดเห็นของคุณโดยทั่วไปเกี่ยวกับการตั้งชื่อส่วนตัววัตถุล็อค?

เมื่อเร็ว ๆ นี้ฉันได้เริ่มตั้งชื่อพวกเขาThreadLock(ดังนั้นชอบตัวเลือกที่ 3) แต่ฉันพบว่าตัวเองถามชื่อนั้น

ฉันมักจะใช้รูปแบบการล็อคนี้ (ในตัวอย่างโค้ดที่ให้ไว้ด้านบน) ตลอดทั้งแอปพลิเคชันของฉันดังนั้นฉันคิดว่ามันสมเหตุสมผลที่จะได้รับความเห็น / การอภิปรายเกี่ยวกับการตั้งชื่อที่มั่นคงสำหรับพวกเขา ขอบคุณ!

ฉันเอานิสัยของเรียกมันว่าSomeResourceLockที่SomeResourceเป็นสิ่งที่คุณต้องการล็อคเข้าถึง / ปรับปรุงคือ (ให้อภัยปัญหาด้ายใด ๆ นี้เป็นเพียงภาพประกอบ)

public class ProcessDataInQueue
{
    private static Queue<Data> _dataQueue = new Queue<Data>();
    private static object _dataQueueLock = new Object();

    public void AddOneItem(Data itemToAdd)
    {
        lock(_dataQueueLock)
        {
            _dataQueue.Enqueue(itemToAdd);
        }
    }

    public void ProcessOneItem()
    {
        Data itemToProcess = null;
        lock(_dataQueueLock)
        {
            itemToProcess = _dataQueue.Dequeue();
        }
        // ... process itemToProcess
    }
}

ฉันมาที่นิสัยนี้หลังจากมีคลาสที่ฉันอาจมีการล็อคหลายครั้งสำหรับทรัพยากรที่แตกต่างกันดังนั้นฉันตั้งชื่อวัตถุล็อคตามทรัพยากรที่มันล็อคการเข้าถึง บางครั้งวัตถุหนึ่งอาจล็อคหลายทรัพยากรซึ่งในกรณีนี้ฉันจะพยายามทำให้ชื่อนั้นเคารพในทางใดทางหนึ่งดังนั้นผู้อ่านจึงรู้ว่า

ฉันมักจะเรียกมันว่าlockerแต่เนื่องจากเป็นเรื่องส่วนตัวฉันเชื่อว่ามันเป็นรายละเอียดในการติดตั้งที่ไม่สำคัญ กฎข้อแรกง่ายๆใช้มาตรฐานของทีม / บริษัท ของคุณ หากไม่มีใครกรุณาทำมันและใช้มัน แต่ในการทำให้ง่าย ๆ ถ้าชั้นเรียนของคุณมีวัตถุล็อคเดียวเรียกได้ว่าfooดีพอ หากคุณมีมากมายธุรกิจที่ดีอาจจะต้องทบทวนการออกแบบของชั้นเรียนก่อนเพื่อดูว่ามันทำสิ่งที่แตกต่างกันมากเกินไปหรือไม่ แต่ถ้าไม่เช่นนั้นชื่อจะกลายเป็นสิ่งที่มีความสำคัญเช่นเดียวกับในตัวอย่างที่วางแผนไว้อย่างสมบูรณ์:

public sealed class CustomerOrders
{
    private readonly object customerLocker = new object();

    private readonly object orderLocker = new object();

    public IEnumerable<Customer> Customers
    {
        get
        {
            lock (this.cutomerLocker)
            lock (this.orderLocker)
            {
                // stuff...
            }
        }

        set
        {
            lock (this.cutomerLocker)
            lock (this.orderLocker)
            {
                // other stuff...
            }
        }
    }

    public IEnumerable<Order> Orders
    {
        get
        {
            lock (this.orderLocker)
            {
                // stuff...
            }
        }

        set
        {
            lock (this.cutomerLocker)
            {
                // different stuff...
            }
        }
    }
}

ฉันมักจะใช้ lck_ ด้วยวิธีนี้ถ้าคุณกดปุ่ม ctrl + f 'lck' คุณจะพบเฉพาะล็อกในขณะที่ 'ล็อค' จะพบสิ่งต่าง ๆ เช่น 'นาฬิกา'

สิ่งต่าง ๆ เช่น lockThis และ Padlock นั้นดีสำหรับพอร์ตการลงทุนของ uni แต่สำหรับโครงการที่เหมาะสมคุณควรใช้ชื่อ semantic จริง ๆ เพื่อที่เมื่อคุณดูที่การประกาศคุณรู้ว่าวัตถุทำอะไรได้จริงโดยไม่ต้องค้นหารหัส