کتابخانه‌ی استاندارد · زمان و همروندی

نخ thread

نگه‌داشتن و منتظر ماندن برای نخ‌هایی که با spawn ساخته می‌شوند.

واردسازی نخ

نام آرگومان‌ها شناسه‌ی خود کد است و معادل فارسی ندارد؛ گونه‌ها، کلیدواژه‌ها و نام بسته‌ها با معادل فارسی نوشته می‌شوند.

در سلام، تابعی را که باید همزمان با بقیه‌ی برنامه اجرا شود با spawn راه می‌اندازید. spawn تابعی بی‌ورودی و بی‌خروجی می‌گیرد و یک عدد به‌عنوان «دسته»ی نخ برمی‌گرداند. با join یا نخ.پیوستن صبر می‌کنید تا آن نخ تمام شود.

بسته‌ی نخ این دسته را در گونه‌ی نخ می‌پیچد تا بتوانید چند نخ را در یک وکتور نگه دارید و همه را یک‌جا منتظر بمانید، و اجرا با پشته نخی با پشته‌ای به اندازه‌ی دلخواه راه می‌اندازد. نخ‌ها متغیرهای سراسری و حافظه‌ی پویا را با هم شریک‌اند؛ برای داده‌ی مشترک همگام سازی یا اتمی را به کار ببرید، برای فرستادن مقدار میان نخ‌ها کانال را، و برای پخش یک حلقه روی همه‌ی هسته‌ها استخر را. نخ را نمی‌شود از بیرون متوقف کرد؛ برای این‌که از نخی بخواهید زودتر تمام کند، زمینه یا یک پرچم اتمی را به کار ببرید که خود نخ بررسی‌اش می‌کند.

تقسیم یک کار میان چند نخ

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

thread-guide-split.salam
واردسازی نخ
واردسازی حافظه

ساختار تکه:
    همگانی آغاز: صحیح۶۴ = ۰
    همگانی انتها: صحیح۶۴ = ۰
    همگانی جمع: صحیح۶۴ = ۰
پایان

تابع جمع بازه(ب: تکه*):
    ناپایا مجموع := ۰ برگردان صحیح۶۴
    ناپایا ای := ب[۰].آغاز
    تا ای <= ب[۰].انتها:
        مجموع += ای
        ای++
    پایان
    ب[۰].جمع = مجموع
پایان

تابع تکه تازه(اول: صحیح۶۴، آخر: صحیح۶۴): تکه*:
    ب := حافظه.تخصیص(اندازه‌گونه(تکه)) برگردان تکه*
    ب[۰] = تکه { آغاز = اول، انتها = آخر }
    برگشت ب
پایان

تابع ریشه:
    اندازه := ۲۵۰ برگردان صحیح۶۴
    ناپایا تکه‌ها := وکتور {} برگردان وکتور<تکه*>
    دیرکن تکه‌ها.آزادکن()
    ناپایا گروه := وکتور {} برگردان وکتور<نخ.نخ>
    دیرکن گروه.آزادکن()
    تکرار ۴ در ش:
        ب := تکه تازه((ش برگردان صحیح۶۴) * اندازه + ۱، (ش برگردان صحیح۶۴ + ۱) * اندازه)
        تکه‌ها.بیفزا(ب)
        گروه = نخ.جمع آوری(گروه، نخ‌ساز(جمع بازه، ب))
    پایان
    نخ.پیوستن به همه(گروه)
    ناپایا کل := ۰ برگردان صحیح۶۴
    هر ب در تکه‌ها:
        سرچاپ ب[۰].آغاز، "تا"، ب[۰].انتها، "="، ب[۰].جمع
        کل += ب[۰].جمع
        حافظه.آزادسازی(ب برگردان تهی*)
    پایان
    سرچاپ "جمع کل:"، کل
پایان
خروجی1 تا 250 = 31375 251 تا 500 = 93875 501 تا 750 = 156375 751 تا 1000 = 218875 جمع کل: 500500

تکه‌ها ممکن است به هر ترتیبی تمام شوند، اما برنامه پاسخ‌ها را فقط بعد از پیوستن به همه و به همان ترتیبی که ذخیره کرده می‌خواند، پس خروجی همیشه یکی است.

کار دیگری کنید تا نخ کارش را بکند

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

thread-guide-background.salam
واردسازی نخ

ناپایا واژه‌ها := ۰
ناپایا خط‌ها := ۰

تابع شمردن متن():
    متن := "the quick brown fox\njumps over\nthe lazy dog"
    ناپایا درون واژه := نادرست
    خط‌ها = ۱
    تکرار متن.طول() در ای:
        ح := متن[ای]
        اگر ح == '\n':
            خط‌ها++
        پایان
        اگر ح == ' ' یا ح == '\n':
            درون واژه = نادرست
        وگرنه وارونه درون واژه:
            درون واژه = درست
            واژه‌ها++
        پایان
    پایان
پایان

تابع ریشه:
    کارگر := نخ.جدید(نخ‌ساز(شمردن متن))
    سرچاپ "نخ اصلی: خواندن تنظیمات"
    سرچاپ "نخ اصلی: باز کردن گزارش"
    نخ.پیوستن(کارگر)
    سرچاپ "خط‌ها:"، خط‌ها، "واژه‌ها:"، واژه‌ها
پایان
خروجینخ اصلی: خواندن تنظیمات نخ اصلی: باز کردن گزارش خط‌ها: 3 واژه‌ها: 9

این‌جا فقط نخ اصلی چاپ می‌کند. اگر هر دو نخ چاپ می‌کردند، ترتیب خط‌ها ممکن بود در هر اجرا فرق کند.

بازگشت عمیق روی پشته‌ی بزرگ‌تر

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

thread-guide-fallback.salam
واردسازی نخ

ناپایا عمق := ۰ برگردان صحیح۶۴

تابع پیمایش(ن: صحیح۶۴): صحیح۶۴:
    اگر ن == ۰:
        برگشت ۰
    پایان
    برگشت ۱ + پیمایش(ن - ۱)
پایان

تابع کار عمیق(_ورودی: تهی*):
    عمق = پیمایش(۳۰۰۰۰۰)
پایان

تابع ریشه:
    ن := نخ.اجرا با پشته(کار عمیق، پوچ، (۱۲۸ * ۱۰۲۴ * ۱۰۲۴) برگردان طبیعی۶۴)
    اگر نخ.معتبر(ن):
        نخ.پیوستن(ن)
    وگرنه:
        سرچاپ "پشته‌ی بزرگ در دسترس نیست، روی همین نخ اجرا می‌شود"
        کار عمیق(پوچ)
    پایان
    سرچاپ "عمق رسیده:"، عمق
پایان
خروجیعمق رسیده: 300000

تابعی که به اجرا با پشته می‌دهید یک تهی* می‌گیرد، پس اگر نخی راه نیفتاد می‌توانید همان تابع را مستقیم با پوچ صدا بزنید.

دام‌ها، و این‌که کدام ابزار

  • به هر نخی که راه می‌اندازید بپیوندید. اگر ریشه برگردد و نخ‌ها هنوز در حال کار باشند، کارشان نیمه‌کاره قطع می‌شود.
  • متغیرهای سراسری میان همه‌ی نخ‌ها مشترک‌اند. اگر دو نخ بی‌قفل یک متغیر را تغییر دهند، پاسخ از اجرایی به اجرای دیگر فرق می‌کند.
  • چاپ چند نخ بی‌ترتیب مشخصی در هم می‌رود. نتیجه‌ها را جمع کنید و از یک نخ چاپ کنید.
  • دسته‌ی صفر یعنی نخ راه نیفتاده است. پیوستن روی آن کاری نمی‌کند، پس هر جا مهم است معتبر را بسنجید.
  • به هر نخ دقیقاً یک بار بپیوندید. روی لینوکس و مک، پیوستن دسته را هم آزاد می‌کند؛ پس پیوستن دوباره به همان نخ حافظه‌ی آزادشده را به کار می‌برد و ممکن است برنامه را از کار بیندازد.
  • جمع آوری همان وکتوری را که گرفته، یک عضو بزرگ‌تر، برمی‌گرداند؛ همیشه نتیجه را دوباره در متغیر بگذارید، مثل گروه = نخ.جمع آوری(گروه، نخ‌ساز(کار)).
می‌خواهیداز این استفاده کنید
منتظر یک یا چند نخ بمانیدنخ‌ساز همراه نخ.پیوستن یا پیوستن به همه
دورهای یک حلقه را روی همه‌ی هسته‌ها اجرا کنیداستخر.برای موازی
نخ‌ها داده‌ی مشترک را تغییر دهندهمگام سازی.قفل یا اتمی.صحیح۶۴
مقدار را از یک نخ به نخ دیگر بفرستیدکانال.کانال
بی‌نگه‌داشتن دسته‌ها بفهمید چند کار تمام شده‌اندهمگام سازی.گروه انتظار

گونه‌ها

نخ Thread

ساختار نخ
یک نخ در حال اجرا یا تمام‌شده.
نامانگلیسیگونهتوضیح
دستهhandleصحیح۶۴ = 0دسته‌ای که spawn برگردانده؛ صفر یعنی نامعتبر.
thread-Join.salam
واردسازی نخ
واردسازی همگام سازی

ناپایا جمع := ۰
ناپایا قفل := همگام سازی.قفل {}

تابع کارگر():
    تکرار ۱۰۰۰:
        همگام سازی.قفل کردن(قفل)
        جمع++
        همگام سازی.باز کردن قفل(قفل)
    پایان
پایان

تابع ریشه:
    قفل = همگام سازی.قفل جدید()
    اول := نخ.جدید(نخ‌ساز(کارگر))
    سرچاپ نخ.معتبر(اول)، نخ.دسته(اول) != ۰
    ناپایا گروه := وکتور {} برگردان وکتور<نخ.نخ>
    دیرکن گروه.آزادکن()
    تکرار ۳:
        گروه = نخ.جمع آوری(گروه، نخ‌ساز(کارگر))
    پایان
    نخ.پیوستن(اول)
    نخ.پیوستن به همه(گروه)
    سرچاپ گروه.طول()، جمع
    خالی := نخ.جدید(۰)
    سرچاپ نخ.معتبر(خالی)، خالی.دسته
    نخ.پیوستن(خالی)
    همگام سازی.نابودسازی(قفل)
پایان
خروجیtrue true 3 4000 false 0

تابع‌ها

جدید New

تابع جدید(h: صحیح۶۴): نخ
دسته‌ی spawn را در یک نخ می‌پیچد.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: thread-Join.salam

اجرا با پشته SpawnStack

تابع اجرا با پشته(fn: صحیح۶۴، arg: تهی*، stack: طبیعی۶۴): نخ
تابعی را روی نخی تازه با اندازه‌ی پشته‌ی دلخواه (به بایت) راه می‌اندازد؛ برای کاری که به پشته‌ی بیش از پیش‌فرض نیاز دارد، مانند بازگشت عمیق. تابع یک تهی* می‌گیرد و چیزی برنمی‌گرداند. اگر سیستم‌عامل نتواند این پشته را بدهد، دسته‌ی نامعتبر برمی‌گرداند، پس با معتبر بسنجید.
thread-SpawnStack.salam
واردسازی نخ

ناپایا جمع := ۰ برگردان صحیح۶۴

تابع شمارش(ن: صحیح۶۴): صحیح۶۴:
    اگر ن <= ۰:
        برگشت ۰
    پایان
    برگشت ۱ + شمارش(ن - ۱)
پایان

تابع کار(_آرگ: تهی*):
    جمع = شمارش(۲۰۰۰۰۰)
پایان

تابع ریشه:
    پشته := (۶۴ * ۱۰۲۴ * ۱۰۲۴) برگردان طبیعی۶۴
    ت := نخ.اجرا با پشته(کار، پوچ، پشته)
    سرچاپ نخ.معتبر(ت)
    نخ.پیوستن(ت)
    سرچاپ جمع
پایان
خروجیtrue 200000

پیوستن Join

تابع پیوستن(t: نخ)
صبر می‌کند تا نخ تمام شود و دسته‌اش را آزاد می‌کند. برای نخ نامعتبر کاری نمی‌کند. به هر نخ فقط یک بار بپیوندید.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: thread-Join.salam

پیوستن به همه JoinAll

تابع پیوستن به همه(threads: وکتور<نخ>)
به ترتیب صبر می‌کند تا همه‌ی نخ‌های وکتور تمام شوند و دسته‌هایشان را آزاد می‌کند. خود وکتور آزاد نمی‌شود.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: thread-Join.salam

معتبر Valid

تابع معتبر(t: نخ): منطقی
اگر دسته صفر نباشد، درست برمی‌گرداند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: thread-Join.salam

دسته Handle

تابع دسته(t: نخ): صحیح۶۴
دسته‌ی نخ.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: thread-Join.salam

جمع آوری Collect

تابع جمع آوری(threads: وکتور<نخ>، h: صحیح۶۴): وکتور<نخ>
نخ تازه‌ای با این دسته به وکتور اضافه می‌کند و وکتور را برمی‌گرداند؛ نتیجه را دوباره در متغیرتان بگذارید.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: thread-Join.salam

تعیین سقف SetLimit

تابع تعیین سقف(n: صحیح۶۴)
بیشترین تعداد نخ زنده در یک زمان را تعیین می‌کند؛ وقتی به سقف برسیم نخ‌ساز صفر برمی‌گرداند. صفر یعنی بدون سقف. نخ تا وقتی پیوسته نشده زنده حساب می‌شود.
thread-Limit.salam
واردسازی حافظه
واردسازی نخ

ناپایا متغیر_stop := پوچ برگردان صحیح۶۴*

تابع hold():
    تا اتمی‌بخوان(متغیر_stop) نابرابر 0:
        گذر
    پایان
پایان

تابع ریشه:
    متغیر_stop = حافظه.تخصیص صفرشده(8 برگردان طبیعی۶۴) برگردان صحیح۶۴*
    اتمی‌بنویس(متغیر_stop، 1 برگردان صحیح۶۴)
    نخ.تعیین سقف(2 برگردان صحیح۶۴)
    الف := نخ‌ساز(hold)
    بافر_محلی := نخ‌ساز(hold)
    نویسه := نخ‌ساز(hold)
    سرچاپ "live: "، نخ.نخ‌های زنده()
    سرچاپ "third refused: "، نویسه برابر 0
    اتمی‌بنویس(متغیر_stop، 0 برگردان صحیح۶۴)
    نخ‌پیوند(الف)
    نخ‌پیوند(بافر_محلی)
    نخ‌پیوند(نویسه)
    سرچاپ "after join: "، نخ.نخ‌های زنده()
    دال := نخ‌ساز(hold)
    سرچاپ "slot free again: "، دال نابرابر 0
    نخ‌پیوند(دال)
    نخ.تعیین سقف(0 برگردان صحیح۶۴)
    حافظه.آزادسازی(متغیر_stop برگردان تهی*)
پایان
خروجیlive: 2 third refused: true after join: 0 slot free again: true

نخ‌های زنده Live

تابع نخ‌های زنده(): صحیح۶۴
تعداد نخ‌هایی که شروع شده‌اند و هنوز پیوسته نشده‌اند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: thread-Limit.salam