Letysite.ru

IT Новости с интернет пространства
0 просмотров
Рейтинг статьи
1 звезда2 звезды3 звезды4 звезды5 звезд
Загрузка...

Критическое исключение при сборке заявки

Алгоритмы взаимного исключения

То есть критические секции не могут выполняться параллельно: [math]forall i,j:i neq j Rightarrow CS_i rightarrow CS_j vee CS_j rightarrow CS_i [/math] . Это значит, что выполнение критических секций будет линеаризуемо. Это требование корректности протокола взаимной блокировки.

Проблема, с которой связаны взаимные исключения, является проблемой совместного использования ресурсов: как можно управлять доступом нескольких процессов к общему ресурсу, когда каждый процесс нуждается в исключительном контроле над этим ресурсом при выполнении своей работы? Решение — делать доступным общий ресурс только тогда, когда процесс находится в определенном сегменте кода, называемом критической секцией. И контролировать доступ к общему ресурсу, контролируя каждое взаимное выполнение той части программы, в которой будет использоваться ресурс.

Успешное решение этой проблемы должно иметь по крайней мере три свойства:

  1. Взаимное исключение (англ. mutual exclusion): только один поток может быть в критической секции.
  1. Отсутствие взаимоблокировок (англ. deadlocks): если несколько потоков пытаются войти в критическую секцию, то хотя бы один из них должен войти в критическую секцию за конечное время.
  2. Отсутствие голодания (англ. starvation-freedom): если какой-то поток пытается войти в критическую секцию, то он войдет в критическую секцию за конечное время. Может быть последовательно усиленно, превращаясь в условие честности (англ. fairness).
    • Квадратичное ожидание (англ. quadratic wait) — [math]O(n^2)[/math] операций.
    • Линейное ожидание (англ. linear wait) — [math]O(n)[/math] операций.
    • Первый пришел, первый обслужен (англ. first come first served)

Требование [math]First Come First Served (FCFS)[/math] формализуется так:

  1. Метод [math]lock[/math] должен состоять из двух последовательных секций.
  1. Секция [math]doorway[/math] должны быть [math]wait free[/math] , то есть выполняться за конечное число шагов, независимо от других потоков.
  2. Секция [math]waiting[/math] должна выполнять условие: Если [math]DW_i Rightarrow DW_j[/math] , то [math]res(WT_i) Rightarrow res(WT_j)[/math] .

Каждая программа может быть разделена на четыре секции, что приводит к четырем состояниям.

Если процесс хочет войти в критический раздел, он должен сначала выполнить раздел [math]try[/math] и подождать, пока он не получит доступ к критическому разделу. После того, как процесс выполнил свой критический раздел и завершился с общими ресурсами, ему необходимо выполнить раздел выхода, чтобы освободить их для использования другими процессами. Затем процесс возвращается в некритический раздел.

Алгоритм Петерсона для [math]2[/math] потоков [ править ]

Простейший алгоритм параллельного программирования для взаимного исключения потоков исполнения кода, разработанный Гарри Петерсоном в [math]1981[/math] г. [1] While Peterson’s original formulation worked with only two processes, the algorithm can be generalized for more than two. Хотя изначально был сформулирован для 2-поточного случая, алгоритм может быть обобщён для произвольного количества потоков. Гарантирует взаимное исключение, отсутствие взаимной блокировки и отсутствие голодания.

Принцип работы: перед тем как начать исполнение критической секции кода, поток должен вызвать процедуру [math]lock()[/math] со своим номером в качестве параметра. Она должна организовать ожидание потоком своей очереди входа в критическую секцию. После исполнения критической секции и выхода из неё поток вызывает другую процедуру [math]unlock()[/math] , после чего уже другие потоки смогут войти в критическую область. Рассмотрим реализацию этого принципа алгоритмом Петерсона для двух потоков.

Корректность алгоритма [ править ]

Взаимное исключение [ править ]

Потоки [math]0[/math] и [math]1[/math] никогда не могут попасть в критическую секцию в один момент времени: если [math]0[/math] вошёл в секцию, он установил [math]want[0][/math] в [math]true[/math] . Тогда либо [math]want[1] = false[/math] (тогда поток [math]1[/math] не в критической секции), либо [math]waiting = 1[/math] (тогда поток [math]1[/math] пытается войти в критическую секцию и крутится в цикле), либо поток [math]1[/math] пытается войти в критическую секцию после установки [math]want[1] = true[/math] , но до установки [math]waiting[/math] и цикла. Таким образом, если оба процесса находятся в критической секции, должно быть [math] want[0] space and space want[1] space and space waiting = 0 space and space waiting = 1 [/math] , но такого не может быть одновременно и мы пришли к противоречию.

Отсутствие взаимной блокировки [ править ]

Для того, чтобы оба процесса находились в ожидании, необходимы противоположные значения переменной [math]waiting[/math] , что невозможно.

Отсутствие голодания [ править ]

Возможна ситуация, когда один процесс будет несколько раз подряд захватывать себе критическую секцию, а другой, изъявивший желание попасть туда, будет ждать. В алгоритме Петерсона процесс не будет ждать дольше, чем один вход в критическую секцию: после выполнения [math]unlock()[/math] и повторного захода в [math]lock()[/math] процесс установит себя как ждущего и попадёт в цикл, который не завершится, пока не отработает другой процесс.

Алгоритм Петерсона для [math]N[/math] потоков [ править ]

Обобщение Алгоритм Петерсона для [math]N[/math] потоков. Гарантирует взаимное исключение, отсутствие блокировки и отсутствие голодания. Но алгоритм не очень честный. «Невезучий» поток может ждать пока другие потоки [math]O(N^2)[/math] раз войдут в критическую секцию (квадратичное ожидание).

Алгоритм Лампорта (вариант [math]1[/math] ) [ править ]

Алгоритм Лампорта – алгоритм разделения общих ресурсов между несколькими потоками обладающий взаимным исключением. Опубликован Лесли Лампортом в 1974 году. [2] Гарантирует взаимное исключение, отсутствие блокировки и линейное ожидание.

Аналогия [ править ]

Алгоритм реализует идею пекарни с устройством, выдающим номерки у входа. Каждому входящему покупателю выдаётся номерок на единицу больше предыдущего. Общий счётчик показывает номер обслуживаемого в данный момент клиента. Все остальные покупатели ждут, пока не закончат обслуживать текущего клиента и табло покажет следующий номер. После того как клиент сделает покупку и сдаст свой номерок, служащий увеличивает на единицу допустимые для выдачи устройством у входа номера. Если совершивший покупку клиент захочет снова что-нибудь купить, он должен будет снова взять номерок у входа и встать в общую очередь.

Пусть покупатели это потоки, получившие номера [math]i[/math] .

Критическая секция [ править ]

Когда поток хочет войти в критическую секцию, он должен проверить номера [math]n[/math] , полученные другими потоками, и убедиться, что у него меньший номер. В случае совпадения [math]n[/math] у двух или нескольких потоков, в критическую секцию входит поток с наименьшим номером потока [math]i[/math] .

Когда поток заканчивает работу в критической секции, он освобождает номер n и выходит из критической секции.

Псевдокод [ править ]

Обладает свойством первый пришел, первый обслужен ( [math]FCFS[/math] ), за счет того, что поток [math]P[/math] выполнивший [math]doorway (DW)[/math] до потока [math]Q[/math] , имеет более ранний номер в очереди. Но метки должны быть бесконечными (их можно заменить на конечные метки).

Взаимное исключение [ править ]

Допустим, что два потока одновременно в [math]CS[/math] . Значит поток [math]id[/math] зашел в [math]CS[/math] последним, в то время как другой поток [math]k != id[/math] уже был в [math]CS[/math] . Но зайти в [math]CS[/math] можно если [math]want[k] == false[/math] или [math](label[k], k) gt (label[id], id)[/math] .

Читать еще:  Сборы новое поколение

Случай 1: [math]want[k] == false[/math]

Случай 2: [math](label[k], k) gt = (label[id], id)[/math]

  • Но значит другой поток зашел по [math]want[id] == false[/math] выполнив свой [math]doorway[/math] до потока [math]id[/math] — противоречие.

Алгоритм Лампорта (вариант [math]2[/math] ) [ править ]

Еще одна реализация алгоритма Лампорта. Метки тоже могут быть бесконечными, несмотря на то, что мы их и сбрасываем при выходе из критической секции.

Взаимное исключение с активным ожиданием

Primary tabs

Forums:

Рассмотрим различные способы реализации взаимного исключения с целью избежать вмешательства в критическую область одного процесса при нахождении там другого и связанных с этим проблем.

Запрещение прерываний.

Самое простое решение заключается в запрещении всех прерываний при входе процесса в критическую область и разрешении прерываний при выходе из области. Если прерывания запрещены, то невозможно прерывание по таймеру. Поскольку процессор переключается с одного процесса на другой только по прерыванию. то отключение прерываний исключает передачу процессора другому процессу. Таким образом, запретив прерывания, процесс может спокойно считывать и сохранять совместно используемые данные, не опасаясь вмешательства другого процесса.
И все же было бы неразумно давать пользовательскому процессу возможность запрета прерываний. Представим, что процесс отключил все прерывания и в результате какого-либо сбоя не включил их обратно. Операционная система на этом моменте может закончить свое существование =)).
К тому же в многопроцессорной системе запрещение прерываний повлияет только на тот процессор, который выполнит инструкцию disable. Остальные процессоры продолжат работу и получат доступ к разделенным данным .

С другой стороны, для ядра характерно запрещение прерываний для некоторых команд при работе с переменными или списками. Возникновение прерываний в момент, когда, например, список готовых процессов находится в неопределенном состоянии, могло бы привести к состоянию состязания. Итак, запрет прерываний бывает полезным в самой операционной системе, но это решение неприемлемо в качестве механизма взаимного исключения для пользовательских процессов .

Переменные блокировки.

Теперь попробуем найти программное решение.

Рассмотрим одну совместную переменную блокировки, изначально равную 0. Если процесс хочет попасть в критическую область, он предварительно считывает значение переменной блокировки. Если переменная равна 0, то процесс заменят ее значение на 1 и входит в критическую область. Если же переменная равна 1, то процесс ждет, пока ее значение сменится на 0. Таким образом, 0 означает, что ни одного процесса в критической области нет, а 1 означает, что какой либо процесс находится в критической области.
У этого метода есть свои проблемы. Представим, что один процесс считывает переменную блокировки, обнаруживает, что она равна 0, но прежде, чем он успевает заменить ее на 1, управление получает другой процесс, успешно заменяющий ее на 1. Когда первый процесс снова получит управление, то он тоже заменит значение переменной блокировки на 1 и два процесса одновременно окажутся в критических областях.

Строгое чередование

  1. целая переменная turn, изначально равная 0, отслеживает, чья очередь входить в критическую область.
  2. Вначале процесс 0 проверяет значение turn, считывает 0 и входит в критическую область(*см. примечание ниже)
  3. Процесс 1 также считывает значение turn, считывает 0 и после этого входит в цикл, непрерывно проверяя, когда значение turn будет равно 1.

опечатка

,чтобы задуманное выполнилось(Вначале процесс 0 проверяет значение turn, считывает 0 и входит в критическую область) необходимо в левом цикле (а) вместо

так как именно во втором случае процесс 0 при изначальном turn=0 сможет миновать цикл
————————————

Постоянная проверка значения переменной в ожидании некоторого значения называется активным ожиданием . Данный способ является бесцельной тратой времени процессора.
Активное ожидание используется только в случае, когда есть уверенность в небольшом времени ожидания.

Блокировка, использующая активное ожидание, называется спин-блокировкой .

Когда процесс 0 покидает критическую область, он изменяет значение turn на 1, позволяя процессу 1 попасть в критическую область.
Фактически этот метод требует, чтобы два процесса попадали в критическую область строго по очереди. Не один из них не может попасть в критическую секцию (например, послать файл на печать) два раза подряд.

Алгоритм Петерсона


Перед тем как обратиться к совместно используемым переменным (то есть перед тем, как войти в критическую область), процесс вызывает процедуру enter_region() со своим номером (0 или 1) в качестве параметра.
Поэтому процессу при необходимости придется подождать, прежде чем входить в критическую область.
После выхода из критической области процесс вызывает процедуру leave_region, чтобы обозначить свой выход и тем самым разрешить другому процессу вход в критическую область.

Команда TSL


Рассмотрим решение, требующее аппаратного обеспечения
.
Многие компьютеры, особенно разработанные с расчетом на несколько процессоров, имеют команду
TSL RX.LOCK
(Test and Set Lock), которая действует следующим образом-
В регистр RX считывается содержимое слова памяти lock, а в ячейке памяти lock хранится некоторое ненулевое значение.
Гарантируется, что операция считывания слова и сохранения неделима — другой процесс не может обратиться к слову в памяти, пока команда не выполнена. Процессор, выполняющий команду TSL, блокирует шину памяти, чтобы остальные процессоры не могли обратиться к памяти.
Рассмотрим пример использования команды TSL для взаимного исключения.

Прежде чем попасть в критическую область, процесс вызывавает процедуру enter_region, которая выполняет активное ожидание вплоть до снятия блокировки, затем она устанавливает блокировку и возвращается.
При выходе из критической области процесс вызывает процедуру leave_region, помещающую ноль в переменную lock. Как и в остальных способах решения проблемы критической области, для корректной работы процесс должен вызвать эти процедуры своевремнно, в противном случае взаимное исключение не удастся.

Собеседование по Java — исключения (exceptions) (вопросы и ответы)

Список вопросов и ответов по теме «Исключения в Java».

К списку вопросов по всем темам

Вопросы

1. Дайте определение понятию “исключение”
2. Какова иерархия исключений.
3. Можно/нужно ли обрабатывать ошибки jvm?
4. Какие существуют способы обработки исключений?
5. О чем говорит ключевое слово throws?
6. В чем особенность блока finally? Всегда ли он исполняется?
7. Может ли не быть ни одного блока catch при отлавливании исключений?
8. Могли бы вы придумать ситуацию, когда блок finally не будет выполнен?
9. Может ли один блок catch отлавливать несколько исключений (с одной и разных веток наследований)?
10. Что вы знаете об обрабатываемых и не обрабатываемых (checked/unchecked) исключениях?
11. В чем особенность RuntimeException?
12. Как написать собственное (“пользовательское”) исключение? Какими мотивами вы будете руководствоваться при выборе типа исключения: checked/unchecked?
13. Какой оператор позволяет принудительно выбросить исключение?
14. Есть ли дополнительные условия к методу, который потенциально может выбросить исключение?
15. Может ли метод main выбросить исключение во вне и если да, то где будет происходить обработка данного исключения?
16. Если оператор return содержится и в блоке catch и в finally, какой из них “главнее”?
17. Что вы знаете о OutOfMemoryError?
18. Что вы знаете о SQLException? К какому типу checked или unchecked оно относится, почему?
19. Что такое Error? В каком случае используется Error. Приведите пример Error’а.
20. Какая конструкция используется в Java для обработки исключений?
21. Предположим, есть блок try-finally. В блоке try возникло исключение и выполнение переместилось в блок finally. В блоке finally тоже возникло исключение. Какое из двух исключений “выпадет” из блока try-finally? Что случится со вторым исключением?
22. Предположим, есть метод, который может выбросить IOException и FileNotFoundException в какой последовательности должны идти блоки catch? Сколько блоков catch будет выполнено?

Читать еще:  Сборщик мусора c

Ответы

1. Дайте определение понятию “исключение”

Исключение — это проблема(ошибка) возникающая во время выполнения программы. Исключения могут возникать во многих случаях, например:

  1. Пользователь ввел некорректные данные.
  2. Файл, к которому обращается программа, не найден.
  3. Сетевое соединение с сервером было утеряно во время передачи данных. И т.д.

Все исключения в Java являются объектами. Поэтому они могут порождаться не только автоматически при возникновении исключительной ситуации, но и создаваться самим разработчиком.

2. Какова иерархия исключений.

Исключения делятся на несколько классов, но все они имеют общего предка — класс Throwable. Его потомками являются подклассы Exception и Error.

Исключения (Exceptions) являются результатом проблем в программе, которые в принципе решаемые и предсказуемые. Например, произошло деление на ноль в целых числах.

Ошибки (Errors) представляют собой более серьёзные проблемы, которые, согласно спецификации Java, не следует пытаться обрабатывать в собственной программе, поскольку они связаны с проблемами уровня JVM. Например, исключения такого рода возникают, если закончилась память, доступная виртуальной машине. Программа дополнительную память всё равно не сможет обеспечить для JVM.

В Java все исключения делятся на два типа: контролируемые исключения (checked) и неконтролируемые исключения (unchecked), к которым относятся ошибки (Errors) и исключения времени выполнения (RuntimeExceptions, потомок класса Exception).

Контролируемые исключения представляют собой ошибки, которые можно и нужно обрабатывать в программе, к этому типу относятся все потомки класса Exception (но не RuntimeException).

3. Можно/нужно ли обрабатывать ошибки jvm?

Обрабатывать можно, но делать этого не стоит. Разработчику не предоставлены инструменты для обработки ошибок системы и виртуальной машины.

4. Какие существуют способы обработки исключений?

  1. try — данное ключевое слово используется для отметки начала блока кода, который потенциально может привести к ошибке.
  2. catch — ключевое слово для отметки начала блока кода, предназначенного для перехвата и обработки исключений.
  3. finally — ключевое слово для отметки начала блока кода, которой является дополнительным. Этот блок помещается после последнего блока ‘catch’. Управление обычно передаётся в блок ‘finally’ в любом случае.
  4. throw — служит для генерации исключений.
  5. throws — ключевое слово, которое прописывается в сигнатуре метода, и обозначающее что метод потенциально может выбросить исключение с указанным типом.

Общий вид конструкции для «поимки» исключительной ситуации выглядит следующим образом:

Алгоритмы взаимного исключения

Системы, состоящие из нескольких процессов, часто легче программировать, используя так называемые критические секции. Когда процессу нужно читать или модифицировать некоторые разделяемые структуры данных, он прежде всего входит в критическую секцию для того, чтобы обеспечить себе исключительное право использования этих данных, при этом он уверен, что никакой процесс не будет иметь доступа к этому ресурсу одновременно с ним. Это называется взаимным исключением. В однопроцессорных системах критические секции защищаются семафорами, мониторами и другими аналогичными конструкциями. Рассмотрим, какие алгоритмы могут быть использованы в распределенных системах.

Централизованный алгоритм

Наиболее очевидный и простой путь реализации взаимного исключения в распределенных системах — это применение тех же методов, которые используются в однопроцессорных системах. Один из процессов выбирается в качестве координатора (например, процесс, выполняющийся на машине, имеющей наибольшее значение сетевого адреса). Когда какой-либо процесс хочет войти в критическую секцию, он посылает сообщение с запросом к координатору, оповещая его о том, в какую критическую секцию он хочет войти, и ждет от координатора разрешение. Если в этот момент ни один из процессов не находится в критической секции, то координатор посылает ответ с разрешением. Если же некоторый процесс уже выполняет критическую секцию, связанную с данным ресурсом, то никакой ответ не посылается; запрашивавший процесс ставится в очередь, и после освобождения критической секции ему отправляется ответ-разрешение. Этот алгоритм гарантирует взаимное исключение, но вследствие своей централизованной природы обладает низкой отказоустойчивостью.

Распределенный алгоритм

Когда процесс хочет войти в критическую секцию, он формирует сообщение, содержащее имя нужной ему критической секции, номер процесса и текущее значение времени. Затем он посылает это сообщение всем другим процессам. Предполагается, что передача сообщения надежна, то есть получение каждого сообщения сопровождается подтверждением. Когда процесс получает сообщение такого рода, его действия зависят от того, в каком состоянии по отношению к указанной в сообщении критической секции он находится. Имеют место три ситуации:

1. Если получатель не находится и не собирается входить в критическую секцию в данный момент, то он отсылает назад процессу-отправителю сообщение с разрешением.

2. Если получатель уже находится в критической секции, то он не отправляет никакого ответа, а ставит запрос в очередь.

3. Если получатель хочет войти в критическую секцию, но еще не сделал этого, то он сравнивает временную отметку поступившего сообщения со значением времени, которое содержится в его собственном сообщении, разосланном всем другим процессам. Если время в поступившем к нему сообщении меньше, то есть его собственный запрос возник позже, то он посылает сообщение-разрешение, в обратном случае он не посылает ничего и ставит поступившее сообщение-запрос в очередь.

Процесс может войти в критическую секцию только в том случае, если он получил ответные сообщения-разрешения от всех остальных процессов. Когда процесс покидает критическую секцию, он посылает разрешение всем процессам из своей очереди и исключает их из очереди.

Алгоритм Token Ring

Совершенно другой подход к достижению взаимного исключения в распределенных системах иллюстрируется рисунком 3.7. Все процессы системы образуют логическое кольцо, т.е. каждый процесс знает номер своей позиции в кольце, а также номер ближайшего к нему следующего процесса. Когда кольцо инициализируется, процессу 0 передается так называемый токен. Токен циркулирует по кольцу. Он переходит от процесса n к процессу n+1 путем передачи сообщения по типу «точка-точка». Когда процесс получает токен от своего соседа, он анализирует, не требуется ли ему самому войти в критическую секцию. Если да, то процесс входит в критическую секцию. После того, как процесс выйдет из критической секции, он передает токен дальше по кольцу. Если же процесс, принявший токен от своего соседа, не заинтересован во вхождении в критическую секцию, то он сразу отправляет токен в кольцо. Следовательно, если ни один из процессов не желает входить в критическую секцию, то в этом случае токен просто циркулирует по кольцу с высокой скоростью.

Читать еще:  Что такое сборочный чертеж определение

Сравним эти три алгоритма взаимного исключения. Централизованный алгоритм является наиболее простым и наиболее эффективным. При его использовании требуется только три сообщения для того, чтобы процесс вошел и покинул критическую секцию: запрос и сообщение-разрешение для входа и сообщение об освобождении ресурса при выходе. При использовании распределенного алгоритма для одного использования критической секции требуется послать (n-1) сообщений-запросов (где n — число процессов) — по одному на каждый процесс и получить (n-1) сообщений-разрешений, то есть всего необходимо 2(n-1) сообщений. В алгоритме Token Ring число сообщений переменно: от 1 в случае, если каждый процесс входил в критическую секцию, до бесконечно большого числа, при циркуляции токена по кольцу, в котором ни один процесс не входил в критическую секцию.

К сожалению все эти три алгоритма плохо защищены от отказов. В первом случае к краху приводит отказ координатора, во втором — отказ любого процесса (парадоксально, но распределенный алгоритм оказывается менее отказоустойчивым, чем централизованный), а в третьем — потеря токена или отказ процесса.

Неделимые транзакции

Все средства синхронизации, которые были рассмотрены ранее, относятся к нижнему уровню, например, семафоры. Они требуют от программиста детального знания алгоритмов взаимного исключения, управления критическими секциями, умения предотвращать клинчи (взаимные блокировки), а также владения средствами восстановления после краха. Однако существуют средства синхронизации более высокого уровня, которые освобождают программиста от необходимости вникать во все эти подробности и позволяют ему сконцентрировать свое внимание на логике алгоритмов и организации параллельных вычислений. Таким средством является неделимая транзакция.

Состязания в многотактных схемах и их исключение

Одной из задач, решаемых при исследовании поведения МС, является проверка ее на устойчивость работы. Основным фактором, определяющим устойчивую работу схемы, является корректное использование (учет) временных соотношений срабатываний входных и внутренних реле.

Пусть имеется схема с памятью, изображенная на рис. 6. При поступлении входных сигналов x1x2=11 (нажаты обе кнопки) включается реле Y и замыкает свой фронтовой контакт в цепи самоблокировки. По алгоритму работы после отпускания кнопки x1 реле X1 выключится, но реле Y должно остаться включенным. Если время отпадания якоря реле Y меньше, чем этот же параметр у реле X1, то при замыкании размыкающего контакта x1 в цепи самоблокировки последняя уже будет разомкнута контактом y. Реле Y выключится и алгоритм работы схемы нарушится. Таким образом, работа данной схемы зависит от соотношения временных параметров входного реле X1 и внутреннего реле Y. Если не учитывать этот фактор, то схема будет работать неустойчиво.

Рис. 6. Схема с памятью

Из примера видно, что для исключения возможных искажений в работе схемы из-за разброса временных параметров реле, необходимо в цепи самоблокировки сохранять сигнал y до полного переключения контакта реле X1. Очевидно, что анализ МС на устойчивость работы по ее схеме возможен только для простейших случаев. Для анализа сложных схем целесообразно использовать кодированную ТП.

Проанализируем работу схемы, изображенной на рис. 3 по ее кодированной ТП (табл. 3).

Рассмотрим клетку (1, 010). В ней задан переход из состояния 3 (Y1=0, Y2=1, Y3=0) в состояние 2 (Y1=0, Y2=0, Y3=1). При этом реле Y2 должно выключиться, а реле Y3 – включиться. Особенность данного перехода состоит в том, что в схеме возникают условия для одновременного изменения состояния двух реле.

Явление, когда в схеме возникают условия для изменения состояния одновременно двух или более реле, называется состязанием реле. Признаком наличия состязаний является следующее: код, записанный в клетке, отличается от кода строки, в которой находится клетка, в двух и более разрядах. В данной ТП имеется два случая состязаний реле, отмеченные знаком «+» (см. табл. 3). Продолжаем рассмотрение перехода 3→2. Обозначим за t2 – время выключения реле Y2, а за t3 – время включения реле Y3. В данном переходе возможны два случая соотношения временных параметров: t2 t3. В первом случае реле Y2 выключится раньше, чем включится реле Y3 и поэтому схема из состояния 3 попадет в состояние 1 (рис. 7). Это состояние является устойчивым. Попав в него, схема в нем и останется. При этом алгоритм работы МС нарушается: вместо состояния 2 схема перешла в состояние 1.

Рис. 7. Устранение критического состязания в клетке (1, 011) таблицы переходов

Состязания, в результате которых нарушается алгоритм работы схемы, называются критическими. Их необходимо исключать.

Во втором случае реле Y3 включится раньше, нежели выключится реле Y2. Поэтому схема из состояния 3 перейдет в состояние 4 с кодом 011. Состояние 4 неустойчиво, и из него схема перейдет в состояние 2 (рис. 7). Таким образом, схема переходит в то состояние, которое и требуется. Алгоритм работы не нарушается и состязания не являются критическими.

Известно четыре способа исключения критических состязаний:

– введение временных задержек;

– специальное кодирование состояний МС;

– синхронизация внешних и внутренних сигналов.

Рассмотрим второй способ исключения критических состязаний – преобразование ТП.

Преобразование ТП является универсальным способом. Этот способ исключает зависимость работы схемы от соотношения временных параметров реле. Будем назвать непосредственный переход схемы из состояния Si в состояние Sj однотактным и обозначать Si→Sj (например, 3→2). Переход схемы из состояния Si в состояние Sj через несколько промежуточных состояний будем называть многотактным и обозначать Si → Sk → Sm → … → Sj. К примеру, 3→4→2 – двухтактный переход.

Преобразование ТП заключается в замене однотактного перехода на многотактный. При этом во всех однотактных переходах, образующих многотактный, изменяется состояние только одного релде, чем исключаются состязания. Например, заменим в таблице 5 переход 3→2 на переход 3→4→2 в клетке (1, 010), т.е. сначала включим реле Y3 (3→4), а затем выключим реле Y2 (4→2). Чтобы это сделать, надо преобразовать ТП. В клетке (1, 010) надо вместо кода состояния 2 = 001 проставить код состояния 4 = 011. Полученный переход 3→4→2 иллюстрируется рис. 7.

Рассмотрим второй случай состязаний в клетке (0, 000). В ней задан переход 1→4. Одновременно изменяют свое состояние реле Y2 и Y3. При t2 ) таблицы переходов

Кодированная таблица переходов, свободная от критических состязаний

Ссылка на основную публикацию
Adblock
detector