مجموعه ای از مقالات

کار با 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 می باشد و در مورد راهکار های حل این مشکل نیز صحبت خواهیم کرد.

منبع


قسمت اول آموزش-برنامه نویسی Asynchronous – آشنایی با Process ها، Thread ها و AppDomain ها

قسمت دوم آموزش- آشنایی با ماهیت Asynchronous در Delegate ها

قسمت سوم آموزش-آشنایی با فضای نام System.Threading و کلاس Thread

قسمت چهارم آموزش- آشنایی با Thread های Foreground و Background در دات نت

قسمت پنجم آموزش- آشنایی با مشکل Concurrency در برنامه های Multi-Threaded و راهکار های رفع این مشکل

قسمت ششم آموزش- آشنایی با کلاس Timer در زبان سی شارپ

قسمت هفتم آموزش-آشنایی با CLR ThreadPool در دات نت

قسمت هشتم آموزش- مقدمه ای بر Task Parallel Library و کلاس Parallel در دات نت

قسمت نهم آموزش- برنامه نویسی Parallel:آشنایی با کلاس Task در سی شارپ

قسمت دهم آموزش-برنامه نویسی Parallel در سی شارپ :: متوقف کردن Task ها در سی شارپ – کلاس CancellationToken

قسمت یازدهم آموزش- برنامه نویسی Parallel در سی شارپ :: کوئری های Parallel در LINQ

قسمت دوازدهم آموزش- آشنایی با کلمات کلیدی async و await در زبان سی شارپ

قسمت سیزدهم آموزش- استفاده از متد WhenAll برای اجرای چندین Task به صورت همزمان در سی شارپ

به خاطر دارید که 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;
}

به خطوط ۴ و ۱۰ دقت کنید، در این خطوط از کلاس 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
۲ + ۶ = ۸

همانطور که مشاهده می کنید، شناسه Thread برای متد Add مقدار ۳ می باشد، به این معنی که متد 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 به میزان ۵ ثانیه و متد با هر بار تکرار حلقه while متد متد Main به اندازه ۱ ثانیه متوقف می شوند. اجرای کد بالا خروجی زیر را تولید می کند:

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...
۲ + ۶ = ۸

با اینکه متد Add فراخوانی شده و Thread مرتبط با آن به مدت ۵ ثانیه در حالت 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 مقدار ۱۰۰۰ میلی ثانیه یا ۱ ثانیه را مشخص کردیم. هر زمان که روند اجرای کد به این دستور می رسد، thread جاری به اندازه ۱ ثانیه منتظر تکمیل اجرای متد 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 قرار دارد بیشتر آشنا خواهیم شد.

منبع


قسمت اول آموزش-برنامه نویسی Asynchronous – آشنایی با Process ها، Thread ها و AppDomain ها

قسمت دوم آموزش- آشنایی با ماهیت Asynchronous در Delegate ها

قسمت سوم آموزش-آشنایی با فضای نام System.Threading و کلاس Thread

قسمت چهارم آموزش- آشنایی با Thread های Foreground و Background در دات نت

قسمت پنجم آموزش- آشنایی با مشکل Concurrency در برنامه های Multi-Threaded و راهکار های رفع این مشکل

قسمت ششم آموزش- آشنایی با کلاس Timer در زبان سی شارپ

قسمت هفتم آموزش-آشنایی با CLR ThreadPool در دات نت

قسمت هشتم آموزش- مقدمه ای بر Task Parallel Library و کلاس Parallel در دات نت

قسمت نهم آموزش- برنامه نویسی Parallel:آشنایی با کلاس Task در سی شارپ

قسمت دهم آموزش-برنامه نویسی Parallel در سی شارپ :: متوقف کردن Task ها در سی شارپ – کلاس CancellationToken

قسمت یازدهم آموزش- برنامه نویسی Parallel در سی شارپ :: کوئری های Parallel در LINQ

قسمت دوازدهم آموزش- آشنایی با کلمات کلیدی async و await در زبان سی شارپ

قسمت سیزدهم آموزش- استفاده از متد WhenAll برای اجرای چندین Task به صورت همزمان در سی شارپ

 

 

 

برنامه نویسی Asynchronous – آشنایی با Process ها، Thread ها و AppDomain ها

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

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

Process چیست؟

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

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

 

parallel programming

 

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

parallel programming

هر یک Process های در حال اجرا حافظه، منابع تخصیص داده شده و روند اجرای مربوط به خود را دارند. در تصویر بالا نیز مشخص است، برای مثال در زمان گرفتن عکس بالا، Prcess مربوط به برنامه paint.net مقدار ۲۰٫۴% از CPU و همچنین ۱۰۷٫۶MB از حافظه را اشغال کرده است. در اینجا بیشتر به بحث 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 را نشان دهیم می توان شکل زیر را مثال زد:

parallel programming

تصویر بالا، یک 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);
    }
}

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

parallel programming

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

منبع


قسمت اول آموزش-برنامه نویسی Asynchronous – آشنایی با Process ها، Thread ها و AppDomain ها

قسمت دوم آموزش- آشنایی با ماهیت Asynchronous در Delegate ها

قسمت سوم آموزش-آشنایی با فضای نام System.Threading و کلاس Thread

قسمت چهارم آموزش- آشنایی با Thread های Foreground و Background در دات نت

قسمت پنجم آموزش- آشنایی با مشکل Concurrency در برنامه های Multi-Threaded و راهکار های رفع این مشکل

قسمت ششم آموزش- آشنایی با کلاس Timer در زبان سی شارپ

قسمت هفتم آموزش-آشنایی با CLR ThreadPool در دات نت

قسمت هشتم آموزش- مقدمه ای بر Task Parallel Library و کلاس Parallel در دات نت

قسمت نهم آموزش- برنامه نویسی Parallel:آشنایی با کلاس Task در سی شارپ

قسمت دهم آموزش-برنامه نویسی Parallel در سی شارپ :: متوقف کردن Task ها در سی شارپ – کلاس CancellationToken

قسمت یازدهم آموزش- برنامه نویسی Parallel در سی شارپ :: کوئری های Parallel در LINQ

قسمت دوازدهم آموزش- آشنایی با کلمات کلیدی async و await در زبان سی شارپ

قسمت سیزدهم آموزش- استفاده از متد WhenAll برای اجرای چندین Task به صورت همزمان در سی شارپ

 

 

کار با Thread ها در زبان سی شارپ – آشنایی با فضای نام System.Threading و کلاس Thread

تا اینجا متوجه شدیم که چگونه می توان با کمک 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 می توان مکانیزمی پیاده کرد که کدهای مورد نظر در بازه های زمانی خاص، مثلاً هر ۵ ثانیه یکبار و در یک 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 به آن دسترسی داشته باشید. در تصویر زیر نمونه ای از این پنجره را در زمان اجرا مشاهده می کنید:

آشنایی با فضای نام System.Threading و کلاس Thread

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

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

دقت کنید در مرحله ۲ می بایست بر اساس 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 ها خواهیم پرداخت.

منبع


قسمت اول آموزش-برنامه نویسی Asynchronous – آشنایی با Process ها، Thread ها و AppDomain ها

قسمت دوم آموزش- آشنایی با ماهیت Asynchronous در Delegate ها

قسمت سوم آموزش-آشنایی با فضای نام System.Threading و کلاس Thread

قسمت چهارم آموزش- آشنایی با Thread های Foreground و Background در دات نت

قسمت پنجم آموزش- آشنایی با مشکل Concurrency در برنامه های Multi-Threaded و راهکار های رفع این مشکل

قسمت ششم آموزش- آشنایی با کلاس Timer در زبان سی شارپ

قسمت هفتم آموزش-آشنایی با CLR ThreadPool در دات نت

قسمت هشتم آموزش- مقدمه ای بر Task Parallel Library و کلاس Parallel در دات نت

قسمت نهم آموزش- برنامه نویسی Parallel:آشنایی با کلاس Task در سی شارپ

قسمت دهم آموزش-برنامه نویسی Parallel در سی شارپ :: متوقف کردن Task ها در سی شارپ – کلاس CancellationToken

قسمت یازدهم آموزش- برنامه نویسی Parallel در سی شارپ :: کوئری های Parallel در LINQ

قسمت دوازدهم آموزش- آشنایی با کلمات کلیدی async و await در زبان سی شارپ

قسمت سیزدهم آموزش- استفاده از متد WhenAll برای اجرای چندین Task به صورت همزمان در سی شارپ

در دوربین های مداربسته ی آنالوگ، رزولوشن با TV Line اندازه گیری می شود. در اکثر دوربین های آنالوگ جدید، TVL بین ۴۲۰ تا ۷۰۰ متغیر است. اگر چه ۴۲۰TVL پایین ترین محسوب می شود، سیستم های امنیت تصویری وجود دارد که لازم است فقط یک فاصله ی کوتاه پوشش داده شود و در اینگونه موارد دوربین های ۴۲۰TVL خوب کار می کنند.

دوربین های ۶۰۰TVL به بالا، تصاویر دقیق تر و کنتراست بالایی دارند. اگر نیاز به تصویر صاف و دقیق دارید، دوربین های بالای ۶۰۰TVL را انتخاب کنید هر چند فاکتور های مهم دیگری مانند میزان لوکس، WDR و … در تصویر دریافتی از دوربین تاثیر گذار هستند.

وقتی دوربین ها تصاویر را دریافت می کنند، آن را از طریق کابل به DVR می فرستند. در DVR، تصاویر از حالت آنالوگ به حالت دیجیتال تبدیل می شوند تا هم روی هارد ذخیره شوند و هم از طریق مانیتور نمایش داده شوند. این مهمترین بخش زنجیره ی دریافت و ذخیره ی تصاویر در دوربین های مدار بسته است.

بهترین دوربین ها با بالاترین کیفیت هم در صورتی که از یک DVR با توانایی تبدیل پایین استفاده شود نمی تواند تصویر خوبی به شما بدهد. DVR ها دو مدل رزولوشن پرکاربرد دارند : D1 , Cif

Cif سایز ۳۲۰*۲۴۰ پیکسل به شما می دهد و D1 سایز ۷۲۰*۴۸۰ و همانطور که مشخص است، D1 چهار برابر بزرگتر از Cif است پس تصویر کمتر فشرده می شود و در نتیجه جزئیات بیشتری را نشان می دهد.

برای انتخاب DVR، رزولوشن ضبط تصاویر را در نظر داشته باشید. بعضی از DVR ها هر دو گزینه را دارند ولی معمولا تعداد فریم بر ثانیه را پایین می آورد تا تصاویر پر کیفیت تری ارائه دهد.

 

رزولوشن در دوربین های مدار بسته

 

دوربین های آی پی (IP) قابلیت این را دارند که تصاویر با رزولوشن خیلی خیلی بالاتر داشته باشند. اولین چیزی که باید در مورد دوربین های آی پی بدانید این است که تصاویر را به صورت دیجیتال دریافت می کند به همین خاطر نیازی به تبدیل یا فشرده سازی وجود ندارد. دومین مسئله این است که دوربین های آی پی تصاویر را از طریق کابل های Ca45 یا Ca46 منتقل می کند که قابلیت گذردهی خیلی بیشتری دارند.

دوربین های ۱٫۳ مگاپیکسل معمولا کوچکترین رزولوشن دوربین های آی پی است( البته رزولوشن های پایین تر هم وجود دارد) که خیلی خیلی بزرگتر و با کیفیت تر از هر دوربین آنالوگ دیگری است.

با این وجود اگر حتی تصاویر ۱۲۸۰*۱۰۲۴ پیکسل هم برایتان کوچک است می توانید از دوربین های ۳ مگا پیکسل که رزولوشن ۲۰۴۸*۱۵۳۶ پیکسل دارند استفاده کنید یا حتی اگر این هم کم است می توانید دوربین های ۵ مگا پیکسل (۱۹۴۴*۲۵۹۲) استفاده کنید.

خلاصه اینکه با دوربین های آنالوگ و استفاده از DVR شما نهایت تصاویر D1, 4Cif, 2Cif ,Cif خواهید داشت که ممکن است بتوانند نیازهای شما را برآورده کنند. ولی اگر نیاز به رزولوشن بالاتری دارید باید دوربین های آی پی را در نظر بگیرید و از آنها استفاده کنید.

 

منبع : http://www.elmcctv.ir

 

موازی سازی(Parallelism) چیست؟

ﺷﺮﮐﺖ ﻫﺎی ﺗﻮﻟﯿﺪ ﮐﻨﻨﺪه ﭘﺮدازﺷﮕﺮ ﺑﺮای اﻓﺰاﯾﺶ ﺳﺮﻋﺖ ﭘﺮدازﻧﺪه ﻣﺠﺒﻮر ﺑﻪ ﺑﺎﻻﺑﺮدن ﻓﺮﮐﺎﻧﺲ ﭘﺮدازﺷﮕﺮ ﺑﻮدﻧﺪ. ﯾﮏ راه اﻓﺰاﯾﺶ وﻟﺘﺎژ ﻣﺼﺮﻓﯽ ﭘﺮدازﻧﺪه ﺑﻮد ﮐﻪ دارای ﻧﻘﺎط ﺿﻌﻔﯽ ﻣﺎﻧﻨﺪ اﻓﺰاﯾﺶ دﻣﺎ و اﻓﺰاﯾﺶ ﻣﺼﺮف ﺑﺎﻃﺮی ﻧﯿﺰ ﺑﻮد. از ﻃﺮﻓﯽ ﺗﻮﻟﯿﺪ ﮐﻨﻨﺪﮔﺎن ﭘﺮدازﻧﺪه ﺑﻪ ﮐﻤﮏ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﺎن ﭘﯽ ﺑﻪ ﺑﯿﮑﺎری زﯾﺎد ﭘﺮدازﺷﮕﺮﻫﺎ در زﻣﺎن ﺳﻮﯾﭻ ﮐﺮدن ﻓﺮاﯾﻨﺪ ﻫﺎ و ﻧﺦ ﻫﺎ ﺷﺪﻧﺪ ﮐﻪ ﺣﺪود ﻧﯿﻤﯽ از زﻣﺎن ﭘﺮدازش را ﺑﻪ ﻫﺪر ﻣﯽ داد. ﺑﺮاي ﺟﺒﺮان ﺣﺎﻓﻈﻪ ﮐﺶ را ﮔﺴﺘﺮش دادﻧﺪ اﻣﺎ ﺑﻪ دﻟﯿﻞ ﮔﺮان ﺑﻮدﻧﺶ ﺑﺎز دﭼﺎر ﻣﺤﺪودﯾﺖ ﺑﻮدﻧﺪ. ﺑﻨﺎﺑﺮاﯾﻦ ﭘﺮدازﻧﺪه ﻫﺎﯾﯽ ﺗﻮﻟﯿﺪ ﮐﺮدﻧﺪ ﮐﻪ ﺑﺘﻮاﻧﺪ ﭘﺮازش ﻣﻮازي را (در اﺑﺘﺪا) در دو ﻫﺴﺘﻪ ﺑﻪ اﺟﺮا ﺑﺮﺳﺎﻧﻨﺪ.

ﻧﺎم اﯾﻦ ﻫﺴﺘﻪ ﻫﺎ ﻫﺴﺘﻪ ﻫﺎی ﺳﺨﺖ اﻓﺰاری ﯾﺎ ﻓﯿﺰﯾﮑﯽ ﮔﺬاﺷﺘﻨﺪ. اﻧﺪك زﻣﺎﻧﯽ ﺑﻌﺪ ﻓﻨﺎوری ای ﺑﺮای رﺳﯿﺪن ﺑﻪ ﭘﺮدازش ﻣﻮازی اﻣﺎ در ﺳﻄﺢ ﻣﺤﺪود Hyper ﺗﺮی و ارزان ﺗﺮ ﺑﺎ ﻧﺎم اﺑﺮ ﻧﺨﯽ ﯾﺎ Hyper-Threading اراﺋﻪ ﮐﺮدﻧﺪ و ﻧﺎم آن را ﻫﺴﺘﻪ ﻫﺎی ﻣﻨﻄﻘﯽ ﯾﺎ ﻧﺦ ﻫﺎی ﺳﺨﺖ اﻓﺰاری ﮔﺬاﺷﺘﻨﺪ. ﺣﺎل ﻧﻮﺑﺖ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﺎن ﺑﻮد ﺗﺎ ﺑﺮﻧﺎﻣﻪ ﻫﺎی ﺑﺮاي اﺳﺘﻔﺎده از اﯾﻦ ﻓﻨﺎوری ﻫﺎی ﻧﻮﯾﻦ ﺑﻨﻮﯾﺴﻨﺪ. ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﻣﻮازی ﻋﻨﻮاﻧﯽ اﺳﺖ، ﮐﻪ ﻣﻮﺿﻮﻋﯽ ﮔﺴﺘﺮده در دﻧﯿﺎي ﻧﺮم اﻓﺰار اﯾﺠﺎد ﮐﺮده است.

روش موازی سازی(Parallelism(

ﺳﺎده ﺗﺮﯾﻦ ﺷﯿﻮه ﻣﻮازي ﺳﺎزي در ﻗﺎﻟﺐ Task ها ﺻﻮرت ﻣﯽ ﮔﯿﺮد، در ﻫﺮ Task ﺗﺎﺑﻊ ﯾﺎ ﻗﻄﻌﻪ ﮐﺪي ﻧﻮﺷﺘﻪ ﻣﯽ ﺷﻮد و ﺳﭙﺲ ﺑﻮﺳﯿﻠﻪ Delegate اي ﮐﻪ ﮐﺎر ﻣﺪﯾﺮﯾﺖ Task ﻫﺎ را ﺑﺮ ﻋﻬﺪه دارد اﯾﻦ  Task ﻫﺎ ﺑﺼﻮرت ﻣﻮازی ﺑﺴﺘﻪ ﺑﻪ ﻫﺴﺘﻪ ﻫﺎی ﻣﻨﻄﻘﯽ در دﺳﺘﺮس اﺟﺮا ﻣﯽ ﺷﻮﻧﺪ. روش ﻫﺎی ﺑﺴﯿﺎری ﺑﺮاي ﻣﻮازی ﺳﺎزی وﺟﻮد دارد ﻣﺎﻧﻨﺪ اﺳﺘﻔﺎده از ﮐﻼس Parallel.For یا Parallel.ForEach ﮐﻪ در ﺟﺎي ﺧﻮد ﮐﺎرﺑﺮد ﻫﺎی ﻣﺨﺘﺺ ﺑﻪ ﺧﻮدﺷﺎن را دارﻧﺪ. همیشه الگورﯾﺘﻢ ﻫﺎی ﺗﺮﺗﯿﺒﯽ را ﻧﻤﯽ ﺗﻮان ﺑﻪ الگورﯾﺘﻤﯽ ﻣﻮازي ﺗﺒﺪﯾﻞ ﮐﺮد ﭼﺮا ﮐﻪ ﮐﺪ ﻫﺎی ﺗﺮﺗﯿﺒﯽ ای ﻫﺴﺘﻨﺪ ﮐﻪ اﺟﺮاي ﮐﺪ ﻫﺎي دﯾﮕﺮ ﻧﯿﺎز ﺑﻪ ﺗﮑﻤﯿﻞ ﺷﺪن آن ﻫﺎ دارد. ﺑﺴﺘﻪ ﺑﻪ الگورﯾﺘﻢ درﺻﺪی از آن را ﻣﯽ ﺗﻮان ﻣﻮازی ﮐﺮد. ﻗﺒﻞ از ﻣﻮازی ﺳﺎزی ﺑﺎﯾﺪ ﻣﻮازی ﺳﺎزی را در ذﻫﻨﺘﺎن ﻃﺮاﺣﯽ ﮐﻨﯿﺪ.


Parallel Programming  یا برنامه نویسی موازی یعنی تقسیم یک مسئله به مسائل کوچکتر و سپردن آن ها به واحد های جداگانه برای پردازش کردن.این مسائل کوچک به صورت همزمان شروع به اجرا می کنند. Parallel Programming وظیفه یا Task را به اجزا مختلفی تقسیم می کند.

فرم های مختلفی از Parallel وجود دارد .مانند bit-level ،  instruction-level، data ، taskدر این آموزش راجع به Data Parallelism و Task Parallelism بحث خواهیم کرد.

تصور کنید هسته CPUمتشکل از چندین ریزپردازنده است که همه این ها به حافظه اصلی دسترسی دارند.هر کدام از این ریزپردازنده ها قسمتی از مسئله را حل می کنند.

Data Parallelism

این مورد بر روی توزیع دیتا در نقاط مختلف تمرکز می کند.یعنی داده را به بخش های مختلفی می شکند.هر کدام از این بخش ها به Thread جداگانه ای برای پردازش داده می شود.

Task Parallelism

این مفهوم وظایف یا Taskها را به بخش هایی شکسته و هر کدام را به یک Thread جهت پردازش می دهد.

در پروژه ای که به صورت ضمیمه این مقاله می باشد (در پروژه DataParallisem)به سه صورت مختلف وظیفه یا Task تعریف شده است.

۱-به صورت Function

۲- به صورت Delegate

۳-به صورت لامبدا

کد این قسمت به صورت زیر می باشد

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
  
namespace TPL_part_1_creating_simple_tasks
{
    class Program
    {
        static void Main(string[] args)
        {
            //Action delegate
            Task task1 = new Task(new Action(HelloConsole));
 
            //anonymous function
            Task task2 = new Task(delegate
            {
                HelloConsole();
            });
             
            //lambda expression
                Task task3 = new Task(() = > HelloConsole());                 
             
            task1.Start();
            task2.Start();
            task3.Start();
             
            Console.WriteLine("Main method complete. Press any key to finish.");
            Console.ReadKey();
        }
        static void HelloConsole()
        {
            Console.WriteLine("Hello Task");
        }
    }
}

 

بعد از اجرا، هر کدام از Task ها اجرا شده البته به صورت همزمان و کارهای محوله به آنها را انجام میدهند.

آموزش موازی سازی در سی شارپ

 

در این آموزش بر روی مفهوم Data Parallelism تمرکز خواهیم کرد.توسط Data Parallelism عملیات یکسانی بر روی المانهای یک مجموعه یا آرایه به صورت همزمان انجام خواهد شد. که در فضای نام System.Threading.Tasks.Parallel قرار دارد. روش اصلی برای انجام Data Parallelismنوشتن یک تابع است که یک حلقه ساده بدون Thread دارد .

public static void DataOperationWithForeachLoop()
       {
           var mySource = Enumerable.Range(0, 1000).ToList();
           foreach (var item in mySource)
           {
               Console.WriteLine("Square root of {0} is {1}", item, item * item);
           }
       }

 

خروجی برنامه را در زیر می بینید

آموزش موازی سازی در سی شارپ

 

عملیات Data Parallelism را می توان با یک حلقه foreach موازی هم انجام داد.

public static void DataOperationWithDataParallelism()
        {
            var mySource = Enumerable.Range(0, 1000).ToList();
            Parallel.ForEach(mySource, values = > CalculateMyOperation(values));
        }
 
        public static  void CalculateMyOperation(int values)
        {
            Console.WriteLine("Square root of {0} is {1}", values, values * values);
        }

بعد از اجرا شکل زیر را خواهید دید.

آموزش موازی سازی در سی شارپ

 

در این کد در داخل حلقه Foreach  یک تابع Delegate قرار دادیم در این تابع به ازای هر تکرار حلقه بر روی مجموعه تابعی که درون Delegate فراخوانی کرده ایم اجرا خواهد شد.

Data Parallelism توسط PLINQ

PLINQ به معنای Parallel LINQ است .این نسخه از لینک جهت پیاده سازی لینک بر روی پردازنده های چند هسته ای نوشته شده است.

توسط لینک می توان اطلاعات را از چندین منبع بازیابی کرد.و در نهایت این نتایج با هم ترکیب می شوند تا نتیجه نهایی Query به دست آید.اما اگر از PLINQاستفاده کنیم این دستورات به جای اینکه پشت سر هم اجرا شوند به صورت موازی اجرا می شوند.

برای این که از PLINQ استفاده کرد فقط کافی است که در انتهای عبارت لینک از AsParallel استفاده کنیم.به کد زیر توجه کنید

public static void DataOperationByPLINQ()
    {
        long mySum = Enumerable.Range(1, 10000).AsParallel().Sum();
        Console.WriteLine("Total: {0}", mySum);
    }

بعد از اجرا شکل زیر را خواهید دید

آموزش موازی سازی در سی شارپ

 

برای به دست آوردن اعداد فرد در این مجموعه توسط Plinq از کد زیر استفاده می کنیم

public static void ShowEvenNumbersByPLINQ()
      {
          var numers = Enumerable.Range(1, 10000);
          var evenNums = from number in numers.AsParallel()
                         where number % 2 == 0
                         select number;
 
          Console.WriteLine("Even Counts :{0} :", evenNums.Count());
      }

پس از اجرا شکل زیر را خواهید دید

آموزش موازی سازی در سی شارپ

 

توسط متد Parallel.Invoke() می توانید چندین متد را مانند شکل زیر به صورت همزمان اجرا کنید.

Parallel.Invoke(    
() = > Method1(mycollection),    
() = > Method2(myCollection1, MyCollection2),    
() = > Method3(mycollection));

 MaxDegreeOfParallelism

ماکزیمم تعداد پردازش های موازی را مشخص می کند در کد زیر و در داخل Foreach در پارامتر دوم ماکزیمم تعداد پردازش های موازی مشخص شده اشت.

loopState.Break()

توسط این کد به Thread هایی که پردازش آنها طول کشیده اجازه می دهیم که بعدا Break شوند.به کد زیر توجه کنید.

var mySource = Enumerable.Range(0, 1000).ToList();    
int data = 0;    
Parallel.ForEach(    
    mySource,    
    (i, state) = >    
    {    
        data += i;    
        if (data  >  100)    
        {    
            state.Break();    
            Console.WriteLine("Break called iteration {0}. data = {1} ", i, data);    
        }    
    });    
Console.WriteLine("Break called data = {0} ", data);    
Console.ReadKey();

منبع

 


فایل ضمیمه این آموزش

TPL_part_1_creating_simple_tasks

رمز فایل: behsan-andish.ir


دانلود کتاب آموزش برنامه نویسی موازی با #C

Parallel Programming In Csharp

رمز فایل: behsan-andish.ir

 

تکنولوژی EFFIO-V و EFFIO-A چیست؟

تکنولوژی EFFIO-V و EFFIO-A که توسط شرکت سونی به بازار عرضه شده اند با قابلیت و عملکردهای بسیار توسعه یافته به عنوان نسل سوم سری EFFIO در نظر گرفته می شود.

این دو محصول جدید میتوانند با سنسور تصویر ۹۶۰H ترکیب شده تا بتوانند کیفیت تصویری بالاتر از ۷۰۰ تی وی لاین را ایجاد نماید. همچنین این آی سی ها بهبود یافتند تا قابلیت هایی از قبیل کاهش نویز سه بعدی (۳D-NR)و قرار گرفتن در معرض مادون قرمز و طیف گسترده ای پویا (WDR) و یا مه زدا DEFOG)) و نمایش تصاویر در شرایط مختلف مانند نور کم ، نور مادون قرمز و نور زیاد که کاملا توسعه یافته در عملکرد خود داشته باشند. علاوه بر این این آی سی ها برای اولین بار قابلیت تشخیص اتوماتیک به صورت صنعتی و انتخاب صحنه را دارا هستند.

EFFIO-V و EFFIO-A ، اصلاح شده تا پردازشگر سیگنال را با وضوح بالا انجام دهد و رزولوشن بالای ۷۰۰تی وی لاین را ایجاد کند که این رزولوشن بالاتر از رزولوشن سری های EFFIOموجود ۶۵۰ تی وی لاین است .

EFFIO-V و EFFIO-A

قابلیت کاهش نویز سه بعدی

این تکنولوژی تاری موضوعات در حال حرکت ، روشنی و سیگنال به نویز تصاویری که حتی در محیط های کم نور هستند را کاهش می دهد. همچنین به طور موثر از شرایط زمانی که انعکاس نور مادون قرمز بیش از حد شده باشد و یا جزئیات نفر پنهان شده باشد و یا زمانی که در اطراف لبه ای بیرونی تصاویر و یا گوشه های تاریک شده (سایه) باشد جلوگیری می کند.
بنابراین قابلیت این تکنولوژی بهبود بخشیدن تصاویر در محیط های کم نور می باشد.

این محصولات عملکرد مناسب در هر شرایطی برای تنظیم تصاویر را دارا هستند . بعضی از نصب ها زمان زیادی برای تنظیم چند دوربین با ویژگی های مختلف برای کیفیت بهتر را از ما می گیرند . اما EFFIO-V و EFFIO-A قابلیت تشخیص اتوماتیک صحنه را دارند و فقط نیاز به یک عملکرد برای ۴۰الگو در صحنه های تصاویر را برای تصویری ایده آل مثل محدوده دینامیکی ، درجه حرارت ، رنگ را دارد. قابلیت انتخاب صحنه از پیش تنظیم شده برای صحنه های عمومی از جمله دوربین های محیط داخل و محیط خارج نصب شده یا نظارت ترافیکی و یا نور پس زمینه تنظیمات اتوماتیک آنها بر پایه تنظیمات برای کیفیت تصویر ایده آل می باشد .

این قابلیت تنظیمات اتوماتیک برای آسان تر شدن نصب و راه اندازی تصاویر با کیفیت است .

 

EFFIO-V و EFFIO-A

 

 

 

استفاده از EFFIO-V و EFFIO-A

استفاده از EFFIO-V و EFFIO-A

 

 

تاری در سایر ccd ها

سایر ccd ها

 

 

منبع

 
Item Effio-V Effio-A
Supported CCDs ۷۶۰ H, 960 H WDR/normal CCD ۷۶۰ H, 960 H normal CCD
 

 

 

 

 

 

 

 

 

 

Functions

Resolution Horizontal over 700 TV lines
WDR
ATR-EX2
Noise reduction ۲D-NR, 3D-NR
Day & Night
Polygon privacy mask Up to 20 masks
E-zoom
Slow shutter
Digital image stabilizer
BLC/HLC
Automatic scene detection function
Scene selection function
AF detector
Motion detection
White pixel detection compensation Static and dynamic
OSD Flexible 8 languages
Lens shading compensation
Defog
Automatic mechanical iris adjustment
External synchronization LL, VSL
RS-485
Coaxial communication ✔ (Coaxitron by Pelco)
Outputs Analog outputs Y/C separate, composite
Digital outputs ITU-R BT.656 compliant
(۲۷ MHz / 36 MHz)
Package ۹۷-pin LFBGA

چرا از فضای رنگی مختلف استفاده می کنیم؟

از فضای رنگی مختلف استفاده می کنیم چون این امکان در آن فضای رنگی به ما داده میشه تا بتوینم رنگ دلخواه مان را به راحتی از محدوده دیگر رنگ ها جدا کنیم .فرض کنید که شما قصد دارید رنگ سبز را در تصویر فیلتر نمایید این بازه شامل طیفی می باشد که یک سمت آن سبز تیره و در سمت دیگر آن سبز روشن می باشد برای جدا کردن آن در فضای رنگی RGB این امکان وجود ندارد که شما بتوان به صورت خطی یعنی هر کانال با یک شرط بازه رنگ دلخواه را انتخاب نمائید پس به خاطر چنین مشکلاتی تصویر را به فضای رنگی HSV انتقال می دهیم که این فضا از اجزای Hue (رنگدانه) ،Saturation(اشباع) و Value(روشنایی) تشکیل شده.برای تفکیک رنگ سبز در این فضای رنگی کافیست محدوده Hue خود که مربوط به رنگ مورد نظر را انتخاب کرده و سپس کل محدوه اشباع و در نهایت انتخاب محدوده دلخواه برای روشنایی پس در این فضای رنگی به راحتی تونستید رنگ دلخواه خودتون را انتخاب کنید.

تبدیل فضای رنگی در opencv

در کتابخانه Opencv می تونیم از تابع cvtColor استفاده کنیم.

مثال:


/*------------------------------------------------------------------------------------------*\
This file contains material supporting chapter 3 of the cookbook:
Computer Vision Programming using the OpenCV Library
Second Edition
by Robert Laganiere, Packt Publishing, 2013.

This program is free software; permission is hereby granted to use, copy, modify,
and distribute this source code, or portions thereof, for any purpose, without fee,
subject to the restriction that the copyright notice may not be removed
or altered from any source or altered source distribution.
The software is released on an as-is basis and without any warranties of any kind.
In particular, the software is not guaranteed to be fault-tolerant or free from failure.
The author disclaims all warranties with regard to this software, any use,
and any consequent failure, is purely the responsibility of the user.

Copyright (C) 2013 Robert Laganiere, www.laganiere.name
\*------------------------------------------------------------------------------------------*/

#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>

#include <iostream>
#include <vector>

void detectHScolor(const cv::Mat& image, // input image
double minHue, double maxHue, // Hue interval
double minSat, double maxSat, // saturation interval
cv::Mat& mask) { // output mask

// convert into HSV space
cv::Mat hsv;
cv::cvtColor(image, hsv, CV_BGR2HSV);

// split the 3 channels into 3 images
std::vector<cv::Mat> channels;
cv::split(hsv, channels);
// channels[0] is the Hue
// channels[1] is the Saturation
// channels[2] is the Value

// Hue masking
cv::Mat mask1; // under maxHue
cv::threshold(channels[0], mask1, maxHue, 255, cv::THRESH_BINARY_INV);
cv::Mat mask2; // over minHue
cv::threshold(channels[0], mask2, minHue, 255, cv::THRESH_BINARY);

cv::Mat hueMask; // hue mask
if (minHue < maxHue)
hueMask = mask1 & mask2;
else // if interval crosses the zero-degree axis
hueMask = mask1 | mask2;

// Saturation masking
// under maxSat
cv::threshold(channels[1], mask1, maxSat, 255, cv::THRESH_BINARY_INV);
// over minSat
cv::threshold(channels[1], mask2, minSat, 255, cv::THRESH_BINARY);

cv::Mat satMask; // saturation mask
satMask = mask1 & mask2;

// combined mask
mask = hueMask&satMask;
}

int main()
{
// read the image
cv::Mat image= cv::imread("boldt.jpg");
if (!image.data)
return 0;

// show original image
cv::namedWindow("Original image");
cv::imshow("Original image",image);

// convert into HSV space
cv::Mat hsv;
cv::cvtColor(image, hsv, CV_BGR2HSV);

// split the 3 channels into 3 images
std::vector<cv::Mat> channels;
cv::split(hsv,channels);
// channels[0] is the Hue
// channels[1] is the Saturation
// channels[2] is the Value

// display value
cv::namedWindow("Value");
cv::imshow("Value",channels[2]);

// display saturation
cv::namedWindow("Saturation");
cv::imshow("Saturation",channels[1]);

// display hue
cv::namedWindow("Hue");
cv::imshow("Hue",channels[0]);

// image with fixed value
cv::Mat newImage;
cv::Mat tmp(channels[2].clone());
// Value channel will be 255 for all pixels
channels[2]= 255;
// merge back the channels
cv::merge(channels,hsv);
// re-convert to BGR
cv::cvtColor(hsv,newImage,CV_HSV2BGR);

cv::namedWindow("Fixed Value Image");
cv::imshow("Fixed Value Image",newImage);

// image with fixed saturation
channels[1]= 255;
channels[2]= tmp;
cv::merge(channels,hsv);
cv::cvtColor(hsv,newImage,CV_HSV2BGR);

cv::namedWindow("Fixed saturation");
cv::imshow("Fixed saturation",newImage);

// image with fixed value and fixed saturation
channels[1]= 255;
channels[2]= 255;
cv::merge(channels,hsv);
cv::cvtColor(hsv,newImage,CV_HSV2BGR);

cv::namedWindow("Fixed saturation/value");
cv::imshow("Fixed saturation/value",newImage);

// Testing skin detection

// read the image
image= cv::imread("girl.jpg");
if (!image.data)
return 0;

// show original image
cv::namedWindow("Original image");
cv::imshow("Original image",image);

// detect skin tone
cv::Mat mask;
detectHScolor(image,
۱۶۰, ۱۰, // hue from 320 degrees to 20 degrees
۲۵, ۱۶۶, // saturation from ~0.1 to 0.65
mask);

// show masked image
cv::Mat detected(image.size(), CV_8UC3, cv::Scalar(0, 0, 0));
image.copyTo(detected, mask);
cv::imshow("Detection result",detected);

// A test comparing luminance and brightness

// create linear intensity image
cv::Mat linear(100,256,CV_8U);
for (int i=0; i<256; i++) {

linear.col(i)= i;
}

// create a Lab image
linear.copyTo(channels[0]);
cv::Mat constante(100,256,CV_8U,cv::Scalar(128));
constante.copyTo(channels[1]);
constante.copyTo(channels[2]);
cv::merge(channels,image);

// convert back to BGR
cv::Mat brightness;
cv::cvtColor(image,brightness, CV_Lab2BGR);
cv::split(brightness, channels);

// create combined image
cv::Mat combined(200,256, CV_8U);
cv::Mat half1(combined,cv::Rect(0,0,256,100));
linear.copyTo(half1);
cv::Mat half2(combined,cv::Rect(0,100,256,100));
channels[0].copyTo(half2);

cv::namedWindow("Luminance vs Brightness");
cv::imshow("Luminance vs Brightness",combined);

cv::waitKey();
}

منبع