ล็อคทำงานอย่างไร

ฉันเห็นว่าสำหรับการใช้วัตถุที่ไม่ปลอดภัยเธรดเราห่อรหัสด้วยล็อคเช่นนี้

private static readonly Object obj = new Object();

lock (obj)
{
    // thread unsafe code
}

ดังนั้นจะเกิดอะไรขึ้นเมื่อหลายเธรดเข้าถึงรหัสเดียวกัน (สมมติว่ามันกำลังทำงานอยู่ในเว็บแอปพลิเคชัน ASP.NET) พวกเขาเข้าคิวหรือไม่ ถ้าเป็นเช่นนั้นพวกเขาจะรอนานแค่ไหน?

ประสิทธิภาพการทำงานมีผลกระทบอะไรบ้างจากการใช้ระบบล็อค?

lockคำสั่งแปลโดย C # 3.0 ต่อไปนี้:

var temp = obj;

Monitor.Enter(temp);

try
{
    // body
}
finally
{
    Monitor.Exit(temp);
}

ใน C # 4.0 มีการเปลี่ยนแปลงและตอนนี้มันถูกสร้างขึ้นดังนี้:

bool lockWasTaken = false;
var temp = obj;
try
{
    Monitor.Enter(temp, ref lockWasTaken);
    // body
}
finally
{
    if (lockWasTaken)
    {
        Monitor.Exit(temp); 
    }
}

คุณสามารถค้นหาข้อมูลเพิ่มเติมเกี่ยวกับสิ่งที่Monitor.Enterไม่ที่นี่ วิธีอ้าง MSDN:

ใช้Enterเพื่อรับการตรวจสอบบนวัตถุที่ส่งผ่านเป็นพารามิเตอร์ หากเธรดอื่นดำเนินการEnter กับวัตถุ แต่ยังไม่ได้ดำเนินการที่เกี่ยวข้องExitเธรดปัจจุบันจะบล็อกจนกว่าเธรดอื่นจะเผยแพร่วัตถุ เป็นเรื่องถูกกฎหมายสำหรับเธรดเดียวกันให้เรียกใช้ Enterมากกว่าหนึ่งครั้งโดยไม่มีการบล็อก อย่างไรก็ตามExitต้องเรียกจำนวนเท่ากัน ก่อนที่เธรดอื่น ๆ ที่รออยู่บนวัตถุจะปลดบล็อก

Monitor.Enterวิธีการจะรออนันต์; มันจะไม่หมดเวลา

มันง่ายกว่าที่คุณคิด

ตามMicrosoft : lockคำหลักช่วยให้มั่นใจว่าเธรดหนึ่งไม่ได้ป้อนส่วนที่สำคัญของรหัสในขณะที่เธรดอื่นอยู่ในส่วนที่สำคัญ หากเธรดอื่นพยายามป้อนรหัสที่ถูกล็อคมันจะรอบล็อกจนกว่าวัตถุจะถูกปล่อยออกมา

lockสายคำหลักEnterที่จุดเริ่มต้นของบล็อกและExitในตอนท้ายของบล็อก lockคำหลักจริง ๆ แล้วจัดการMonitorคลาสที่ส่วนท้าย

ตัวอย่างเช่น:

private static readonly Object obj = new Object();

lock (obj)
{
    // critical section
}

objในโค้ดข้างต้นเป็นครั้งแรกด้ายเข้าสู่ส่วนที่สำคัญและจากนั้นมันจะล็อค เมื่อเธรดอื่นพยายามเข้าใช้เธรดอื่นจะพยายามล็อกobjซึ่งถูกล็อกโดยเธรดแรกแล้ว เธรดที่สองจะต้องรอให้เธรดแรกถูกปล่อยออกobjมา เมื่อเธรดแรกobjจบแล้วเธรดอื่นจะล็อกและจะเข้าสู่ส่วนที่สำคัญ

ไม่พวกเขาไม่ได้เข้าคิวพวกเขากำลังนอนหลับ

คำสั่งล็อคของแบบฟอร์ม

lock (x) ... 

โดยที่ x คือนิพจน์ของชนิดข้อมูลอ้างอิงเทียบเท่ากับ

var temp = x;
System.Threading.Monitor.Enter(temp); 
try { ... } 
finally { System.Threading.Monitor.Exit(temp); }

คุณเพียงแค่ต้องรู้ว่าพวกเขากำลังรอซึ่งกันและกันและมีเพียงหนึ่งเธรดเท่านั้นที่จะเข้าสู่ล็อคบล็อกส่วนอื่น ๆ จะรอ ...

จอภาพถูกเขียนอย่างสมบูรณ์ใน. net ดังนั้นจึงเร็วพอและดูที่ Class Monitorพร้อมตัวสะท้อนแสงเพื่อดูรายละเอียดเพิ่มเติม

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

ผลกระทบต่อประสิทธิภาพขึ้นอยู่กับวิธีที่คุณล็อค คุณสามารถค้นหารายการการเพิ่มประสิทธิภาพที่ดีได้ที่นี่: http://www.thinkingparallel.com/2007/07/31/10-ways-to-reduce-lock-contention-in-threaded-programs/

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

ส่วนภายในคำสั่งล็อคสามารถดำเนินการได้โดยหนึ่งเธรดดังนั้นกระทู้อื่น ๆ ทั้งหมดจะรอไปเรื่อย ๆ เพื่อให้เธรดที่ถือล็อคให้เสร็จสิ้น สิ่งนี้สามารถทำให้เกิดการหยุดชะงักที่เรียกว่า

lockคำสั่งจะแปลให้เรียกไปEnterและวิธีการของExitMonitor

lockคำสั่งจะรอไปเรื่อย ๆ สำหรับวัตถุล็อคที่จะได้รับการปล่อยตัว

ล็อคเป็นจริงระดับการตรวจสอบที่ซ่อนอยู่