Beheben Sie einen durch i++ verursachten Fehler

In der Spalte „Java-Grundlagen-Tutorial“ werden Fehler vorgestellt, die durch i++ verursacht werden.

Hallo zusammen, als jemand, der täglich Fehler schreibt und behebt, werde ich euch heute einen Unfall vorstellen, der erst vor ein paar Tagen behoben wurde. Ich muss zugeben, dass es überall, wo ich bin, immer so viele Käfer gibt.

Ursache

Die Geschichte begann vor ein paar Tagen. Es gab eine Exportfunktion, die nicht sehr häufig verwendet wurde, dass es unabhängig von den Bedingungen nur eine exportierte Daten gab, aber tatsächlich die Abfrage Basierend auf den Bedingungen war Es gibt viele Daten, und auf der Seite werden viele Daten abgefragt. (Dieses Problem wurde behoben, sodass die damaligen Kibana-Protokolle nicht mehr gefunden werden können.) Also habe ich meine Arbeit beiseite gelegt und mich an die Arbeit gemacht, um mir dieses Problem anzusehen.

Analyse

Der Beschreibung des Problems zufolge kann es nur in den folgenden Situationen auftreten:

Es wird nur ein Datensatz basierend auf den Suchbedingungen abgefragt.

Führen Sie eine entsprechende Geschäftsverarbeitung für die abgefragten Daten durch, was zu nur einem Endergebnis führt.

Nach der logischen Verarbeitung der Dateiexportkomponente gibt es nur ein Ergebnis.

2. Exkurs
3. 
   Als ich dies schrieb, dachte ich plötzlich an eine klassische Interviewfrage, die Analyse der Ursache des MQ-Nachrichtenverlusts. Hahaha, tatsächlich wird es aus mehreren Blickwinkeln grob analysiert. (Wenn ich die Gelegenheit habe, einen Artikel über MQ zu schreiben)

Exkurs

Also habe ich es einzeln analysiert:

Finden Sie die SQL des relevanten Unternehmens und die entsprechenden Parameter. Die Abfrage kann abgerufen werden . Da es mehr als ein Datenelement gibt, kann die erste Ein-Situation ausgeschlossen werden.

Vermittlungsgeschäfte beinhalten relevante Berechtigungen, Datensensibilität usw. Nach der Freigabe gibt es immer noch nur ein Datenelement.

Wenn die Dateiexportkomponente die Daten empfängt, zeigt das gedruckte Protokoll auch nur einen Eintrag, was bedeutet, dass ein Problem mit der Logik des zugehörigen Geschäfts vorliegen muss.

1. Da dieser Code in einer vollständigen Methode geschrieben ist, ist es für Arthas schwierig, Fehler zu beheben, sodass er das Protokoll Schritt für Schritt zur Fehlerbehebung einrichten muss. (Wenn es sich also um ein großes Stück Logik handelt, wird empfohlen, es in zwei Untermethoden aufzuteilen. Erstens wird die Idee beim Schreiben klar sein und es wird ein modulares Konzept geben. Was die Wiederverwendung von Methoden betrifft, I Ich werde es nicht weiter erwähnen. Sobald ein Problem auftritt, ist es aus Erfahrung einfacher, es zu beheben.
2. Endlich in einer for-Schleife positioniert.
3. Code

Schauen wir uns ohne weitere Umschweife direkt den Code an. Wie wir alle wissen, war ich schon immer jemand, der den Code des Unternehmens schützte, also muss ich ihn hier für alle simulieren. Dem Problem nach zu urteilen, ist der exportierte Objektdatensatz leer

import com.google.common.collect.Lists;import java.util.List;public class Test {    public static void main(String[] args) {        // 获取Customer数据，这里就简单模拟
        List<Customer> customerList = Lists.newArrayList(new Customer("Java"), new Customer("Showyool"), new Customer("Soga"));        int index = 0;
        String[][] exportData = new String[customerList.size()][2];        for (Customer customer : customerList) {
            exportData[index][0] = String.valueOf(index);
            exportData[index][1] = customer.getName();
            index = index++;
        }
        System.out.println(JSON.toJSONString(exportData));
    }
}class Customer {    public Customer(String name) {        this.name = name;
    }    private String name;    public String getName() {        return name;
    }    public void setName(String name) {        this.name = name;
    }
}复制代码

Dieser Code scheint nichts zu sein, er dient dazu, die Kundensammlung in ein zweidimensionales Array von Zeichenfolgen umzuwandeln. Das Ausgabeergebnis zeigt jedoch: Dies stimmt mit dem überein, was wir gesagt haben. Es gibt mehrere Abfragen, aber nur eine wird ausgegeben.

Wenn wir genau hinsehen, können wir feststellen, dass die Ausgabedaten immer die letzten sind. Das heißt, jedes Mal, wenn die Kundensammlung durchlaufen wird, überschreibt letztere die erstere. Mit anderen Worten, der Index dieses Index ist immer nicht vorhanden geändert, es war immer 0.

Modellierung

Es scheint, dass unsere Selbstinkrementierung einige Probleme hat, also schreiben wir einfach ein Modell

public class Test2 {    public static void main(String[] args) {        int index = 3;
        index = index++;
        System.out.println(index);
    }
    
}复制代码

Wir vereinfachen die obige Geschäftslogik in ein solches Modell, dann ist das Ergebnis keine Überraschung 3.

Erklärung

Dann führen wir javap aus und sehen, wie der JVM-Bytecode interpretiert wird:

javap -c Test2

Compiled from "Test2.java"public class com.showyool.blog_4.Test2 {  public com.showyool.blog_4.Test2();
    Code:       0: aload_0       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:       0: iconst_3       1: istore_1       2: iload_1       3: iinc          1, 1
       6: istore_1       7: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
      10: iload_1      11: invokevirtual #3                  // Method java/io/PrintStream.println:(I)V
      14: return}复制代码

Hier werde ich kurz auf die JVM-Bytecode-Anweisungen eingehen (ich werde später einen ausführlichen Artikel schreiben, wenn ich die Gelegenheit dazu habe)

Zuerst wir Zuerst müssen Sie wissen, dass es hier zwei Konzepte gibt: den Operandenstapel und die lokale Variablentabelle. Diese beiden sind einige Datenstrukturen, die im Stapelrahmen des Stapels der virtuellen Maschine vorhanden sind, wie in der Abbildung gezeigt:

Wir können Verstehe es einfach Weil die Funktion des Operandenstapels darin besteht, Daten zu speichern und Daten auf dem Stapel zu berechnen, während die lokale Variablentabelle einige Informationen über Variablen speichert.
Dann werfen wir einen Blick auf die obige Anweisung:

0:iconst_3 (schiebe zuerst die Konstante 3 auf den Stapel)

1: istore_1 (出栈操作，将值赋给第一个参数，也就是将3赋值给index)

2: iload_1  (将第一个参数的值压入栈，也就是将3入栈，此时栈顶的值为3)

3: iinc 1, 1 (将第一个参数的值进行自增操作，那么此时index的值是4)

6: istore_1 (出栈操作，将值赋给第一个参数，也就是将3赋值给index)

也就是说index这个参数的值是经历了index->3->4->3，所以这样一轮操作之后，index又回到了一开始赋值的值。

延伸一下

这样一来，我们发现，问题其实出在最后一步，在进行运算之后，又将原先栈中记录的值重新赋给变量，覆盖掉了 如果我们这样写:

public class Test2 {    public static void main(String[] args) {        int index = 3;
        index++;
        System.out.println(index);
    }

}

Compiled from "Test2.java"public class com.showyool.blog_4.Test2 {  public com.showyool.blog_4.Test2();
    Code:       0: aload_0       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:       0: iconst_3       1: istore_1       2: iinc          1, 1
       5: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       8: iload_1       9: invokevirtual #3                  // Method java/io/PrintStream.println:(I)V
      12: return}复制代码

可以发现，这里就没有最后一步的istore_1，那么在iinc之后，index的值就变成我们预想的4。
还有一种情况，我们来看看:

public class Test2 {    public static void main(String[] args) {        int index = 3;
        index = index + 2;
        System.out.println(index);
    }

}

Compiled from "Test2.java"public class com.showyool.blog_4.Test2 {  public com.showyool.blog_4.Test2();
    Code:       0: aload_0       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:       0: iconst_3       1: istore_1       2: iload_1       3: iconst_2       4: iadd       5: istore_1       6: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       9: iload_1      10: invokevirtual #3                  // Method java/io/PrintStream.println:(I)V
      13: return}复制代码

0: iconst_3 (先将常量3压入栈)
1: istore_1 (出栈操作，将值赋给第一个参数，也就是将3赋值给index)
2: iload_1  (将第一个参数的值压入栈，也就是将3入栈，此时栈顶的值为3)
3: iconst_2 (将常量2压入栈, 此时栈顶的值为2，2在3之上)
4: iadd (将栈顶的两个数进行相加，并将结果压入栈。2+3=5，此时栈顶的值为5)
5: istore_1 (出栈操作，将值赋给第一个参数，也就是将5赋值给index)

看到这里各位观众老爷肯定会有这么一个疑惑，为什么这里的iadd加法操作之后，会影响栈里面的数据，而先前说的iinc不是在栈里面操作？好的吧，我们可以看看JVM虚拟机规范当中，它是这么描述的:

指令iinc对给定的局部变量做自增操作，这条指令是少数几个执行过程中完全不修改操作数栈的指令。它接收两个操作数： 第1个局部变量表的位置，第2个位累加数。比如常见的i++,就会产生这条指令

看到这里，我们知道，对于一般的加法操作之后复制没啥问题，但是使用i++之后，那么此时栈顶的数还是之前的旧值，如果此刻进行赋值就会回到原来的旧值，因为它并没有修改栈里面的数据。所以先前那个bug，只需要进行自增不赋值就可以修复了。

Abschließend

Vielen Dank, dass Sie das gesehen haben. Das Obige ist mein gesamter Prozess zur Behebung dieses Fehlers. Obwohl dies nur ein kleiner Fehler ist, lohnt es sich dennoch, ihn zu lernen und darüber nachzudenken. Ich werde weiterhin die Fehler und Wissenspunkte teilen, die ich in Zukunft gefunden habe, und hoffe auch, dass ihr ihm folgt 🔜 Likes$Verwandte kostenlose Lernempfehlungen:$Java Basic Tutorial

Das obige ist der detaillierte Inhalt vonBeheben Sie einen durch i++ verursachten Fehler. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!