Ответ 1

Изменить: вопрос был немного запутанным, поэтому я отвечаю на него двумя разными способами.

Потоки уровня OS vs Green Threads

Для ясности я обычно говорю "потоки уровня OS" или "родные потоки" вместо "потоки уровня ядра" (которые я путал с "потоками ядра" в моем первоначальном ответе ниже.) Созданы потоки уровня ОС и управляется ОС. Большинство языков поддерживают их. (C, недавняя Java и т.д.). Их чрезвычайно сложно использовать, потому что вы несете 100% ответственности за предотвращение проблем. На некоторых языках даже встроенные структуры данных (такие как хэш или словари) будут разрываться без дополнительного кода блокировки.

Противоположностью OS-потока является зеленый поток, который управляется вашим языком. Этим нитям присваиваются различные названия в зависимости от языка (сопрограммы в C, goroutines в Go, волокна в Ruby и т.д.). Эти потоки существуют только на вашем языке, а не в вашей ОС. Поскольку язык выбирает контекстные переключатели (т.е. В конце инструкции), он предотвращает ТОНЫ тонких условий гонки (например, просмотр частично скопированной структуры или необходимость блокировки большинства структур данных). Программист видит "блокирующие" вызовы (т.е. data = file.read()), но язык переводит его в асинхронные вызовы в ОС. Затем язык позволяет запускать другие зеленые потоки в ожидании результата.

Зеленые потоки намного проще для программиста, но их производительность варьируется: если у вас много потоков, зеленые потоки могут быть лучше как для процессора, так и для ОЗУ. С другой стороны, большинство языков зеленого потока не могут использовать преимущества нескольких ядер. (Вы даже не можете купить одноядерный компьютер или телефон!). И плохая библиотека может остановить весь язык, выполняя блокирующий вызов ОС.

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

системные вызовы и другие виды использования, недоступные для потоков пользовательского уровня

Это только половина истины. Да, вы можете легко вызвать проблемы, если сами вызываете ОС (т.е. Делаете что-то, что блокирует). Но язык обычно имеет замены, поэтому вы даже не замечаете. Эти замены действительно вызывают ядро, немного иначе, чем вы думаете.

Нити ячеек vs Пользовательские потоки

Изменить: Это мой первоначальный ответ, но речь идет о потоках пользовательского пространства и потоках, связанных с ядром, которые (в ретроспективе), вероятно, не были вопросом.

Пользовательские потоки и потоки ядра точно такие же. (Вы можете посмотреть, просматривая/proc/и увидите, что там также есть потоки ядра.)

Пользовательский поток - это тот, который выполняет код пространства пользователя. Но он может вызывать в пространстве ядра в любое время. Он по-прежнему считается потоком "Пользователь", хотя он выполняет код ядра на повышенных уровнях безопасности.

Поток ядра - это тот, который запускает только код ядра и не связан с процессом пользовательского пространства. Это похоже на "UNIX-демоны", за исключением того, что они являются демонами только для ядра. Таким образом, вы можете сказать, что ядро ​​является многопоточной программой. Например, для обмена есть поток ядра. Это заставляет все проблемы подкачки "сериализоваться" в один поток.

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

Фактически, все потоки начинаются в пространстве ядра, потому что операция clone() происходит в пространстве ядра. (И есть множество учетных записей ядра, прежде чем вы сможете "вернуться" к новому процессу в пользовательском пространстве.)

Ответ 2

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

два отдельных процесса не могут совместно использовать пространство памяти.

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

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

Теперь, возвращаясь к вашим вопросам, по одному.

Я не уверен в различиях между потоками уровня пользователя и уровня ядра.

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

- потоки уровня пользователя

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

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

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

- Темы уровня ядра

Эти потоки в основном не зависят от текущих процессов и выполняются операционной системой.

Эти потоки требуются операционной системой для таких задач, как управление памятью, управление процессами и т.д.

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

Большинство потоков уровня ядра не могут быть вытеснены потоками уровня пользователя.

MS DOS written for Intel 8088 didn't have dual mode of operation. Thus, a user level process had the ability to corrupt the entire operating system.

- Потоки уровня пользователя, сопоставленные с потоками ядра

Это, пожалуй, самая интересная часть. Многие потоки уровня пользователя сопоставляются с потоком уровня ядра, который в свою очередь взаимодействует с ядром.

Некоторые из видных отображений:

Один к одному

Когда один поток пользовательского уровня отображает только один поток ядра.

: каждый поток пользователей сопоставляет один поток ядра. Даже если один из пользовательских потоков выдает системный вызов блокировки, остальные процессы остаются незатронутыми.

Недостатки: для каждого пользовательского потока требуется один поток ядра для взаимодействия, а потоки ядра дороги для создания и управления.

Много к одному

Когда многие пользовательские потоки сопоставляются с одним потоком ядра.

: несколько потоков ядра не требуются, поскольку похожие потоки пользователей могут быть сопоставлены с одним потоком ядра.

Недостаток: даже если один из пользовательских потоков выдает системный вызов блокировки, все остальные пользовательские потоки, сопоставленные этому потоку ядра, блокируются.

Кроме того, хороший уровень concurrency не может быть достигнут, так как ядро ​​будет обрабатывать только один поток ядра за раз.

Многие для многих

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

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

Недостаток: количество потоков ядра, если не принято осторожно, может замедлить работу системы.

Другая часть вашего вопроса:

Поддерживаемые ядра потоки имеют доступ к ядру для системных вызовов и другие виды использования, недоступные для потоков пользовательского уровня.

Итак, потоки пользовательского уровня просто потоки, созданные программистом когда затем использовать потоки, поддерживаемые ядрами, для выполнения операций, которые не может нормально выполняться из-за его состояния?

Частично правильно. Почти весь поток ядра имеет доступ к системным вызовам и другим критическим прерываниям, поскольку потоки ядра отвечают за выполнение процессов ОС. Пользовательский поток не будет иметь доступа к некоторым из этих важных функций. например текстовый редактор никогда не может снимать поток, который имеет возможность изменить физический адрес процесса. Но при необходимости пользовательский поток может отображать поток ядра и выдавать некоторые системные вызовы, которые он не может выполнять как независимый объект. Затем поток ядра сопоставляет этот системный вызов с ядром и будет выполнять действия, если они считаются подходящими.

Ответ 3

В некоторых средах разработки или языках добавляются собственные потоки, такие как функция, написанная для использования некоторых знаний об окружающей среде, например, среда GUI может реализовать некоторые функции потоков, которые переключаются между пользовательскими потоками в каждом цикле событий. В игровой библиотеке может быть некоторое поведение, например, для символов. Иногда поведение пользовательского потока, как и поведение, может быть реализовано по-другому, например, я много работаю с cocoa, и у него есть механизм таймера, который выполняет ваш код каждые x секунд, использует долю секунды, и это похоже на нить. Ruby имеет функцию выхода, которая похожа на совлокальные потоки. Преимущество пользовательских потоков заключается в том, что они могут переключаться в более предсказуемое время. С потоком ядра каждый раз, когда поток запускается снова, он должен загружать любые данные, на которых он работал, это может занять много времени, при этом пользовательские потоки можно переключать, когда вы закончите работу над некоторыми данными, поэтому не нужно перезагружается. Я не сталкивался с пользовательскими потоками, которые выглядят так же, как и потоки ядра, только такие, как механизмы, подобные таймеру, хотя я читал о них в старых текстовых книгах, поэтому мне интересно, были ли они более популярными в прошлом, но с появление настоящих многопоточных ОС (современные Windows и Mac OS X) и более мощное оборудование. Интересно, не ушли ли они из-за неё.

Ответ 4

пользователь Темы: 1. Библиотека обеспечивает поддержку создания потоков, планирования и управления без поддержки ядра. 2. Ядро, не осознающее создание и планирование потоков пользовательского уровня, выполняется в пространстве пользователя без вмешательства ядра. 3. Поток пользовательского уровня, как правило, быстрый, чтобы создавать и управлять, но у них есть недостатки. 4. Если ядро ​​однопоточное, то любой поток пользовательского уровня, выполняющий системный вызов блокировки, вызовет весь процесс блокировки, даже если другие потоки доступны для запуска в пределах выражение. 5. Библиотеки пользовательских потоков включают POSIX Pthreads, Mach C-threads, и Solaris 2 UI-threads.

Нити ядра: 1. Ядро выполняет создание потоков, планирование и управление в пространстве ядра. 2. Потоки ядра, как правило, медленнее создавать и управлять, чем пользовательские потоки. 3. Ядро управляет потоками, если поток выполняет системный вызов блокировки. 4. Многопроцессорная среда, ядро ​​может планировать потоки на разных процессорах. 5. Включая потоки ядра Windows NT, Windows 2000, Solaris 2, BeOS и Tru64 UNIX (ранее Digital Digital UN1X).

Ответ 5

Цитата здесь:

Потоки на уровне ядра

Чтобы сделать параллелизм более дешевым, аспект выполнения процесса разделен на потоки. Таким образом, ОС теперь управляет потоками и процессами. Все операции с потоками реализованы в ядре, и ОС планирует все потоки в системе. Управляемые потоки ОС называются потоками уровня ядра или процессами с небольшим весом. NT: темы Solaris: облегченные процессы (LWP).

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

Преимущества:

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

Недостатки:

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

Потоки уровня пользователя

Потоки уровня ядра делают параллелизм намного дешевле, чем процесс, потому что гораздо меньше состояния для выделения и инициализации. Однако для мелкозернистого параллелизма потоки уровня ядра по-прежнему страдают от чрезмерной нагрузки. Операции с потоками все еще требуют системных вызовов. В идеале мы требуем, чтобы операции с потоками выполнялись так же быстро, как и вызов процедуры. Потоки уровня ядра должны быть общими, чтобы удовлетворить потребности всех программистов, языков, сред выполнения и т.д. Для такого мелкозернистого параллелизма нам все еще нужны "более дешевые" потоки. Чтобы сделать потоки дешевыми и быстрыми, они должны быть реализованы на уровне пользователя. Потоки уровня пользователя полностью управляются системой времени выполнения (библиотека уровня пользователя). Ядро ничего не знает о потоках уровня пользователя и управляет ими так, как если бы они были однопоточными процессами. Потоки уровня пользователя являются небольшими и быстрыми, каждый поток представлен ПК, регистром, стеком и небольшим блоком управления потоками. Создание нового потока, переключение между потоками и синхронизация потоков выполняются с помощью вызова процедуры. т.е. без участия ядра. Потоки уровня пользователя в сто раз быстрее потоков уровня ядра.

Преимущества:

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

Недостатки:

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