(İş parçacıkları) problem - unix / windows process ... · bu i parçacıkları ezamanlı...

1

Silberschatz, Galvin and Gagne 2002 7.1 Operating System Concepts

Hafta 07: Threads (İş Parçacıkları)

Overview (Genel Bakış)

Multithreading Models (Çoklu Thread Modelleri)

Threading Issues (Thread Sorunları)

Pthreads (Pthreadler)

Solaris 2 Threads (Solaris 2 Threadleri)

Windows 2000 Threads (Windows 2000 Threadleri)

Java Threads (Java Threadleri)

Silberschatz, Galvin and Gagne 2002 7.2

Problem - Unix / Windows

PROCESS-Süreçleri "ağır" dır

Işlem bağlamda, çok sayıda veri

bellek yönetimi

dosya sistemleri, vb okuduğunuz zaman

İşlemci çok bilgi önbelleğe

Bellek Yönetimi bilgileri

Etkin sayfaları Önbellekleri

Pahalı içerik anahtarları ve tuzaklar

100 adlı mikrosaniye

Ayrı süreçler ayrı adres boşluk var

Paylaşılan bellek sınırlı veya varolmayan

İç eşzamanlıklı uygulamalar zor

Bağımsız süreçler vs işbirliği faaliyetleri arasındaki izolasyon

Temelde farklı hedefleri olan işlerde

Operating System Concepts


Proses=Bir iş parçacığı (single thread)

İşlemci Zamanlayıcısı

www.cnn.com

Proses C

0

100

5000

12000

Birinci resim

İkinci resim

Üçüncü resim

Üç resim üç ayrı proses

gibi istenebilse

Internet den resmin

gelmesini bekle

Internet den resmin

gelmesini bekle

Internet den resmin

gelmesini bekle

Sayfanın ekranda

gösterilmesi çok daha hızlı olur


Örnek - 1

Web Sunucusu - Aynı anda birden çok istekleri desteklemek için ne

yaparız?

Bir çözüm:

Paralel olarak çalıştırılacak çeşitli süreçler oluşturmak

Süreçleri aynı adres alanı eşlemek için paylaşılan bellek (shmget ()) kullanmalı

OS için paralel zamanlama

Etkin değil

Alan(space) : PCB, sayfa tabloları, vs

Zaman(time): OS yapıları (fork ()) ve bağlam anahtarı oluşturma



Örnek 2

Yoğun işlem işleme sistemleri

Örneğin, uçak rezervasyonları veya banka ATM

işlemleri

1000 saniyede işlem

İşlem başına çok küçük hesaplama olsa da

İşlem başına ayrı süreçler çok pahalı

Diğer teknikler (örneğin, mesaj vermek) çok daha

karmaşıktır

Operating System Concepts Silberschatz, Galvin and Gagne 2002 7.6

Bu Problem

Kısmen

Unix, Linux ve Windows ve

Büyük, güçlü işlemciler (ör., Pentium 4) bir eserdir

En büyük sistemlerde meydana eğilimindedir

Küçük ölçekli sistemlerde seyrek

PDA'lar, cep telefonları, el oyunları

Kapalı sistemlerde (örneğin, kontrollü uygulamaları)


2


Çözüm - Threads

Bir iş parçacığı-thread bir Unix veya Windows süreci

bağlamında bir program veya yordam yürütme

Diğer bir deyişle, süreç kavramın da uzman

Bir iş parçacığı kendi var

Program sayacı, kaydediciler

yığın

Bir iş parçacığı hisse

Adres alanı, yığın, statik veri

Tüm diğer kaynaklar

Aynı işlem, tüm diğer konuları ile


İş parçacığı (thread)

Bazı uygulamalarda bir prosesin içinde farklı bölümleri

belli sınırlar içinde birbirinden bağımsız çalıştırılabilir

Bir proses içinde birden fazla proses parçacığı paralel

olarak çalıştırılabilir. Böyle proses parçacıklarına iş parçacığı (thread) denir.

İş parçacığı kavramının yararı bir proses içinde çoklu

çalıştırma imkanının sunulmasıdır.

Tek bir proses içinde çoklu iş parçacıklarının

çalıştırılabilmesi, çoklu programlamada birden fazla prosesin çalıştırılabilmesine denktir.


Threads –İş Parçacıkları

İşlemin eş zamanlı olarak işlenen her bir bölümüdür.

İş parçacığı ve işlem arasındaki fark bir işletim

sisteminden iş parçacığının oluşturuluşu ve kaynakların

paylaşılmasıdır.

Çoğu durumda iş parçacıkları işlemlerin-process içinde

yer alır, onları oluştururlar.

Çoklu iş parçacıkları paralel olarak pek çok bilgisayar

sisteminde uygulanabilir.

İşlemler aynı kaynakları paylaşmazlar (bellek gibi). Fakat aynı işlem içindeki farklı thread ler aynı kaynakları

paylaşabilirler.


İş Parçacığı(Thread) Modeli

Bir süreç içerisindeki tüm threadler, aynı adres uzayını,

açık dosyaları, genel değişkenler gibi kaynakları paylaşırlar.

Süreçler ise fiziksel belleği, diskleri, yazmaçları, ve diğer

genel kaynakları paylaşırlar.

Her thread kendi sürecinin içerisindeki tüm adreslere

erişebilir, bir thread başka bir thread'in yığınına(stack) yazabilir, okuyabilir, ya da tamamen boşaltabilir.

Threadler yanı işi gerçekleştirmek üzerinde ortaklaşa çalışırlar.




Birinci kolonda bir süreç içerisindeki tüm

threadlerce paylaşılan değişkenler, ikinci kolonda ise thread’e özel olan değişkenler listelenmiştir.


Her process-süreç için Her iş parçacığı-thread için

Adres Uzayı(Address Space)

Genel değişkenler

Açık dosyalar

Çocuk süreçler

Askıya alma ikazları (pending alarms)

Sinyal ve sinyal işleyiciler hesap bilgisi

Program sayacı (program counter)

Yazmaçlar(registers)

Yığın(Stack)

Durum bilgisi(state)



Süreçler gibi threadlerde hazır(ready), bloklanmış(blocked),

çalışır(running) ve sonlanmış(terminated) durumlarında bulunabilir.

Çalışır durumda olan thread şu anda aktiftir ve işlemciyi kullanmaktadır.

Bloklanmış bir thread, bir olayın olmasını beklemektedir.

Örneğin, klavyeden bir verinin girilmesini bekleyen thread

bloklanmıştır.

Hazır olan thread ise çalışabilir durumdadır ve kendisine

sıra geldiginde çalışacaktır.


http://tr.wikipedia.org/wiki/%C4%B0%C5%9Flem_(bilgisayar)

http://tr.wikipedia.org/wiki/%C4%B0%C5%9Fletim_sistemi

http://tr.wikipedia.org/wiki/%C4%B0%C5%9Fletim_sistemi

3




Her threadin kendi yığını(stack) bulunmaktadır.


Örnek

Şimdi öyle bir uygulama düşünelim ki:

–Bu uygulama bir dosyadan okuma yapsın,

–Okuduğu veri üzerinde hesaplama yapıp,

–Hesaplamanın sonucunu başka bir dosyaya yazsın.

Burada kaç işlemden bahsediyoruz?

1.Dosyadan okuma yapma (G/Ç)

2.Okunan veri üzerinde hesaplama yapma (CPU çalışıyor)

3.Hesaplama sonucunu başka bir dosyaya yazma (G/Ç)


Silberschatz, Galvin and Gagne 2002 7.15 Threads

CS-502 Fall 2006 15

Threads

0x00000000

0xFFFFFFFF

Virtual

address space

code

(text)

static data

heap

thread 1 stack

PC (T2)

SP (T2)

thread 2 stack

thread 3 stack

SP (T1)

SP (T3)

PC (T1)

PC (T3)

SP

PC


Threads


•Linux, Windows ve Unix çeşitli sürümleri kendi

parçacığı arayüzlere sahip

•Standart değil, ama benzer

•Bazı konular

•Unix Örneğin, ERRNO - sistem çağrıları tarafından statik bir değişken seti

•Fork() ve exec () anlamı


Threads Kimler konuları oluşturur

ve yönetir?

Kullanıcı düzeyinde uygulanması

Fonksiyon kütüphanesi ile yapılır (örneğin, POSIX)

Süre sistemi - kullanım alanı dışında, süreç yönetimine benzer

Windows NT - lifler: Bir kullanıcı düzeyinde process

mekanizması

Kernel uygulanması - Yeni sistem çağrıları ve yönetmek için

yeni bir varlık

Linux: Hafif süreci (YSP)

Windows NT ve XP: Threads

Operating System Concepts Silberschatz, Galvin and Gagne 2002 7.18 Operating System Concepts

Benefits (Faydaları)

Responsiveness (Yanıt verme kabiliyeti)

Resource Sharing (Kaynak Paylaşımı)

Economy (Ekonomik)

Utilization of MP Architectures (MP Mimarilerinin kullanımı)

4


Threads

thread bir nesne değil bir akış kontrolü yöntemidir

Sırayla işletilecek bir dizi komut barındırır

Thread bir nesnedir ???????????------------

Farklı metotlar ile

Yeni bir Thread oluşturup çalışabilir hale getirir

ve run()

Yeni Thread hayatına bu metodun içinde başlar


User Threads(Kullanıcı Threadleri)

Thread management done by user-level threads library

(Thread yönetimi kullanıcı-seviye threadleri kütüphanesi tarafından yapılır.)

Examples (Örnekler)

- POSIX Pthreads (POSIX Pthreadleri)

- Mach C-threads (Mach C-threadleri)

- Solaris threads (Solaris threadleri)


Kernel Threads(Çekirdek Thredleri)

Supported by the Kernel (Çekirdek tarafından desteklenir)


- Windows 95/98/NT/2000/son sürümler

- Solaris

- Tru64 UNIX

- BeOS

- Linux


Single and Multithreaded Processes

(Tek ve Çoklu Thread Süreçleri)


Threads (İş Parçacıkları)

Multithreading:Program içerisinde aynı anda

birden fazla işin yapılabilmesi.

Aynı program içerisinde birçok Thread çalışabilir.

Bu iş parçacıkları eşzamanlı olarak asenkron veya

senkron olarak çalışabilir.


Multithreading vs. Multiprocessing

• Bağımsız işlemlerle karşılaştırıldığında iş parçacıkları daha

hafiftir

• İş parçacıkları aynı adres alanını paylaştıkları için veri ve

kodları paylaşabilir.

• İçerik değiştirme iş parçacıklarında işlemlere göre daha az

pahalıdır.

• İş parçacıkları arası haberleşme işlemler arası

haberleşmeye göre daha ucuzdur

• İş parçacıkları farklı görevlerin aynı zaman aralığında gerçekleştirilmesine olanak sağlarlar

5

Silberschatz, Galvin and Gagne 2002 7.25 Silberschatz, Galvin and Gagne 2002 7.26 Operating System Concepts

Multithreading Models

(Çoklu Thread Modelleri)

Many-to-One (Çoka Bir)

One-to-One (Bire Bir)

Many-to-Many (Çoka Çok)


Many-to-One (Çoktan- Bire)

Many user-level threads mapped to single kernel

thread. (Çok sayıda kullanıcı-seviye threadleri tek çekirdek

thread’i ile eşlenir.)

Used on systems that do not support kernel threads.

(Çekirdek threadlerini desteklemeyen sistemlerde

kullanılır.)


Many-to-One Model (Çokludan-tek

Modeli)


One-to-One (Bire Bir)

Each user-level thread maps to kernel thread.

(Her kullanıcı-seviye thread’i çekirdek thread’i ile eşlenir.)


- Windows 95/98/NT/2000

- OS/2


One-to-one Model (Bire Bir Modeli)

6


Many-to-Many Model

(Çoktan-Çoka Modeli)

Allows many user level threads to be mapped to many

kernel threads. (Çok sayıda kullanıcı-seviye threadlerinin, çok sayıda

çekirdek threadleri ile eşleşmesini sağlar.)

Allows the operating system to create a sufficient number of kernel threads.

(İşletim sisteminin yeterli sayıda çekirdek threadi

oluşturmasını sağlar. )

Solaris 2

Windows NT/2000 with the ThreadFiber package

(ThreadFiber paketi ile Windows NT/2000)


Many-to-Many Model

(Çoktan- Çoka Modeli)


Threading Issues

(Threading Sorunları)

Semantics of fork() and exec() system calls

(fork() ve exec() sistem çağrılarının semantiği)

Thread cancellation (Thread iptal etme)

Signal handling (Sinyal işleme)

Thread pools (Thread havuzları)

Thread specific data (Thread özel verisi)


Pthreads

a POSIX standard (IEEE 1003.1c) API for thread

creation and synchronization. (Thread yaratma ve senkronizasyon için bir POSIX

standartı(IEEE 1003.1c) vardır.)

API specifies behavior of the thread library,

implementation is up to development of the library.

(API thread kütüphanesinin davranışını belirtir,

uygulama kütüphanenin gelişmesine bağlıdır.)

Common in UNIX operating systems.

(Unix işletim sistemlerinde yaygın olarak kullanılır)


Solaris 2 Threads

(Solaris 2 Threadleri)


Solaris Process (Solaris Süreci)

7


Windows 2000 Threads

(Windows 2000 Threadleri)

Implements the one-to-one mapping.

(Bire Bir eşlemede uygulanır.)

Each thread contains (her thread şu özellikleri içerir)

- a thread id (thread id’si)

- register set (belirlenen kayıt)

- separate user and kernel stacks (ayrı kullanıcı ve çekirdek yığınları )

- private data storage area (özel veri depolama alanı)


Linux Threads (Linux Threadleri)

Linux refers to them as tasks rather than threads.

(Linux onları threadler yerine görevler olarak içerir)

Thread creation is done through clone() system call.

(Thread oluşturulması clone() sistem çağrısı tarafından yapılır)

Clone() allows a child task to share the address space of the parent task (process)

(Clone() çocuk görevin, ana görevin adres alanını

paylaşmasını sağlar.)


Java Threads (Java Threadleri)

Java threads may be created by:

(Java threadleri aşağıdakiler tarafından oluşturulabilir:)

Extending Thread class

(Thread sınıfına uzanma)

Implementing the Runnable interface

(Çalıştırılabilir ara yüzleri yürütme)

Java threads are managed by the JVM.

(Java threadleri JVM tarafından yönetilir.)


Java Thread States

(Java Thread Durumu)


Win32-THREAD’LER

Thread kullanımı Win32 sistemleriyle mümkün hale getirilmiştir.

Klasik UNIX sistemlerinde thread kavramı yoktur. Ancak son yıllarda UNIX sistemlerine de thread konusu dahil edilmiştir.

Bir process n thread’den oluşur. Her process çalışmaya tek bir thread’le başlar. Buna ana thread denir.

Process’in çalışması ana thread’den başlar.

Diğer thread’ler herhangi bir zamanda herhangi bir thread içerisinde CreateThread API fonksiyonuyla yaratılırlar.


Thread bir process’in farklı bir programmış gibi çalışabilen parçalarına denir.

Win32’nin zaman paylaşımlı çalışma sistemi process temelinde değil thread temelinde yapılmaktadır.

Örneğin sistemde üç process çalışmakta olsun.

P1 process’inin üç, P2 process’inin dört, P3 process’inin de iki thread’i olsun.

Win32 sistemlerinin işleme süresi-quanta süresi 20 ms’dir.

Sistem her quanta süresi dolduğunda dokuz thread’den birini bırakacak diğerini alacaktır.

8



Bir process’in thread’leri sanki ayrı

programlarmış gibi asenkron bir biçimde ele alınıp çalıştırılırlar.

C programcısı için herhangi bir fonksiyon thread olarak tanımlanabilir.

Bir thread CreateThread API fonksiyonuyla yaratılıp çalıştırılmaya başlanır.


Aşağıdaki durumlardan bir tanesi oluştuğunda

sonlanır.

1. Thread olarak belirlenen fonksiyonun içerisinde

ExitThread API fonksiyonunun çağırılması ile,

2. Thread olarak belirlenen fonksiyon ana bloğunu

bitirip sonlandığında,

3. Thread olarak belirtilen fonksiyon içerisinde

return anahtar sözcüğü kullanılarak fonksiyon

sonlandırıldığında.


Aslında thread olarak belirlenen fonksiyon yalnızca thread’in başlangıç ve bitiş noktalarını belirlemekte etkilidir. Yoksa thread bir akış belirtir.

Ana thread’in başlangıç noktası derleyicinin başlangıç kodudur. WinMain başlangıç kodu tarafından çağırılır.

WinMain akış bakımından ana thread’i temsil eder.

Bir process yaratıldığında ana thread işletim sistemi tarafından yaratılır. Yani WinMain içerisinde akış ana thread üzerindedir. Fakat ana thread’in başlangıç noktası derleyicinin başlangıç kodudur.


Örneğin iki thread’in akışı aynı herhangi bir fonksiyonun içerisinde olabilir.

Özetle thread bir akış belirtir.

Thread fonksiyonu ise sadece akışın başlangıç fonksiyonudur.

Bir thread fonksiyonu bittiğinde akış nereden devam edecektir?

---Aslında thread fonksiyonu CreateThread API fonksiyonu içerisinden çağırılır. Thread fonksiyonu doğal olarak sonlandığında akış CreateThread içerisinden devam eder. İşte o noktada ExitThread fonksiyonu uygulanır.


CreateThread ve ExitThread fonksiyonları mantıksal olarak şunları yapmaktadır:

CreateThread()

{

Yeni akış yarat

Thread fonksiyonunu çağır ExitThread

}

ExitThread()

{

Akışı sil

}

• Tabii CreateThread API fonksiyonu çağırıldığında bu fonksiyon yeni bir akışı yaratarak kendi akışına devam eder.

9


Bir process’in thread’ler arasındaki geçişlerinde sayfa tablosunda hiçbir değişiklik yapılmaz. Yani bir process’in bütün thread’leri aynı adres alanı içerisinde çalışmaktadır.

Aynı thread’lerin arasındaki haberleşme normal global değişkenler kullanılarak yapılabilir. Ancak farklı process’lerin thread’leri arasındaki geçiş sırasında sayfa tablosu yeniden düzenlenir.

Böylece farklı process’lerin thread’leri arasıda adres alanı bakımından bir izolasyon sağlanmış durumundadır.

Aynı process’in thread’leri arasındaki geçiş zamansal bakımdan farklı process’lerin thread’leri arasındaki geçişten daha hızlıdır.


Thread’lerle Çalışmanın Process’lerle

Çalışmaya Göre Avantajları

Thread sisteminin olmadığı işletim sistemlerinde işlemler process’lerle yapılır. Thread’lerle çalışmanın process’lerle çalışmaya göre avantajları şunlardır:

1. Thread’ler arasındaki geçiş işlemi process’ler arasındaki geçiş işleminden daha hızlı yapılır(Tabii farklı process’lerin thread’leri arasındaki geçiş söz konusuysa bu daha yavaştır).

2. Çoklu thread çalışmalarında process’in bloke olma olasılığı daha azdır. Örneğin klavyeden bir girdi beklense tüm process bloke edilmez, yalnızca işlemin yapıldığı thread bloke edilir(Process’in bloke edilmesi işletim sisteminin bir process’i dışsal bir olay gerçekleşene kadar çizelge dışı bırakması işlemidir).

3. Thread’ler arası haberleşme process’ler arası haberleşmeden çok daha kolaydır. Sadece global değişkenlerle haberleşme sağlanabilir.


Thread’lerle Çalışmanın

Process’lerle Çalışmaya Göre

Dezavantajları

1. Thread’ler arasında process’lere göre daha yoğun

bir senkronizasyon uygulamak gerekir.

2. Process’ler birbirlerinden izole edildikleri için çok

process’le çalışılması daha güvenlidir.


İşlevlerine Göre Thread’lerin

Sınıflandırılması

1. Uyuyan Thread’ler(sleepers threads): Bu tür thread’ler bir olay oluşana kadar beklerler. Olay oluşunca bir faaliyet gösterirler. Sonra o olay oluşana kadar yeniden beklerler. Tabii bekleme işi thread bloke edilerek yapılmaktadır.

2. Tek İş Yapan Thread’ler(one shot threads): Bu thread’ler bir olay gerçekleşene kadar bekler. Olay gerçekleşince faaliyet gösterir ve thread’in çalışması biter.

3. Önceden Faaliyet Gösteren Thread’ler(anticipating threads): Burada ileride yapılacak bir işlem önceden yapılır. Eğer akış o işleme gerek kalmayacak bir biçimde gelişiyorsa işlem boşuna yapılmış olur. Eğer akış o işlemin farklı bir biçimde yapılmasını gerektirecek bir şekilde gelişiyorsa o işlem yeniden yapılır.

4. Beraber Faaliyet Gösteren Thread’ler: Burada spesifik bir iş vardır. CPU’dan daha fazla zaman alacak biçimde işlem birden fazla thread tarafından yapılır.

5. Bağımsız Faaliyet Gösteren Thread’ler: Bu thread’ler tamamen farklı amaçları gerçekleştirmek için yazılır. Genellikle bir senkronizasyon problemi oluşturmazlar. Tasarım kolaylığı sağlamak amacıyla kullanılırlar.


Thread’lerin Öncelik

Derecelendirilmesi

Windows ve UNIX sistemleri çizelgeleme algoritması olarak döngüsel çizelgeleme(round robin scheduling) metodu kullanılır.

Bu çizelgeleme yönteminde process’ler ya da thread’ler sırasıyla çalıştırılır.

Liste bittiğinde başa dönülerek tekrardan başlanır. Ancak Win32’de öncelikli döngüsel çizelgeleme(priority round robin scheduling) denilen bir yöntem kullanılır.

Bu yöntemde her thread’in 0-31 arasında bir öncelik derecesi vardır. Bu yöntemde en yüksek öncelikli thread grubu diğerlerine bakılmaksızın kendi aralarında çalıştırılır. O grup tamamen bitirilince daha düşük gruptakiler yine kendi aralarında çizelgelenir ve işlemler böyle devam ettirilir.


Örneğin sistemde 8 tane thread şu önceliklerle bulunsun:

İlk önce 18 öncelikliler işleme alınır.

Bu grup bitirilince 14’lükler kendi aralarında çalıştırılır ve bitirilirler.

Sonra 8’likler en son da 1’likler kendi aralarında çalıştırılıp bitirilirler.

Düşük öncelikli thread’lerin çalışma olasılıkları düşük olmakla birlikte 0 değildir.

Ancak düşük öncelikli thread’ler iki nedenden dolayı çalışma fırsatı bulabilirler:

10


1. Yüksek öncelikli bütün thread’lerin bir t anında bloke edilmiş olma olasılığı vardır. Böylelikle düşük öncelikli thread’ler de çalışma fırsatı bulur.

2. Win32 sistemleri ismine dinamik yükseltme(dynamic boosting) uygular. Dinamik yükseltme uygulanan iki durum vardır:

a) Bir thread 3-4 saniye süresince hiç çalışma fırsatı bulamadıysa Win32 tarafından önceliği 2 quanta süresi kadar 15’e yükseltilir. 2 quantadan sonra tekrar eski derecesine indirilir.

b) Hiçbir giriş-çıkış faaliyetine yol açmayan ve hiçbir penceresi olmayan process’lere background process denir. Bir penceresi olan ve giriş-çıkış işlemi kullanan process’lere foreground process denir. Giriş-çıkış işlemlerine yol açan sistem fonksiyonları otomatik olarak process’i bir quanta süresi için 2 derece, sonraki quanta süresi içinse 1 derece yükseltirler. Sonraki quanta’larda eski haline döndürülürler.


ThreadState



C# Örnekleri(Ve diğerleri)


using System;

using System.Threading;

namespace ConsoleApplication10

{

class ThreadTest

{

static void Main()

{

Thread t = new Thread (WriteY); // Kick off a new thread t.Start(); // running WriteY()

// Simultaneously, do something on the main thread.

for (int i = 0; i < 1000; i++) Console.Write ("x");

}

static void WriteY()

{

for (int i = 0; i < 1000; i++) Console.Write ("y");

}

}

} Silberschatz, Galvin and Gagne 2002 7.58

İşletim Sistemlerinde Thread


Çekirdeklerde büyük, çoklu iş parçacıklı programlara

dönüşmüştür.

Eşzamanlı etkinliği çok

Aynı anda çalışan birden çok cihaz

Aynı anda birden fazla uygulama faaliyetleri

Yararlı bir araç

Özel çekirdek iplik paketleri, senkronizasyon ilkellerini, vb

Karmaşık OS ortamlar için faydalı


using System;

using System.Threading;

namespace ConsoleApplication10

{

class ThreadTest

{

bool done;

static void Main()

{

new Thread(Go).Start(); // Call Go() on a new thread

Go(); // Call Go() on the main thread

}

static void Go() {

// Declare and use a local variable - 'cycles'

for (int cycles = 0; cycles < 5; cycles++) Console.Write('?');

}

}

}


Kaynakçalar


Yrd.Doç.Dr.Nurettin Beşli –Sistem Programcılığı

(İş parçacıkları) problem - unix / windows process ... · bu i parçacıkları ezamanlı...

Documents