پاورپوینت سیلبرشاتز سیستم عامل سولاریس

اسلایدهای سیلبرشاتز (سیستم عامل سولاریس)

مفاهیم کلی
مدل های چند ریسه ای (Multithreading)
استفاده از ریسه ها
سیسم عامل سولاریس
ریسه های سولاریس 2
ریسه های سیستم عامل ویندوز XP
ریسه های Linux
ریسه های Java

مروری بر عناوین مطالب

یک ریسه …
گاهی اوقات با نام پردازه سبک وزن (LWP) نیز شناخته می شود.
از یک شناسه ریسه، یک شمارنده برنامه، یک مجموعه ثبات و یک پشته تشکیل شده است.
تقریبا همه چیز را با سایر ریسه های همان پردازه به اشتراک می گذارد.
بخش کد
بخش داده
منابع در اختیار گذاشته شده توسط سیستم عامل مانند پرونده های باز.
مفاهیم کلی

یک پردازه تک ریسه ای تنها یک ریسه کنترلی دارد.
استفاده از چندین ریسه کنترلی به پردازه اجازه می دهد چندین کار را به صورت همزمان انجام دهد.

پردازه های تک ریسه ای و چند ریسه ای

پاسخ دهی
از آنجا که اجرای برنامه حتی در صورت متوقف شدن بخشی از آن باز هم ادامه می یابد، پاسخ دهی برنامه بهبود می یابد.
اشتراک منابع
به صورت پیش فرض، ریسه ها حافظه و منابع پردازه را به اشتراک میگذارند.
صرفه جویی در منابع سیستمی
ایجاد یک ریسه به مراتب ارزانتر از ایجاد یک پردازه است.
بهره برداری از معماری های چندپردازنده
اجرای هر ریسه روی یک پردازنده  افزایش درجه توازی و کارایی
مزایای ریسه ها

ریسه های کاربر
مدیریت ریسه ها توسط کتابخانه ریسه ای در سطح کاربر انجام می شود.
نمونه ها: کتابخانه pthreads در سیستم عامل های POSIX، کتابخانه C-threads در مکینتاش و کتابخانه UI-threads در سولاریس.

ریسه های هسته
هسته مستقیما از ریسه ها حمایت می کند.
نمونه ها: ویندوز 95، 98، NT و 2000، سولاریس، یونیکس Tru64، BeOS و لینوکس
ریسه های کاربر و هسته

سولاریس نام گونه ای از سیستم عامل یونیکس است که توسط سان مایکروسیستمز تولید می شود و به صورت رایگان [۱] قابل استفاده است.
این سیستم عامل در سال ۱۹۹۲ عرضه شد .
سیستم عامل سولاریس

جایگزین سان اواس در کامپیوترهای سان گردید. شرکت سان بوسیله اوراکل خریداری گردیده است و این شرکت در سال ۲۰۱۰ نسخه ۱۱، سیستم عامل سولاریس را ارایه کرده است
این سیستم به طور گسترده در رایانه های سرور و برای مدیریت شبکه های رایانه ای مورد استفاده قرار می گیرد.

سیستم عامل سولاریس

مدل های چند ریسه ای
مدل چند به یک (Many-to-One)
مدل یک به یک (One-to-One)
مدل چند به چند (Many-to-Many)
مدل های چند ریسه ای

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

در این مدل هر ریسه سطح کاربر به یک ریسه سطح هسته نگاشت می شود.
نمونه ها: ویندوز 95، 98، NT و 2000، OS/2.
مدل یک به یک

این مدل اجازه می دهد چندین ریسه سطح کاربر به چندین ریسه سطح هسته نگاشت شوند.
سیستم عامل اجازه دارد به تعداد کافی ریسه سطح هسته ایجاد کند.
نمونه ها: سولاریس 2، ویندوز NT و 2000 که کتابخانه Fiber روی آنها نصب شده باشد.
مدل چند به چند

مانند چند به چند؛ با این تفاوت که اجازه می دهد یک ریسه سطح کاربر به یک ریسه سطح هسته اختصاص یابد.
مثال: IRIX, HP-UX, Tru64 Unix, Solaris 8
مدل دو سطحی

وقتی یک ریسه fork را فراخوانی می کند، آیا پردازه جدید از تمام ریسه های پردازه قبلی نسخه برداری می کند یا فقط از ریسه فراخواننده یک نسخه ایجاد می کند؟
برخی نگارش های یونیکس دو روال fork ارایه می کنند:
یک نسخه از تمام ریسه ها نسخه برداری می کند.
یک نسخه فقط از ریسه فراخواننده نسخه برداری می کند.
با فراخوانی exec برنامه مشخص شده در پارامترهای فراخوانی جایگزین پردازه فراخواننده و تمامی ریسه های آن می شود.
روال های fork () و exec ()

به فرایند پایان دهی یک ریسه پیش از پایان کار آن «ابطال ریسه» می گوییم.
ابطال ریسه ممکن است به دو صورت متفاوت رخ دهد:
1. ابطال ناهمگام:
یک ریسه دیگر بلافاصله به اجرای ریسه هدف پایان می دهد.
2. ابطال به تعویق افتاده:
ریسه هدف به صورت دوره ای چک می کند که آیا باید به اجرای خود خاتمه دهد یا خیر؟
ابطال ریسه (Thread Cancellation)

در سیستم های یونیکس از سیگنال برای اطلاع رسانی به پردازه ها در مورد وقایع استفاده می شود.
یک رسیدگی کننده سیگنال (Signal Handler) برای پردازش سیگنالها مورد استفاده قرار می گیرد.
سیگنال توسط یک رخداد خاص ایجاد می شود.
سیگنال به پردازه تحویل داده می شود
سیگنال مورد رسیدگی قرار می گیرد.
گزینه ها:
سیگنال را به ریسه ی مربوطه تحویل دهیم.
سیگنال را به همه ریسه های موجود در پردازه تحویل دهیم.
سیگنال را به ریسه هایی معین در پردازه تحویل دهیم.
یک ریسه خاص را مسئول دریافت همه سینگالها قرار دهیم.

رسیدگی به سیگنال (Signal Handling)

ایده کلی:
هنگام راه اندازی پردازه تعدادی ریسه نیز ایجاد کن.
این ریسه ها را در یک مخزن قرار بده و منتظر بمان تا پردازه اعلام نیاز به یک ریسه کند.

معمولا پاسخ به یک درخواست خدمات با استفاده از یک ریسه موجود سریع تر از حالتی است که باید یک ریسه نیز ایجاد شود.
مخزن ریسه (Thread Pool)

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

واسط برنامه نویسی استاندارد POSIX (IEEE 1003.1c) برای ایجاد و همگامی ریسه ها.

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

معمولا در سیستم عامل های یونیکس از این کتابخانه استفاده می شود.
Pthreads

سولاریس 2 علاوه بر Pthreads با فراهم کردن UI-threads از ریسه های سطح کاربر نیز پشتیبانی می کند.
پردازه های سبک وزن (LWP) بین ریسه های سطح کاربر و ریسه های سطح هسته قرار گرفته اند.
هر پردازه حداقل یک LWP دارد.
تنها ریسه های سطح کاربری که به یک LWP متصل باشند اجرا می شوند. سایر ریسه ها یا متوقف شده اند و یا منتظر اختصاص یک LWP هستند.
ریسه های سولاریس 2

ریسه های سولاریس 2

یک پردازه در سولاریس 2

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

در لینوکس به ریسه ها به عنوان وظیفه (task) ارجاع می شود.

ایجاد ریسه ها با استفاده از فراخوانی روال سیستمی clone () انجام می شود.

پس از اجرای clone () فضای حافظه وظیفه (یا پردازه) پدر بین پدر و فرزند به اشتراک گذاشته می شود.
ریسه های لینوکس

به دو صورت می توان در جاوا ریسه ایجاد کرد: ارث بری کلاس Thread و پیاده سازی واسط Runnable.
ریسه های جاوا توسط JVM مدیریت می شوند.
ریسه های جاوا