sub.srt

1
00:00:01,576 --> 00:00:07,099
تصور کنید دو تا برنامه داریم که  هر دو از یک سری منابع مشترک استفاده کنن

2
00:00:07,099 --> 00:00:08,400
مثلا یه تکه داده

3
00:00:08,400 --> 00:00:11,102
که هر دو برنامه نیاز دارن بهش دسترسی داشته باشن

4
00:00:12,066 --> 00:00:16,294
مثلا اگر یه برنامه بخواد بگه مقدار (متغیری) رو یک واحد ببر بالا

5
00:00:16,460 --> 00:00:17,853
هیچ مشکلی نیست!

6
00:00:17,855 --> 00:00:20,207
برنامه میتونه ببینه که مقدار داده چیه

7
00:00:20,208 --> 00:00:22,082
یک  عدد بالاتر رو محاسبه کنه

8
00:00:22,082 --> 00:00:24,484
و بعد عدد جدید رو جایگزین مقدار اولیه اش بکنه

9
00:00:25,568 --> 00:00:29,695
البته چالشی که کامپیوتر با اون مواجه میشه، دست و پنجه نرم کردن با همزمانی هست

10
00:00:30,149 --> 00:00:34,267
اگر دو برنامه تلاش کنن تا در یک لحظه به داده مشترک دسترسی پیدا کنن

11
00:00:34,268 --> 00:00:35,795
چی میشه ؟!

12
00:00:35,795 --> 00:00:38,411
خب احتمالا اینجا به مشکل میخوریم

13
00:00:38,686 --> 00:00:40,262
خب اگر بدشانس باشیم

14
00:00:40,262 --> 00:00:42,750
هر دو برنامه به مقدار اصلی نگاه میکنن

15
00:00:42,862 --> 00:00:45,508
هر دو یک واحد بالاتر رو محاسبه میکنن

16
00:00:45,509 --> 00:00:49,176
و هردو تلاش میکنن که عدد محاسبه شده رو جایگزین مقدار اصلی کنن

17
00:00:49,545 --> 00:00:52,179
ما میخواستیم دو بار مقدار رو اضافه کنیم

18
00:00:52,179 --> 00:00:56,740
اما در حقیقت فقط یک بار عدد رو اضافه کردیم

19
00:00:57,298 --> 00:01:00,154
این یک مثال از "وضعیت رقابت" است

20
00:01:00,155 --> 00:01:02,399
و ما میخوایم ازش جلوگیری کنیم اگر بشه

21
00:01:02,774 --> 00:01:05,534
برای این کار به یک روش نیاز داریم

22
00:01:05,575 --> 00:01:08,759
که مطمئن بشیم تنها یک برنامه در لحظه

23
00:01:08,760 --> 00:01:12,361
میتونه به یک ناحیه خاص از کد دسترسی داشته باشه

24
00:01:12,361 --> 00:01:15,361
که معمولا بهش میگن منطقه بحرانی

25
00:01:16,117 --> 00:01:20,397
یک روش ساده اینه که برنامه رو مجبور کنیم که نوبتی کار کنه

26
00:01:20,572 --> 00:01:22,572
میتونیم یک متغیر به برنامه اضافه کنیم

27
00:01:22,572 --> 00:01:25,790
که مسئولیت داره ببینه نوبت کیه

28
00:01:26,302 --> 00:01:29,328
نشانگر کارش رو با نشون دادن یک برنامه شروع میکنه

29
00:01:29,329 --> 00:01:33,311
و تنها همون برنامه اجازه داره که وارد منطقه حساس بشه

30
00:01:33,960 --> 00:01:36,322
زمانی که برنامه، منطقه حساس رو ترک میکنه

31
00:01:36,322 --> 00:01:38,852
میتونه نشانگر رو به سمت دیگه بچرخونه

32
00:01:38,855 --> 00:01:41,284
تا نوبت رو به اون یکی برنامه بده

33
00:01:42,171 --> 00:01:48,311
این روش تضمین میکنه که فقط یک برنامه در هر زمان، در منطقه حساس قرار داره

34
00:01:48,944 --> 00:01:51,075
اما این روش عالی نیست

35
00:01:51,076 --> 00:01:57,879
اگر برای مثال یکی از برنامه ها نیاز داشته باشه که به منطقه حساس بیشتر از دیگری دسترسی داشته باشه

36
00:01:58,435 --> 00:02:01,034
اگر ما نیاز داشته باشیم که به منطقه حساس بریم

37
00:02:01,036 --> 00:02:03,108
اما نوبت برنامه دیگه باشه

38
00:02:03,109 --> 00:02:04,822
پس محبوریم صبر کنیم

39
00:02:04,968 --> 00:02:09,145
حتی اگر برنامه دیگه تا بعد ها نیاز به منطقه حساس نداشته باشه

40
00:02:09,632 --> 00:02:12,997
پس حتما باید یک راه بهتر وجود داشته باشه

41
00:02:13,203 --> 00:02:20,112
مسئله اصلی ما وقتی ایجاد میشه که هر دو برنامه تلاش میکنند همزمان به منطقه حساس دسترسی داشته باشن

42
00:02:20,388 --> 00:02:23,349
بدون توجه به اینکه اون یکی برنامه هم دسترسی میخواد

43
00:02:24,193 --> 00:02:31,467
بیاین به هر برنامه یک راه بدیم برای اینکه قصد ورود خودش به منطقه رو اعلام کنه

44
00:02:31,467 --> 00:02:33,805
قبل از اینکه واقعا بخواد وارد بشه

45
00:02:34,474 --> 00:02:37,217
ما به هر برنامه یک چراغ سیگنال میدیم

46
00:02:37,218 --> 00:02:40,288
که میتونه روشن و یا خاموش بشه

47
00:02:41,021 --> 00:02:44,199
هر زمانی که هر برنامه بخواد وارد منطقه حساس بشه

48
00:02:44,199 --> 00:02:47,344
اول چراغ خودشون رو روشن میکنه

49
00:02:47,346 --> 00:02:49,092
که قصدش رو اعلام کنه

50
00:02:49,370 --> 00:02:54,026
بعد، برای امن بودن منطقه، هر برنامه باید این رو قانون رعایت کنه

51
00:02:54,217 --> 00:03:00,711
یک برنامه هرگز نمیتونه وارد منطقه حساس بشه اگر چراغ اون یکی برنامه روشن باشه

52
00:03:02,215 --> 00:03:05,043
اگر چراغ اون یکی برنامه خاموش باشه

53
00:03:05,044 --> 00:03:07,817
پس میفهمیم که نمیخواد وارد منطقه حساس بشه

54
00:03:07,818 --> 00:03:11,122
پس ما مجازیم  که وارد منطقه بشیم و از اطلاعات اشتراکی استفاده کنیم

55
00:03:11,521 --> 00:03:14,456
بدون توجه به اینکه نشانگر به سمت کجاست

56
00:03:15,584 --> 00:03:19,293
اگر برنامه دیگه اعلام نکنه که میخواد وارد بشه

57
00:03:19,294 --> 00:03:22,616
میفهمیم که میتونیم بدون مشکل وارد منطقه بشیم

58
00:03:23,198 --> 00:03:27,215
وقتی که کارمون تموم شد میتونیم بیایم بیرون و چراغمون رو خاموش کنیم

59
00:03:27,501 --> 00:03:34,270
این روش به برنامه ای که بیشتر به منطقه حساس نیاز داره، اجازه میده کارشو بکنه

60
00:03:34,765 --> 00:03:41,258
اما یک چیزی که باید حواسمون باشه اینه که چه اتفاقی میفته وقتی هر دو میخوان وارد بشن

61
00:03:41,764 --> 00:03:45,687
در این وضعیت، هر دو برنامه چراغ خودشون رو روشن میکنن

62
00:03:45,688 --> 00:03:46,817
اما حواستون باشه

63
00:03:46,818 --> 00:03:53,096
هیچ برنامه ای اجازه نداره که به منطقه وارد بشه زمانی که چراغ اون یکی روشنه

64
00:03:53,593 --> 00:03:57,675
بنابراین هر دو برنامه در قسمتی گیر کردند که بهش میگن "قفل مرگ" (دد لاک)

65
00:03:57,715 --> 00:04:02,193
هر دو برنامه تا ابد منتظر این میمونن که چراغ اون یکی خاموش بشه

66
00:04:02,194 --> 00:04:04,569
ولی هیچکدوم از چراغ ها خاموش نمیشه

67
00:04:05,367 --> 00:04:09,336
پس ما به روشی نیاز داریم که این مشکل رو حل کنیم

68
00:04:09,625 --> 00:04:11,609
زمانی که هر دو چراغ روشن هستند

69
00:04:11,610 --> 00:04:15,231
خب، اینجا میتونیم به اشاره گر توجه کنیم

70
00:04:15,233 --> 00:04:18,411
که بتونه تصمیم بگیره که در مرحله بعد، کدوم میتونه وارد منطقه بشه

71
00:04:18,735 --> 00:04:21,572
هر وقت خواستیم که وارد منطقه حساس بشیم

72
00:04:21,572 --> 00:04:24,684
اما چراغ اون یکی برنامه روشنه

73
00:04:24,685 --> 00:04:27,447
میتونه چک کنه که نوبت کیه

74
00:04:27,879 --> 00:04:32,089
اگر اشاره گر بگه که نوبت برنامه دیگه هست

75
00:04:32,091 --> 00:04:35,115
پس ما باید چراغ خودمون رو خاموش کنیم

76
00:04:35,593 --> 00:04:37,596
بعد صبر کنیم که نوبتمون بشه

77
00:04:37,596 --> 00:04:42,119
و تنها بعد از اون چراغ خودمون رو دوباره روشن کنیم

78
00:04:42,817 --> 00:04:44,398
در همون زمان برنامه دیگه

79
00:04:44,399 --> 00:04:48,002
وقتی که ببینه چراغ ما خاموش شده

80
00:04:48,004 --> 00:04:49,954
وارد منطقه میشه

81
00:04:49,956 --> 00:04:51,838
کارشو با داده اشتراکی انجام بده

82
00:04:51,838 --> 00:04:53,016
بعدش بیاد بیرون

83
00:04:53,190 --> 00:04:57,560
وقتی که خارج شد، برنامه باید نشانگر رو به سمت ما بچرخونه

84
00:04:57,560 --> 00:05:00,894
بعدش میتونه چراغ خودش رو خاموش کنه

85
00:05:01,822 --> 00:05:04,091
وقتی که ببینیم اشاره گر به سمت ما جابه جا شده

86
00:05:04,093 --> 00:05:06,548
ما چراغ خودمون رو روشن میکنیم

87
00:05:06,548 --> 00:05:09,492
و چون چراغ برنامه دیگه خاموشه

88
00:05:09,494 --> 00:05:12,781
آزادیم که خودمون وارد منطقه حساس بشیم

89
00:05:13,863 --> 00:05:19,112
این الگوریتم "دکر" برای مسئله "انحصار متقابل" بود

90
00:05:19,274 --> 00:05:21,670
اول ما چراغ سیگنال خودمون رو روشن میکنیم

91
00:05:22,100 --> 00:05:24,966
و تا زمانی که سیگنال برنامه دیگه روشنه

92
00:05:25,411 --> 00:05:27,377
ما نمیتونیم وارد منطقه حساس بشیم

93
00:05:27,387 --> 00:05:31,100
پس به جاش باید ببینیم که آیا نوبت دیگری هست یا نه

94
00:05:31,550 --> 00:05:34,838
اگر هست، ما چراغ خودمون رو خاموش میکنیم

95
00:05:34,867 --> 00:05:37,069
منتظر میمونیم تا نوبتمون بشه

96
00:05:37,069 --> 00:05:39,699
و بعد چراغ خودمون رو دوباره روشن کنیم

97
00:05:40,742 --> 00:05:43,370
وقتی که چراغ برنامه دیگه خاموش میشه

98
00:05:43,370 --> 00:05:45,353
میتونیم وارد منطقه حساس بشیم

99
00:05:45,379 --> 00:05:46,850
و کاری که نیاز داریم رو انجام بدیم

100
00:05:46,850 --> 00:05:48,622
و نشانگر رو به سمت دیگه تکون بدیم

101
00:05:48,624 --> 00:05:50,670
برای اینکه نوبت برنامه دیگه بشه

102
00:05:50,670 --> 00:05:53,473
و بعدش چراغ خودمون رو خاموش کنیم

103
00:05:54,423 --> 00:05:58,170
این دقت خیلی زیادی هست برای چیزی که به ظاهر مسئله ساده ای هست

104
00:05:58,172 --> 00:05:59,968
اما ما به این دقت نیاز داریم

105
00:06:00,644 --> 00:06:03,206
بدون مطلع کردن ممکنه به "وضعیت رقابت" برسیم

106
00:06:03,206 --> 00:06:06,819
که در اون حالت هر دو برنامه همزمان وارد منطقه حساس میشن

107
00:06:06,915 --> 00:06:08,723
بدون دنبال کردن نوبت ها

108
00:06:08,723 --> 00:06:11,379
ناخودآگاه به برنامه سریعتر اجازه میدیم

109
00:06:11,358 --> 00:06:13,822
که تمام دسترسی منطقه حساس رو بگیره

110
00:06:13,822 --> 00:06:17,675
و برنامه دیگه رو برای دسترسی که نیاز داره زجر بده

111
00:06:18,475 --> 00:06:20,690
و بدون اینکه چراغ خودمون رو خاموش کنیم

112
00:06:20,692 --> 00:06:22,338
زمانی که نوبت برنامه دیگه هست

113
00:06:22,339 --> 00:06:24,598
ممکنه در وضعیت قفل مرگ(دد لاک) گیر کنیم

114
00:06:25,322 --> 00:06:27,487
این ها نمونه هایی از چالش هایی هستند

115
00:06:27,487 --> 00:06:30,524
که باید با اونا کنار بیایم وقتی داریم با همزمانی فکر میکنیم

116
00:06:30,978 --> 00:06:34,357
الگوریتم "دکر" تنها راهی نیست که این مشکل رو حل میکنه

117
00:06:34,358 --> 00:06:37,721
اما یکی از اولین الگوریتم هایی بود که برای این کار اختراع شد

118
00:06:38,064 --> 00:06:41,095
که قادره بدون نیاز به سخت افزار خاصی کار کنه

119
00:06:41,096 --> 00:06:43,002
فقط سه تکه داده میخواد

120
00:06:43,132 --> 00:06:44,132
دو تا چراغ

121
00:06:44,132 --> 00:06:45,132
و یک نشانگر برای نوبت دهی

122
00:06:45,151 --> 00:06:52,151
که مطمئن بشیم دو برنامه، بدون مشکل به اطلاعات مشترک دسترسی دارن