Threads et pools de threads

1,Concept de thread

Au moins un processus après l'exécution d'un programme,Un processus peut contenir plus d'un thread.

Le thread est une unit é d'exécution dans le processus,Responsable de l'exécution du programme dans le processus actuel,Il y a au moins un thread dans un processus.Il peut y avoir plusieurs Threads dans un processus,.Cette application peut aussi être appelée Multithreading.

2,Programmation des threads

Répartition du temps：Tous les Threads prennent tour à tourCPUDroit d'utiliser,Répartir également les dépenses par filCPULe temps.

Calendrier préventif：Les Threads hautement prioritaires sont utilisés en premierCPU,Si le thread a la même priorité,

3,Le fil principal

javaUtiliserjava.lang.ThreadClasse pour thread,Tous les objets filetés doivent êtreThreadExemples de classes ou d'autres sous - classes.Le rôle de chaque thread est d'accomplir certaines tâches,En fait, c'est exécuter un flux de programme, c'est - à - dire un code exécuté séquentiellement.JavaUtilisez l'exécuteur de fil pour représenter ce flux de programme.

4,Comment implémenter le thread

public class xiancehng {
	public static void main(String[] args) {		
		Thread thread = new SubThread();
		thread.start();			
	}
}
//Créer un sous - thread
class SubThread extends Thread {
	@Override
    //RéécriturerunMéthodes
	public void run() {
		Thread t = Thread.currentThread();
		String name = t.getName();
		for (int i = 0; i < 10; i++) {
			System.out.println(name + i);
		}
	}
}

public class xiangcheng2 {
	public static void main(String[] args) {
		Runnable runnable = new Runnable() {
			@Override
			public void run() {
				System.out.println("hello word");
			}
		};
		new Thread(runnable).start();
	}
}

5,Principe Multithreading

public class duoxiancheng1 {
	public static void main(String[] args) {
		System.out.println("Ici.mainThread");
		Thread thread = new ZiThread("Xiao Qiang");
		thread.start();
		for (int i = 0; i < 10; i++) {
			System.out.println("Wangcai." + i);
		}
	}
}

class ZiThread extends Thread {
	public ZiThread(String name) {
		super(name);
	}

	@Override
	public void run() {
		Thread t = Thread.currentThread();
		String name = t.getName();
		for (int i = 0; i < 10; i++) {
			System.out.println(name + i);
		}
	}
}

 

 6,ThreadCatégorie

Méthode de construction：

        public Thread();                                                 Assigner un nouvel objet thread

        public Thread(String name);                              Assigner un nouvel objet thread avec le nom spécifié

        public Thread(Runnable target);                         Assigner un nouvel objet thread à la cible spécifiée

        public Thread(Runnable target,String name);     Assigner un nouvel objet thread pour spécifier la destination et spécifier un nom

Méthode d'adhésion：

        public String getName();                                     Obtenir le nom actuel du thread

        public void start();                                                Exécution du thread d'appel runMéthodes

        public void run();                                                 Les tâches exécutées par le thread sont définies ici

        public static void sleep(long millis);                    Le thread en cours d'exécution indique combien de millisecondes s'arrêtent

        public static Thread currentThread();                 Renvoie une référence à l'objet thread actuellement en cours d'exécution

7,ThreadEtRunnableLa différence entre

RunnableAvantages：

        1, Convient à plusieurs Threads manipulant le même objet de tâche .

        2,Peut être évitéjavaLimites de l'héritage unique dans.

        3,Augmenter la robustesse du programme,Réaliser l'opération de découplage,Le Code peut être partagé par plusieurs Threads,Le Code et le fil sont indépendants.

        4,Le pool de Threads ne peut être placé que dans l'implémentationRunableOuCallableThreads de classe,Ne peut pas être placé directement dans l'héritageThreadLa classe de.Peut être évitéjavaLimites de l'héritage unique dans.

8,La méthode de classe interne anonyme implémente la création de Threads

public static void main(String[] args) {
		Runnable r = new Runnable() {
			@Override
			public void run() {
				for (int i = 0; i < 10; i++) {
					System.out.println(Thread.currentThread().getName() + i);					
				}				
			}
			
		};
		new Thread(r).start();
	}

9,Sécurité des fils

CAS：Le cinéma vend des billets.,Nous simulons le processus de vente de billets dans les cinémas.Supposons que le film à jouer soit  “Moi et ma patrie”,Total des sièges pour ce film100- Oui.(Ce film ne peut être vendu que100Un billet.).

Simulons la fenêtre de billetterie du cinéma.,Réaliser la vente simultanée de plusieurs fenêtres “Piggy Paige”Ce billet de film(Plusieurs fenêtres ensemble pour vendre ceci100Un billet.)Fenêtre requise,Utiliser des objets filetés pour simuler;J'ai besoin de billets,RunnableSous - classe interface pour simuler.

public class xcanq {
	public static void main(String[] args) {
		Ticket ticket = new Ticket();
		new Thread(ticket, "Fenêtre1").start();
		new Thread(ticket, "Fenêtre2").start();
		new Thread(ticket, "Fenêtre3").start();
	}
}

class Ticket implements Runnable {
	private int ticket = 100;
	@Override
	public void run() {
		while (true) {
			synchronized (this) {
				if (ticket > 0) {
					try {
						Thread.sleep(200);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					String name = Thread.currentThread().getName();
					System.out.println(name + "En vente" + ticket + "Un billet.");
					ticket--;
				}
			}

		}
	}
}

10,LockVerrouillage

Mode d'emploi：

        public void lock();

        public void unlock();

11,État du fil

NEW	Nouveau statut	Après la création d'un thread ,Avant le démarrage,C'est dans cet état..
TERMINATED	État d'extinction	Une fois que le thread a terminé la tâche,Dans cet état.
RUNNABLE	État opérationnel	Thread est en pleine tâche ,C'est dans cet état..
BLOCKED	État de blocage	Accèssynchronized Impossible de verrouiller l'objet ,Dans cet état.
WAITING	État d'attente illimité	AccèsLock Impossible de verrouiller l'objet ,C'est dans cet état..
TIMED_WAITING	État d'attente du timing	Mise en œuvresleepMéthodes,C'est dans cet état..

12,sleepEtwaitLa différence entre

13,waitEtnotifyMéthodes

（1）waitMéthodes

        Le fil n'est plus actif,Ne participe plus à l'expédition,Entrée wait set Moyenne,Pour ne pas gaspiller CPU Ressources,Et ne va pas rivaliser avec la serrure,L'état du fil est WAITING.

        Il attend que d'autres fils fassent une action spéciale,C'est - à - dire“Notification（notify）”Les fils qui attendent sur cet objet sontwait set Libéré dans,Retour à la file d'attente d'expédition（ready queue）Moyenne.

（2）notifyMéthodes

        Sélectionnez wait set Un thread est libéré;Par exemple,Quand le restaurant est libre, Les clients qui attendent le repas le plus longtemps sont les premiers Asseyez - vous..

（3）notifyAllMéthodes

        Pour libérer l'objet notifié wait set Tous les fils sur.

Attention!：

（1）waitMéthodes etnotifyLa méthode doit être appelée par le même objet de verrouillage.Parce que：L'objet de verrouillage correspondant peut passer parnotifyLe réveil utilise la même paire de serruresComme un appelwaitLe fil après la méthode.

（2）waitMéthodes etnotifyLa méthode appartient àObjectMéthode de la classe.Parce que：L'objet de verrouillage peut être n'importe quel objet,Tout objet appartient à une classe qui suitAllez.ObjectClasse.

（3）waitMéthodes etnotifyLa méthode doit être utilisée dans un bloc de code de synchronisation ou une fonction de synchronisation.Parce que：Ceci doit être appelé par l'objet de verrouillage2CarréDroit.

14,Communication par fil

CAS：

        Fils de pavage de paquets production de paquets,Mangez des fils pour consommer des paquets.Quand il n'y a pas de pain（L'état du paquet estfalse）,Le fil d'alimentation attend,Fils de pavage de paquets production de paquets（C'est - à - dire que l'état du paquet esttrue）,Et prévenez le fil mangeur（Désactiver l'état d'attente de la nourriture）,Parce qu'il y a déjà des sacs,Ensuite, le thread de pavage du paquet est en attente.

        Et puis...,La question de savoir si le fil mangeur peut être exécuté dépend de l'acquisition de la serrure. Si la nourriture arrive

Prends la serrure,Alors faites l'acte de manger des boulettes,Finis les boulettes.（L'état du paquet estfalse）,Et prévenez les fils de patch（Déverrouiller l'état d'attente du magasin de paquets）,Le fil d'alimentation entre dans l'attente.La question de savoir si le thread de sous - Lay peut être exécuté dépend de l'acquisition de la serrure.

Définir les sous - classes de paquets ：

public class Baozi {
	String pier;
	String xianer;
	boolean flag = false;

}

Définir le fil de nourriture ：

public class Chihuo extends Thread {
	private Baozi bz;
	public Chihuo(String name, Baozi bz) {
		super(name);
		this.bz = bz;
	}

	@Override
	public void run() {
		while (true) {
			synchronized (bz) {
				if (bz.flag == true) {
					System.out.println("La nourriture est en train de manger"+bz.pier+bz.xianer+"Baozi.");					
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					bz.flag = false;
					bz.notify();
				} else {
					try {
						bz.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
		}
	}
}

Définir le thread de sous - Lay du paquet ：    

public class BaoZiPu extends Thread {
	private Baozi bz;
	public BaoZiPu(String name, Baozi bz) {
		super(name);
		this.bz = bz;
	}

	@Override
	public void run() {
		int count = 0;
		while (true) {
			synchronized (bz) {
				if (bz.flag == true) {
					try {
						bz.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				} else {
					System.out.println("Le magasin de Baozi commence à faire des Baozi.");
					if (count % 2 == 0) {
						bz.pier = "Peau de glace";
						bz.xianer = "Wuren";
					} else {
						bz.pier = "Peau mince";
						bz.xianer = "Bœuf et oignons verts";
					}
					count++;
					bz.flag = true;
					System.out.println("Le sac est fait：" + bz.pier + bz.xianer);
					System.out.println("Mangez, mangez");
					bz.notify();
				}
			}
		}
	}
}

Test thread：

public class Test {
	public static void main(String[] args) {
		Baozi bz = new Baozi();
		Chihuo ch = new Chihuo("Mangez.", bz);
		BaoZiPu bzp = new BaoZiPu("Baozi shop",bz);	
		bzp.start();
		ch.start();
	}
}

15,Concept de pool de Threads

        En fait, c'est un conteneur qui contient plusieurs fils,Les fils peuvent être réutilisés,Suppression de la création fréquente d'objets filetés,Il n'est pas nécessaire de créer des Threads à plusieurs reprises et de consommer trop de ressources.

16,Avantages du pool de threads 

（1）Réduire la consommation de ressources.Réduit le nombre de fois que vous créez et détruisez des Threads,Chaque fil de travail peut être réutilisé,Exécuter plusieurs tâches.

（2）Augmenter la vitesse de réponse.Quand la mission arrive,Les tâches peuvent être exécutées sans attendre la création du thread.

（3）Améliorer la maniabilité des fils.Selon la capacité du système,Ajuster le nombre de fils de travail dans le pool de fils,Prévenir la surconsommationDépôt,Et j'ai mis le serveur à terre.(Chaque fil nécessite environ1MBMémoire,Plus les fils sont ouverts,Plus la mémoire est consommée,Dernier arrêt).

17,Utilisation du pool de threads

Créer un pool de threads：public static ExecutorService newFixedThreadPool(int nThreads)

Utilisation d'objets threadpool ：public Future<?> submit(Runnable task)

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class xcc {
	public static void main(String[] args) {
		ExecutorService service = Executors.newFixedThreadPool(2);
		MyRunnable r = new MyRunnable();
		service.submit(r);		
	}
}
class MyRunnable implements Runnable {
	@Override
	public void run() {
		System.out.println("Je veux un coach.");
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("Le Coach arrive： " + Thread.currentThread().getName());
		System.out.println("Apprends - moi à nager.,Après la livraison,Le coach est de retour à la piscine.");
	}
}