Process ve Thread

#include <stdio.h>
#include <windows.h>
#include <tchar.h>

// Child Process olarak başlatılacak uygulamanın adı
#define CHILD_PROCESS_APP _T("C:\\Windows\\System32\\notepad.exe")

// Parent Process'in ana fonksiyonu
int _tmain(int argc, TCHAR* argv[])
{
    // Process başlangıç bilgileri için yapı
    STARTUPINFO si;
    // Yeni Process ve onun ana Thread'i hakkındaki bilgileri tutar
    PROCESS_INFORMATION pi;

    // si yapısını sıfırla
    ZeroMemory(&si, sizeof(si));
    si.cb = sizeof(si);
    // pi yapısını sıfırla
    ZeroMemory(&pi, sizeof(pi));

    // 1. ADIM: Parent Çalışıyor
    _tprintf(_T("PARENT: Ana Process basladi (ID: %lu).\n"), GetCurrentProcessId());

    // 2. ADIM: Child Process olusturuluyor
    _tprintf(_T("PARENT: Child Process olusturuluyor (%s).\n"), CHILD_PROCESS_APP);

    // CreateProcess fonksiyonu ile yeni bir Process olustur
    if (!CreateProcess(
        NULL,                       // Uygulama Modul Adi (NULL, komut satiri kullanilacaksa)
        CHILD_PROCESS_APP,          // Komut Satiri (Bu ornekte notepad.exe)
        NULL,                       // Process Handle'i guvenlik nitelikleri
        NULL,                       // Thread Handle'i guvenlik nitelikleri
        FALSE,                      // Handle miras alimi (inherit handles)
        0,                          // Olusturma bayraklari (normal olusturma)
        NULL,                       // Yeni ortam bloklari
        NULL,                       // Yeni dizin adi
        &si,                        // STARTUPINFO yapisi
        &pi                         // PROCESS_INFORMATION yapisi (sonuclar buraya yazilir)
    ))
    {
        _tprintf(_T("PARENT: CreateProcess basarisiz oldu (%lu).\n"), GetLastError());
        return 1;
    }

    // 3. ADIM: Parent bekliyor
    _tprintf(_T("PARENT: Child Process (ID: %lu) basladi. Tamamlanmasini bekliyor...\n"), pi.dwProcessId);

    // Child Process'in tamamlanmasini bekle
    // pi.hProcess, Child Process'in handle'idir.
    // INFINITE, bekleme isleminin sinirsiz olacagi anlamina gelir.
    WaitForSingleObject(pi.hProcess, INFINITE);

    // 4. ADIM: Child Process Tamamlandi
    _tprintf(_T("PARENT: Child Process tamamlandi.\n"));

    DWORD exitCode = 0;
    if (GetExitCodeProcess(pi.hProcess, &exitCode)) {
        _tprintf(_T("PARENT: Child Process cikis kodu: %lu.\n"), exitCode);
    }

    // Process ve Thread handle'larini kapat
    CloseHandle(pi.hProcess);
    CloseHandle(pi.hThread);

    // 5. ADIM: Parent sonlaniyor
    _tprintf(_T("PARENT: Ana Process sonlaniyor.\n"));

    return 0;
}

Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:

PARENT: Ana Process basladi (ID: 18868).
PARENT: Child Process olusturuluyor (C:\Windows\System32\notepad.exe).
PARENT: Child Process (ID: 26332) basladi. Tamamlanmasini bekliyor...

Notepad uygulamasını kapattığımızda program aşağıdaki ifadeleri ekrana yazar ve sona erer:

PARENT: Child Process tamamlandi.
PARENT: Child Process cikis kodu: 0.
PARENT: Ana Process sonlaniyor.

Çalışma mantığı ve sırası

CreateProcess çağrıldığında,

1. İşletim sistemi, notepad.exe için yeni ve izole bir Process alanı oluşturur.
2. Bu yeni Process'in kodunu çalıştırmak için otomatik olarak bir ana Thread oluşturur ve yürütmeyi bu Thread'e verir.
3. PROCESS_INFORMATION yapısı (pi), hem yeni Process'in (pi.hProcess) hem de bu ana Thread'in (pi.hThread) handle'larını (tanıtıcılarını) içerir.

Bu örnekte, notepad.exe çalışmaya başladığında, işletim sisteminde iki ayrı Process (sizin uygulamanız ve Notepad) ve her Process içinde en az birer Thread çalışıyor olacaktır.

#include <stdio.h>
#include <windows.h>
#include <tchar.h>

// Child Process olarak başlatılacak uygulamanın adı ve komut satırı
// Not: Bu örnekte, Child Process'in hemen kapanmaması için 'cmd.exe' başlatıp /k parametresi ile açık tutuyoruz.
// /k parametresi, komutu çalıştırdıktan sonra pencereyi kapatmamasını söyler.
#define CHILD_COMMAND_LINE _T("cmd.exe /k echo Child Process calisiyor...")

// Parent Process'in ana fonksiyonu
int _tmain(int argc, TCHAR* argv[])
{
    STARTUPINFO si;
    PROCESS_INFORMATION pi;

    ZeroMemory(&si, sizeof(si));
    si.cb = sizeof(si);
    ZeroMemory(&pi, sizeof(pi));

    // 1. ADIM: Parent Çalışıyor
    _tprintf(_T("PARENT: Ana Process basladi (ID: %lu).\n"), GetCurrentProcessId());

    // 2. ADIM: Child Process olusturuluyor
    _tprintf(_T("PARENT: Child Process olusturuluyor (Beklenmeyecek).\n"));

    // CreateProcess fonksiyonu ile yeni bir Process olustur
    if (!CreateProcess(
        NULL,                               // Uygulama Modul Adi (NULL, komut satiri kullanilacaksa)
        CHILD_COMMAND_LINE,                 // Komut Satiri (Bu ornekte cmd.exe /k ...)
        NULL,                               // Process Handle'i guvenlik nitelikleri
        NULL,                               // Thread Handle'i guvenlik nitelikleri
        FALSE,                              // Handle miras alimi
        CREATE_NEW_CONSOLE,                 // Olusturma bayraklari: Yeni bir konsol penceresinde baslat
        NULL,                               // Yeni ortam bloklari
        NULL,                               // Yeni dizin adi
        &si,                                // STARTUPINFO yapisi
        &pi                                 // PROCESS_INFORMATION yapisi (sonuclar buraya yazilir)
    ))
    {
        _tprintf(_T("PARENT: CreateProcess basarisiz oldu (%lu).\n"), GetLastError());
        return 1;
    }

    // 3. ADIM: Parent Kendi Isine Devam Ediyor
    _tprintf(_T("PARENT: Child Process (ID: %lu) baslatildi ve serbest birakildi.\n"), pi.dwProcessId);

    // Parent, Child'i beklemek yerine kendi isine devam ediyor.
    // Ilk ornekteki 'WaitForSingleObject' cagrisi burada YOK.

    _tprintf(_T("PARENT: Kendi islerimi yapiyorum... (5 saniye bekleyecegim).\n"));
    Sleep(5000); // Parent Process 5 saniye boyunca bekler (bu sırada Child Process çalışmaya devam eder).

    // 4. ADIM: Handle'lari kapatma
    // Artık beklemeye gerek kalmadığı için handle'ları hemen kapatabiliriz.
    CloseHandle(pi.hProcess);
    CloseHandle(pi.hThread);

    // 5. ADIM: Parent sonlaniyor
    _tprintf(_T("PARENT: Ana Process sonlaniyor. Child Process bagimsiz calismaya devam edecek.\n"));

    return 0;
}

Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:

PARENT: Ana Process basladi (ID: 21088).
PARENT: Child Process olusturuluyor (Beklenmeyecek).
PARENT: Child Process (ID: 20828) baslatildi ve serbest birakildi.
PARENT: Kendi islerimi yapiyorum... (5 saniye bekleyecegim).

5 saniye sonra program aşağıdaki ifadeleri ekrana yazar ve sona erer:

PARENT: Ana Process sonlaniyor. Child Process bagimsiz calismaya devam edecek.

Çalışma mantığı ve sırası

Bu örnekte kritik olan fark, Child Process'in oluşturulmasından sonra WaitForSingleObject fonksiyonunun kullanılmamasıdır.

Bu yöntem, hizmetler (services), arka plan güncelleyicileri veya kullanıcı arayüzü uygulamasının uzun süren bir işlemi başka bir Process'e delege etmesi gereken durumlar için idealdir.

#include <stdio.h>
#include <windows.h>
#include <tchar.h>

// İşçi Thread'lere aktarılacak yapı (Parametreler)
typedef struct ThreadData {
    int threadId;
    int loopCount;
} ThreadData;

// 1. İŞÇİ THREAD FONKSİYONU
// Bu fonksiyon, yeni bir Thread baslatildiginda yurutecegi kodu icerir.
DWORD WINAPI WorkerThreadFunction(LPVOID lpParam)
{
    // Parametre olarak gonderilen ThreadData yapisini al
    ThreadData* data = (ThreadData*)lpParam;

    _tprintf(_T("THREAD-%d: Basladi. %d kez donme yapacak.\n"), data->threadId, data->loopCount);

    // Uzun suren bir gorevi simule eden dongu
    for (int i = 0; i < data->loopCount; i++)
    {
        // Her 1000 iterasyonda bir ilerleme mesaji goster
        if ((i + 1) % 1000 == 0)
        {
            _tprintf(_T("THREAD-%d: Ilerleme: %d/%d\n"), data->threadId, i + 1, data->loopCount);
        }

        // Cok kisa bir duraklama ile CPU'nun diger Thread'lere de zaman vermesini saglayabiliriz (Istege Bagli)
        // Sleep(0);
    }

    _tprintf(_T("THREAD-%d: Tamamlandi.\n"), data->threadId);

    // Thread'in basarili bir sekilde sonlandigini belirten cikis kodu
    return 0;
}


int _tmain(int argc, TCHAR* argv[])
{
    const int NUM_THREADS = 2;
    HANDLE hThreadArray[NUM_THREADS];
    ThreadData threadData[NUM_THREADS];

    _tprintf(_T("ANA THREAD: Uygulama basladi (ID: %lu).\n"), GetCurrentThreadId());

    // --- 1. ve 2. Isçi Thread'lerin Olusturulmasi ---

    // Thread 1 icin verileri hazirla
    threadData[0].threadId = 1;
    threadData[0].loopCount = 500000;

    // Thread 2 icin verileri hazirla
    threadData[1].threadId = 2;
    threadData[1].loopCount = 750000; // Daha uzun surecek bir is

    for (int i = 0; i < NUM_THREADS; i++)
    {
        // CreateThread fonksiyonu ile yeni bir Thread olustur
        hThreadArray[i] = CreateThread(
            NULL,                            // Guvenlik nitelikleri
            0,                               // Baslangic stack boyutu (0 = varsayilan)
            WorkerThreadFunction,            // Thread fonksiyonu (yurutulecek kod)
            &threadData[i],                  // Thread fonksiyonuna gonderilecek parametre
            0,                               // Olusturma bayraklari (0 = hemen calistir)
            NULL                             // Thread ID'si (NULL = ihtiyacimiz yok)
        );

        if (hThreadArray[i] == NULL)
        {
            _tprintf(_T("ANA THREAD: Thread olusturma basarisiz oldu. Hata kodu: %lu\n"), GetLastError());
            return 1;
        }
        _tprintf(_T("ANA THREAD: Thread-%d baslatildi.\n"), threadData[i].threadId);
    }

    _tprintf(_T("ANA THREAD: Tum Isçi Thread'ler baslatildi. Tamamlanmalarini bekliyorum...\n"));

    // --- Isçi Thread'lerin Beklenmesi ---

    // Tum isçi Thread'lerin tamamlanmasini bekle.
    // WaitForMultipleObjects: Birden fazla nesneyi (Thread handle'ini) bekler.
    WaitForMultipleObjects(
        NUM_THREADS,         // Beklenecek nesne sayisi
        hThreadArray,        // Nesne handle'larinin dizisi
        TRUE,                // TRUE: Tum nesnelerin sinyal vermesini bekle (AND operasyonu)
        INFINITE             // Sinirsiz sure bekle
    );

    // --- Sonlandirma ---

    _tprintf(_T("ANA THREAD: Tum Isçi Thread'ler tamamlandi.\n"));

    // Handle'lari kapat
    for (int i = 0; i < NUM_THREADS; i++)
    {
        CloseHandle(hThreadArray[i]);
    }

    _tprintf(_T("ANA THREAD: Uygulama basarili sekilde sonlaniyor.\n"));

    return 0;
}

Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:

ANA THREAD: Uygulama basladi (ID: 30572).
ANA THREAD: Thread-1 baslatildi.
THREAD-1: Basladi. 500000 kez donme yapacak.
THREAD-1: Ilerleme: 1000/500000
THREAD-1: Ilerleme: 2000/500000
THREAD-1: Ilerleme: 3000/500000
THREAD-1: Ilerleme: 4000/500000
THREAD-1: Ilerleme: 5000/500000
ANA THREAD: Thread-2 baslatildi.
ANA THREAD: Tum Isci Thread'ler baslatildi. Tamamlanmalarini bekliyorum...
THREAD-2: Basladi. 750000 kez donme yapacak.
THREAD-2: Ilerleme: 1000/750000
THREAD-2: Ilerleme: 2000/750000
THREAD-2: Ilerleme: 3000/750000
.
.
.
THREAD-2: Ilerleme: 747000/750000
THREAD-2: Ilerleme: 748000/750000
THREAD-2: Ilerleme: 749000/750000
THREAD-2: Ilerleme: 750000/750000
THREAD-2: Tamamlandi.
ANA THREAD: Tum Is├ği Thread'ler tamamlandi.
ANA THREAD: Uygulama basarili sekilde sonlaniyor.

Çalışma mantığı ve sırası

Bu kodun çalışması, Multi-threading'in temel faydalarını gösterir:

1. Ana Thread (Main Thread): Uygulamanın kontrolünü başlatır ve CreateThread fonksiyonunu iki kez çağırarak iki yeni yürütme akışı (Worker Thread 1 ve 2) oluşturur.
2. Eşzamanlı yürütme: Worker Thread 1 ve Worker Thread 2 aynı anda (çok çekirdekli sistemde tam paralel, tek çekirdekte zaman dilimleriyle dönüşümlü) çalışmaya başlar. Her iki Thread de kendi WorkerThreadFunction fonksiyonunu çalıştırır, ancak parametre olarak farklı döngü sayıları almıştır.
3. Hızlı yanıt verme (Responsiveness): Bu senaryoda, Ana Thread'in görevi sadece yönetimdir. Ana Thread, uzun sürecek olan hesaplama görevlerini İşçi Thread'lere devrederek kendisi (eğer bir kullanıcı arayüzü olsaydı) kullanıcı girdilerine yanıt vermeye devam edebilirdi.
4. Bloklama ve senkronizasyon: Ana Thread, tüm işçi Thread'lerin bitmesini garanti etmek için WaitForMultipleObjects fonksiyonunu kullanır. Bu çağrı, tüm işçi Thread'ler işlerini bitirene kadar Ana Thread'i bloke eder. Bu, Thread'ler arası basit bir senkronizasyon mekanizmasıdır.
5. Kaynak paylaşımı: Her iki işçi Thread de aynı Process'in bellek alanını, global değişkenlerini ve diğer kaynaklarını paylaşır (bu örnekte _tprintf ile konsol çıktısını paylaşırlar, bu da çıktıların karışık görünmesine neden olabilir; bu da eşzamanlılıkta yarış koşulu riskine bir örnektir).

#include <stdio.h>
#include <windows.h>
#include <tchar.h>

// Child Process'in dosya yolu (Adim 2'de derlenecek dosya)
#define CHILD_APP_PATH _T(".\\ChildApp.exe") 
// Ikinci Child Process
#define CHILD_APP_2 _T("notepad.exe")

// --- Parent Process Icindeki Ek Thread Fonksiyonu ---
DWORD WINAPI ParentWorkerThread(LPVOID lpParam) 
{
    int delaySeconds = *((int*)lpParam);
    _tprintf(_T("  [PARENT EK THREAD]: Basladi (ID: %lu). %d saniye calisacak.\n"), GetCurrentThreadId(), delaySeconds);
    
    for (int i = 0; i < delaySeconds; i++)
    {
        Sleep(1000); 
        _tprintf(_T("  [PARENT EK THREAD]: Gecen sure %d saniye.\n"), i + 1);
    }

    _tprintf(_T("  [PARENT EK THREAD]: Gorev tamamlandi ve sonlaniyor.\n"));
    return 0;
}


// --- ANA FONKSIYON (Parent Process ve Ana Thread) ---
int _tmain(int argc, TCHAR* argv[]) 
{
    // Parent Process'e ait ek Thread icin handle ve data
    HANDLE hParentWorkerThread;
    int parentThreadDelay = 5;

    // Child Process'ler icin yapilar
    STARTUPINFO si[2];
    PROCESS_INFORMATION pi[2];
    
    // Child Process komut satirlari
    TCHAR child1Cmd[] = CHILD_APP_PATH; // ChildApp.exe'yi cagir
    TCHAR child2Cmd[] = CHILD_APP_2;    // Notepad'i cagir
    TCHAR* childCmds[] = { child1Cmd, child2Cmd };
    
    for(int i = 0; i < 2; i++) {
        ZeroMemory(&si[i], sizeof(si[i]));
        si[i].cb = sizeof(si[i]);
        ZeroMemory(&pi[i], sizeof(pi[i]));
    }

    _tprintf(_T("=================================================================\n"));
    _tprintf(_T("PARENT ANA THREAD: Uygulama basladi (ID: %lu).\n"), GetCurrentThreadId());
    _tprintf(_T("-----------------------------------------------------------------\n"));


    // 1. Adim: Parent Process Icine Ek Thread Olusturma
    hParentWorkerThread = CreateThread(
        NULL, 0, ParentWorkerThread, &parentThreadDelay, 0, NULL
    );

    if (hParentWorkerThread == NULL) {
        _tprintf(_T("HATA: Parent Ek Thread olusturulamadi.\n")); return 1;
    }
    _tprintf(_T("PARENT ANA THREAD: Parent Ek Thread baslatildi.\n"));


    // 2. Adim: 2 Adet Child Process Olusturma
    for (int i = 0; i < 2; i++)
    {
        _tprintf(_T("PARENT ANA THREAD: Child Process %d olusturuluyor: %s\n"), i + 1, childCmds[i]);
        
        if (!CreateProcess(
            NULL, childCmds[i], NULL, NULL, FALSE, 0, NULL, NULL, &si[i], &pi[i]
        )) 
        {
            _tprintf(_T("HATA: Child Process %d olusturulamadi (%lu).\n"), i + 1, GetLastError());
            pi[i].hProcess = NULL; pi[i].hThread = NULL;
            continue;
        }

        _tprintf(_T("PARENT ANA THREAD: Child Process %d (ID: %lu) baslatildi.\n"), i + 1, pi[i].dwProcessId);
        CloseHandle(pi[i].hThread); // Child'in ana Thread handle'ini kapat
    }

    _tprintf(_T("-----------------------------------------------------------------\n"));
    _tprintf(_T("PARENT ANA THREAD: Parent Ek Thread'in bitmesini bekliyorum...\n"));
    
    // Parent Ana Thread, kendi ek Thread'inin bitmesini bekler
    WaitForSingleObject(hParentWorkerThread, INFINITE);

    _tprintf(_T("PARENT ANA THREAD: Parent Ek Thread bitti.\n"));
    
    // Tum Child Process'lerin bitmesini bekle
    // ChildApp.exe 7 saniye sonra bitecek, notepad.exe kullanici kapatana kadar calisacak.
    _tprintf(_T("PARENT ANA THREAD: Tum Child Process'lerin bitmesini bekliyorum...\n"));
    
    HANDLE hChildProcesses[] = { pi[0].hProcess, pi[1].hProcess };
    WaitForMultipleObjects(2, hChildProcesses, TRUE, INFINITE);

    _tprintf(_T("-----------------------------------------------------------------\n"));
    _tprintf(_T("PARENT ANA THREAD: Tum Child Process'ler bitti. Uygulama sonlaniyor.\n"));

    CloseHandle(hParentWorkerThread);
    CloseHandle(pi[0].hProcess); 
    CloseHandle(pi[1].hProcess); 

    return 0;
}

#include <stdio.h>
#include <windows.h>
#include <tchar.h>

// Child Process'in Ek Thread Fonksiyonu
DWORD WINAPI ChildWorkerThread(LPVOID lpParam) 
{
    int threadId = *((int*)lpParam);
    
    _tprintf(_T("  [CHILD EK THREAD]: Basladi (ID: %lu). 7 saniye calisacak.\n"), GetCurrentThreadId());
    
    // Uzun sureli bir isi simule et
    for (int i = 0; i < 7; i++)
    {
        Sleep(1000); // 1 saniye bekle
        _tprintf(_T("  [CHILD EK THREAD]: Gecen sure %d saniye.\n"), i + 1);
    }

    _tprintf(_T("  [CHILD EK THREAD]: Gorev tamamlandi ve sonlaniyor.\n"));
    return 0;
}

// Child Process'in Ana Fonksiyonu (Ana Thread)
int _tmain(int argc, TCHAR* argv[]) 
{
    HANDLE hWorkerThread;
    int workerThreadId = 99; // Ornek bir ID
    
    _tprintf(_T("CHILD PROCESS: Basladi. Ana Process ID: %lu, Ana Thread ID: %lu\n"), GetCurrentProcessId(), GetCurrentThreadId());
    
    // Ek Thread'i Olustur
    hWorkerThread = CreateThread(
        NULL,                            // Guvenlik nitelikleri
        0,                               // Stack boyutu
        ChildWorkerThread,               // Thread fonksiyonu
        &workerThreadId,                 // Parametre (ID)
        0,                               // Olusturma bayraklari
        NULL                             // Thread ID
    );

    if (hWorkerThread == NULL) {
        _tprintf(_T("CHILD PROCESS: HATA! Ek Thread olusturulamadi (%lu).\n"), GetLastError());
        return 1;
    }
    _tprintf(_T("CHILD PROCESS: Ek Thread baslatildi. Kendi Ek Thread'inin bitmesini bekliyor.\n"));
    
    // Ana Thread, kendi olusturdugu Ek Thread'in bitmesini bekler
    WaitForSingleObject(hWorkerThread, INFINITE);

    CloseHandle(hWorkerThread);
    
    _tprintf(_T("CHILD PROCESS: Tum Thread'ler bitti. Child Process sonlaniyor.\n"));
    
    // Child Process sonlaniyor.
    return 0;
}