producteur - consommateur en Java multithreading

Je veux écrire le programme en utilisant le multithreading attendre et de les informer des méthodes en Java.

Ce programme a une pile (max-longueur = 5). Producteur de générer des nombre pour toujours et à le mettre dans la pile, et les consommateurs de choisir parmi la pile.

Lorsque la pile est pleine producteur doit attendre et quand la pile est vide, les consommateurs doivent attendre.

Le problème est qu'il s'exécute une seule fois, je veux dire une fois qu'il produit 5 nombre il s'arrête, mais j'ai mis exécuter des méthodes dans while(true) bloc à courir non-stop pouvoir mais il ne le fait pas.

Voici ce que j'ai essayé jusqu'à présent.

Producteur de classe:

package trail;
import java.util.Random;
import java.util.Stack;

public class Thread1 implements Runnable {
    int result;
    Random rand = new Random();
    Stack<Integer> A = new Stack<>();

    public Thread1(Stack<Integer> A) {
        this.A = A;
    }

    public synchronized void produce()
    {
        while (A.size() >= 5) {
            System.out.println("List is Full");
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        result = rand.nextInt(10);

        System.out.println(result + " produced ");
        A.push(result);
        System.out.println(A);

        this.notify();
    }

    @Override
    public void run() {
        System.out.println("Producer get started");

        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        while (true) {
            produce();
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Et le consommateur:

package trail;

import java.util.Stack;

public class Thread2 implements Runnable {
    Stack<Integer> A = new Stack<>();

    public Thread2(Stack<Integer> A) {
        this.A = A;
    }

    public synchronized void consume() {
        while (A.isEmpty()) {
            System.err.println("List is empty" + A + A.size());
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.err.println(A.pop() + " Consumed " + A);
        this.notify();
    }

    @Override
    public void run() {
        System.out.println("New consumer get started");
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        while (true) {
            consume();
        }
    }
}

et ici est la méthode principale:

public static void main(String[] args) {

        Stack<Integer> stack = new Stack<>();

        Thread1 thread1 = new Thread1(stack);//p
        Thread2 thread2 = new Thread2(stack);//c
        Thread A = new Thread(thread1);
        Thread B = new Thread(thread2);
        Thread C = new Thread(thread2);
        A.start();

        B.start();
        C.start();     
    }

Quels objets sont synchronisation sur le producteur? Quels objets sont synchronisation sur le consommateur?
veuillez remplir le code et supprimer les lignes vides et ceux avec des commentaires inutiles
prodeuce méthode dans Thread1 de classe et de consommer de la méthode dans Thread2 classe sont synchornized
Regardez: stackoverflow.com/documentation/java/121/...

OriginalL'auteur Saeed Mirzaee | 2013-08-13

2

Je pense que ce sera mieux pour comprendre et faire face à la synchronisation en général, si vous essayez de séparer les trois choses qui sont actuellement mixte:
1. Tâche qui va faire le travail réel. Noms de classes Thread1 & Thread2 sont trompeuses. Ils ne sont pas Thread objets, mais ils sont en fait des emplois ou des tâches de mise en œuvre de l'interface Runnable vous donnez à Thread objets.
2. Fil objet lui-même de laquelle vous créez dans les principales
3. Partagé objet qui encapsule synchronisée des opérations logiques sur une file d'attente, une pile etc. Cet objet sera partagée entre les tâches. Et à l'intérieur de cet objet partagé que vous prenez soin d'ajouter/supprimer des opérations (avec synchronisation des blocs ou des méthodes synchronisées). Actuellement (comme il a été souligné déjà), la synchronisation est faite sur la tâche elle-même (c'est à dire chaque tâche attend et informe sur son propre cadenas et rien ne se passe). Lorsque vous séparez les préoccupations, c'est à dire laisser une classe faire une chose correctement, il finira par devenir clair, où est le problème.
OriginalL'auteur Alex P
2

Votre consommation et vous producteur sont synchronisés sur différents objets et ne pas se bloquer les uns les autres. Si cela fonctionne, j'oserais dire que c'est accidentel.

Lire sur java.util.concurrent.BlockingQueue et java.util.concurrent.ArrayBlockingQueue. Ces vous fournir plus moderne et plus simples à mettre en œuvre ce modèle.

http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/BlockingQueue.html

où puis-je trouver de l'article utile?
docs.oracle.com/javase/7/docs/api/java/util/concurrent/...

OriginalL'auteur Bex

Vous devez synchroniser sur la pile au lieu de le mettre au niveau de la méthode, essayez ce code.

Aussi, ne pas initalize la pile dans votre fil classes de toute façon vous êtes de passage dans le constructeur de la classe principale, donc pas besoin de cela.

Toujours essayer d'éviter de marque de la méthode, avec synchronisation des mots clés plutôt que d'essayer de mettre de la section critique de code dans le bloc synchronisé, car plus la taille de votre synchronisé zone plus il aura un impact sur les performances.

Donc, toujours mettre uniquement que le code en bloc synchronisé qui ont besoin de la sécurité des threads.

Code Du Producteur :

public void produce() {
    synchronized (A) {
        while (A.size() >= 5) {
            System.out.println("List is Full");
            try {
                A.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        result = rand.nextInt(10);

        System.out.println(result + " produced ");
        A.push(result);
        System.out.println("stack ---"+A);

        A.notifyAll();
    }
}

Code De La Consommation :

public void consume() {
    synchronized (A) {
        while (A.isEmpty()) {
            System.err.println("List is empty" + A + A.size());
            try {
                System.err.println("wait");
                A.wait();

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.err.println(A.pop() + " Consumed " + A);
        A.notifyAll();
    }
}

ce n'A. notifyAll() vraiment?
Il notfiy tous les threads en attente sur un événement en particulier , dans notre cas, ce sera lorsque le producteur thread est en attente sur la pile soit vide et de la consommation de threads en attente sur la pile pour contenir des données. - merci
Pourquoi nous utilisons une boucle while et pas si ? Toutes les raisons précises ?

OriginalL'auteur saurav

Essayez ceci:

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class CircularArrayQueue<T> {
private volatile Lock rwLock = new ReentrantLock();
private volatile Condition emptyCond = rwLock.newCondition();
private volatile Condition fullCond = rwLock.newCondition();
private final int size;
private final Object[] buffer;
private volatile int front;
private volatile int rare;
/**
* @param size
*/
public CircularArrayQueue(int size) {
this.size = size;
this.buffer = new Object[size];
this.front = -1;
this.rare = -1;
}
public boolean isEmpty(){
return front == -1;
}
public boolean isFull(){
return (front == 0 && rare == size-1) || (front == rare + 1);
}
public void enqueue(T item){
try {
//get a write lock
rwLock.lock();
//if the Q is full, wait the write lock
if(isFull())
fullCond.await();
if(rare == -1){
rare = 0;
front = 0;
} else if(rare == size - 1){
rare = 0;
} else {
rare ++;
}
buffer[rare] = item;
//System.out.println("Added\t: " + item);
//notify the reader
emptyCond.signal();
} catch(InterruptedException e){
e.printStackTrace();
} finally {
//unlock the write lock
rwLock.unlock();
}
}
public T dequeue(){
T item = null;
try{
//get the read lock
rwLock.lock();
//if the Q is empty, wait the read lock
if(isEmpty())
emptyCond.await();
item = (T)buffer[front];
//System.out.println("Deleted\t: " + item);
if(front == rare){
front = rare = -1;
} else if(front == size - 1){
front = 0;
} else {
front ++;
}
//notify the writer
fullCond.signal();
} catch (InterruptedException e){
e.printStackTrace();
} finally{
//unlock read lock
rwLock.unlock();
}
return item;
}
}

OriginalL'auteur Sabuj Das

0

Vous pouvez utiliser Java est génial java.util.concurrent et de ses classes.

Vous pouvez facilement mettre en œuvre le producteur problème de consommation à l'aide de la
BlockingQueue. Un BlockingQueue prend déjà en charge des opérations en attente
pour la file d'attente pour devenir non-vide lors de la récupération d'un élément, et d'attendre
pour l'espace disponible dans la file d'attente lors du stockage d'un élément.

Sans BlockingQueue, chaque fois que nous mettons les données de la file d'attente de chez le producteur
côté, nous avons besoin de vérifier si la file d'attente est pleine, et si complet, attendre un certain
temps, vérifiez à nouveau et de continuer. De même du côté du consommateur, nous
faudrait vérifier si la file d'attente est vide, et si vide, attendre un certain
temps, vérifiez à nouveau et de continuer. Cependant, avec BlockingQueue nous n'avons pas
avoir à écrire une logique supplémentaire que de simplement ajouter des données à partir de Producteur et
des données d'enquête auprès des Consommateurs.

Lire la suite De:

http://javawithswaranga.blogspot.in/2012/05/solving-producer-consumer-problem-in.html

http://www.javajee.com/producer-consumer-problem-in-java-using-blockingqueue

OriginalL'auteur Ankur Lathi
0

utilisation BlockingQueue,LinkedBlockingQueue c'était vraiment simple.
http://developer.android.com/reference/java/util/concurrent/BlockingQueue.html

OriginalL'auteur Shimon Doodkin

package javaapplication;
import java.util.Stack;
import java.util.logging.Level;
import java.util.logging.Logger;
public class ProducerConsumer {
public static Object lock = new Object();
public static Stack stack = new Stack();
public static void main(String[] args) {
Thread producer = new Thread(new Runnable() {
int i = 0;
@Override
public void run() {
do {
synchronized (lock) {
while (stack.size() >= 5) {
try {
lock.wait();
} catch (InterruptedException e) {
}
}
stack.push(++i);
if (stack.size() >= 5) {
System.out.println("Released lock by producer");
lock.notify();
}
}
} while (true);
}
});
Thread consumer = new Thread(new Runnable() {
@Override
public void run() {
do {
synchronized (lock) {
while (stack.empty()) {
try {
lock.wait();
} catch (InterruptedException ex) {
Logger.getLogger(ProdCons1.class.getName()).log(Level.SEVERE, null, ex);
}
}
while(!stack.isEmpty()){
System.out.println("stack : " + stack.pop());
}
lock.notifyAll();
}
} while (true);
}
});
producer.start();
consumer.start();
}
}

OriginalL'auteur geekyBird

Ont un coup d'oeil à cet exemple de code:

import java.util.concurrent.*;
import java.util.Random;
public class ProducerConsumerMulti {
public static void main(String args[]){
BlockingQueue<Integer> sharedQueue = new LinkedBlockingQueue<Integer>();
Thread prodThread  = new Thread(new Producer(sharedQueue,1));
Thread consThread1 = new Thread(new Consumer(sharedQueue,1));
Thread consThread2 = new Thread(new Consumer(sharedQueue,2));
prodThread.start();
consThread1.start();
consThread2.start();
} 
}
class Producer implements Runnable {
private final BlockingQueue<Integer> sharedQueue;
private int threadNo;
private Random rng;
public Producer(BlockingQueue<Integer> sharedQueue,int threadNo) {
this.threadNo = threadNo;
this.sharedQueue = sharedQueue;
this.rng = new Random();
}
@Override
public void run() {
while(true){
try {
int number = rng.nextInt(100);
System.out.println("Produced:" + number + ":by thread:"+ threadNo);
sharedQueue.put(number);
Thread.sleep(100);
} catch (Exception err) {
err.printStackTrace();
}
}
}
}
class Consumer implements Runnable{
private final BlockingQueue<Integer> sharedQueue;
private int threadNo;
public Consumer (BlockingQueue<Integer> sharedQueue,int threadNo) {
this.sharedQueue = sharedQueue;
this.threadNo = threadNo;
}
@Override
public void run() {
while(true){
try {
int num = sharedQueue.take();
System.out.println("Consumed: "+ num + ":by thread:"+threadNo);
Thread.sleep(100);
} catch (Exception err) {
err.printStackTrace();
}
}
}   
}

Notes:

Commencé un Producer et deux Consumers selon votre énoncé du problème
Producer va produire des nombres aléatoires entre 0 à 100 en boucle infinie
Consumer consomment ces numéros dans une boucle infinie
Les deux Producer et Consumer verrou de partage libre et Thread-safe LinkedBlockingQueue qui est Thread-safe. Vous pouvez supprimer wait() et notify() méthodes si vous utilisez ces avancées simultanées des constructions.

OriginalL'auteur Ravindra babu

-1

Semble que vous avez omis quelque chose à propos de wait(), notify() et synchronized.
Voir cet exemple, il devrait vous aider.

OriginalL'auteur SeniorJD

Vous devez vous connecter pour publier un commentaire.