Linux multi-thread mutex: mekanisme penyegerakan selamat benang

Sistem Linux ialah sistem pengendalian yang menyokong pelaksanaan serentak pelbagai tugas Ia boleh menjalankan berbilang proses pada masa yang sama, dengan itu meningkatkan penggunaan dan kecekapan sistem. Walau bagaimanapun, jika terdapat berbilang utas dalam proses, dan utas ini perlu berkongsi beberapa data atau sumber, ketidakkonsistenan data atau persaingan sumber mungkin berlaku, yang membawa kepada ralat atau pengecualian sistem. Untuk menyelesaikan masalah ini, anda perlu menggunakan beberapa mekanisme penyegerakan, seperti semaphore, pembolehubah keadaan, mutex, dll. Antaranya, mutex ialah mekanisme penyegerakan yang agak mudah dan berkesan Ia membenarkan benang mengunci data atau sumber yang dikongsi apabila mengaksesnya untuk menghalang utas lain daripada mengaksesnya pada masa yang sama, sekali gus memastikan keselamatan benang. Artikel ini akan memperkenalkan kaedah pengecualian bersama mutex berbilang benang dalam sistem Linux, termasuk pemulaan, penguncian, buka kunci dan pemusnahan mutex.

Segerakkan

Berbilang utas dalam proses yang sama berkongsi sumber memori proses Apabila berbilang utas mengakses sumber dikongsi yang sama pada masa yang sama, mereka perlu menyelaras antara satu sama lain untuk mengelakkan masalah seperti ketidakkonsistenan data dan penyelarasan dan komunikasi dipanggil isu penyegerakan benang Idea penyegerakan benang adalah untuk membenarkan berbilang benang mengakses sumber yang dikongsi secara berurutan dan bukannya selari

.

Pengecualian Bersama VS Penyegerakan

• Pengecualian bersama: bermakna sumber tertentu membenarkan hanya seorang pelawat mengaksesnya pada masa yang sama, dan adalah unik dan eksklusif. Tetapi pengecualian bersama tidak boleh mengehadkan susunan pelawat mengakses sumber, iaitu akses tidak tertib. Jika operasi itu adalah operasi atom, ia secara semula jadi saling eksklusif
• Penyegerakan: merujuk kepada akses teratur sumber oleh pelawat melalui mekanisme lain atas dasar pengecualian bersama (dalam kebanyakan kes). Dalam kebanyakan kes, penyegerakan sudah melaksanakan pengecualian bersama, terutamanya apabila semua penulisan kepada sumber mestilah saling eksklusif. Dalam beberapa kes, berbilang pelawat boleh dibenarkan mengakses sumber pada masa yang sama

Mutex:

• Pada asasnya, ia adalah kunci yang menyediakan akses eksklusif kepada sumber, jadi fungsi utama Mutex adalah untuk pengecualian bersama. Mutex membenarkan hanya satu utas untuk mengakses data pada masa yang sama, dan boleh dianggap sebagai sejenis semaphore 0/1
• Nilai objek Mutex hanya 0 dan 1. Mewakili keadaan kunci dan keadaan terbiar Mutex masing-masing:
  • Status kunci: Objek semasa dikunci Jika proses/benang pengguna cuba mengunci sumber kritikal, ia akan memasuki menunggu
  • Keadaan melahu: Objek semasa melahu, proses/benang pengguna boleh mengunci sumber kritikal, dan kemudian nilai Mutex berkurangan sebanyak 1 dan menjadi 0.
• Mutex boleh mempunyai nilai awal apabila ia dibuat, menunjukkan sama ada Mutex berada dalam keadaan terkunci atau keadaan terbiar selepas ia dibuat.
• Dalam urutan yang sama, untuk mengelakkan kebuntuan, sistem tidak membenarkan Mutex dikunci dua kali berturut-turut (sistem biasanya kembali serta-merta selepas panggilan kedua). Dalam erti kata lain, dua operasi yang sepadan iaitu mengunci dan membuka kunci perlu diselesaikan dalam urutan yang sama.

Model Mutex

#include 
pthread_mutex_t  mutex                //定义互斥锁               
pthread_mutex_init()            //初始化锁          
pthread_mutex_lock()/pthread_mutex_trylock()  ...     //加锁                  
pthread_mutex_unlock()          //解锁                        
pthread_mutex_destroy()         //销毁                        
//成功返回0,失败返回error number
#include 
int pthread_mutex_init  (pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);
int pthread_mutex_lock  (pthread_mutex_t *mutex);
int pthread_mutex_trylock   (pthread_mutex_t *mutex);
int pthread_mutex_unlock    (pthread_mutex_t *mutex);
int pthread_mutex_destroy   (pthread_mutex_t *mutex);

kebuntuan

Kebuntuan berlaku terutamanya apabila terdapat berbilang kunci bergantung, dan ia berlaku apabila satu benang cuba mengunci mutex dalam susunan yang bertentangan dengan benang lain
Apabila benang black ball menggunakan sumber kongsi ke arah A->, dan benang bola putih menggunakan sumber kongsi dalam urutan B->A, malangnya, benang black ball mengunci sumber A sehingga ia memperoleh Sumber B yang dilepaskan, benang bola putih mengunci sumber B sehingga ia memperoleh sumber A yang dilepaskan. Keputusan akhir ialah mereka tidak dapat memperoleh sumber yang mereka inginkan, dan mereka semua mengunci sumber yang dikehendaki pihak lain

解决死锁：

• 对共享资源操作前一定要获得锁
• 完成操作后一定要释放锁
• 尽量短的时间占用锁
• 如果有多锁，如获得的顺序是ABC顺序，那么释放顺序也该是ABC
• 线程错误返回时会释放它所获得的锁

例子

#include
#include
#include
#include

char* buf[5];
int pos;
//1.定义互斥量
pthread_mutex_t mutex;
void* task(void* pv){
    //3.使用互斥量进行加锁
    pthread_mutex_lock(&mutex);
    
    //4.访问共享内存
    buf[pos]=(char*)pv;
    sleep(1);
    pos++;

    //5.使用互斥量进行解锁
    pthread_mutex_unlock(&mutex);
}
main(){
    //2.初始化互斥量
    pthread_mutex_init(&mutex,NULL);

    pthread_t thread;
    pthread_create(&thread,NULL,task,(void*)"zhangfei");
    pthread_t thread2;
    pthread_create(&thread2,NULL,task,(void*)"guanyu");
    
    pthread_join(thread,NULL);
    pthread_join(thread2,NULL);

    //打印字符指针数组中的有效数据
    int i=0;
    for(i=0;iprintf("%s ",buf[i]);
    }
    printf("\n");
    //6.如果不再使用则销毁互斥量
    pthread_mutex_destroy(&mutex);
    return 0;
}

本文介绍了Linux系统中多线程互斥量的互斥的方法，包括互斥量的初始化、加锁、解锁和销毁等方面。通过了解和掌握这些知识，我们可以更好地使用互斥量来实现多线程之间的同步，提高系统的稳定性和效率。当然，Linux系统中多线程互斥量还有很多其他的特性和用法，需要我们不断地学习和研究。希望本文能给你带来一些启发和帮助。

Atas ialah kandungan terperinci Linux multi-thread mutex: mekanisme penyegerakan selamat benang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!