Bir işlem ve bir iş parçacığı arasındaki fark nedir?

Bir işlem ve bir iş parçacığı arasındaki teknik fark nedir?

'Süreç' gibi bir kelimenin aşırı kullanıldığını ve ayrıca donanım ve yazılım konuları olduğunu hissediyorum. Erlang gibi dillerde hafif süreçlere ne dersiniz ? Bir terimi diğerinin üzerinde kullanmak için kesin bir neden var mı?

Hem işlemler hem de iş parçacıkları bağımsız yürütme dizileridir. Tipik fark, iş parçacıklarının (aynı işlemden) paylaşılan bir bellek alanında çalışması, süreçlerin ayrı bellek alanlarında çalışmasıdır.

Hangi "donanım" ve "yazılım" konularına atıfta bulunabileceğinizden emin değilim. İş parçacıkları, CPU özelliği yerine bir çalışma ortamı özelliğidir (CPU genellikle iş parçacıklarını verimli hale getiren işlemlere sahiptir).

Erlang, paylaşılan bellek çoklu programlama modelini göstermediği için "işlem" terimini kullanır. Onlara "evre" demek, hafızayı paylaştıkları anlamına gelir.

İşlem
Her işlem, bir programı yürütmek için gereken kaynakları sağlar. Bir işlemin sanal adres alanı, yürütülebilir kodu, sistem nesnelerine açık tutma yerleri, bir güvenlik bağlamı, benzersiz bir işlem tanımlayıcısı, ortam değişkenleri, bir öncelik sınıfı, minimum ve maksimum çalışma kümesi boyutları ve en az bir yürütme iş parçacığı vardır. Her işlem, genellikle birincil iş parçacığı olarak adlandırılan tek bir iş parçacığıyla başlatılır, ancak iş parçacıklarının herhangi birinden ek iş parçacıkları oluşturabilir.

İş Parçacığı
Bir iş parçacığı, bir işlem içinde yürütülmek üzere zamanlanabilen bir varlıktır. Bir işlemin tüm iş parçacıkları sanal adres alanını ve sistem kaynaklarını paylaşır. Ayrıca, her iş parçacığı özel durum işleyicileri, bir zamanlama önceliği, iş parçacığı yerel depolaması, benzersiz bir iş parçacığı tanımlayıcısı ve sistemin iş parçacığı içeriğini zamanlanana kadar kaydetmek için kullanacağı bir dizi yapı tutar. İş parçacığı bağlamı iş parçacığının makine kayıtları kümesini, çekirdek yığınını, iş parçacığı ortam bloğunu ve iş parçacığının işleminin adres alanındaki bir kullanıcı yığınını içerir. İş parçacıklarının, istemcilerin kimliğine bürünmek için kullanılabilecek kendi güvenlik bağlamları da olabilir.

Bu bilgiler Microsoft Dokümanlar'da burada bulundu: İşlemler ve İş Parçacıkları Hakkında

Microsoft Windows, birden çok işlemden aynı anda birden çok iş parçacığının eşzamanlı yürütülmesinin etkisini oluşturan önleyici çoklu görevi destekler. Çok işlemcili bir bilgisayarda, sistem aynı anda bilgisayarda işlemci olduğu kadar çok iş parçacığı yürütebilir.

Süreci:

• Bir programın yürütme örneğine işlem denir.
• Bazı işletim sistemleri yürütülmekte olan bir programı ifade etmek için 'görev' terimini kullanır.
• Bir işlem daima birincil bellek veya rasgele erişim belleği olarak da adlandırılan ana bellekte saklanır.
• Bu nedenle, bir işlem etkin varlık olarak adlandırılır. Makine yeniden başlatılırsa kaybolur.
• Birkaç işlem aynı programla ilişkilendirilebilir.
• Çok işlemcili bir sistemde, birden çok işlem paralel olarak yürütülebilir.
• Tek işlemcili bir sistemde, gerçek paralellik elde edilemese de, bir işlem zamanlama algoritması uygulanır ve işlemcinin her işlemi bir kerede bir eşzamanlılık yanılsaması yaratacak şekilde yürütmesi planlanır.
• Örnek: 'Hesap Makinesi' programının birden fazla örneğini yürütme. Örneklerin her biri bir süreç olarak adlandırılır.

Konu:

• Bir iş parçacığı, işlemin bir alt kümesidir.
• Gerçek bir sürece benzer olduğu, ancak bir süreç bağlamında yürütüldüğü ve çekirdek tarafından sürece ayrılan kaynakları paylaştığı için 'hafif bir süreç' olarak adlandırılır.
• Genellikle, bir işlemin yalnızca bir denetim iş parçacığı vardır - bir seferde yürütülen bir makine talimatları kümesi.
• Bir işlem aynı zamanda talimatları eşzamanlı olarak yürüten birden fazla yürütme iş parçacığından oluşabilir.
• Birden fazla kontrol iş parçacığı, çok işlemcili sistemlerde mümkün olan gerçek paralellikten yararlanabilir.
• Tek işlemcili bir sistemde, bir iş parçacığı programlama algoritması uygulanır ve işlemci, her iş parçacığını birer birer çalıştıracak şekilde zamanlanır.
• Bir işlemde çalışan tüm iş parçacıkları aynı adres alanını, dosya tanımlayıcıları, yığını ve işlemle ilgili diğer öznitelikleri paylaşır.
• Bir işlemin iş parçacıkları aynı belleği paylaştığından, işlem içindeki paylaşılan verilere erişimin senkronize edilmesi benzeri görülmemiş bir önem kazanır.

Yukarıdaki bilgiyi Bilgi Görevinden ödünç aldım ! blog .

İlk olarak, teorik yöne bakalım. Bir işlem ile bir iş parçacığı arasındaki farkı ve aralarında paylaşılanları anlamak için bir sürecin kavramsal olarak ne olduğunu anlamalısınız.

Biz bölümünden aşağıdaki gelmiş 2.2.2 Klasik Konu Modeli içinde Modern İşletim Sistemleri 3e Tanenbaum tarafından:

Süreç modeli iki bağımsız kavrama dayanmaktadır: kaynak gruplama ve yürütme. Bazen onları ayırmak yararlı olabilir; iş parçacığı burada devreye ....

Diye devam ediyor:

Bir sürece bakmanın bir yolu, ilgili kaynakları bir arada gruplamanın bir yolu olmasıdır. Bir işlem, diğer metinlerin yanı sıra program metni ve verilerini içeren bir adres alanına sahiptir. Bu kaynaklar açık dosyaları, alt işlemleri, bekleyen alarmları, sinyal işleyicileri, muhasebe bilgilerini ve daha fazlasını içerebilir. Onları bir süreç şeklinde bir araya getirerek daha kolay yönetilebilirler. Bir sürecin sahip olduğu diğer kavram, genellikle sadece iş parçacığına kısaltılmış bir yürütme iş parçacığıdır. İş parçacığında bir sonraki çalıştırılacak komutu izleyen bir program sayacı vardır. Mevcut çalışma değişkenlerini tutan kayıtları vardır. Yürütme geçmişini içeren, çağrılan ancak henüz döndürülmeyen her yordam için bir kare içeren bir yığını vardır. Bir iş parçacığının bazı işlemlerde yürütülmesi gerekse de, iplik ve süreci farklı kavramlardır ve ayrı ayrı ele alınabilir. Süreçler kaynakları birlikte gruplandırmak için kullanılır; evreler CPU üzerinde yürütülmesi planlanan varlıklardır.

Daha sonra aşağıdaki tabloyu sağlar:

Per process items             | Per thread items
------------------------------|-----------------
Address space                 | Program counter
Global variables              | Registers
Open files                    | Stack
Child processes               | State
Pending alarms                |
Signals and signal handlers   |
Accounting information        |

Donanım çoklu kullanım sorunuyla ilgilenelim . Klasik olarak, CPU, tek bir program sayacı ve kayıt kümesi aracılığıyla iş parçacığının durumunu koruyarak tek bir yürütme iş parçacığını destekleyecektir. Ama önbellek kaçarsa ne olur? Ana bellekten veri almak uzun zaman alıyor ve bu sırada CPU sadece boşta oturuyor. Yani birisi temelde iki iş parçacığı durumu (PC + kayıtları) kümesi fikrine sahipti, böylece başka bir iş parçacığı (belki aynı işlemde, belki farklı bir işlemde) diğer iş parçacığı ana bellekte beklerken iş yapabilir. Bu kavramın HyperThreading ve Simultaneous Multithreading (kısaca SMT) gibi birçok adı ve uygulaması vardır .

Şimdi yazılım tarafına bakalım. Temel olarak yazılım tarafında iş parçacığı uygulamak için üç yol vardır.

1. Kullanıcı Alanı Konuları
2. Çekirdek Konuları
3. İkisinin bir kombinasyonu

İş parçacıklarını uygulamak için ihtiyacınız olan tek şey CPU durumunu kaydetme ve birçok durumda kullanıcı alanında yapılabilen çoklu yığınları koruma yeteneğidir. Kullanıcı alanı iş parçacıklarının avantajı, çekirdeğe hapsolmanıza gerek olmadığı ve iş parçacıklarınızı istediğiniz gibi zamanlayabileceğiniz için süper hızlı iş parçacığı geçişidir. En büyük dezavantajı, ilk olarak iş parçacıklarını kullanmamızın en büyük nedenlerinden biri olan G / Ç'yi (tüm süreci ve tüm kullanıcı iş parçacıklarını engelleyecek) engellememektir. G / Ç iş parçacıklarını kullanarak engellemek, birçok durumda program tasarımını büyük ölçüde basitleştirir.

Çekirdek iş parçacığı, tüm zamanlama sorunlarını işletim sistemine bırakmanın yanı sıra engelleme G / Ç'yi kullanabilme avantajına sahiptir. Ancak her iş parçacığı anahtarı, potansiyel olarak nispeten yavaş olan çekirdeğe hapsolmayı gerektirir. Ancak, bloke edilmiş G / Ç nedeniyle iş parçacığı değiştiriyorsanız, G / Ç işlemi zaten sizi zaten çekirdeğe hapsettiğinden bu gerçekten bir sorun değildir.

Diğer bir yaklaşım, her ikisini birden çok kullanıcı iş parçacığına sahip olan çok sayıda çekirdek iş parçacığıyla birleştirmektir.

Dolayısıyla, terminoloji sorunuza geri dönersek, bir sürecin ve bir yürütme dizisinin iki farklı kavram olduğunu ve hangi terimi kullanacağınızı seçtiğinizin neden bahsettiğinize bağlı olduğunu görebilirsiniz. "Hafif ağırlık süreci" terimi ile ilgili olarak, kişisel olarak hiçbir şey görmüyorum çünkü ne olup bittiğini ve "icra konusu" terimini de aktarmıyor.

Eşzamanlı programlama ile ilgili daha fazla açıklama

1. Bir işlemin kendine özgü bir yürütme ortamı vardır. Bir işlem genellikle eksiksiz, özel bir dizi temel çalışma zamanı kaynağı içerir; özellikle, her işlemin kendi bellek alanı vardır.

2. Bir süreç içinde iş parçacıkları vardır - her süreç en az bir tane içerir. İş parçacıkları, bellek ve açık dosyalar dahil olmak üzere işlemin kaynaklarını paylaşır. Bu etkili fakat potansiyel olarak sorunlu bir iletişim sağlar.

Ortalama bir insanı akılda tutarak,

Bilgisayarınızda Microsoft Word ve web tarayıcısını açın. Biz buna iki süreç diyoruz .

Microsoft Word'de, bir şey yazarsınız ve otomatik olarak kaydedilir. Şimdi, düzenleme ve kaydetmenin paralel olarak gerçekleştiğini gözlemlediniz - bir iş parçacığında düzenleme ve diğer iş parçacığında kaydetme.

Bir uygulama bir veya daha fazla işlemden oluşur. Bir süreç, en basit ifadeyle, bir yürütme programıdır. Bir veya daha fazla iş parçacığı işlem bağlamında çalışır. İş parçacığı, işletim sisteminin işlemci zamanını ayırdığı temel birimdir. Bir iş parçacığı, şu anda başka bir iş parçacığı tarafından yürütülmekte olan parçalar da dahil olmak üzere işlem kodunun herhangi bir bölümünü yürütebilir. Fiber, uygulama tarafından manuel olarak programlanması gereken bir yürütme birimidir. Lifler, onları programlayan iplikler bağlamında çalışır.

Buradan çalındı .

İşlem, kod, bellek, veri ve diğer kaynakların bir toplamıdır. Bir iş parçacığı, işlem kapsamında yürütülen bir kod dizisidir. Aynı işlem içinde aynı anda çalışan birden çok iş parçacığına sahip olabilirsiniz (genellikle).

Proses ve İplik için gerçek dünya örneği Bu size iplik ve proses hakkında temel fikir verecektir

Yukarıdaki bilgileri Scott Langham'ın Yanıtından ödünç aldım - teşekkürler

Süreci:

1. İşlem ağır bir işlemdir.
2. Süreç ayrı bellek, veri, kaynaklar vb olan ayrı bir programdır.
3. İşlem fork () yöntemi kullanılarak oluşturulur.
4. Süreç arasındaki bağlam geçişi zaman alıcıdır.
   

Örnek:
Diyelim ki herhangi bir tarayıcıyı açın (Mozilla, Chrome, IE). Bu noktada yeni süreç yürütülmeye başlanacaktır.

İş Parçacığı:

1. İş parçacıkları hafif süreçlerdir. İş parçacıkları işlem içinde paketlenir.
2. İş parçacıklarının paylaşılan bir belleği, verileri, kaynakları, dosyaları vb. Vardır.
3. Konular clone () yöntemi kullanılarak oluşturulur.
4. İş parçacıkları arasındaki bağlam geçişi İşlem olarak fazla zaman almaz.
   

Örnek:
Tarayıcıda birden çok sekme açma.

• Her işlem bir iş parçacığıdır (birincil iş parçacığı).
• Ancak her iş parçacığı bir süreç değildir. Bu, bir sürecin bir parçasıdır (varlığı).

Hem iş parçacıkları hem de işlemler, işletim sistemi kaynak tahsisinin atomik birimleridir (yani CPU zamanının aralarında nasıl bölündüğünü ve diğer işletim sistemi kaynaklarına sahip olma modelini açıklayan bir eşzamanlılık modeli vardır). Bir fark var:

• Paylaşılan kaynaklar (iş parçacıkları tanımı gereği belleği paylaşıyor, yığın ve yerel değişkenler dışında hiçbir şeyleri yok; işlemler de belleği paylaşabilir, ancak bunun OS tarafından tutulan ayrı bir mekanizması vardır)
• Ayırma alanı (işlemler için çekirdek alanı ve iş parçacıkları için kullanıcı alanı)

Yukarıdaki Greg Hewgill, "işlem" kelimesinin Erlang anlamı hakkında doğruydu ve burada Erlang'ın neden hafif işlemleri yapabileceğine dair bir tartışma var.

Hem işlemler hem de iş parçacıkları bağımsız yürütme dizileridir. Tipik fark, iş parçacıklarının (aynı işlemden) paylaşılan bir bellek alanında çalışması, süreçlerin ayrı bellek alanlarında çalışmasıdır.

süreç

Yürütülen bir programdır. program bölümü, program sayacının değeri ve işlemci kaydının içeriği ile temsil edilen geçerli etkinlik gibi bir metin bölümüne sahiptir. Ayrıca, geçici veriler (işlev parametreleri, adreslenen dönüş ve yerel değişkenler gibi) içeren işlem yığınını ve genel değişkenleri içeren bir veri bölümünü de içerir. Bir işlem ayrıca, işlem çalışma süresi boyunca dinamik olarak ayrılan bellek olan bir yığın da içerebilir.

Konu

Bir iş parçacığı CPU kullanımının temel birimidir; bir iş parçacığı kimliği, bir program sayacı, kayıt kümesi ve bir yığın içerir. aynı sürece ait diğer iş parçacıklarıyla kod bölümünü, veri bölümünü ve açık dosyalar ve sinyaller gibi diğer işletim sistemi kaynaklarını paylaştı.

- İşletim Sisteminden Galvin Tarafından Alınmıştır

http://lkml.iu.edu/hypermail/linux/kernel/9608/0191.html

Linus Torvalds (torvalds@cs.helsinki.fi)

Sal, 6 Ağu 1996 12:47:31 +0300 (EET DST)

İletilere göre sıralandı: [tarih] [konu] [konu] [yazar]

Sonraki mesaj: Bernd P. Ziller: "Re: Hata!

Önceki mesaj: Linus Torvalds: "Re: I / O istek siparişi"

5 Ağustos 1996 Pzt, Peter P. Eiserloh şunu yazdı:

İplik kavramını açık tutmalıyız. Çok fazla insan bir iş parçacığını bir süreçle karıştırıyor gibi görünüyor. Aşağıdaki tartışma linux'un mevcut durumunu yansıtmaz, daha ziyade üst düzey bir tartışmada kalma girişimidir.

HAYIR!

"İş parçacıkları" ve "süreçlerin" ayrı varlıklar olduğunu düşünmek için hiçbir neden yoktur. Geleneksel olarak bu şekilde yapılır, ancak kişisel olarak bu şekilde düşünmenin büyük bir hata olduğunu düşünüyorum. Bu şekilde düşünmenin tek nedeni tarihsel bagajdır.

Hem iş parçacıkları hem de süreçler sadece bir şeydir: "yürütme bağlamı". Farklı vakaları yapay olarak ayırt etmeye çalışmak sadece kendi kendini sınırlar.

Burada COE olarak adlandırılan bir "yürütme bağlamı", yalnızca bu COE'nin tüm durumunun bir araya gelmesidir. Bu durum CPU durumu (kayıtlar vb.), MMU durumu (sayfa eşlemeleri), izin durumu (uid, gid) ve çeşitli "iletişim durumları" (açık dosyalar, sinyal işleyicileri vb.) Geleneksel olarak, bir "iş parçacığı" ve "işlem" arasındaki fark esas olarak bir iş parçacığının CPU durumuna (+ muhtemelen başka bir minimum duruma) sahip olması, diğer tüm bağlamın işlemden gelmesidir. Bununla birlikte, bu , COE'nin toplam durumunu bölmenin sadece bir yoludur ve bunu yapmanın doğru yolu olduğunu söyleyen hiçbir şey yoktur. Kendinizi bu tür bir görüntüyle sınırlamak sadece aptalca.

Linux bu düşünen yolu (ve İşe şeyler istiyorum yön) orada olmasıdır olan bir "süreç" ya da bir "iş parçacığı" diye bir şey. Yalnızca COE'nin bütünü vardır (Linux tarafından "görev" olarak adlandırılır). Farklı COE'ler bağlamlarının bölümlerini birbirleriyle paylaşabilir ve bu paylaşımın bir alt kümesi geleneksel "iş parçacığı" / "işlem" kurulumudur, ancak bu gerçekten SADECE bir alt küme olarak görülmelidir (önemli bir alt kümedir, ancak bu önem gelir tasarımdan değil, standartlardan: Linux üzerinde standartlara uygun iş parçacığı programlarını da açıkça uygulamak istiyoruz).

Kısacası: İş parçacığı / süreç düşünme şekli etrafında tasarlamayın. Çekirdek, COE düşünme şekli etrafında tasarlanmalıdır ve daha sonra pthreads kütüphanesi , sınırlı pthreads arayüzünü COE'lere bakmak için bu şekilde kullanmak isteyen kullanıcılara aktarabilir.

Tıpkı COE'yi iş parçacığının / sürecin aksine düşündüğünüzde neyin mümkün olduğuna bir örnek olarak:

• Harici bir "cd" programı, UNIX ve / veya işlem / iş parçacığında geleneksel olarak imkansız olan bir şey yapabilirsiniz (aptal örnek, ancak fikir, geleneksel UNIX ile sınırlı olmayan bu tür "modüllere" sahip olabilmenizdir. / thread kurulumu). Şunu yapın:

klon (CLONE_VM | CLONE_FS);

çocuk: yürütmek ("harici-cd");

/ * "execve ()" sanal makineyle olan ilişkisini kesecektir, bu yüzden CLONE_VM kullanmamızın tek nedeni klonlama işlemini daha hızlı yapmaktı * /

• Doğal olarak "vfork ()" yapabilirsiniz (minimal çekirdek desteğine uygundur, ancak bu destek CUA'nın mükemmel düşünme şekline uyar):

klonu (CLONE_VM);

child: koşmaya devam et, sonunda execute ()

anne: idam beklemek

• harici "IO deamons" yapabilirsiniz:

klonu (CLONE_FILES);

child: açık dosya tanımlayıcıları vb.

Anne: Açılan çocuğun ve vv.

Yukarıdakilerin hepsi iş parçacığı / süreç düşünme tarzına bağlı olmadığınızdan çalışır. Örneğin, CGI betiklerinin "yürütme konuları" olarak yapıldığı bir web sunucusu düşünün. Bunu geleneksel iş parçacıklarıyla yapamazsınız, çünkü geleneksel iş parçacıkları her zaman tüm adres alanını paylaşmak zorundadır, bu nedenle web sunucusunun kendisinde yapmak istediğiniz her şeye bağlamanız gerekir (bir "iş parçacığı" çalışamaz) başka bir çalıştırılabilir).

Soruna bir "yürütme bağlamında" olarak düşünmek yerine, istedikleri takdirde görevleri artık vb dış programları çalıştırmak (= ebeveynden adres alanını birbirinden ayırmak) seçti, ya da ebeveyn ile örnek payı her şey için can haricinde için dosya tanımlayıcıları (böylece alt "iş parçacıkları", üst öğe hakkında endişelenmeye gerek kalmadan çok sayıda dosyayı açabilir: alt "iş parçacığı" çıktığında otomatik olarak kapanırlar ve üst dosyada fd'leri kullanmazlar) .

Örneğin, dişli bir "inetd" düşünün. Düşük çatal + exec istiyorsanız, Linux yolu ile "fork ()" kullanmak yerine her iş parçacığının sadece CLONE_VM ile paylaşıldığı çok parçacıklı bir inetd yazabilirsiniz (adres alanını paylaşın, ancak dosyayı paylaşmayın) tanımlayıcılar vb.). Daha sonra çocuk, harici bir hizmetse (örneğin rlogind) veya belki de iç inetd hizmetlerinden (echo, timeofday) biri olabilirse, bu durumda sadece bir şey yapar ve çıkar.

Bunu "thread" / "process" ile yapamazsınız.

Linus

Linux Kernel'in İşletim Sistemi Görünümünden cevap vermeye çalışıyor

Bir program belleğe başlatıldığında bir işlem haline gelir. Bir işlemin kendi adres alanı vardır, yani .textderlenmiş kodun .bssdepolanması, başlatılmamış statik veya global değişkenlerin depolanması vb. Gibi bellekte çeşitli segmentlere sahiptir .
Her işlemin kendi program sayacı ve kullanıcı alanı yığını olacaktır .

Çekirdeğin içinde, her işlemin kendi çekirdek yığını (güvenlik sorunları için kullanıcı alanı yığınından ayrılır) ve adı task_structişlemin önceliği, durumu gibi işlemle ilgili tüm bilgileri depolayan, genellikle işlem denetim bloğu olarak soyutlanan bir yapıya sahip olacaktır. , (ve bir sürü başka yığın).
Bir işlem birden çok yürütme iş parçacığına sahip olabilir.

İş parçacıklarına geldiklerinde, bir işlemin içinde bulunurlar ve ana işlemin adres alanını, dosya sistemi kaynakları, bekleyen sinyalleri paylaşma, veri paylaşımı (değişkenler ve talimatlar) gibi iş parçacığı oluşturma sırasında geçirilebilen diğer kaynaklarla paylaşırlar, böylece iş parçacıklarını hafif ve böylece daha hızlı içerik geçişi sağlar.

Çekirdeğin içinde, her iş parçacığının, task_structiş parçacığını tanımlayan yapı ile birlikte kendi çekirdek yığını vardır . Bu nedenle çekirdek, farklı varlıklarla aynı işlemin iş parçacıklarını görüntüler ve kendi içlerinde zamanlanabilir. Aynı işlemdeki iş parçacıkları, iş parçacığı grubu kimliği ( tgid) olarak adlandırılan ortak bir kimliği paylaşır , ayrıca işlem kimliği ( pid) olarak adlandırılan benzersiz bir kimliğe sahiptir .

Java dünyasıyla ilgili bu soruya cevap vermeye çalışıyorum.

İşlem, bir programın yürütülmesidir, ancak iş parçacığı, işlem içindeki tek bir yürütme dizisidir. Bir işlem birden çok iş parçacığı içerebilir. Bir iş parçacığına bazen hafif bir işlem denir .

Örneğin:

Örnek 1: Bir JVM tek bir işlemde çalışır ve JVM'deki iş parçacıkları bu işleme ait yığını paylaşır. Bu nedenle birkaç iş parçacığı aynı nesneye erişebilir. İş parçacıkları yığını paylaşır ve kendi yığın alanlarına sahiptir. Bir iş parçacığının bir yöntemi ve yerel değişkenlerini çağırması iş parçacığını diğer iş parçacıklarından nasıl korur. Ancak yığın iplik için güvenli değildir ve iplik güvenliği için senkronize edilmelidir.

Örnek 2: Bir program, tuş vuruşlarını okuyarak resim çizemeyebilir. Program, klavye girişine tüm dikkatini vermelidir ve bir seferde birden fazla olayı işleme yeteneğinden yoksun olması, soruna yol açacaktır. Bu sorunun ideal çözümü, bir programın iki veya daha fazla bölümünün aynı anda sorunsuz bir şekilde gerçekleştirilmesidir. Konular bunu yapmamızı sağlar. Burada Çizim resmi bir işlemdir ve tuş vuruşunu okumak alt işlemdir (iş parçacığı).

Konu ve Süreç arasındaki fark nedir?

İşlem, uygulamanın yürütme örneğidir ve iş parçacığı, işlem içindeki yürütme yoludur. Ayrıca, bir işlem birden çok iş parçacığı içerebilir. Bir iş parçacığının bir işlemin yapabileceği her şeyi yapabileceğini unutmayın. Ancak bir işlem birden çok iş parçacığından oluşabileceğinden, bir iş parçacığı 'hafif' bir işlem olarak düşünülebilir. Bu nedenle, bir iplik ve bir süreç arasındaki temel fark, her birinin gerçekleştirmek için kullanıldığı çalışmadır. İş parçacıkları küçük görevler için kullanılırken, süreçler daha 'ağır' görevler için kullanılır - temel olarak uygulamaların yürütülmesi.

Bir iş parçacığı ve işlem arasındaki diğer bir fark, aynı işlem içindeki iş parçacıklarının aynı adres alanını paylaşması, farklı işlemlerin paylaşmamasıdır. Bu, evrelerin aynı veri yapıları ve değişkenlerden okunmasına ve bunlara yazılmasına izin verir ve ayrıca evreler arasındaki iletişimi kolaylaştırır. IPC olarak da bilinen süreçler arasındaki iletişim veya süreçler arası iletişim oldukça zordur ve kaynak yoğundur.

İşte iş parçacıkları ve süreçler arasındaki farkların bir özeti:

1. İş parçacıklarının oluşturulması, ayrı bir adres alanı gerektirmedikleri için işlemlerden daha kolaydır.

2. Birden çok iş parçacığı, her seferinde yalnızca bir iş parçacığı tarafından değiştirilmesi gereken veri yapılarını paylaştığı için dikkatli programlama gerektirir. İleti dizilerinin aksine, işlemler aynı adres alanını paylaşmaz.

3. İplikler, süreçlerden çok daha az kaynak kullandıkları için hafif kabul edilir.

4. İşlemler birbirinden bağımsızdır. Aynı adres alanını paylaştıklarından, iş parçacıkları birbirine bağımlı olduğundan, farklı iş parçacıklarının birbirine basmaması için dikkatli olunmalıdır.
   Bu, yukarıdaki # 2'yi belirtmenin başka bir yoludur.

5. Bir işlem birden çok iş parçacığından oluşabilir.

Kod Projesi'ndeki makalelerden birinden aldığım şey şu . Sanırım gereken her şeyi açık bir şekilde açıklıyor.

İş parçacığı, iş yükünü ayrı yürütme akışlarına bölmek için başka bir mekanizmadır. Bir iplik bir işlemden daha hafiftir. Bu, tam bir üflemeli işlemden daha az esneklik sunduğu anlamına gelir, ancak daha hızlı başlatılabilir, çünkü İşletim Sisteminin kurulumu daha azdır. Bir program iki veya daha fazla iş parçacığından oluştuğunda, tüm iş parçacıkları tek bir bellek alanını paylaşır. İşlemlere ayrı adres alanları verilir. tüm iş parçacıkları tek bir yığın paylaşır. Ancak her iş parçacığına kendi yığını verilir.

Süreci:

Süreç temel olarak yürütülen bir programdır. Aktif bir varlıktır. Bazı işletim sistemleri yürütülmekte olan bir programı ifade etmek için 'görev' terimini kullanır. Bir işlem daima birincil bellek veya rasgele erişim belleği olarak da adlandırılan ana bellekte saklanır. Bu nedenle, bir işlem etkin varlık olarak adlandırılır. Makine yeniden başlatılırsa kaybolur. Birkaç işlem aynı programla ilişkilendirilebilir. Çok işlemcili bir sistemde, birden çok işlem paralel olarak yürütülebilir. Tek işlemcili bir sistemde, gerçek paralellik elde edilemese de, bir işlem zamanlama algoritması uygulanır ve işlemcinin her işlemi bir kerede bir eşzamanlılık yanılsaması yaratacak şekilde yürütmesi planlanır. Örnek: 'Hesap Makinesi' programının birden fazla örneğini yürütme. Örneklerin her biri bir süreç olarak adlandırılır.

Konu:

Bir iş parçacığı, işlemin bir alt kümesidir. Gerçek bir sürece benzer olduğu, ancak bir süreç bağlamında yürütüldüğü ve çekirdek tarafından sürece ayrılan kaynakları paylaştığı için 'hafif bir süreç' olarak adlandırılır. Genellikle, bir işlemin yalnızca bir denetim iş parçacığı vardır - bir seferde yürütülen bir makine talimatları kümesi. Bir işlem aynı zamanda talimatları eşzamanlı olarak yürüten birden fazla yürütme iş parçacığından oluşabilir. Birden fazla kontrol iş parçacığı, çok işlemcili sistemlerde mümkün olan gerçek paralellikten yararlanabilir. Tek işlemcili bir sistemde, bir iş parçacığı programlama algoritması uygulanır ve işlemci, her iş parçacığını birer birer çalıştıracak şekilde zamanlanır. Bir işlemde çalışan tüm iş parçacıkları aynı adres alanını, dosya tanımlayıcıları, yığını ve işlemle ilgili diğer öznitelikleri paylaşır. Bir işlemin iş parçacıkları aynı belleği paylaştığından,

ref- https://practice.geeksforgeeks.org/problems/difference-between-process-and-thread

Bir görüşmeci açısından, temelde duymak istediğim sadece 3 ana şey vardır, ayrıca bir sürecin birden fazla iş parçacığı olabileceği gibi bariz şeylerin yanı sıra:

1. İş parçacıkları aynı bellek alanını paylaşır, yani bir iş parçacığı başkalarının iş parçacığı belleğinden belleğe erişebilir. İşlemler normal olarak yapamaz.
2. Kaynaklar. Kaynaklar (bellek, tutamaçlar, soketler, vb.), İş parçacığı sonlandırması değil, işlem sonlandırıldığında serbest bırakılır.
3. Güvenlik. Bir işlemin sabit bir güvenlik belirteci vardır. Öte yandan, bir iş parçacığı farklı kullanıcıları / simgeleri taklit edebilir.

Daha fazlasını isterseniz, Scott Langham'ın yanıtı hemen hemen her şeyi kapsar. Bütün bunlar bir işletim sistemi perspektifinden. Farklı diller, görevler, hafif iş parçacıkları ve benzeri gibi farklı kavramları uygulayabilir, ancak bunlar sadece iplikleri (Windows'ta fiberler) kullanmanın yollarıdır. Donanım ve yazılım iş parçacığı yoktur. Donanım ve yazılım istisnaları ve kesintileri veya kullanıcı modu ve çekirdek iş parçacıkları vardır .

1. Bir iş parçacığı paylaşılan bir bellek alanında çalışır, ancak bir işlem ayrı bir bellek alanında çalışır
2. Bir iplik hafif bir işlemdir, ancak bir işlem ağır bir işlemdir.
3. Bir iş parçacığı, işlemin bir alt türüdür.

Görselleştirerek öğrenmekten daha rahat olanlar için, burada Süreci ve Konuları açıklamak için oluşturduğum kullanışlı bir diyagram var.
MSDN'deki bilgileri kullandım - İşlemler ve Konular Hakkında

Gömülü dünyadan gelmekle, süreç kavramının sadece MMU (bellek yönetim birimi) olan "büyük" işlemcilerde ( masaüstü CPU'lar, ARM Cortex A-9 ) ve MMU'ları destekleyen destek sistemlerinde ( Linux gibi ). FreeRTOS gibi küçük / eski işlemciler ve mikrodenetleyiciler ve küçük RTOS işletim sistemi ( gerçek zamanlı işletim sistemi ) ile MMU desteği yoktur ve bu nedenle işlem yoktur, yalnızca iş parçacıkları vardır.

İş parçacıkları birbirlerinin belleğine erişebilir ve işletim sistemi tarafından aralıklı bir şekilde zamanlanır, böylece paralel olarak çalışırlar (veya çok çekirdekli gerçekten paralel çalışırlar).

İşlemler ise MMU tarafından sağlanan ve korunan özel sanal bellek sanal alanlarında yaşar. Bu kullanışlıdır çünkü şunları sağlar:

1. buggy sürecinin tüm sistemi çökmesini önler.
2. Diğer süreç verilerini görünmez ve ulaşılamaz hale getirerek güvenliğin sağlanması. Süreç içindeki asıl çalışma bir veya daha fazla iplik tarafından halledilir.

1. Temel olarak, bir iş parçacığı işlem iş parçacığı olmadan çalışamaz bir işlemin bir parçasıdır.
2. Bir iplik hafif, işlem ise ağırdır.
3. işlem arasındaki iletişim biraz zaman gerektirir, iş parçacığı ise daha az zaman gerektirir.
4. İş parçacıkları aynı bellek alanını paylaşabilirken, süreç ayrı ayrı yaşar.

Süreç : yürütülen program süreç olarak bilinir

Konu : İş parçacığı, programın diğer kısmı ile "biri diğeri" kavramına dayalı olarak yürütülen bir işlevdir, bu nedenle iş parçacığı sürecin bir parçasıdır.

Ne yazık ki neredeyse tüm cevapları inceledim, ne yazık ki, şu anda OS dersini alan bir lisans öğrencisi olarak iki kavramı tam olarak anlayamıyorum. Yani bazı işletim sistemi kitaplarından okuyan adamların çoğu, yani iş parçacıklarının işlem adres adresinden yararlandıkları için işlem birimindeki genel değişkenlere erişebildikleri anlamına gelir. Yine de, yeni soru neden süreçler olduğu ortaya çıkıyor, bilişsel olarak zaten ipliklerin süreçlere karşı daha hafif olduğunu biliyoruz. Önceki cevaplardan birinden alıntılanan görüntüyü kullanarak aşağıdaki örneğe bakalım ,

Libre Office gibi bir kelime belgesinde aynı anda çalışan 3 iş parçacığımız var . Birincisi, kelimenin yanlış yazılmış olup olmadığının altını çizerek yazım denetimi yapar. İkincisi klavyeden harf alıp yazdırır. Ve son bir şey yanlış giderse çalışılan belgeyi kaybetmemek her kısa sürede belgeyi kaydeder. Bu durumda, 3 iş parçacığı, işlemlerinin adres alanı olan ortak bir belleği paylaştıkları ve böylece düzenlenmekte olan belgeye erişebildikleri için 3 işlem olamaz. Bu yüzden yol, kelime bulgusu ile birlikte iki buldozerle birlikte, bunlardan biri görüntüde eksiklik olsa da.

Python'da (yorumlanmış dil) çoklu iş parçacığı içeren bir algoritma oluştururken, yürütme süresinin daha önce oluşturduğum sıralı algoritmaya kıyasla daha iyi olmadığını görünce şaşırdım. Bu sonucun nedenini anlamak için biraz okuma yaptım ve öğrendiğim şeyin çok iş parçacıklı ve çok süreçli arasındaki farkları daha iyi anlayabileceğimiz ilginç bir bağlam sunduğuna inanıyorum.

Çok çekirdekli sistemler birden fazla yürütme iş parçacığı uygulayabilir ve bu nedenle Python çok iş parçacığını desteklemelidir. Ancak Python derlenmiş bir dil değildir ve bunun yerine yorumlanmış bir dildir ¹ . Bu, programın çalışması için yorumlanması gerektiği anlamına gelir ve yorumlayıcı, yürütülmeye başlamadan önce programın farkında değildir. Ancak bildiği şey Python'un kurallarıdır ve bu kuralları dinamik olarak uygular. Python'daki optimizasyonlar, esas olarak çalıştırılacak kod değil, yorumlayıcının kendisinin optimizasyonları olmalıdır. Bu, C ++ gibi derlenmiş dillerin aksine ve Python'da çoklu iş parçacığı için sonuçları vardır. Özellikle, Python çoklu iş parçacığını yönetmek için Global Tercüman Kilidini kullanır.

Öte yandan, derlenmiş bir dil de derlenmiştir. Program "tamamen" işlenir, burada önce sözdizimsel tanımlarına göre yorumlanır, daha sonra bir dil agnostik ara temsili ile eşleştirilir ve son olarak yürütülebilir bir koda bağlanır. Bu işlem, kod derleme sırasında kullanılabilir olduğundan kodun yüksek düzeyde optimize edilmesini sağlar. Çeşitli program etkileşimleri ve ilişkileri, yürütülebilir programın oluşturulduğu anda tanımlanır ve optimizasyon hakkında sağlam kararlar verilebilir.

Modern ortamlarda Python'un tercümanı çoklu iş parçacığına izin vermeli ve bu hem güvenli hem de verimli olmalıdır. Burada, yorumlanmış bir dil ile derlenmiş bir dilin arasındaki fark resme girer. Tercüman dahili olarak paylaşılan verileri farklı evrelerden rahatsız etmemeli, aynı zamanda hesaplamalar için işlemci kullanımını optimize etmemelidir.

Önceki yazılarda belirtildiği gibi, hem işlem hem de iş parçacığı, birbirinden bağımsız sıralı yürütmelerdir; birincil fark, belleğin bir işlemin birden çok iş parçacığı arasında paylaşılması, işlemler ise bellek alanlarını yalıtır.

Python'da veriler, Global Tercüman Kilidi tarafından farklı iş parçacıklarının eşzamanlı erişiminden korunur. Herhangi bir Python programında aynı anda yalnızca bir iş parçacığının yürütülmesini gerektirir. Öte yandan, her işlem için bellek başka bir işlemden izole edildiğinden ve işlemler birden çok çekirdek üzerinde çalışabildiğinden, birden çok işlem çalıştırmak mümkündür.

¹ Donald Knuth'un Bilgisayar Programlama Sanatı: Temel Algoritmalar konusunda yorumlayıcı rutinleri iyi bir açıklaması vardır.

Aynı işlemdeki iş parçacıkları Belleği paylaşır, ancak her iş parçacığının kendi yığını ve kayıtları vardır ve iş parçacıkları yığına özgü iş parçacığı verilerini depolar. İş parçacıkları hiçbir zaman bağımsız olarak çalışmaz, bu nedenle süreçler arası iletişim süreçler arası iletişime kıyasla çok daha hızlıdır.

İşlemler asla aynı belleği paylaşmaz. Bir alt işlem oluşturulduğunda, üst işlemin bellek konumunu çoğaltır. Süreç iletişimi, kanal, paylaşılan bellek ve mesaj ayrıştırma kullanılarak yapılır. İş parçacıkları arasında bağlam geçişi çok yavaş.

Şimdiye kadar bulduğum en iyi cevap Michael Kerrisk 'Linux Programlama Arayüzü' :

Modern UNIX uygulamalarında, her işlem birden çok yürütme iş parçacığına sahip olabilir. İş parçacıklarını öngörmenin bir yolu, aynı sanal belleği ve bir dizi diğer özelliği paylaşan bir süreçler dizisidir. Her iş parçacığı aynı program kodunu yürütür ve aynı veri alanını ve yığınını paylaşır. Ancak, her iş parçacığının yerel değişkenleri ve işlev çağrısı bağlantı bilgilerini içeren kendi yığını vardır. [LPI 2.12]

Bu kitap büyük bir açıklık kaynağıdır; Julia Evans, bu makalede Linux gruplarının gerçekten nasıl çalıştığını temizleme konusunda yardımından bahsetti .

Örnek 1: Bir JVM tek bir işlemde çalışır ve JVM'deki iş parçacıkları bu işleme ait yığını paylaşır. Bu nedenle birkaç iş parçacığı aynı nesneye erişebilir. İş parçacıkları yığını paylaşır ve kendi yığın alanlarına sahiptir. Bir iş parçacığının bir yöntemi ve yerel değişkenlerini çağırması iş parçacığını diğer iş parçacıklarından nasıl korur. Ancak yığın iplik için güvenli değildir ve iplik güvenliği için senkronize edilmelidir.

Neredeyse aynılar ... Ama asıl fark, bir iplik hafif ve bir işlem bağlam değiştirme, iş yükü ve benzeri açısından ağırdır.