ทำไมฉันไม่สามารถใช้โอเปอเรเตอร์ 'ที่รอ' อยู่ภายในเนื้อความของคำสั่งล็อกได้

ไม่อนุญาตให้ใช้คำสำคัญที่รอใน C # (. NET Async CTP)

จากMSDN :

ไม่สามารถใช้นิพจน์ที่รออยู่ในฟังก์ชันซิงโครนัสในนิพจน์แบบสอบถามใน catch หรือ block สุดท้ายของคำสั่งการจัดการข้อยกเว้นในบล็อกคำสั่งล็อกหรือในบริบทที่ไม่ปลอดภัย

ฉันคิดว่านี่เป็นเรื่องยากหรือเป็นไปไม่ได้สำหรับทีมคอมไพเลอร์ที่จะใช้ด้วยเหตุผลบางอย่าง

ฉันพยายามแก้ไขด้วยคำสั่งการใช้:

class Async
{
    public static async Task<IDisposable> Lock(object obj)
    {
        while (!Monitor.TryEnter(obj))
            await TaskEx.Yield();

        return new ExitDisposable(obj);
    }

    private class ExitDisposable : IDisposable
    {
        private readonly object obj;
        public ExitDisposable(object obj) { this.obj = obj; }
        public void Dispose() { Monitor.Exit(this.obj); }
    }
}

// example usage
using (await Async.Lock(padlock))
{
    await SomethingAsync();
}

อย่างไรก็ตามสิ่งนี้ไม่ทำงานตามที่คาดไว้ การเรียกใช้ Monitor.Exit ภายใน ExitDisposable.Dispose ดูเหมือนว่าจะบล็อกไปเรื่อย ๆ ฉันสงสัยว่าความไม่น่าเชื่อถือของการทำงานของฉันและเหตุผลที่รองบไม่ได้รับอนุญาตในคำสั่งล็อคที่เกี่ยวข้องอย่างใด

ไม่มีใครรู้ว่าทำไมรอไม่ได้รับอนุญาตภายในเนื้อหาของคำสั่งล็อค?

ฉันคิดว่านี่เป็นเรื่องยากหรือเป็นไปไม่ได้สำหรับทีมคอมไพเลอร์ที่จะใช้ด้วยเหตุผลบางอย่าง

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

โทรไปที่ Monitor.Exit ภายใน ExitDisposable.Dispose ดูเหมือนว่าจะบล็อกไปเรื่อย ๆ ฉันสงสัยว่าความไม่น่าเชื่อถือของการทำงานของฉันและเหตุผลที่รองบไม่ได้รับอนุญาตในคำสั่งล็อคที่เกี่ยวข้องอย่างใด

ถูกต้องคุณได้ค้นพบว่าทำไมเราถึงทำให้มันผิดกฎหมาย การรออยู่ในล็อคเป็นสูตรสำหรับการผลิตเดดล็อก

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

ที่เลวร้ายยิ่งรหัสจะกลับมาในหัวข้ออื่น (ในสถานการณ์ขั้นสูงตามปกติคุณเลือกขึ้นมาอีกครั้งในหัวข้อที่ได้รอ แต่ไม่จำเป็นต้อง) ซึ่งในกรณีการปลดล็อคจะปลดล็อคล็อคในหัวข้อที่แตกต่างจากด้ายที่เกิด ล็อคออก นั่นเป็นความคิดที่ดีหรือไม่? เลขที่

ฉันทราบว่ามันยังเป็น "การปฏิบัติที่เลวร้ายที่สุด" ที่จะทำyield returnภายในlockด้วยเหตุผลเดียวกัน มันถูกกฎหมายที่จะทำ แต่ฉันหวังว่าเราจะทำให้มันผิดกฎหมาย เราจะไม่ทำผิดพลาดแบบเดียวกันกับ "รอ"

ใช้SemaphoreSlim.WaitAsyncวิธีการ

 await mySemaphoreSlim.WaitAsync();
 try {
     await Stuff();
 } finally {
     mySemaphoreSlim.Release();
 }

โดยทั่วไปมันจะเป็นสิ่งที่ผิดที่ต้องทำ

วิธีนี้สามารถนำมาใช้ได้สองวิธี:

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

• ปลดล็อคในระหว่างการรอและ reququire มันเมื่อรอผลตอบแทน
  นี้ละเมิดหลักการของความประหลาดใจอย่างน้อย IMO ซึ่งวิธีการที่ไม่ตรงกันควรประพฤติอย่างใกล้ชิดที่เป็นไปได้เช่นรหัสซิงโครเทียบเท่า - เว้นแต่คุณจะใช้Monitor.Waitในการป้องกันการล็อคคุณคาดว่าจะ เป็นเจ้าของล็อคในช่วงระยะเวลาของบล็อก

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

// Now it's clear where the locks will be acquired and released
lock (foo)
{
}
var result = await something;
lock (foo)
{
}

ดังนั้นโดยห้ามไม่ให้คุณจากการรอในบล็อกล็อคตัวเองภาษาที่จะบังคับให้คุณคิดเกี่ยวกับสิ่งที่คุณจริงๆต้องการที่จะทำและทำให้ทางเลือกที่ชัดเจนในรหัสที่คุณเขียน

นี่เป็นเพียงส่วนขยายของคำตอบนี้

using System;
using System.Threading;
using System.Threading.Tasks;

public class SemaphoreLocker
{
    private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);

    public async Task LockAsync(Func<Task> worker)
    {
        await _semaphore.WaitAsync();
        try
        {
            await worker();
        }
        finally
        {
            _semaphore.Release();
        }
    }
}

การใช้งาน:

public class Test
{
    private static readonly SemaphoreLocker _locker = new SemaphoreLocker();

    public async Task DoTest()
    {
        await _locker.LockAsync(async () =>
        {
            // [asyn] calls can be used within this block 
            // to handle a resource by one thread. 
        });
    }
}

สิ่งนี้อ้างถึงhttp://blogs.msdn.com/b/pfxteam/archive/2012/02/12/10266988.aspx , http://winrtstoragehelper.codeplex.com/ , ที่เก็บแอพ Windows 8 และ. net 4.5

นี่คือมุมของฉันในเรื่องนี้:

คุณลักษณะภาษา async / await ทำให้หลายสิ่งค่อนข้างง่าย แต่ก็ยังแนะนำสถานการณ์ที่ไม่ค่อยพบก่อนที่จะใช้การโทรแบบ async: reentrance

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

นี่เป็นสถานการณ์จริงที่ฉันเจอในแอพ windows 8 App store: แอพของฉันมีสองเฟรม: การเข้าและออกจากเฟรมฉันต้องการโหลด / เซฟข้อมูลบางอย่างไปยังไฟล์ / ที่เก็บข้อมูล เหตุการณ์ OnNavigatedTo / From ถูกใช้สำหรับการบันทึกและการโหลด การบันทึกและการโหลดทำได้โดยฟังก์ชั่นยูทิลิตี้ async (เช่นhttp://winrtstoragehelper.codeplex.com/ ) เมื่อนำทางจากเฟรม 1 ถึงเฟรม 2 หรือในทิศทางอื่นโหลด async และการทำงานที่ปลอดภัยจะถูกเรียกและรอ ตัวจัดการเหตุการณ์กลายเป็น async ที่คืนค่าเป็นโมฆะ => ไม่สามารถรอได้

อย่างไรก็ตามการดำเนินการเปิดไฟล์ครั้งแรก (ให้บอกว่า: ภายในฟังก์ชั่นการบันทึก) ของยูทิลิตี้ก็เป็น async เช่นกันดังนั้นการรอคอยครั้งแรกก็กลับมาควบคุมเฟรมเวิร์กซึ่งบางครั้งเรียกยูทิลิตี้อื่น ๆ ขณะนี้การโหลดพยายามเปิดไฟล์เดียวกันและหากไฟล์นั้นเปิดอยู่ในตอนนี้สำหรับการดำเนินการบันทึกล้มเหลวด้วยข้อยกเว้น ACCESSDENIED

วิธีแก้ปัญหาขั้นต่ำสำหรับฉันคือรักษาความปลอดภัยการเข้าถึงไฟล์ผ่านการใช้และ AsyncLock

private static readonly AsyncLock m_lock = new AsyncLock();
...

using (await m_lock.LockAsync())
{
    file = await folder.GetFileAsync(fileName);
    IRandomAccessStream readStream = await file.OpenAsync(FileAccessMode.Read);
    using (Stream inStream = Task.Run(() => readStream.AsStreamForRead()).Result)
    {
        return (T)serializer.Deserialize(inStream);
    }
}

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

ที่นี่ คือโครงการทดสอบของฉัน: แอพ windows 8 app store ที่มีการทดสอบการโทรสำหรับรุ่นดั้งเดิมจากhttp://winrtstoragehelper.codeplex.com/และเวอร์ชันที่แก้ไขของฉันที่ใช้ AsyncLock จาก Stephen Toub http: //blogs.msdn co.th / b / pfxteam / เก็บ / 2012 / 12/02 / 10266988.aspxco.th

ฉันขอแนะนำลิงก์นี้ได้ไหม: http://www.hanselman.com/blog/ComparingTwoTechniquesInNETAsynchronousCoordinationPrimitives.aspx

Stephen Taub ได้ใช้วิธีแก้ปัญหาสำหรับคำถามนี้ดูที่การสร้างแนวทางการประสานงาน Async ตอนที่ 7: AsyncReaderWriterLockAsyncReaderWriterLock

สตีเฟ่นเตาได้รับการยกย่องอย่างสูงในอุตสาหกรรมดังนั้นสิ่งที่เขาเขียนมีแนวโน้มที่จะเป็นของแข็ง

ฉันจะไม่ทำซ้ำรหัสที่เขาโพสต์ไว้ในบล็อกของเขา แต่ฉันจะแสดงวิธีใช้:

/// <summary>
///     Demo class for reader/writer lock that supports async/await.
///     For source, see Stephen Taub's brilliant article, "Building Async Coordination
///     Primitives, Part 7: AsyncReaderWriterLock".
/// </summary>
public class AsyncReaderWriterLockDemo
{
    private readonly IAsyncReaderWriterLock _lock = new AsyncReaderWriterLock(); 

    public async void DemoCode()
    {           
        using(var releaser = await _lock.ReaderLockAsync()) 
        { 
            // Insert reads here.
            // Multiple readers can access the lock simultaneously.
        }

        using (var releaser = await _lock.WriterLockAsync())
        {
            // Insert writes here.
            // If a writer is in progress, then readers are blocked.
        }
    }
}

หากคุณต้องการวิธีการที่ถูกนำเข้าสู่. NET Framework ให้ใช้SemaphoreSlim.WaitAsyncแทน คุณจะไม่ได้รับล็อคผู้อ่าน / นักเขียน แต่คุณจะได้ลองและทดสอบการใช้งาน

อืมดูเหมือนน่าเกลียดดูเหมือนว่าจะใช้งานได้

static class Async
{
    public static Task<IDisposable> Lock(object obj)
    {
        return TaskEx.Run(() =>
            {
                var resetEvent = ResetEventFor(obj);

                resetEvent.WaitOne();
                resetEvent.Reset();

                return new ExitDisposable(obj) as IDisposable;
            });
    }

    private static readonly IDictionary<object, WeakReference> ResetEventMap =
        new Dictionary<object, WeakReference>();

    private static ManualResetEvent ResetEventFor(object @lock)
    {
        if (!ResetEventMap.ContainsKey(@lock) ||
            !ResetEventMap[@lock].IsAlive)
        {
            ResetEventMap[@lock] =
                new WeakReference(new ManualResetEvent(true));
        }

        return ResetEventMap[@lock].Target as ManualResetEvent;
    }

    private static void CleanUp()
    {
        ResetEventMap.Where(kv => !kv.Value.IsAlive)
                     .ToList()
                     .ForEach(kv => ResetEventMap.Remove(kv));
    }

    private class ExitDisposable : IDisposable
    {
        private readonly object _lock;

        public ExitDisposable(object @lock)
        {
            _lock = @lock;
        }

        public void Dispose()
        {
            ResetEventFor(_lock).Set();
        }

        ~ExitDisposable()
        {
            CleanUp();
        }
    }
}

ฉันลองใช้ Monitor (รหัสด้านล่าง) ซึ่งดูเหมือนว่าจะใช้งานได้ แต่มี GOTCHA ... เมื่อคุณมีหลายเธรดมันจะให้ ... System.Threading.SynchronizationLockException

using System;
using System.Threading;
using System.Threading.Tasks;

namespace MyNamespace
{
    public class ThreadsafeFooModifier : 
    {
        private readonly object _lockObject;

        public async Task<FooResponse> ModifyFooAsync()
        {
            FooResponse result;
            Monitor.Enter(_lockObject);
            try
            {
                result = await SomeFunctionToModifyFooAsync();
            }
            finally
            {
                Monitor.Exit(_lockObject);
            }
            return result;
        }
    }
}

ก่อนหน้านี้ฉันเพิ่งทำสิ่งนี้ แต่มันอยู่ในตัวควบคุม ASP.NET ดังนั้นมันจึงทำให้เกิดการหยุดชะงัก

public async Task<FooResponse> ModifyFooAsync() { lock(lockObject) { return SomeFunctionToModifyFooAsync.Result; } }