ArrayBlockingQueue et ajouter vs mettez vs capacité

De Javadoc de ArrayBlockingQueue ArrayBlockingQueue:

ajouter

public boolean add(E e)

Inserts the specified element at the tail of this queue if it is possible 
to do so immediately without exceeding the queue's capacity, returning true 
upon success and throwing an IllegalStateException if this queue is full.

J'ai toujours interpretted cette déclaration (la partie if it is possible to do so immediattely) comme suit:

Si la file d'attente dispose d'un espace libre, puis l'insérer réussira. Si il n'y a pas d'espace vide alors elle ne réussira pas.

Mais ma compréhension était mal ici.

Dans un cas simple que j'ai décidé d'utiliser un ArrayBlockingQueue pour, par exemple, de 20 éléments (petite file d'attente) et ayant un thread:

queue.take()

l'autre thread n'a pas d'ajouter un élément à la file d'attente via le add méthode malgré la file d'attente était presque vide.

J'ai vérifié également par l'intermédiaire de débogage.

Une fois, j'ai remplacé l'appel de queue.add(element) à queue.put(element) l'élément est en effet ajouté à la file d'attente.

Donc ce qui est différent dans ces méthodes?

Pour quelle autre raison (en plus de la capacité) pourrait le plus se produit pas?

Mise à JOUR:

public class ConnectionListener implements Observer {

  public static BlockingQueue<ConnectionObject> queueConnections = new   ArrayBlockingQueue<ConnectionObject>(10);

  @Override
  public void update(Observable arg0, Object arg1) {
      ConnectionObject con = ((ConnectionObject)arg1);
      queueConnections.add(con);
  }

}

ConnectionObject est juste un support pour des valeurs de Chaîne.

public class ConnectionObject {
  private String user;  
  private String ip;
   //etc  
}

Et le consommateur:

public class ConnectionTreeUpdater extends Thread {  
  @Override
  public void run() {
    while(true){  
    try {  
    final ConnectionObject con = ConnectionListener.queueConnections.take();

Si j'utilise add aucune exception n'est levée, mais l'élément n'est pas ajouté à la file d'attente.

Juste une pensée: peut-être, car le consommateur est "en attente" dans la file d'attente, si pour une gestion interne de l'élément ne peut pas être ajoutée, elle ne sera pas ajoutée et aucune exception n'est levée.Pourrait-ce être le cas.

Sinon, je ne comprends pas pourquoi il n'y a pas d'exception et avec put le code fonctionne.

Sont put et add destiné à être utilisé différemment?

Je soupçonne que vous avez été la capture et ignorant l'exception levée par add() mais sans voir ton code c'est juste une supposition. Vous avez besoin d'afficher un petit exemple de code illustrant le problème que vous rencontrez.
En fait il n'y a pas d'exception à ajouter. J'ai juste fait queue.add et le code renvoyé immédiatement, sans l'ajout de l'élément et non l'exception
Veuillez peut-on voir un complet et reproductible de cas de test qui illustre ce comportement (add() pas lancer une exception, mais aussi de ne pas ajouter l'élément à la file d'attente).
Non, il n'a pas. Qu'il soit ajouté à la file d'attente, ou il a jeté une exception. Ce sont les deux seules issues possibles.
post avec un peu de code

OriginalL'auteur Cratylus | 2011-10-09

15

C'est assez simple en fait:
- si la file d'attente n'est pas plein, les deux méthodes de réussir;
- si la file est pleine, add() échoue avec une exception alors que () blocs.
Je pense que la documentation est assez clair sur le dessus. Si vous n'êtes pas d'accord, et je voudrais un deuxième avis, vous pourriez examiner le code source pour ArrayBlockingQueue:
```
public boolean add(E e) {
    if (offer(e))
        return true;
    else
        throw new IllegalStateException("Queue full");
}

public boolean offer(E e) {
    if (e == null) throw new NullPointerException();
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        if (count == items.length)
            return false;
        else {
            insert(e);
            return true;
        }
    } finally {
        lock.unlock();
    }
}

public void put(E e) throws InterruptedException {
    if (e == null) throw new NullPointerException();
    final E[] items = this.items;
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        try {
            while (count == items.length)
                notFull.await();
        } catch (InterruptedException ie) {
            notFull.signal(); //propagate to non-interrupted thread
            throw ie;
        }
        insert(e);
    } finally {
        lock.unlock();
    }
}
```
If you find the documentation ambiguous, you can verify this by looking at the source code - Il y a bien une différence entre un détail de l'implémentation et de la documentation, donc je ne suis pas vraiment heureux avec les conseils en général. Si la documentation n'est pas claire (même si je pense que c'est assez clair dans ce cas), l'ouverture d'un bug est plus judicieux je pense (je n'ai pas fait que pour Java, mais plus d'une fois pour msdn [bien la doc de l'api win32 est un gâchis de bien ;-)])
Je vois votre point de vue. Cependant, depuis un rapport de bug, il y a un bug (ou un motif raisonnable de croire qu'il y a un bug). Dans ce cas, les deux la documentation et le code très clairement la même chose (à mes yeux en tout cas).
Je suis d'accord que dans ce cas, la documentation est assez claire (le bien et le code n'est évidemment le droit thingTM). Simplement, si la documentation n'était vraiment pas clair, juste à la recherche à la mise en œuvre et en supposant qu'il ne pourrait jamais changer serait une mauvaise idée. La création d'un bug de la documentation pour voir si c'était juste une honnête de la supervision ou de gauche non défini pour une bonne raison est imo le meilleur cours de l'action (et bien d'abord de googler autour évidemment 😉 )
Alors que je suis d'accord avec vous sur un certain niveau, si vous soupçonnez qu'il y a un bug, vous écrivez un cas de tests reproductibles à démontrer, et puis de déposer le rapport. L'OP ne semble pas en mesure de fournir ce, après s'être demandé, donc, à ce point de leur dire de regarder le source n'est pas terrible suggestion. Soupçonner il y a un bug dans l'écurie, de l'ancien code qui est utilisé par des millions de développeurs de tous les jours est tout simplement de mauvais logique et la marque d'un mauvais ingénieur. Jeff (co-fondateur de la SORTE) décrit ce dans: codinghorror.com/blog/2008/03/...
Je suis loin de dire qu'il y a un bug là, juste que c'est pas une bonne idée de regarder la mise en œuvre si la documentation ne précise pas quelque chose ou n'est pas claire. Afin de répondre à une question sur le comportement d'une fonction de "à la Recherche à la src de code, on procède de la manière suivante" peut conduire à des problèmes intéressants en bas de la route. Exemple? Le C# string fonction de hachage est documenté nulle part et NE fait modifier par le biais de versions, qui conduisent à des problèmes intéressants en bas de la route. Edit: L'OP a changé son post un peu depuis ce ici a été rédigé de sorte que le contexte a un peu changé.

OriginalL'auteur NPE

L'une des parties les plus importantes de débogage d'un problème est l'écriture d'un scénario de test à assurez-vous que ce que vous pensez qu'il se passe est en effet en passe. Cela prouve ou réfute votre théorie.

Le cas de test ci-dessous montre que les méthodes que vous utilisez se comportent exactement comme la documentation (que vous citez) membres:

public static void main(String[] args) {
final ArrayBlockingQueue<Integer> myQueue =
new ArrayBlockingQueue<Integer>(10);
Thread t1 = new Thread(new Runnable() {
public void run()
{
int i = 0;
while (true)
{
try
{
myQueue.add(i);
System.out.println("Added to queue! value: " + 
i + 
" size: " + myQueue.size());
i++;
}
catch (Exception e)
{
System.out.println("add() threw exception, size: " +
myQueue.size());
try
{
Thread.sleep(1000);
}
catch (InterruptedException ex)
{
Logger.getLogger(Main.class.getName()).log(Level.SEVERE, 
null, ex);
}
}
}
}
});
Thread t2 = new Thread(new Runnable() {
public void run()
{
while (true)
{
try
{
Integer i = myQueue.take();
System.out.println("Took a off the queue! value: " + 
i + 
" size: " + myQueue.size());
Thread.sleep(100);
}
catch (InterruptedException ex)
{
Logger.getLogger(Main.class.getName()).log(Level.SEVERE, 
null, ex);
}
}
}
});
t1.start();
t2.start();
}

OriginalL'auteur Brian Roach

Vous devez vous connecter pour publier un commentaire.