Explication détaillée de la communication avec les threads Java
- 高洛峰original
- 2017-01-05 15:20:481571parcourir
La communication par thread est utilisée pour assurer le fonctionnement coordonné des threads. Généralement, les problèmes de communication par thread doivent être pris en compte lors de la synchronisation des threads.
1. La communication par thread traditionnelle
utilise généralement les trois méthodes fournies par la classe Objeclt :
wait() fait attendre le thread actuel et libère le verrou de la synchronisation. monitor , jusqu'à ce que d'autres threads appellent la méthode notify() ou notifyAll() du moniteur de synchronisation pour réveiller le thread.
notify(), réveille les threads en attente sur ce moniteur de synchronisation, s'il y en a plusieurs, un sera sélectionné au hasard pour se réveiller
notifyAll(), réveille tous les threads en attente sur ce moniteur de synchronisation moniteur de synchronisation , une fois que ces threads se disputent les ressources via la planification, un thread acquiert le verrou de ce moniteur de synchronisation puis s'exécute.
Ces trois méthodes doivent être appelées par l'objet moniteur de synchronisation et se répartissent en deux situations :
Lors de la synchronisation de la méthode, puisque le moniteur de synchronisation est cet objet, ces trois méthodes peuvent être appelées directement .
Un exemple est le suivant :
public class SyncMethodThreadCommunication {
static class DataWrap{
int data = 0;
boolean flag = false;
public synchronized void addThreadA(){
if (flag) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
data++;
System.out.println(Thread.currentThread().getName() + " " + data);
flag = true;
notify();
}
public synchronized void addThreadB() {
if (!flag) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
data++;
System.out.println(Thread.currentThread().getName() + " " + data);
flag = false;
notify();
}
}
static class ThreadA extends Thread {
private DataWrap data;
public ThreadA(DataWrap dataWrap) {
this.data = dataWrap;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
data.addThreadA();
}
}
}
static class ThreadB extends Thread {
private DataWrap data;
public ThreadB(DataWrap dataWrap) {
this.data = dataWrap;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
data.addThreadB();
}
}
}
public static void main(String[] args) {
//实现两个线程轮流对数据进行加一操作
DataWrap dataWrap = new DataWrap();
new ThreadA(dataWrap).start();
new ThreadB(dataWrap).start();
}
}Lors de la synchronisation d'un bloc de code, vous devez utiliser l'objet moniteur pour appeler ces trois méthodes.
Les exemples sont les suivants :
public class SyncBlockThreadComminication {
static class DataWrap{
boolean flag;
int data;
}
static class ThreadA extends Thread{
DataWrap dataWrap;
public ThreadA(DataWrap dataWrap){
this.dataWrap = dataWrap;
}
@Override
public void run() {
for(int i = 0 ; i < 10; i++) {
synchronized (dataWrap) {
if (dataWrap.flag) {
try {
dataWrap.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
dataWrap.data++;
System.out.println(getName() + " " + dataWrap.data);
dataWrap.flag = true;
dataWrap.notify();
}
}
}
}
static class ThreadB extends Thread{
DataWrap dataWrap;
public ThreadB(DataWrap dataWrap){
this.dataWrap = dataWrap;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
synchronized (dataWrap) {
if (!dataWrap.flag) {
try {
dataWrap.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
dataWrap.data++;
System.out.println(getName() + " " + dataWrap.data);
dataWrap.flag = false;
dataWrap.notify();
}
}
}
}
public static void main(String[] args) {
//实现两个线程轮流对数据进行加一操作
DataWrap dataWrap = new DataWrap();
new ThreadA(dataWrap).start();
new ThreadB(dataWrap).start();
}
}2. Utilisez la condition pour contrôler la communication des threads
Lorsque vous utilisez l'objet Lock pour garantir la synchronisation, utilisez l'objet Condition pour assurer la coordination.
Un exemple est le suivant :
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import com.sun.media.sound.RIFFInvalidDataException;
import javafx.scene.chart.PieChart.Data;
public class SyncLockThreadCommunication {
static class DataWrap {
int data;
boolean flag;
private final Lock lock = new ReentrantLock();
private final Condition condition = lock.newCondition();
public void addThreadA() {
lock.lock();
try {
if (flag) {
try {
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
data++;
System.out.println(Thread.currentThread().getName() + " " + data);
flag = true;
condition.signal();
} finally {
lock.unlock();
}
}
public void addThreadB() {
lock.lock();
try {
if (!flag) {
try {
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
data++;
System.out.println(Thread.currentThread().getName() + " " + data);
flag = false;
condition.signal();
} finally {
lock.unlock();
}
}
}
static class ThreadA extends Thread{
DataWrap dataWrap;
public ThreadA(DataWrap dataWrap) {
this.dataWrap = dataWrap;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
dataWrap.addThreadA();
}
}
}
static class ThreadB extends Thread{
DataWrap dataWrap;
public ThreadB(DataWrap dataWrap) {
this.dataWrap = dataWrap;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
dataWrap.addThreadB();
}
}
}
public static void main(String[] args) {
//实现两个线程轮流对数据进行加一操作
DataWrap dataWrap = new DataWrap();
new ThreadA(dataWrap).start();
new ThreadB(dataWrap).start();
}
}Les wait(), singal() et singalAll() de l'objet Condition correspondent aux wait(), notify() et méthodes notifyAll() respectivement.
3. Utilisez la file d'attente de blocage BlockingQueue pour contrôler la communication des threads
BlockingQueue est une sous-interface de l'interface Queue. Elle est principalement utilisée pour la communication des threads. Elle a une caractéristique : lorsque le thread producteur. essaie d'entrer dans BlockingQueue Lorsqu'un élément est inséré, si la file d'attente est pleine, le thread est bloqué ; lorsque le thread consommateur tente de retirer un élément de BlockingQueue, si la file d'attente est vide, le thread est bloqué. Ces deux fonctionnalités correspondent respectivement à deux méthodes prenant en charge le blocage, put(E e) et take()
Les exemples sont les suivants :
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class BlockingQueueThreadComminication {
static class DataWrap{
int data;
}
static class ThreadA extends Thread{
private BlockingQueue<DataWrap> blockingQueue;
public ThreadA(BlockingQueue<DataWrap> blockingQueue, String name) {
super(name);
this.blockingQueue = blockingQueue;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
try {
DataWrap dataWrap = blockingQueue.take();
dataWrap.data++;
System.out.println(getName() + " " + dataWrap.data);
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
static class ThreadB extends Thread{
private BlockingQueue<DataWrap> blockingQueue;
private DataWrap dataWrap;
public ThreadB(BlockingQueue<DataWrap> blockingQueue, DataWrap dataWrap, String name) {
super(name);
this.blockingQueue = blockingQueue;
this.dataWrap = dataWrap;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
try {
dataWrap.data++;
System.out.println(getName() + " " + dataWrap.data);
blockingQueue.put(dataWrap);
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public static void main(String[] args) {
///实现两个线程轮流对数据进行加一操作
DataWrap dataWrap = new DataWrap();
BlockingQueue<DataWrap> blockingQueue = new ArrayBlockingQueue<>(1);
new ThreadA(blockingQueue, "Consumer").start();
new ThreadB(blockingQueue, dataWrap, "Producer").start();
}
}BlockingQueue a cinq classes d'implémentation :
File d'attente ArrayBlockingQueue BlockingQueue implémentée sur la base d'un tableau
File d'attente LinkedBlockingQueue BlockingQueue implémentée sur la base d'une liste chaînée
Les éléments de PriorityBlockingQueue doivent implémenter l'interface Comparable et le tri des éléments est personnalisé selon le Comparateur.
SynchronousQueue est une file d'attente synchrone, nécessitant que les opérations d'accès à la file d'attente soient effectuées en alternance.
Les éléments de la collection DelayQueue doivent implémenter l'interface Delay. Les éléments de la file d'attente sont triés en fonction de la valeur de retour de la méthode d'interface Delay getDelay().
Ce qui précède représente l'intégralité du contenu de cet article. J'espère qu'il sera utile à l'apprentissage de chacun. J'espère également que tout le monde soutiendra le site Web PHP chinois.
Pour des articles plus détaillés sur la communication des threads Java, veuillez faire attention au site Web PHP chinois !