Pengaturcaraan pelbagai bahasa C: Pengoptimuman praktikal dan penyelesaian masalah

Pengaturcaraan Multithreaded Bahasa C: Pengoptimuman Praktikal dan Penyelesaian Masalah

Dalam sistem komputer moden, pengaturcaraan multithread telah menjadi teknologi yang diperlukan untuk meningkatkan prestasi aplikasi. Artikel ini akan meneroka pengaturcaraan multithread dalam bahasa C, termasuk teknik pengoptimuman dan penyelesaian masalah biasa, dan memberikan contoh praktikal untuk memperdalam pemahaman.

Petua Pengoptimuman

• Melindungi data bersama dengan mutexes: Menggunakan mutexes menghalang pelbagai benang daripada mengakses data bersama pada masa yang sama, mengelakkan keadaan perlumbaan dan rasuah data.
• Mengoptimumkan Granularity Lock: Menggunakan kunci halus (hanya mengunci sumber yang anda perlukan) dapat meningkatkan prestasi.
• Menggunakan primitif serentak: Menggunakan primitif serentak seperti pembolehubah bersyarat, semaphores, dan pagar dapat meningkatkan kebolehbacaan dan kebolehpercayaan kod anda.
• Mengurangkan penciptaan dan kemusnahan benang: Membuat dan memusnahkan benang memerlukan sumber, dan menggunakan semula benang sebanyak mungkin dapat meningkatkan kecekapan.

Penyelesaian masalah

• DEARLOCK: Kebuntuan berlaku apabila dua atau lebih benang sedang menunggu pihak lain melepaskan kunci. Salah satu cara untuk mengelakkan kebuntuan adalah mengikuti perintah penguncian.
• Keadaan perlumbaan: Keadaan perlumbaan berlaku apabila pelbagai benang mengakses data bersama pada masa yang sama. Menggunakan mutexes atau operasi atom boleh menyelesaikan masalah ini.
• Rasuah data: Apabila pelbagai benang mengubah suai data yang dikongsi pada masa yang sama, rasuah data mungkin berlaku. Gunakan mekanisme perlindungan seperti mutexes untuk mengelakkannya daripada berlaku.

Kes praktikal

Mari kita pertimbangkan program yang mengira nombor utama. Kita boleh menggunakan multithreading untuk mengira nombor perdana dalam julat yang berbeza selari:

 #include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

// Struktur parameter thread typedef struct {
    int start;
    int akhir;
} thread_args_t;

// Fungsi Thread Pengiraan Perdana tidak sah* prime_thread (void* arg) {
    thread_args_t* args = (thread_args_t*) arg;
    int num_primes = 0;
    
    // Cari nombor perdana dalam julat yang ditentukan (int i = args-> start; i <args-> end; i) {
        // Tentukan sama ada saya adalah nombor utama int is_prime = 1;
        untuk (int j = 2; j * j <= i; j) {
            jika (i % j == 0) {
                is_prime = 0;
                rehat;
            }
        }
        
        jika (is_prime) {
            num_primes;
        }
    }
    
    // lulus hasil kembali ke pulangan thread utama (void*) num_primes;
}

int main (int argc, char ** argv) {
    int num_threads = 4; // bilangan benang int num_ranges = 5; // bilangan nombor perdana int start_ranges [num_ranges]; // Nilai Mula setiap julat int end_ranges [num_ranges]; // Nilai akhir setiap julat // Inisialisasi julat int per_range = 100000/ num_ranges; // saiz setiap julat untuk (int i = 0; i <num_ranges; i) {
        start_ranges [i] = per_range * i;
        end_ranges [i] = per_range * (i 1);
    }
    
    // Buat mutex pthread_mutex_t mutex;
    pthread_mutex_init (& mutex, null);
    
    // Buat benang pthread_t threads [num_threads];
    thread_args_t thread_args [num_threads];
    
    int total_primes = 0;
    untuk (int i = 0; i <num_threads; i) {
        // set parameter thread thread_args [i] .start = start_ranges [i];
        thread_args [i] .end = end_ranges [i];
        
        // buat thread pthread_create (& threads [i], null, & prime_thread, & thread_args [i]);
    }
    
    // tunggu semua benang diselesaikan untuk (int i = 0; i <num_threads; i) {
        tidak sah* hasil;
        pthread_join (threads [i], & result);
        
        // Gunakan mutex untuk melindungi akses kepada total_primes pthread_mutex_lock (& ​​mutex);
        total_primes = (int) hasil;
        pthread_mutex_unlock (& ​​mutex);
    }
    
    // Cetak hasil printf ("jumlah prima: %d \ n", total_primes);
    
    // memusnahkan mutex pthread_mutex_destroy (& mutex);
    kembali 0;
}

Atas ialah kandungan terperinci Pengaturcaraan pelbagai bahasa C: Pengoptimuman praktikal dan penyelesaian masalah. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!