حسین احمدی
بنیانگذار توسینسو و برنامه نویس و توسعه دهنده ارشد وب

کاملترین آموزش کار با Thread ها در سی شارپ (C#) رایگان

در این مطلب قصد داریم تا با مبحث برنامه نویسی Asynchronous و کار با Thread ها در زبان سی شارپ (C#) آشنا شویم. قابلیت Thread ها در سی شارپ این امکان را به ما می دهد تا چندین کار را به صورت همزمان انجام دهیم که این کار باعث بهینه شدن اجرای برنامه ما خواهد شد. در این مطلب با من همراه باشید تا این قابلیت بیشتر آشنا شویم.

دوره های شبکه، برنامه نویسی، مجازی سازی، امنیت، نفوذ و ... با برترین های ایران

Process و Thread

فرض کنید قصد دارید 500،000 رکورد را پردازش کنیم. در صورتی که به صورت عادی اقدام به پیاده سازی این قابلیت کنیم، در طول پردازش این اطلاعات برنامه ما دیگر قابل استفاده نخواهد بود و مجبوریم صبر کنیم تا عملیات پردازش اطلاعات تمام شود یا بهتر است یک مثال دیگر بزنیم.فرض کنید زمانی که در حال تماشای یک فیلم هستید دیگر امکان انجام کارهای دیگر، مثلاً تایپ در برنامه Word یا برنامه نویسی نباشد.

اما هیچ گاه این مشکلات برای شما بوجود نمی آید، زیرا سیستم عامل ها به بهترین شکل عملیات هم زمانی را پیاده سازی کرده و به شما این اجازه را می دهند تا در آن واحد نسبت به انجام چندین عملیات اقدام کنید. در زبان سی شارپ نیز این امکان برنامه نویسان داده شده است تا نسبت به پیاده سازی عملیات ها به صورت همزمان اقدام کنند. ب

رای اینکار باید از Thread ها استفاده کنیم که در طول چند مطلب قصد داریم با شیوه های مختلف استفاده از Thread ها آشنا شویم. اما قبل از شروع کد نویسی بهتر است که با یکسری مفاهیم اولیه آشنا شده و سپس به سراغ قابلیت ها برنامه نویسی Asynchronous در زبان سی شارپ برویم.

Process چیست؟

زمانی که کاربر برنامه ای را اجرا می کند مقداری از حافظه و همچنین منابع به این برنامه تخصیص داده می شوند. اما همانطور که گفتیم یکی از قابلیت های سیستم های عامل این است که می توان چندین برنامه را به صورت همزمان اجرا کرد.

یکی از وظایف سیستم عامل تفکیک حافظه و منابع برای هر یک از برنامه های در حال اجرا است که این جدا سازی بوسیله Process ها انجام می شود. در حقیقت هر Process مرزبندی بین برنامه های اجرا است برای جدا سازی منابع و حافظه های تخصیص داده شده.

دقت کنید که لزوماً تعداد Process برابر با تعداد برنامه های در حال اجرا نیست، یک برنامه می تواند یک یا چند Process را در زمان اجرا درگیر کند. در سیستم عامل ویندوز می توان از بخش Task Manager لیست برنامه های در حال اجرا و Process ها را مشاهده کرد. در تصویر زیر لیست برنامه هایی که بر روی سیستم من در حال اجرا است را مشاهده می کنید:

img1

در صورتی که بر روی دکمه More details کلیک کنید می توانید از تب Processes لیست Process های در حال اجرا را مشاهده کنید:

img2

هر یک Process های در حال اجرا حافظه، منابع تخصیص داده شده و روند اجرای مربوط به خود را دارند. در تصویر بالا نیز مشخص است، برای مثال در زمان گرفتن عکس بالا، Prcess مربوط به برنامه paint.net مقدار 20.4% از CPU و همچنین 107.6MB از حافظه را اشغال کرده است.

در اینجا بیشتر به بحث CPU Usage باید دقت کنیم که نشان دهنده میزان استفاده یک Process از CPU است. CPU Usage در حقیقت یک ترتیب اجرا است که اصطلاحاً به آن Thread می گویند. هر Process می تواند شامل یک یا چندین Thread باشد که هر Thread وظیفه انجام یک عملیات خاص را بر عهده دارد. اما زمان اجرای هر Process یک Thread اولیه اجرا می شود که به آن اصطلاحاً Main Thread گفته می شود.

Process های Multi-Thread

همانطور که گفتیم هر Process می تواند شامل یک یا چندین Thread باشد. این Thread ها تنها توسط Process ایجاد نمی شوند و افرادی که اقدام به ایجاد نرم افزار می کنند (همان برنامه نویس های معروف) نیز می توانند برای انجام عملیات های مورد نظر اقدام به ایجاد Thread کنند.

برای مثال محیط Visual Studio را در نظر بگیرید، این محیط در طول زمان نوشتن کدها عملیات های دیگری را نیز برای شما انجام می دهد، مانند پردازش سایر فایل های پروژه، رنگی کردن کدها، نمایش Intellisense و ...، اما شما احساس می کنید که تمامی این کار به صورت همزمان انجام می شوند.

به این دلیل که برای هر یک از این عملیات ها یک Thread جداگانه ایجاد می شود که تمامی این Thread ها در Prcess مربوط به Visual Studio در حال اجرا هستند و به همین دلیل شما نباید منتظر بمانید تا عملیات های در حال اجرا به اتمام برسند و می توانید کار خود را ادامه دهید.

Thread های در حال اجرا در یک Process نیاز به یکسری اطلاعات در مورد Process دارند تا بتوانند به کار خود ادامه دهند. به این اطلاعات اصطلاحاً Prcess Global Data یا داده های عمومی یک پراسس می گویند. اگر بخواهیم نمایی کلی از یک Process را نشان دهیم می توان شکل زیر را مثال زد:

img3

تصویر بالا، یک Process را نشان می دهد که شامل دو Thread است، هر یک از این Thread ها یک وظیفه خاص را انجام می دهند، اما به سکری اطلاعات دسترسی دارند که به آن ها PGD یا Process Global Data می گویند.تا اینجا با دو مفهوم Process و Thread آشنا شدیم

اما همانطور که گفتیم در زبان سی شارپ می توانیم Thread هایی ایجاد کنیم که هر Thread یک کار خاص را انجام می دهد. برای کار با Thread ها و برای شروع، با کلاسی به نام Thread که در فضای نام System.Threading قرار دارد کار می کنیم. به صورت زیر می توانیم یک thread جدید با استفاده از کلاس Thread ایجاد کرده و آنرا اجرا کنیم:

static void Main(string[] args)
{
    var thread1 = new Thread(Thread1Job);
    var thread2 = new Thread(Thread2Job);
    var thread3 = new Thread(Thread3Job);
    thread1.Start();
    thread2.Start();
    thread3.Start();
}

public static void Thread1Job()
{
    for (int counter = 0; counter < 50; counter++)
    {
        Console.WriteLine("From thread1: " + counter);
    }
}

public static void Thread2Job()
{
    for (int counter = 0; counter < 50; counter++)
    {
        Console.WriteLine("From thread2: " + counter);
    }
}

public static void Thread3Job()
{
    for (int counter = 0; counter < 50; counter++)
    {
        Console.WriteLine("From thread3: " + counter);
    }
}

همانطور که مشاهده می کنید در کد بالا 3 شئ از نوع Thread ایجاد کردیم و برای پارامتر Constructor متد مورد نظر را ارسال کردیم. Constructor کلاس Thread پارامترش از نوع Delegate است و به همین دلیل می توان یک متد را جهت اجرا در Thread به عنوان پارامتر به آن ارسال کرد. بعد از تعریف thread ها به ترتیب آن را بوسیله متد Start اجرا می کنیم. در تصویر زیر خروجی کد بالا را مشاهده می کنید که کد های Thread ها به صورت همزمان اجرا شدند:

img4

اگر در کد بالا متد ها را بدون استفاده از Thread ها فراخوانی می کردیم Thread2Job پس از اجرای Thread1Job اجرا شده و الی آخر. در این مطلب مقدمه ای بر مبحث Thread ها در زبان سی شارپ داشتیم. در مطالب بعدی با اصول اولیه و مکانیزم های مختلف استفاده از Thread ها و همچنین ریسک هایی که در زمان استفاده از Thread ها وجود دارد آشنا خواهیم شد.

فراخوانی Delegate ها به صورت Asynchronous

به خاطر دارید که Delegate نوع های داده ای بودند که اطلاعات مربوط به یک متد را در خود نگهداری می کردند؟ زمانی که یک delegate جدید تعریف می کنید، در حقیقت کلاس جدیدی ایجاد می شود که این کلاس، از کلاس MultiCastDelegate مشتق شده است.

این موضوع باعث می شود که delegate تعریف شده شامل یکسری متدها باشد. قبلاً با delegate ها و شیوه فراخوانی آن ها آشنا شدیم. در این مطلب می خواهیم با شیوه فراخوانی متدها به صورت Asynchronous آشنا شویم. زمانی که از روی یک delegate شئ ای برای یک متد ایجاد می کنیم، این شئ شامل دو متد به نام های زیر است:

  1. BeginInvoke
  2. EndInvoke

از این دو متد می توان برای فراخوانی delegate ها به صورت Asynchronous استفاده کرد. اگر به خاطر داشته باشید، delegate ها یک متد دیگر نیز داشتند به نام Invoke که به وسیله این متد می توانستیم delegate را به صورت عادی فراخوانی کنیم.

تفاوت Invoke و BeginInvoke در این است که متد Invoke عملیات فراخوانی را در Thread جاری انجام می دهد، اما متد BeginInvoke یک Thread جدید ایجاد کرده و delegate را در آن Thread فراخوانی می کند. برای آشنایی بیشتر با یک مثل جلو می رویم، Delegate ای به صورت زیر تعریف می کنیم:

public delegate int MathOperation(int n1, int n2);

در ادامه کد زیر را نیز اضافه می کنیم:

static void Main(string[] args)
{
    MathOperation operation = new MathOperation(Add);
    Console.WriteLine("Main thread ID:"+Thread.CurrentThread.ManagedThreadId);
    operation(2, 6);
}

public static int Add(int n1, int n2)
{
    Console.WriteLine("Add thread ID: " + Thread.CurrentThread.ManagedThreadId);
    return n1 + n2;
}

به خطوط 4 و 10 دقت کنید، در این خطوط از کلاس Thread استفاده کردیم، کلاس Thread یک Property دارد به نام CurrentThread که اطلاعات Thread جاری که متد در آن اجرا شده است را بر میگرداند، خاصیت CurrentThread از نوع کلاس Thread است که بوسیله خاصیت ManagedThreadId می توان شناسه Thread در حال اجرا را بدست آورد. بعد اجرای کد بالا با خروجی زیر مواجه می شویم:

Main thread ID:1
Add thread ID: 1

همانطور که مشاهده می کنید شناسه Thread بر هر دو متد Main و Add یکسان است، اما همانطور که گفتیم می خواهیم متد Add را در یک Thread جداگانه اجرا کنیم. در اینجا از متد BeginInvoke که برای Delegate تعریف شده استفاده می کنیم. برای MathOperation متد BeginInvoke به صورت زیر تعریف شده است:

IAsyncResult BeginInvoke(int n1, int n2, AsyncCallBack callback, object state);

همانطور که مشاهده می کنید پارامترهای اول و دوم تعریف شده برای BeginInvoke مبتنی بر پارامترهایی است که برای Delegate تعریف کردیم. پارامترهای callback و state را هم بعداً بررسی می کنیم، در حال حاضر برای فراخوانی متد BeginInvoke برای این دو پارامتر مقدار null ارسال می کنیم.همچنین متد EndInvoke نیز برای MathOperation به صورت زیر تعریف شده است:

int EndInvoke(IAsyncResult result);

همانطور که مشاهده می کنید مقدار بازگشتی EndInvoke از نوع int است که بر اساس نوع بازگشتی delegate تعریف شده مشخص می شود. همچنین پارامتر ورودی EndInvoke از نوع IAsyncResult است که در ادامه به بررسی این interface خواهیم پرداخت.

اینترفیس IAsyncResult

همانطور که مشاهده کردید، مقدار بازگشتی متد BeginInvoke از نوع IAsyncResult است. این interface در متدهای BeginInvoke و EndInvoke استفاده می شود، در متد BeginInvoke مقدار بازگشتی شئ ای از نوع IAsyncResult است و در متد EndInvoke پارامتر ورودی این متد از نوع IAsyncResult می باشد. تعریف IAsyncResult به صورت زیر است:

public interfae IAsyncResult
{
    object AsyncState { get; set; }
    WaitHandle AsyncWaitHandle { get; set; }
    bool CompletedSynchronously { get; set; }
    bool IsCompleted { get; set; }
}

در ساده ترین حالت ممکن شما نیازی به کار با اعضاء این اینترفیس ندارید، تنها کاری که باید بکنید نگهداری مقدار بازگردانده شده از متد BeginInvoke و ارسال آن به متد EndInvoke در زمان مناسب برای گرفتن خروجی است. برای آشنایی بیشتر با متدهای BeginInvoke و EndInvoke و همچنین استفاده از IAsyncResult با یک مثال ساده جلو می رویم. کدی که برای MathOperation در ابتدای این مطلب نوشتیم را به صورت زیر تغییر می دهیم:

MathOperation operation = new MathOperation(Add);
Console.WriteLine("Main thread ID:"+Thread.CurrentThread.ManagedThreadId);
var result = operation.BeginInvoke(2, 6, null, null);
Console.WriteLine("Task in Main method.");
var answer = operation.EndInvoke(result);
Console.WriteLine("2 + 6 = {0}", answer);

بعد از اجرای کد بالا، خروجی به صورت زیر خواهد بود:

Main thread ID:1
Task in Main method.
Add thread ID: 3
2 + 6 = 8

همانطور که مشاهده می کنید، شناسه Thread برای متد Add مقدار 3 می باشد، به این معنی که متد Add در حال اجرا در یک Thread جداگانه از Thread اصلی برنامه یا Main Thread است. اما یک موضوع هنوز باقی مانده، Synchronization. به متد Main دقت کنید

زمانی که delegate با متد BeginInvoke فراخوانی می شود و بعد از آن پیغام Task in Main method را در خروجی چاپ می کنیم، در حقیقت Thread جاری برای لحظاتی متوقف شده و بعد بوسیله متد EndInvoke خروجی را دریافت می کنیم.

اما کاری که ما می خواهیم انجام دهیم همزمانی اجرای متد WriteLine و متد Add است برای اینکار باید از اعضاء IAsyncResult استفاده کنیم. در این اینترفیس خصوصیتی تعریف شده با نام IsCompleted که در صورت اتمام اجرای متد مقدار true را بر میگرداند. کدی که نوشتیم را به صورت زیر تغییر می دهیم:

static void Main(string[] args)
{
    MathOperation operation = new MathOperation(Add);
    Console.WriteLine("Main thread ID:"+Thread.CurrentThread.ManagedThreadId);
    var result = operation.BeginInvoke(2, 6, null, null);
    while (!result.IsCompleted)
    {
        Console.WriteLine("Task in Main method...");
        Thread.Sleep(1000);
    }
    Console.WriteLine("Task in Main method.");
    var answer = operation.EndInvoke(result);
    Console.WriteLine("2 + 6 = {0}", answer);
}

public static int Add(int n1, int n2)
{
    Console.WriteLine("Add thread ID: " + Thread.CurrentThread.ManagedThreadId);
    Thread.Sleep(5000);
    return n1 + n2;
}

به متد Thread.Sleep دقت کنید، این متد روند اجرای Thread را برای مدت زمان مشخص شده متوقف می کند. عدد وارد شده به میلی ثانیه است. در کد بالا متد Add به میزان 5 ثانیه و متد با هر بار تکرار حلقه while متد متد Main به اندازه 1 ثانیه متوقف می شوند. اجرای کد بالا خروجی زیر را تولید می کند:

Main thread ID:1
Task in Main method...
Add thread ID: 3
Task in Main method...
Task in Main method...
Task in Main method...
Task in Main method...
2 + 6 = 8

با اینکه متد Add فراخوانی شده و Thread مرتبط با آن به مدت 5 ثانیه در حالت Sleep قرار گرفته، اما متد Main در حال انجام کار خودش است و تا زمانی که متد Add کامل نشده و IsCompleted در IAsyncResult مقدار true بر نگرداند دستور WriteLine فراخوانی شده و پیام Task in Main method بر روی صفحه نمایش داده می شود.

در این کد ما از خاصیت IsCompleted استفاده کردیم، یکی دیگر از راه ها برای پیاده سازی حالت گفته شده استفاده از متد WaitOn است که در کلاس WaitHandle پیاده سازی شده است. خاصیت AsyncWaitHandle در IAsyncResult شئ ای از نوع WaitHandle بر می گرداند. یکی از مزیت های استفاده از این متد قابلیت مشخص کردن time out برای block کردن thread جاری است، یعنی دیگر نیازی به استفاده از Thread.Sleep نخواهیم داشت:

MathOperation operation = new MathOperation(Add);
Console.WriteLine("Main thread ID:"+Thread.CurrentThread.ManagedThreadId);
var result = operation.BeginInvoke(2, 6, null, null);
while (!result.AsyncWaitHandle.WaitOne(1000,true))
{
    Console.WriteLine("Task in Main method...");
}
var answer = operation.EndInvoke(result);
Console.WriteLine("2 + 6 = {0}", answer);

همانطور که مشاهده می کنید، برای متد WaitOn در حلقه while مقدار 1000 میلی ثانیه یا 1 ثانیه را مشخص کردیم. هر زمان که روند اجرای کد به این دستور می رسد، thread جاری به اندازه 1 ثانیه منتظر تکمیل اجرای متد Add شده و سپس وارد حلقه while می شود. در صورتی که کار متد Add به اتمام برسد، متد WaitOn مقدار true بر میگرداند. در مورد پارامتر دوم WaitOn که مقدار true به آن پاس داده شده در بخش های مرتبط با Synchronization Context صحبت خواهیم کرد.

استفاده از AsyncCallBack

تا اینجا گفتیم که چگونه می توان اجرای همزمان دو Thread را بوسیله Delegate ها پیاده سازی کرد، همچنین با نحوه کنترل دریافت خروجی از Thread های اجرا شده آشنا شدیم و گفتیم که بوسیله IAsyncResult می توان خروجی را دریافت کرد. اگر به خاطر داشته باشید زمان فراخوانی متد BeginInvoke برای دو پارامتر callback و state مقدار null ارسال کردیم.

در این قسمت می خواهیم در مورد پارامتر callback صحبت کنیم، این پارامتر که یک Delegate از نوع AsyncCallBack قبول می کند، به ما این امکان را می دهد تا متدی را به متد BeginInvoke پاس دهیم. این delegate زمانی اجرا می شود که روند اجرای متدی که با BeginInvoke فراخوانی شده است به اتمام برسد. متدی که برای callback باید ارسال شود باید به مبتنی بر signature زیر باشد:

void CallBackMethod(IAsyncResult result)
{
     // code for callback
}

مثالی که تا این لحظه بر اساس آن جلو آمدیم را به صورت زیر تغییر می دهیم تا از قابلیت AsynCallBack استفاده کند:

private static bool isDone = false;

static void Main(string[] args)
{
    MathOperation operation = new MathOperation(Add);
    Console.WriteLine("Main thread ID:"+Thread.CurrentThread.ManagedThreadId);
    var result = operation.BeginInvoke(2, 6, new AsyncCallback(CallBack), null);
    while (!isDone)
    {
        Console.WriteLine("Task in Main method...");
        Thread.Sleep(1000);
    }
    var answer = operation.EndInvoke(result);
    Console.WriteLine("2 + 6 = {0}", answer);
}

public static void CallBack(IAsyncResult result)
{
    isDone = true;
}

همانطور که در کد بالا مشاهده می کنید در ابتدا یک فیلد با نام isDone تعریف شده که از آن برای مشخص کردن وضعیت اجرای Thread استفاده می کنیم. زمانی که متد BeginInvoke را فراخوانی می کنیم به عنوان پارامتر سوم شئ ای از نوع AsyncCallback که متد CallBack برای آن مشخص شده ارسال می شود

این متد زمانی فراخوانی می شود که روند اجرای Thread مرتبط با متد Add به اتمام برسد، متد CallBack پس از اجرا مقدار isDone را برابر true قرار می دهد و به همین دلیل از حلقه while تعریف شده در متد Main خارج می شویم.همانطور که در کد بالا مشاهده می کنید پارامتر ورودی CallBack از نوع IAsyncResult است، یعنی می توان عملیات گرفتن خروجی را در داخل CallBack نیز انجام داد. برای اینکار کد بالا را به صورت زیر تغییر می دهیم:

private static bool isDone = false;

static void Main(string[] args)
{
    MathOperation operation = new MathOperation(Add);
    Console.WriteLine("Main thread ID:"+Thread.CurrentThread.ManagedThreadId);
    operation.BeginInvoke(2, 6, new AsyncCallback(CallBack), null);
    while (!isDone)
    {
        Console.WriteLine("Task in Main method...");
        Thread.Sleep(1000);
    }            
}

public static void CallBack(IAsyncResult result)
{
    AsyncResult asyncRes = (AsyncResult) result;
    var opDelegate = (MathOperation) asyncRes.AsyncDelegate;
    var answer = opDelegate.EndInvoke(result);
    Console.WriteLine("2 + 6 = {0}", answer);
    isDone = true;
}

تغییراتی که در کد بالا دادیم به ترتیب:

  1. ابتدا در متد CallBack پارامتر ورودی result را به کلاس AsyncResult تبدیل کردیم، کلاس AsyncResult اینترفیس IAsyncResult را پیاده سازی کرده است و علاوه بر اعضاء این اینترفیس یکسری اعضاء دیگر دارد از جمله AsyncDelegate که شئ delegate فراخوانی شده را برای ما بر می گرداند.
  2. در قدم بعدی AsyncDelegate را به MathOperation تبدیل کردیم.
  3. در انتها عملیاتی که در متد Main برای گرفتن خروجی نوشته بودیم را به متد CallBack منتقل کردیم تا بتوانیم خروجی متد Add را گرفته و در پنجره Console نمایش دهیم.
  4. در انتها مقدار isDone را برابر true قرار دادیم تا اطلاع دهیم عملیات اجرای متد به پایان رسیده است.

ارسال و دریافت داده های دلخواه بین Thread ها

در خاتمه این قسمت آموزشی با پارامتر چهارم متد BeginInvoke، یعنی state آشنا می شویم. بوسیله این پارامتر می توان یک مقدار یا شئ دلخواه را به Delegate ارسال و از آن بوسیله IAsyncResult استفاده کرد. برای مثال، می خواهیم زمانی که Delegate را فراخوانی می کنیم یک رشته را به delegate پاس داده و در متد CallBack آن را نمایش دهیم. کد نوشته شده را به صورت زیر تغییر می دهیم:

private static bool isDone = false;

static void Main(string[] args)
{
    MathOperation operation = new MathOperation(Add);
    Console.WriteLine("Main thread ID:"+Thread.CurrentThread.ManagedThreadId);
    operation.BeginInvoke(2, 6, new AsyncCallback(CallBack), "This is state passed to thread from Main Method!!");
    while (!isDone)
    {
        Console.WriteLine("Task in Main method...");
        Thread.Sleep(1000);
    }            
}

public static void CallBack(IAsyncResult result)
{
    Console.WriteLine("State: " + result.AsyncState);
    AsyncResult asyncRes = (AsyncResult) result;
    var opDelegate = (MathOperation) asyncRes.AsyncDelegate;
    var answer = opDelegate.EndInvoke(result);
    Console.WriteLine("2 + 6 = {0}", answer);
    isDone = true;
}

در متد و زمان فراخوانی delegate بوسیله BeginInvoke به عنوان پارامتر چهارم یک رشته را به عنوان state ارسال کرده و در CallBack بوسیله خاصیت AsyncState توانستیم state ارسال شده را گرفته و در خروجی نمایش دهیم.تا این قسمت شما یاد گرفتید که چگونه در زبان دات نت می توان با کمک Delegate ها اقدام به اجرای کدها در یک Thread جداگانه کرد. در قسمت های بعدی آموزش با نحوه استفاده از کلاس Thread که در فضای نام System.Threading قرار دارد بیشتر آشنا خواهیم شد.

فضای نام System.Threading

تا اینجا متوجه شدیم که چگونه می توان با کمک Delegate ها کدها را در یک Thread جداگانه و به صورت Asynchrnonous اجرا کرد. در ادامه مباحث مرتبط با برنامه نویسی Asynchronous به سراغ فضای نام System.Threading می رویم.

این فضای نام شامل یکسری کلاس است که روند نوشتن برنامه Multi-Threaded را آسان می کند. کلاس های زیادی در این فضای نام وجود دارد که هر یک استفاده خاص خودش را دارد. در زیر با توضیح اولیه برخی از کلاس های این فضای نام آشنا می شویم:

  1. Interlocked: از این کلاس برای اجرای عملیات های atomic یا Atomic Operations بر روی متغیرهایی که در بین چندین Thread به اشتراک گذاشته شدند استفاده می شود.
  2. Monitor: از این کلاس برای پیاده سازی Synchronization بر روی اشیاء ای که Thread به آن دسترسی دارند استفاده می شود. در سی شارپ کلمه کلیدی lock در پشت زمینه از مکانیزم Monitor برای Synchronization استفاده می کنید که در بخش های بعدی با این تکنیک بیشتر آشنا می شویم.
  3. Mutex: از این کلاس برای اعمال Synchronization بین AppDomain ها استفاده می شود.
  4. ParameterizedThreadStart: این delegate به thread ها این اجازه را می دهد تا متدهایی پارامتر ورودی دارند را فراخوانی کند.
  5. Semaphor: از این کلاس برای محدود کردن تعداد Thread هایی که می توانند به یک Resource دسترسی داشته باشند استفاده می شود.
  6. Thread: به ازای هر Thread ایجاد شده برای برنامه باید یک کلاس از نوع Thread ایجاد کرد. در حقیقت کلاس Thread نقش اصلی را در ایجاد و استفاده از Thread ها دارد.
  7. ThreadPool: بوسیله این کلاس می توان به Thread-Pool مدیریت شده توسط خود CLR دسترسی داشت.
  8. ThreadPriority: بوسیله این enum می توان درجه اهمیت یک Thread را مشخص می کند.
  9. ThreadStart: از این delegate برای مشخص کردن متدی که در Thread باید اجرا شود استفاده می شود. این delegate بر خلاف ParameterizedThreadStart پارامتری قبول نمیکند.
  10. ThreadState: بوسیله این enum می توان وضعیت جاری یک thread را مشخص کرد.
  11. Timer: بوسیله کلاس Timer می توان مکانیزمی پیاده کرد که کدهای مورد نظر در بازه های زمانی خاص، مثلاً هر 5 ثانیه یکبار و در یک Thread مجزا اجرا شوند.
  12. TimerCallBack: از این delegate برای مشخص کردن کدی که داخل timer باید اجرا شود استفاده می شود.

کلاس System.Threading.Thread

کلاس Thread اصلی ترین کلاس موجود در فضای نام System.Threading است. از یک کلاس برای دسترسی به Thread هایی که در روند اجرای یک AppDomain ایجاد شده اند استفاده می شود. همچنین بوسیله این کلاس می تواند Thread های جدید را نیز ایجاد کرد.

کلاس Thread شامل یکسری متد و خصوصیت است که در این قسمت می خواهیم با آن ها آشنا شویم. ابتدا به سراغ خصوصیت CurrentThread که یک خصوصیت static در کلاس Thread است می رویم. بوسیله این خصوصیت می توان اطلاعات Thread جاری را بدست آورد.

برای مثال در صورتی که در متد Main از این خصوصیت استفاده شود می توان به اطلاعات مربوط به Thread اصلی برنامه دسترسی داشت یا اگر برای یک متد Thread جداگانه ای ایجاد شود، در صورت استفاده از این خصوصیت در بدنه متد به اطلاعات Thread ایجاد شده دسترسی خواهیم داشت. در ابتدا با یک مثال می خواهیم اطلاعات Thread اصلی برنامه را بدست آوریم:

var primaryThread = Thread.CurrentThread;
primaryThread.Name = "PrimaryThread";
Console.WriteLine("Thread Name: {0}", primaryThread.Name);
Console.WriteLine("Thread AppDomain: {0}", Thread.GetDomain().FriendlyName);
Console.WriteLine("Thread Context Id: {0}", Thread.CurrentContext.ContextID);
Console.WriteLine("Thread Statred: {0}", primaryThread.IsAlive);
Console.WriteLine("Thread Priority: {0}", primaryThread.Priority);
Console.WriteLine("Thread State: {0}", primaryThread.ThreadState);

دقت کنید در ابتدا با به Thread یک نام دادیم. در صورتی که نامی برای Thread انتخاب نشود خصوصیت Name مقدار خالی بر میگرداند. مهمترین مزیت تخصیص نام برای Thread راحت تر کردن امکان debug کردن کد است. در Visual Studio پنجره ای وجود دارد به نام Threads که می توانید در زمان اجرای برنامه از طریق منوی Debug->Windows->Threads به آن دسترسی داشته باشید. در تصویر زیر نمونه ای از این پنجره را در زمان اجرا مشاهده می کنید:

img1

اما بریم سراغ موضوع اصلی، یعنی ایجاد Thread و اجرای آن. در ابتدا در مورد مراحل ایجاد یک Thread صحبت کنیم، معمولاً برای ایجاد یک Thread مراحل زیر را باید انجام دهیم:

  1. در ابتدا باید متدی ایجاد کنیم که وظیفه آن انجام کاری است که قرار است در یک Thread جداگانه انجام شود.
  2. در مرحله بعد باید یکی از delegate های ParameterizedThreadStart برای متدهایی که پارامتر ورودی دارند یا ThreadStart برای متدهای بدون پارامتر را انتخاب کرده و یک شئ از آن ایجاد کنیم که به عنوان سازنده متد مورد نظر به آن پاس داده می شود.
  3. از روی کلاس Thread یک شئ جدید ایجاد کرده و به عنوان سازنده شئ ای که از روی delegate های گفته شده در مرحله 2 ساختیم را به آن ارسال کنیم.
  4. اطلاعات و تنظیمات اولیه مورد نظر برای Thread مانند Name یا Priority را برای آن ست کنیم.
  5. متد Start را در کلاس Thread را برای شروع کار Thread فراخوانی کنیم. با این کار متدی که در مرحله 2 مشخص کردیم در یک Thread جداگانه اجرا می شود.

دقت کنید در مرحله 2 می بایست بر اساس signature متدی که قصد اجرای آن در thread جداگانه را داریم، delegate مناسب انتخاب شود. همچنین ParameterizedThreadStart پارامتری که به عنوان ورودی قبول می کند از نوع Object است، یعنی اگر می خواهید چندین پارامتر به آن ارسال کنید می بایست حتماً یک کلاس یا struct ایجاد کرده و آن را به عنوان ورودی به کلاس Start ارسال کنید. با یک مثال ساده که از ThreadStart برای اجرای Thread استفاده می کند شروع می کنیم:

static void Main(string[] args)
{
    ThreadStart threadStart = new ThreadStart(PrintNumbers);
    Thread thread = new Thread(threadStart);
    thread.Name = "PrintNumbersThread";
    thread.Start();
    while (thread.IsAlive)
    {
        Console.WriteLine("Running in primary thread...");
        Thread.Sleep(2000);
    }
    Console.WriteLine("All done.");
    Console.ReadKey();
}

public static void PrintNumbers()
{
    for (int counter = 0; counter < 10; counter++)
    {
        Console.WriteLine("Running from thread: {0}", counter + 1);
        Thread.Sleep(500);
    }
}

در ابتدا متدی تعریف کردیم با نام PrintNumbers که قرار است در یک Thread مجزا اجرا شود. همانطور که مشاهده می کنید این متد نه پارامتر ورودی دارد و نه مقدار خروجی، پس از ThreadStart استفاده می کنیم. بعد از ایجاد شئ از روی ThreadStart و ایجاد Thread، نام Thread را مشخص کرده و متد Start را فراخوانی کردیم.

به حلقه while ایجاد شده دقت کنید، در این حلقه بوسیله خصوصیت IsAlive گفتیم تا زمانی که Thread ایجاد شده در حال اجرا است کد داخل while اجرا شود. همچنین بوسیله متد Sleep در متد Main و متد PrintNumbers در عملیات اجرا برای Thread های مربوط به متد تاخیر ایجاد کردیم. بعد اجرای کد بالا خروجی زیر نمایش داده می شود:

Running in primary thread...
Running from thread: 1
Running from thread: 2
Running from thread: 3
Running from thread: 4
Running in primary thread...
Running from thread: 5
Running from thread: 6
Running from thread: 7
Running from thread: 8
Running in primary thread...
Running from thread: 9
Running from thread: 10
All done.

در قدم بعدی فرض کنید که قصد داریم بازه اعدادی که قرار است در خروجی چاپ شود را به عنوان پارامتر ورودی مشخص کنیم، در اینجا ابتدا یک کلاس به صورت زیر تعریف می کنیم:

public class PrintNumberParameters
{
    public int Start { get; set; }
    public int Finish { get; set; }
}

در قدم بعدی کلاس PrintNumbers را به صورت زیر تغییر می دهیم:

public static void PrintNumbers(object data)
{
    PrintNumberParameters parameters = (PrintNumberParameters) data;
    for (int counter = parameters.Start; counter < parameters.Finish; counter++)
    {
        Console.WriteLine("Running from thread: {0}", counter);
        Thread.Sleep(500);
    }
}

همانطور که مشاهده می کنید، پارامتر ورودی PrintNumbers از نوع object است و در بدنه ورودی را به کلاس PrintNumberParameters تبدیل کرده و از آن استفاده کردیم. در مرحله بعد متد Main را باید تغییر داده و به جای ThreadStart از ParameterizedThreadStart استفاده کنیم، همچنین به عنوان پارامتر ورودی برای متد Start شئ ای از PrintNumberParameters ایجاد کرده و با عنوان پارامتر به آن ارسال می کنیم:

ParameterizedThreadStart threadStart = new ParameterizedThreadStart(PrintNumbers);
Thread thread = new Thread(threadStart);
thread.Name = "PrintNumbersThread";
thread.Start(new PrintNumberParameters() {Start = 5, Finish = 13});
while (thread.IsAlive)
{
    Console.WriteLine("Running in primary thread...");
    Thread.Sleep(2000);
}
Console.WriteLine("All done.");
Console.ReadKey();

با اعمال تغییرات ذکر شده و اجرای کد، اعداد بر اساس بازه مشخص شده در خروجی چاپ می شوند. در این قسمت از مطلب مربوط به Thread ها با نحوه ایجاد و استفاده از Thread ها آشنا شدیم. در قسمت های بعدی به مباحث دیگری در مورد Thread ها خواهیم پرداخت.

مفاهیم Foreground و Background

زمانی که یک Thread جدید در برنامه های دات نت ایجاد می شوند، این Thread ها می توانند به دو صورت Foreground و Background اجرا شوند:

  1. Thread های Foreground: زمانی که کی Thread در حالت Foreground اجرا می شود باعث می شود که Thread اصلی برنامه تا زمان کامل شدن اجرای Thread ایجاد شده در حالت اجرا بماند. یعنی از Shut-down شدن Primary Thread توسط CLR جلوگیری می شود.
  2. Thread های Background: این Thread ها که با نام Daemon Thread شناخته می شوند به CLR می گوید که اجرای این Thread آنقدر اهمیت ندارد که Thread اصلی برنامه بخواهد منتظر بماند تا عملیات آن به اتمام برسد و می تواند در هر زمان که Thread اصلی برنامه به اتمام رسید، به صورت خودکار Thread های Background را نیز از بین ببرد.

توجه کنید که کلیه Thread هایی که در برنامه ها ایجاد می کنیم به صورت پیش فرض در حالت Foreground قرار دارند. برای آشنایی بیشتر با این موضوع نمونه کد زیر را در نظر بگیرید:

static void Main(string[] args)
{
    var thread = new Thread(PrintNumbers);
    thread.Start();
}

public static void PrintNumbers()
{
    for (int counter = 1; counter < 10; counter++)
    {
        Console.WriteLine(counter);
        Thread.Sleep(200);
    }
}

همانطور که گفتیم Thread ایجاد شده به صورت پیش فرض از نوع Foreground است و به همین دلیل تا زمانی که روند اجرای Thread ایجاد شده به اتمام نرسد از برنامه خارج نمی شویم و کلیه اعداد در خروجی چاپ می شوند. اما در کد زیر Thread ایجاد شده به صورت Background است و خواهیم دید که پس از اجرای برنامه به دلیل اینکه Thread اصلی زودتر از Thread ایجاد شده به اتمام می رسد، CLR به صورت خودکار Thread ایجاد شده را از بین می برد و اعداد به صورت کامل در خروجی نمایش داده نمی شوند:

static void Main(string[] args)
{
    var thread = new Thread(PrintNumbers);
    thread.IsBackground = true;
    thread.Start();
}

public static void PrintNumbers()
{
    for (int counter = 1; counter < 10; counter++)
    {
        Console.WriteLine(counter);
        Thread.Sleep(200);
    }
}

در برنامه های واقعی باید با دقت نوع Thread ها را انتخاب کرد، برای مثال فرض کنید که در برنامه شما در یک Thread جداگانه عملیاتی بر روی داده های بانک اطلاعاتی انجام می شود و نتیجه این عملیات در انتها باید در جایی ذخیره شود، می توانید

برای اینکار یک Thread از نوع Foreground ایجاد کرده تا پس از خروج از برنامه، Thread اصلی منتظر اتمام انجام عملیات شده و سپس عملیات خروج کامل انجام شود. در مبحث بعدی در مورد موضوع همزمانی یا Concurrency صحبت می کنیم که از مشکلات اساسی در زمینه برنامه نویسی asynchronous می باشد و در مورد راهکار های حل این مشکل نیز صحبت خواهیم کرد

رفع مشکل Concurrency

زمانی که ما برنامه های Multi-Threaded می نویسیم، برخی اوقات Thread های ایجاد شده به داده های مشترک در سطح برنامه دسترسی دارند و وظیفه ما به عنوان برنامه نویس این است که مطمئن باشیم دسترسی چند Thread به داده های مشترک باعث بروز مشکل نمی شود.

برای آشنایی بیشتر با این موضوع شرایطی را در نظر بگیرید که یک متد قرار است در چندین thread مختلف به صورت جداگانه اجرا شود، بعد از شروع کار هر thread زمانبندی اجرا توسط CLR به هر thread به صورت خودکار انجام شده و ما نمی توانیم دخالتی در این موضوع داشته باشیم، ممکن است در این بین اختصاص زمان به یک thread بیش از thread دیگر انجام شود و در این بین خروجی مناسب مد نظر ما ایجاد نمی شود. برای آشنایی با این موضوع متد PrintNumbers که در زیر تعریف کردیم را در نظر بگیرید:

public static void PrintNumbers()
{
    Console.Write("{0} is printing numbers > ", Thread.CurrentThread.Name);
    for (int counter = 0; counter < 10; counter++)
    {
        Thread.Sleep(200*new Random().Next(5));
        Console.Write("{0},", counter);
    }
    Console.WriteLine();
}

در مرحله بعد متد Main را به صورت زیر تغییر می دهیم تا 10 thread ایجاد شده و سپس کلیه thread ها اجرا شوند:

Thread[] threads = new Thread[10];

for (int index = 0; index < 10; index++)
{
    threads[index] = new Thread(PrintNumbers);
    threads[index].Name = string.Format("Worker thread #{0}.", index);
}

foreach (var thread in threads)
{
    thread.Start();
}

Console.ReadLine();

همانطور که مشاهده می کنید کلیه thread ها به صورت همزمان اجرا می شوند، اما پس از اجرا کد بالا، خروجی برای بار اول به صورت خواهد بود، البته دقت کنید که با هر بار اجرا خروجی تغییر می کند و ممکن است برای بار اول خروجی زیر برای شما تولید نشود:

Worker thread #0. is printing numbers > Worker thread #1. is printing numbers > Worker thread #2. is printing numbers > Worker thread #3. is printing numbers > 0,Worker thread #4. is printing numbers > 0,1,1,2,3,2,Worker thread #5. is printing numbers > 0,4,3,1,4,2,5,Worker thread #6. is printing numbers > 5,3,Worker thread #7. is printing numbers > 4,6,6,0,Worker thread #8. is printing numbers > Worker thread #9. is printing numbers > 0,0,7,5,7,0,1,0,1,0,6,8,8,1,2,1,1,0,2,9,
7,3,2,2,9,
2,1,8,3,3,3,4,2,1,9,
4,4,4,5,3,3,5,5,5,6,2,6,6,7,6,4,4,7,7,8,9,
8,9,
7,8,9,
5,5,3,8,6,7,8,9,
6,7,8,9,
4,5,9,
6,7,8,9,

اگر برنامه را مجدد اجرا کنید خروجی متفاوتی از خروجی قبلی دریافت خواهیم کرد:

Worker thread #0. is printing numbers > Worker thread #1. is printing numbers > Worker thread #2. is printing numbers > Worker thread #3. is printing numbers > Worker thread #4. is printing numbers > Worker thread #5. is printing numbers > Worker thread #6. is printing numbers > 0,Worker thread #7. is printing numbers > 1,2,0,1,3,2,4,3,Worker thread #8. is printing numbers > Worker thread #9. is printing numbers > 0,0,0,0,0,0,5,4,5,6,7,8,9,
6,7,8,9,
1,1,0,0,1,1,1,1,1,1,2,2,2,2,2,2,2,2,3,3,3,4,5,6,7,8,9,
3,3,3,3,3,4,4,4,4,5,6,7,8,9,
5,6,7,8,9,
5,6,7,5,6,7,8,9,
8,4,4,4,5,5,6,6,7,7,9,
5,8,8,6,9,
9,
7,8,9,

همانطور که مشاهده می کنید خروجی های ایجاد کاملاً با یکدیگر متفاوت هستند. مشخص است که در اینجا مشکلی وجود دارد و همانطور که در ابتدا گفتیم این مشکل وجود همزمانی یا Concurrency در زمان اجرای thread هاست. زمابندی CPU برای اجرای thread ها متفاوت است

و با هر بار اجرا زمان های متفاوتی به thread ها برای اجرا تخصیص داده می شود. اما خوشبختانه مکانیزم های مختلفی برای رفع این مشکل و پیاده سازی Synchronizqation وجوددارد که در ادامه به بررسی راهکاری های مختلف برای حل مشکل همزمانی می پردازیم.

پیاده سازی Synchronization با کلمه کلیدی lock

اولین مکانیزم مدیریت همزمانی در زمان اجرای Thread ها استفاده از کلمه کلیدی lock است. این کلمه کلیدی به شما این اجازه را می دهد تا یک scope مشخص کنید که این scope باید به صورت synchronized بین thread ها به اشتراک گذاشته شود

یعنی زمانی که یک thread وارد scope ای شد که با کلمه کلیدی lock مشخص شده، thread های دیگر باید منتظر شوند تا thread جاری که در scope قرار دارد از آن خارج شود. برای استفاده از lock شما اصطلاحاً می بایست یک token را برای scope مشخص کنید که معمولاً این کار با ایجاد یک شئ از نوع object و مشخص کردن آن به عنوان token برای synchronization استفاده می شود. شیوه کلی استفاده از lock به صورت زیر است:

lock(token)
{
    // all code in this scope are thread-safe
}

اصطلاحاً می گویند کلیه کدهایی که در بدنه lock قرار دارند thread-safe هستند. برای اینکه کد داخل متد PrintNumbers به صورت thread-safe اجرا شود، ابتدا باید یک شئ برای استفاده به عنوان token در کلاس Program تعریف کنیم:

class Program
{
    public static object threadLock = new object();

    ....

در قدم بعدی کد داخل متد PrintNumbers را به صورت زیر تغییر می دهیم:

public static void PrintNumbers()
{
    lock (threadLock)
    {
        Console.Write("{0} is printing numbers > ", Thread.CurrentThread.Name);
        for (int counter = 0; counter < 10; counter++)
        {
            Thread.Sleep(200 * new Random().Next(5));
            Console.Write("{0},", counter);
        }
        Console.WriteLine();
    }
}

با اعمال تغییر بالا، زمانی که thread جدیدی قصد وارد شدن به scope مشخص شده را داشته باشد، باید منتظر بماند تا کار thread جاری به اتمام برسد تا اجرای thread جدید شروع شود. با اعمال تغییر بالا، هر چند بار که کد نوشته شده را اجرا کنید خروجی زیر را دریافت خواهید کرد:

Worker thread #0. is printing numbers > 0,1,2,3,4,5,6,7,8,9,
Worker thread #1. is printing numbers > 0,1,2,3,4,5,6,7,8,9,
Worker thread #2. is printing numbers > 0,1,2,3,4,5,6,7,8,9,
Worker thread #3. is printing numbers > 0,1,2,3,4,5,6,7,8,9,
Worker thread #4. is printing numbers > 0,1,2,3,4,5,6,7,8,9,
Worker thread #5. is printing numbers > 0,1,2,3,4,5,6,7,8,9,
Worker thread #6. is printing numbers > 0,1,2,3,4,5,6,7,8,9,
Worker thread #7. is printing numbers > 0,1,2,3,4,5,6,7,8,9,
Worker thread #8. is printing numbers > 0,1,2,3,4,5,6,7,8,9,
Worker thread #9. is printing numbers > 0,1,2,3,4,5,6,7,8,9,

پیاده سازی Synchronization بوسیله کلاس Monitor

در قسمت قبل که از کلمه کلیدی lock استفاده کردیم، در حقیقت به در پشت زمینه از کلاس Monitor که در فضای نام System.Threading قرار دارد استفاده شده است. زمانی که از کلمه کلیدی lock استفاده می کنیم این کد تبدیل به کدی می شود که از Monitor برای پیاده سازی Synchronization استفاده می کند (می توان این موضوع را با ابزار ildasm.exe و مشاهده کد IL متوجه شد). نحوه استفاده از کلاس Mutex را در کد زیر که تغییر داده شده متد PrintNumbers است مشاهده می کنید:

public static void PrintNumbers()
{
    Monitor.Enter(threadLock);            
    try
    {
        Console.Write("{0} is printing numbers > ", Thread.CurrentThread.Name);
        for (int counter = 0; counter < 10; counter++)
        {
            Thread.Sleep(200*new Random().Next(5));
            Console.Write("{0},", counter);
        }
        Console.WriteLine();
    }
    finally
    {
        Monitor.Exit(threadLock);
    }
}

متد Enter در کلاس Monitor اعلام می کند که thread ای وارد محدوده ای شده است که باید thread-safe باشد. به عنوان پارامتر ورودی برای این متد token ایجاد شده یعنی obj را ارسال می کنیم. در قدم بعدی کل کدی که مربوط به ناحیه thread-safe است باید داخل بدنه try-catch نوشته شود و البته بخش finaly نیز برای آن نوشته شده باشد

همانطور که می دانید بخش finally قسمتی از بدنه try است که در هر صورت اجرا می شود. در قسمت finally متد Exit را با پارامتر threadLock که همان token مربوطه است فراخوانی می کنیم، یعنی thread در حال اجرا از محدوده thread-safe خارج شده است.

دلیل نوشتن try-catch در کد بالا این است که در صورت وقوع خطا عملیات خروج از محدوده thread-safe در هر صورت انجام شود و thread های دیگر منتظر ورود به این محدوده نمانند. شاید این سوال برای شما بوجود بیاید که با وجود کلمه کلیدی lock چه دلیلی برای استفاده از کلاس Monitor وجود دارد؟

دلیل این موضوع کنترل بیشتر بر روی ورود thread ها و اجرای کدهای thread-safe است. برای مثال، بوسیله متد Wait در کلاس Monitor می توان مشخص کرد که یک thread چه مدت زمانی را برای ورود به ناحیه thread-safe باید منتظر بماند و همچنین متدهای Pulse و PulseAll را می توان برای اطلاع رسانی به سایر thread ها در مورد اینکه کار thread جاری به اتمام رسیده استفاده کرد. البته در اکثر موقعیت ها استفاده از کلمه کلیدی lock کافی است و نیازی به استفاده از کلاس Monitor نمی باشد.

پیاده سازی Synchronization با استفاده از کلاس Interlocked

زمانی که قصد داریم مقدار یک متغیر را تغییر دهیم یا عملگرهای ریاضی را بر روی دو متغیر اعمال کنیم، عملیات های انجام شده به دو صورت Atomic و Non-Atomic انجام می شوند. مبحث عملیات عملیات های Atomic چیزی بیش از چند خط نیاز دارد تا توضیح داده شود

اما به طور خلاصه می توان گفت که عملیات های Atomic عملیات هایی هستند که تنها در یک مرحله یا step انجام می شوند. اگر کدهای IL مرتبط به مقدار دهی متغیرها و البته عملگرهای ریاضی را بر روی بیشتر نوع های داده در دات نت مشاهده کنیم میبینیم که این عملیات ها بیشتر به صورت non-atomic هستند

یعنی بیش از یک مرحله برای انجام عملیات مربوط نیاز است که این موضوع می تواند در برنامه های Multi-threaded مشکل ساز شود. در حالت ساده می توان بوسیله مکانیزم lock عملیات synchronization را برای این عملیات ها پیاده سازی کرد:

int value = 1;
lock(token)
{
    value++;
}

اما برای شرایطی مانند مثال بالا استفاده از lock یا کلاس monitor باعث ایجاد overhead اضافی می شود که برای حل این مشکل می توان از کلاس Interlocked برای اعمال synchronization در اعمال انتساب مقدار یا مقایسه مقادیر استفاده کرد. برای مثال، زمانی که می خواهیم مقدار یک متغیر را با استفاده از کلاس Interlocked اضافه کنیم به صورت می توانیم این کار را پیاده سازی کنیم:

int myNumber = 10;
Interlocked.Increment(ref myNumber);

متد Increment در کلاس Interlocked یک مقدار به متغیر مشخص شده اضافه می کند و البته این کار در محیط Thread-Safe انجام می شود. برای کاهش مقدار می توان از متد Decrement به صورت مشابه استفاده کرد:

int myNumber = 10;
Interlocked.Decrement(ref myNumber);

همچنین برای مقایسه و مقدار دهی مقدار یک متغیر می توان از متد CompareExchange استفاده به صورت زیر استفاده کرد:

int myNumber = 10;
Interlocked.CompareExchange(ref myNumber, 15, 10);

در کد بالا در صورتی که مقدار متغیر myNumber برابر 10 باشد، مقدار آن با 15 عوض خواهد شد.

پیاده سازی Synchronization بوسیله خاصیت [Synchronization]

در مطلبی که در مورد Object Context Boundry صحبت کردیم گفتیم که خاصیت [Synchronization] زمانی که بر روی یک کلاس قرار میگیرد، باعث می شود که کد داخل آن کلاس به صورت Thread-Safe اجرا شود. در این قسمت می خواهیم کد مربوط به متد PrintNumbers را به صورت Thread-Safe و با کمک Object Context Boundry و همچنین خاصیت [Synchronization] پیاده سازی کنیم.

برای این کار ابتدا یک کلاس با نام Printer پیاده سازی کرده و متد PrintNumbers را داخل آن قرار می دهیم. دقت کنید که کلاس Printer می بایست از کلاس ContextBoundObject مشتق شده باشد و خاصیت [Synchronization] بر روی آن قرار گرفته باشد:

[Synchronization]
public class Printer : ContextBoundObject
{
    public void PrintNumbers()
    {
        Console.Write("{0} is printing numbers > ", Thread.CurrentThread.Name);
        for (int counter = 0; counter < 10; counter++)
        {
            Thread.Sleep(200*new Random().Next(5));
            Console.Write("{0},", counter);
        }
        Console.WriteLine();
    }
}

پس از انجام تغییرات بالا متد Main را به صورتی تغییر می دهیم که از متد Print در کلاس Printer استفاده کند:

Printer printer = new Printer();

Thread[] threads = new Thread[10];

for (int index = 0; index < 10; index++)
{
    threads[index] = new Thread(printer.PrintNumbers);
    threads[index].Name = string.Format("Worker thread #{0}.", index);
}

foreach (var thread in threads)
{
    thread.Start();
}

Console.ReadLine();

با انجام کارهای بالا و اجرای برنامه مشاهده خواهیم کرد که با وجود عدم استفاده از کلمه کلیدی lock یا کلاس Monitor، برنامه به صورت Thread-Safe اجرا شده و خروجی مناسب برای ما تولید می شود. در اینجا مبحث مربوط به Synchronization به اتمام رسیده و در قسمت در مورد کلاس Timer در فضای نام System.Threading صحبت خواهیم کرد.

کلاس Timer

خیلی وقت ها در برنامه ها نیاز است که کد ما در بازه های زمانی مشخص اجرا شود، برای مثال کدی که باید هر 5 ثانیه یا هر یک دقیقه یکبار اجرا شده و عملیات خاصی را انجام دهد، مانند نمایش تاریخ و ساعت در برنامه و یا بررسی ایمیل ها و مطلع کردن کاربر از ایمیل های جدید.

برای شرایطی از این قبیل می توانیم از کلاس Timer که در فضای نام System.Threading قرار گرفته و وابسه به delegate ای با نام TimerCallback است استفاده کنیم. برای آشنایی بیشتر با این کلاس برنامه ای در محیط کنسول می نویسیم که زمان جاری را تا زمانی که کاربر کلیدی را فشار دهد بر روی خروجی نمایش می دهد. ابتدا یک متد با نام PrintTime به صورت زیر ایجاد می کنیم:

public static void PrintTime(object state)
{
    Console.WriteLine(DateTime.Now.ToString("hh:mm:ss"));
}

کار این متد نمایش تاریخ به صورت ساعت:دقیقه:ثانیه می باشد. دقت کنید که این متد یک پارامتر از نوع object و با نام state میگیرد. دلیل وجود این پارامتر به این خاطر است که TimerCallback که delegate مورد استفاده در کلاس Timer است متدی با این Signature قبول می کند.

در قدم بعدی باید یک شئ از کلاس Timer ایجاد کنیم. علاوه بر اینکه باید TimerCallback را نیز ایجاد کنیم، کلاس Timer به عنوان سازنده به ما این اجازه را می دهد تا پارامترهای مورد نیاز برای آماده سازی Timer را به آن ارسال کنیم، مانند بازه زمانی که کد مورد نظر باید اجرا شود، شئ ای که به عنوان state در زمان فراخوانی متد مورد نظر به آن ارسال می شود و مدت زمان مکس قبل از اولین فراخوانی متد مشخص شده برای Timer. کد زیر را در متد Main می نویسیم:

static void Main(string[] args)
{
    TimerCallback callback = new TimerCallback(PrintTime);

    Timer timer = new Timer(callback, null, 0, 1000);
    Console.WriteLine("Press any key to terminate application...");
    Console.ReadKey();
}

همانطور که مشاهده می کنید ابتدا شئ ای از روی TimerCallback ایجاد کرده، در قدم بعدی کلاس Timer را به همراه پارامتر های مورد نیاز ایجاد کردیم. پارامتر ها به ترتیب:

  1. شئ ای از نوع TimerCallback
  2. شئ ای که برای state استفاده می شود که در کد بالا مقدار null ارسال شده است
  3. مقدار زمان مکس قبل از اولین فراخوانی متد مشخص شده برای Timer
  4. بازه های زمانی برای اجرای متد PrintTime که در اینجا 1000 میلی ثانیه یا 1 ثانیه یکبار است.

با اجرای کد بالا و تا زمانی که کلیدی را فشار ندهیم زمان جاری بر روی خروجی نمایش داده می شود:

Press any key to terminate application...
06:40:06
06:40:07
06:40:08
06:40:09
06:40:10
06:40:11

برای مشخص کردن state پارامتر دوم را می توانیم تغییر دهیم، برای نمونه کد PrintNumbers را به صورت زیر تغییر می دهیم:

public static void PrintTime(object state)
{
    Console.WriteLine(DateTime.Now.ToString("hh:mm:ss") + " {0}", state);
}

و سپس شئ مورد نظر را از متد Main به صورت زیر به سازنده Timer به عنوان پارامتر دوم ارسال می کنیم:

Timer timer = new Timer(callback, "State from Main Method!", 0, 1000);

با اجرای کد بالا خروجی به صورت زیر خواهد بود:

Press any key to terminate application...
06:42:10 State from Main Method!
06:42:11 State from Main Method!
06:42:12 State from Main Method!
06:42:13 State from Main Method!
06:42:14 State from Main Method!
06:42:15 State from Main Method!

از سری مباحث کار با Thread ها موضوع CLR ThreadPool باقی مانده که در قسمت بعد در مورد آن صحبت کرده و پس از آن کار با Task Parallel Library را شروع خواهیم کرد.

CLR ThreadPool

به عنوان آخرین مبحث از سری مباحث مرتبط کار با Thread ها به سراغ نقش CLR ThreadPool می رویم. در قسمت ماهیت Asynchronous در delegate ها گفتیم که بوسیله متد BeginInvoke و EndInvoke می توان یک متد را به صورت Asynchronous فراخوانی کرد، اما نکته ای که اینجا وجود دارد این است که CLR با این کار به صورت مستقیم Thread جدیدی ایجاد نمی کند! برای کارآیی بیشتر متد BeginInvoke یک آیتم در ThreadPool ایجاد می کند که فراخوانی آن در زمان اجرا مدیریت می شود.

برای اینکه بتوانیم به طور مستقیم با این قابلیت در ارتباط باشیم، کلاسی با نام ThreadPool در فضای نام System.Threading وجود دارد که قابلیت این کار را به ما می دهد.برای مثال اگر بخواهیم فراخوانی یک متد را به Thread Pool بسپاریم، کافیست از متد استاتیکی که در کلاس ThreadPool و با نام QueueUserWorkItem وجود دارد استفاده کنیم. بوسیله این متد می توان Callback مرتبط با کار مد نظر و همچنین شئ ای که به عنوان state استفاده می شود را به این متد ارسال کنیم. در زیر ساختار این کلاس را مشاهده می کنید:

public static class ThreadPool
{
    public static bool QueueUserWorkItem(WaitCallback callback);
    public static bool QueueUserWorkItem(WaitCallback callback, object state);
} 

پارامتر WaitCallBack می تواند به هر متدی که نوع بازگشتی آن void و پارامتر ورودی آن از نوع System.Object است اشاره کند. دقت کنید که اگر مقداری برای state مشخص نکنید، به صورت خودکار مقدار null به آن پاس داده می شود. برای آشنایی بیشتر با این کلاس به مثال زیر که همان مثال نمایش اعداد در خروجی است دقت کنید، در ابتدا کلاس Printer:

public class Printer
{
    object threadLock = new object();
    public void PrintNumbers()
    {
        lock (threadLock)
        {
            Console.Write("{0} is printing numbers > ", Thread.CurrentThread.Name);
            for (int counter = 0; counter < 10; counter++)
            {
                Thread.Sleep(200 * new Random().Next(5));
                Console.Write("{0},", counter);
            }
            Console.WriteLine();
        }
    }
}

در ادامه کد متد Main که با استفاده از ThreadPool عملیات ایجاد Thread ها را انجام می دهد:

class Program
{
    static void Main(string[] args)
    {
        var printer = new Printer();
        for (int index = 0; index < 10; index++)
            ThreadPool.QueueUserWorkItem(PrintNumbers, printer);

        Console.ReadLine();
    }

    static void PrintNumbers(object state)
    {
        var printer = (Printer) state;
        printer.PrintNumbers();
    }
}

شاید این سوال برای شما پیش بیاید که مزیت استفاده از ThreadPool نسبت به اینکه به صورت دستی عملیات ایجاد و فراخوانی thread ها را انجام دهیم چیست؟ در زیر به برخی از مزایای اینکار اشاره می کنیم:

  1. Thread Pool به صورت بهینه تعداد عملیات مدیریت thread هایی که می بایست ایجاد شوند، شروع شوند یا متوقف شوند را برای ما انجام می دهد.
  2. با استفاده از Thread Pool شما می توانید تمرکز خود را به جای ایجاد و مدیریت Thread ها بر روی منطق و اصل برنامه بگذارید و سایر کارها را به عهده CLR بگذارید.

اما موارد زیر نیز را مد نظر داشته باشید که مزیت ایجاد و مدیریت thread ها به صورت دستی می باشند:

  1. thread های ایجاد شده توسط thread pool به صورت پیش فرض از نوع foreground هستند، همچنین شما می توانید بوسیله ایجاد thread ها به صورت دستی Priority آن ها را نیز مشخص کنید.
  2. اگر ترتیب اجرای thread ها برای شما مهم باشند یا نیاز داشته باشید thread ها را به صورت دستی حذف یا متوقف کنید این کار بوسیله thread pool امکان پذیر نیست.

با به پایان رسیدن این مطلب، بحث ما بر روی Thread ها به پایان می رسد. به امید خدا در مطالب بعدی راجع به بحث Parallel Programming صحبت خواهیم خواهیم کرد.


حسین احمدی
حسین احمدی

بنیانگذار توسینسو و برنامه نویس و توسعه دهنده ارشد وب

حسین احمدی ، بنیانگذار TOSINSO ، توسعه دهنده وب و برنامه نویس ، بیش از 12 سال سابقه فعالیت حرفه ای در سطح کلان ، مشاور ، مدیر پروژه و مدرس نهادهای مالی و اعتباری ، تخصص در پلتفرم دات نت و زبان سی شارپ ، طراحی و توسعه وب ، امنیت نرم افزار ، تحلیل سیستم های اطلاعاتی و داده کاوی ...

20 تیر 1395 این مطلب را ارسال کرده

نظرات