Что такое процесс и поток?

Процесс - это контейнер потоков.

Fyi через MSDN: netStartBinding: В привязке по умолчанию используется безопасность транспорта с согласованной проверкой подлинности. Это согласование пытается использовать Kerberos, но если это не сработает, оно будет возвращено назад и будет использовать старый протокол NTLM . Kerberos - отличный выбор, если вы находитесь в доменной среде; для его использования необходимо, чтобы и ваша служба, и клиенты работали под учетными записями домена. Также необходимо настроить имя участника службы (SPN) для службы.

Создание класса модели данных для каждой таблицы займет пару минут, что позволяет легко сопоставить базу данных с помощью ORM, например, Hibernate, или путем написания собственных JDBC DAO. Это гораздо проще, чем глубоко вдаваться в размышления.

Можно создать утилиту, которая опрашивает структуру базы данных для таблицы и создает класс модели данных и DAO для вас. Можно также создать модель в Java и создать утилиту для создания схемы базы данных и DAO из нее (используя отражение и аннотации Java 5 для помощи). Не забывайте о том, что JavaStartNames отличаются от database_column_names обычно.

Процесс - это один полный объект, например, exe-файл или jvm. Может быть дочерний процесс родительского процесса, где exe-файл снова запускается в отдельном пространстве. Поток - это отдельный путь выполнения в том же процессе, где процесс управляет потоком для выполнения, остановки и т.д.

С Windows, хотя бы один раз вы перешли Win 3.1, операционная система (ОС) содержит несколько процессов, каждый со своим собственным пространством памяти, и не может взаимодействовать с другими процессами без ОС.

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

Поток управляется процессом, процесс - операционной системой

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

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

Это не физические отрезки веревки, если вы об этом спрашиваете. ;)

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

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

Если вы посмотрите на компьютер с физической точки зрения, вы получите беспорядочную электронику, которая имитирует то, что делает Машина Тьюринга . Попытка сделать что-нибудь полезное с сырой машиной Truing Machine превратит ваш мозг в желе за пять минут. Чтобы избежать этого неприятного опыта, компьютерщики разработали набор абстракций для разделения различных аспектов вычислений. Это позволяет вам сосредоточиться на том уровне абстракции, который вас интересует, не беспокоясь обо всем остальном, поддерживающем его. Некоторые вещи были включены в схемы (например, сумматоры и т.п.), что делает их физическими, но подавляющее большинство того, с чем мы работаем, основано на заданных абстракциях. Как правило, используемые нами абстракции имеют некоторую математическую основу.Вот почему стеки, очереди и "состояние" играют такую ​​важную роль в вычислениях - существует хорошо обоснованный математический набор вокруг этих абстракций, который позволяет нам опираться на {{1} }} их манипуляции.

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

Несколько других людей разместили ссылки и объяснения того, что такое потоки и процессы, однако ни один из них не указывает на что-либо «физическое». Как вы уже догадались, они на самом деле представляют собой просто набор структур данных и правил, которые находятся в более широком контексте операционной системы (который, в свою очередь, представляет собой просто больше структур данных и правил ...)

Программное обеспечение похоже на луковицу, слои на слоях на слоях, как только вы удалите все слои (абстракции), ничего особенного не останется! Но лук все еще очень настоящий.

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

[1] map{chr(ord()-1)} ...

Таким образом, последовательность типа «6qD» приведет к «5rC» (символы перед '6', 'q' и 'D' соответственно). Основной интерес представляет массив последовательностей около начала:

[2] ">>>E!)",">>>E)",">>>E",">>>",">>",">",""

Это определяет последовательность «масок», которые мы будем подставлять позже, в эту строку:

[3] "9$_*\x{0e}"

Они будут вставлены в точке $ _ . Последовательности \x {0e} представляет шестнадцатеричный управляющий символ; обратите внимание, что \x {0d} , символ непосредственно перед ним, является возвратом каретки. Это то, что подставится в [3], когда мы сделаем [1].

Перед сборкой последовательности [3] мы добавим число ! равно i для каждого элемента в [2]. Каждый последующий элемент получает еще один ! , чем предшествующий элемент. Обратите внимание, что символ, значение которого находится непосредственно перед ! является пространством .

Остальная часть сценария итерируется над каждым из собранных элементов массива, которые теперь выглядят примерно так:

[4] "!!!!!9>>>E!)\x{0e}",  ---> "     8===D ("
    "!!!!!!9>>>E)\x{0e}",  ---> "      8===D("
    "!!!!!!!9>>>E\x{0e}",  ---> "       8===D"
    "!!!!!!!!9>>>\x{0e}",  ---> "        8==="
    "!!!!!!!!!9>>\x{0e}",  ---> "         8=="
    "!!!!!!!!!!9>\x{0e}",  ---> "          8="
    "!!!!!!!!!!!9\x{0e}",  ---> "           8"

Затем операция reverse добавляет те же самые элементы в обратном порядке, создавая цикл.

На этом этапе вы должны видеть, как появляется образец, который создает анимацию. Теперь это просто вопрос перемещения через каждый шаг в анимации и обратно, что выполняется остальной сценарий. Задержка времени каждого шага определяется оператором выбора

[5] select undef, undef, undef, 0.25

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

Композитный образец - это первое, что приходит мне на ум...

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

Физически:

• Процесс - это структура, которая поддерживает учетные данные владельца, список потоков и список открытых дескрипторов

• Поток - это структура содержащий контекст (т.е.сохраненный набор регистров + место для выполнения), набор PTE, описывающих, какие страницы отображаются в виртуальное адресное пространство процесса, и владелец.

Это, конечно, чрезвычайно упрощенное объяснение, но оно содержит важные моменты. Фундаментальной единицей выполнения как в Linux, так и в Windows является поток - планировщик ядра не заботится о процессах (много). Вот почему в Linux поток - это просто процесс, который совместно использует PTE с другим процессом.

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

Не думаю, что тебе нужно заботиться.

Нормальные конвенции запроса - вещи как __ stdcall и __ fastcall. Они определяют способ преобразования подписи вызова в формат стека, то, кто (вызывающий или вызываемый абонент) отвечает за сохранение и восстановление регистров и т.д. Например, __ fastcall должен использовать больше регистров, где __ stdcall использовал бы больше стека.

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

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

Я часто пишу на Post It Notes, потому что вы можете легко перемещать их по мере обсуждения отношений между объектами. Кроме того, различные цвета Post его может передать смысл.

Ниже приведен пример:

alt text http://www.matterco.com/wp-content/themes/matter/images/art057.jpg

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

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

Итак, что такое процесс. Ну, это как абстрактный «контейнер» сущности для запуска потоков. Что касается ОС в первом приближении, это сущность, в которой ОС выделяет некоторые виртуальные машины, назначает некоторые системные ресурсы (например, дескрипторы файлов, сетевые сокеты), & c.

Как они работают вместе? ОС создает «процесс», резервируя для него некоторые ресурсы и запуская «основной» поток. Этот поток может породить больше потоков. Это потоки в одном процессе. Они более или менее могут так или иначе делиться этими ресурсами (скажем, блокировка может понадобиться им, чтобы не испортить веселье для других & c). С этого момента ОС обычно отвечает за поддержание этих потоков «внутри» этой виртуальной машины (обнаружение и предотвращение попыток доступа к памяти, которая не «принадлежит» этому процессу), обеспечивая определенный тип планирования этих потоков, чтобы они могли запускать «один за другим, а не просто один-все-время».

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

Надеюсь, это поможет, С уважением, Том.

Трудно дать краткий ответ, который оправдывает этот вопрос.

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

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

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

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

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

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

Изменить: идеи применимы и к абстрактным платформам, таким как Java.

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

Ну, я еще не видел ответа на вопрос "Что они представляют собой физически". Так что я попробую.

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

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

Процесс включает в себя следующее:

• Частное виртуальное адресное пространство
• Программа.
• Список ручек.
• Маркер доступа.
• Уникальный идентификатор процесса.
• Хотя бы один поток.
• Указатель на родительский процесс, независимо от того, существует этот процесс или нет.

При этом процесс может содержать несколько потоков.

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

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

У меня есть пара страниц в моей вики, на которые вы можете взглянуть:

Процесс

Тема

Мы неоднократно обсуждали здесь именно этот вопрос. Возможно, вы найдете здесь полезную информацию:

В чем разница между процессом и потоком

Процесс и поток

Поток и процесс

Я бы сказал, что :

Процесс имеет область памяти, открытые файлы, ..., и один или несколько потоков.

Поток - это поток инструкций, который может быть запланирован системой на процессоре.

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

Их конкретные реализации сильно различаются .

Сравните, например, процесс Erlang и процесс Windows: процесс Erlang очень легкий, часто менее 400 байт. Вы можете без проблем запустить 10 миллионов процессов на не очень свежем ноутбуке. Они запускаются очень быстро, они умирают очень быстро, и ожидается, что вы сможете использовать их для очень коротких задач. С каждым процессом Erlang связан свой собственный сборщик мусора. Процессы Erlang никогда не могут совместно использовать память.

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

Потоки аналогичны: поток Linux NPTL на x86 может иметь размер всего 4 KiByte, а с помощью некоторых уловок вы можете запустить 800000+ на 32-битной машине x86. Машина, безусловно, будет работать с тысячами, а может быть, и с десятками тысяч потоков. Поток .NET CLR имеет минимальный размер около 1 мегабайта, что означает, что всего 4000 из них съедят все ваше адресное пространство на 32-битной машине. Итак, хотя 4000 потоков Linux NPTL обычно не проблема, вы не можете даже запустить 4000 потоков .NET CLR, потому что перед этим у вас закончится память.

Процессы ОС и потоки ОС также по-разному реализуются в разных операционных системах. Основные два подхода: ядро ​​знает только о процессах. Потоки реализуются библиотекой пользовательского пространства без какого-либо знания ядра. В этом случае снова есть два подхода: 1: 1 (каждый поток отображается на один процесс ядра) или m: n (m потоков сопоставляется с n процессами, где обычно m> n и часто n == # процессоров). Это был ранний подход, применявшийся во многих операционных системах после изобретения потоков.Однако он обычно считается неэффективным и был заменен почти во всех системах вторым подходом: потоки реализованы (по крайней мере частично) в ядре, так что теперь ядро ​​знает о двух различных объектах, потоках и процессах.

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

В зависимости от того, как вы устанавливаете эти флаги, вы получаете либо поток (общий доступ почти ко всему), либо процесс (общий доступ ко всем системным ресурсам, таким как системные часы, пространство имен файловой системы, сетевое пространство имен, пространство имен идентификатора пользователя, процесс ID, но не разделяют адресное пространство). Но вы также можете получить некоторые другие довольно интересные вещи. Вы можете легко получить тюрьмы в стиле BSD (в основном те же флаги, что и процесс, но не разделяйте файловую систему или сетевое пространство имен). Или вы можете получить то, что другие ОС называют контейнером или зоной виртуализации (например, тюрьмой, но не разделяйте пространства имен UID и PID и системные часы). Пару лет назад с помощью технологии под названием KVM (Kernel Virtual Machine) вы даже можете получить полноценную виртуальную машину (не делитесь ничем, даже таблицами страниц процессора).[Самое замечательное в этом то, что вы можете повторно использовать хорошо настроенный зрелый планировщик задач в ядре для всех этих вещей. Одна из причин, за которую виртуальная машина Xen часто критиковала, была низкая производительность ее планировщика.У разработчиков KVM есть гораздо лучший планировщик, чем у Xen, и самое лучшее, что им даже не пришлось писать для него ни строчки кода!]

Итак, в Linux производительность потоков и процессов намного ближе чем в Windows и многих других системах, потому что в Linux это одно и то же. Это означает, что шаблоны использования очень разные: в Windows вы обычно выбираете между использованием потока и процесса в зависимости от их веса: могу ли я позволить себе процесс или должен ли я использовать поток, даже если я на самом деле не хочу делиться государственный? В Linux (и обычно в Unix в целом) вы принимаете решение на основе их семантики: действительно ли я хочу делиться состоянием или нет?

Одна из причин , почему процессы в Unix, как правило, легче, чем в Windows, - это другое использование: в Unix процессы являются базовой единицей как параллелизма, так и функциональности. Если вы хотите использовать параллелизм, вы используете несколько процессов. Если ваше приложение можно разбить на несколько независимых частей, вы используете несколько процессов. Каждый процесс делает только одно и только одно. Даже простой однострочный сценарий оболочки часто включает десятки или сотни процессов. Приложения обычно состоят из множества, часто недолговечных процессов.

В Windows потоки являются основными единицами параллелизма, а компоненты COM или объекты .NET - основными единицами функциональности. Приложения обычно состоят из одного длительного процесса.

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

Практически единственное, что вы можете сказать о потоках и процессах:

• потоки принадлежат процессам
• потоки легче, чем процессы
• потоки разделяют большинство состояний друг с другом
• процессы значительно разделяют состояние меньше, чем у потоков (в частности, они обычно не разделяют память, если специально не запрашивается)

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

В любой современной операционной системе у одного процесса есть виртуальный ЦП, виртуальная память, виртуальный ввод-вывод.

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

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

Виртуальная память: http://en.wikipedia.org/wiki/Virtual_memory вы можете перейти по ссылке.

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

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

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

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