Les processus de système d'exploitation et les fils 4

Processus-fil - Synchronisation

• interruption masquable

  • Processeur unique, le plus simple est d'entrer dans la zone critique immédiatement après le masque toutes les interruptions, puis tourner à gauche interrompue, la masquées interruptions d'horloge d'interruption sont masquées, cpu ne sera pas effectuer le processus de commutation.
  • De cette façon, de nombreux inconvénients, sinon enfonçons, multi-processeur d'interruption des instructions de masque à une seule autre entrée en vigueur de cpu cpu peuvent encore entrer dans la zone critique, et donc pas applicable.

• Occupé algorithme d'attente

  • Voici trois moyens concurrents de verrouillage sont occupés avec d'autres besoins. Quand ils n'ont pas la serrure et entrer dans la zone critique nécessaire d'attendre que le cycle a été mis en place, une telle perte de temps CPU, problème d'inversion de priorité peut également se produire.

  • problème d'inversion de priorité : supposons qu'il existe une priorité parmi les discussions, tant en tant que fil de priorité plus élevée est dans l'état prêt a été exécuté sans cpu de rachat. Faible fil de priorité parce que si à un moment donné un fil à faible priorité dans la région critique et d' effectuer des opérations gratuites telles que thread de haute priorité est cpu, auquel cas un thread de priorité plus élevé comme occupé et ne sera donc pas se rendre cpu, et ne peut pas cpu pour se faire effectuant des opérations zone critique de sorte que vous ne pouvez pas remettre le verrou, ce qui provoque un blocage.

  • algorithme de rotation stricte

    • algorithme de rotation stricte peut contrôler deux threads d' accéder à une ressource partagée utilisateur unique sans violation d'accès se produit. Mais il y a une rotation stricte ordre d'exécution.

      int turn=0;//运行权限的线程id
      void enter(int process){
          //如果turn不为当前线程则一直循环等待
          while(turn != process);
      }
      void leave(int process){
          //将运行权限交给另一个线程
          turn = 1-process;
      }
      

    • algorithme de rotation stricte a un inconvénient important est un fil pour obtenir les ressources et le pouvoir après l'utilisation partirez à un autre thread alors qu'un autre thread s'il n'y a pas accès à cette ressource et de l'utilisation après l'achèvement de ce fil ne peut pas laisser encore une fois, l'accès aux ressources.

    • Par conséquent, l'accès aux ressources dans l'algorithme d'ordre strict de rotation doit être strictement suivi cette séquence 0-1-0-1 obtenue.

  • L'algorithme de Peterson

    • L'algorithme de Peterson est une implémentation de mutex algorithme de programmation concurrente qui peut contrôler deux threads accès mono-utilisateur à une ressource partagée sans violation d'accès.

    • Et par rapport à l'algorithme de rotation stricte, il évite une certaine mesure, après avoir quitté un accès fil aux ressources et l'accès aux ressources a dû attendre un autre thread et laisser obtenir au détriment des ressources. Pour la concurrence sur demande - un seul thread possédera le drapeau de la concurrence sera mis en place dans un autre thread va attendre.

      #define TRUE  1
      #define FALSE 0
      int turn;  		//当前有权限的线程id
      int flag[2];	//是否竞争标志位
      void enter(int porcess){
          int other = 1 - process; //另一个线程号
          interested[process] = TRUE; //当前开始了竞争
          turn = other; //权限给对方线程
          //如果当前线程没有权限且对方的竞争标志位为true则等待。
          while(turn != process && flag[other] == TRUE);
      }
      void leave(int process){
          inserested[process] = FASLE;//取消了竞争
      }
      

    • Il peut être vu que par le code

      • 1 l'autre thread n'est pas sur une véritable concurrence dans leur propre drapeau
      • 2 Lorsque l'autre thread exécute tour = autre lorsque les droits à ce fil
      • Après 3 autres threads pour obtenir les ressources lorsque la ressource laissera leur drapeau concurrentiel est définie sur false
      • Ceci est peut être obtenu que l'un des trois cas pour répondre à la ressource plutôt que d'attendre le cycle.

    • T0 exécution, T2 n'a pas été exécutée

      T0	T1
      drapeau [0] = true	aucune exécution
      tourner = 1	aucune exécution
      Ils ne sont pas entrés dans la circulation, l'accès aux ressources	aucune exécution

    • Lorsqu'il est exécuté T0, T1 également effectué

      T0 en circulation devant le juge, T1 marquera leur position concurrentielle est vrai, ce qui entraîne dans le cycle T0 a été effectuée à attendre jusqu'à ce que l'autorisation T1 tourner = 0 à T0, T0 avant la fin du cycle pour obtenir les ressources.

      T0	T1
      drapeau [0] = true	drapeau [1] = true
      tourner = 1	aucune exécution
      Ne pas attendre la permission de cycle de	aucune exécution
      Ne pas attendre la permission de cycle de	tourner = 0
      Obtenir l'autorisation, la fin du cycle pour obtenir des ressources	Ne pas attendre la permission de cycle de
      drapeau [0] = fausse concurrence annulée	Ne pas attendre la permission de cycle de
      aucune exécution	L'autre partie d'annuler le concours, la fin du cycle pour obtenir des ressources

  • instruction TSL et XCHG

    • TSL et XCHG fournissent lecture atomique et des fonctionnalités mises à jour, utilisez ces instructions peut facilement atteindre la fonction de verrouillage du programme de la compétition multithread.

    • Le TSL (test et d' instruction de verrouillage), le TSL RX, serrure, un registres d'adresse de mot mémoire RX, lire, et une valeur non nulle stocké dans l'adresse de mémoire. Lecture et écriture est garantie atomique. La mise en œuvre de la directive verrouille le bus mémoire du processeur pour interdire les autres cpu pour accéder à cette adresse.

      enter_region:
      	;复制LOCK地址存的值到REGISTER寄存器上
      	;并将LOCK地址的值设置为1
      	TSL REGISTER,LOCK 
      	CMP REGISTER,#0  ;判断取出的值是否为0
      	JNE enter_region ;不是0则代表锁已被占有，继续循环
      	RET ;获得到了锁，返回调用者
      leave_region:
      	MOVE LOCK,#0 ;向LOCK地址存入0
      	RET          ;返回调用者
      

    • XCHG (d'instruction de permutation atomique), le mot de mémoire XCHG RX, LOCK, traitera les mots du registre RX verrouillage sont échangés. Il peut être utilisé à la place TSL, sont tous Intel instructions x86 XCHG synchronisation sous-jacente utilisée.

      enter_region:
      	MOVE REGISTER,#1   ;寄存器中放个1
      	XCHG REGISTER,LOCK ;交换LOCK与寄存器的数值
      	CMP REGISTER,#0    ;判断LOCK之前存的是否为0
      	JNE enter_region   ;不是0则说明锁已经设置，循环等待
      	RET ;获得了锁，返回调用者
      leave_region:
      	MOVE LOCK,#0  ;在LOCK处存入0
      	RET           ;返回调用者
      

• Wake obtenir des blocs de fil occupés, etc.

  • sommeil et systèmes appel de réveil, peuvent enfiler dans la serrure quand vous ne pouvez pas être bloquées, au lieu d'attendre cpu occupé, cpu éviter le gaspillage des ressources.

  • sémaphore

    • Sémaphore est par une variable entière du nombre cumulé de sillage. Répartis en bas opération.
    • vers le bas de l'opération de sémaphore> 0 du signal moins un sémaphore = 0, le fil dort.
    • les opérations dans la quantité de signal quand aucun fil pour dormir plus un sémaphores, ou suite au hasard un fil.
    • Remarque: Pour les variables de fonctionnement sémaphores doit être atomique.

  • mutex

    • Si aucune des fonctions de comptage Sémaphore, vous pouvez utiliser une version simplifiée de celle-ci - mutex.

    • mutex et déverrouillage divisé en deux opérations, un seul bit peuvent être exprimées.

    • Si vous appelez un verrou, si un autre thread a acquis le verrou du fil est bloqué.

    • Fil acquiert le verrou lorsque vous déverrouillez au hasard parce qu'ils ne peuvent pas se réveiller un fil verrouillé et bloqué.

      ;一种用户级线程的解决方案
      mutex_lock:
      	TSL REGISTER,MUTEX ;互斥量复制到寄存器中，互斥量置1
      	CMP REGISTER,#0 ;判断复制出来的互斥量是否为0
      	JZE ok ;是0则获得了锁直接结束
      	CALL thread_yield ;不是0则让出cpu资源
      	JMP mutex_lock ;阻塞恢复后回到开始重新尝试加锁
      ok: RET
      
      mutex_unlock:
      	MOVE MUTEX,#0 ;将互斥量值0
      	RET
      

  • La fonction de synchronisation fourni pthread

    • Pthread fournit deux mécanismes de synchronisation: mutex, variables de condition.

    • mutex

      • Mutex (mutex) en même temps un seul fil peut être obtenu, alors que d'autres threads ont échoué tenter d'obtenir des blocs jusqu'à ce que le mutex est d'autres fils déverrouillé.

      • Il fournit une série d'appels

        appels de la discussion	description
        pthread_mutex_init	Création d'un mutex
        pthread_mutex_destory	La révocation d'un mutex
        pthread_mutex_lock	Obtenir un mutex ou une obstruction
        pthread_mutex_trylock	Ou l'échec d'obtenir un mutex
        pthread_mutex_unlock	mutex sortie

    • variables Condition

      • Lorsque la variable d'état permet à un thread à un certain nombre de conditions ne sont pas réunies en raison de bloquer jusqu'à ce qu'un autre fil pour faire le travail afin que les conditions sont réunies pour réveiller les threads bloqués.

      • Il fournit une série d'appels

      appels de la discussion	description
      pthread_cond_init	Créer une variable de condition
      pthread_cond_destory	La révocation d'une variable de condition
      pthread_cond_wait	Les blocs en attente d'un signal
      pthread_cond_signal	Réveillez-il envoie un signal à un autre thread
      pthread_cond_broadcast	Ils se réveillent plusieurs threads pour envoyer des signaux au

      • pthread_cond_wait passant une fonction mutex mutex, lorsque vous appelez libère déverrouiller le mutex atomique, et à ce fil ajouté à la file d'attente, quand il se réveillera, la fonction va revenir se battre à nouveau pour obtenir le mutex.

    • Des exemples de conditions d'utilisation avec mutex variables

      #include<pthread.h>
      int value=0;
      pthread_mutex_t mutex;
      pthread_cond_t cond;
      void provider(){
          lock(&mutex);
      	while(value<=0){
      		pthread_cond_wait(&cond,&mutex);
      	}
      	unlock(&mutex);
      }
      void consumer(){
          lock(&mutex);
      	if(value==0){
      		value++;
      	}
      	if(value>0){
      		pthread_cond_signal(&cond);
      	}
      	unlock(&mutex);
      }
      

    • la variable condition est résolu dans certains cas, nous avons besoin d'attendre lorsque les conditions sont remplies, si seulement vous aurez besoin de mutex de verrouillage, puis déterminer si les conditions sont remplies, se répondent pas à la nécessité de libérer le jugement sommeil de verrouillage et de verrouillage ou répétition. Le cycle a été causé par cpu des déchets, le sommeil et parce que l'état d'attente recyclé est satisfaite et donc incapable de déterminer le temps de sommeil de temps de sommeil peut être trop long.

    • Alors, profitez de dans ce cas avec une file d'attente variable d'état avec des avis en mode réveil devient une performance plus robuste, et lorsque les conditions ne sont pas remplies, il sera ajouté au fil de la file d'attente et le travail d'autres threads peuvent provoquer les conditions sont réunies réveiller un fil en attente dans la file d'attente. Cela permettra non seulement d'éviter les déchets cpu jugement de verrouillage du cycle apporté et éviter les inconvénients d'une longue période de sommeil.