Alle warnen davor, dass Java DateFormat nicht threadsicher ist, und ich verstehe das Konzept theoretisch.

Aber ich kann mir nicht vorstellen, mit welchen tatsächlichen Problemen wir aufgrund dessen konfrontiert werden können. Angenommen, ich habe ein DateFormat-Feld in einer Klasse und dasselbe wird in verschiedenen Methoden in der Klasse (Formatieren von Daten) in einer Umgebung mit mehreren Threads verwendet.

Wird dies verursachen:

• jede Ausnahme wie Formatausnahme
• Diskrepanz in Daten
• irgendein anderes Problem?

Erklären Sie bitte auch warum.

Probieren wir es aus.

Hier ist ein Programm, in dem mehrere Threads eine gemeinsame Nutzung verwenden SimpleDateFormat.

Programm :

public static void main(String[] args) throws Exception {

    final DateFormat format = new SimpleDateFormat("yyyyMMdd");

    Callable<Date> task = new Callable<Date>(){
        public Date call() throws Exception {
            return format.parse("20101022");
        }
    };

    //pool with 5 threads
    ExecutorService exec = Executors.newFixedThreadPool(5);
    List<Future<Date>> results = new ArrayList<Future<Date>>();

    //perform 10 date conversions
    for(int i = 0 ; i < 10 ; i++){
        results.add(exec.submit(task));
    }
    exec.shutdown();

    //look at the results
    for(Future<Date> result : results){
        System.out.println(result.get());
    }
}

Führen Sie dies einige Male aus und Sie werden sehen:

Ausnahmen :

Hier einige Beispiele:

1.

Caused by: java.lang.NumberFormatException: For input string: ""
    at java.lang.NumberFormatException.forInputString(NumberFormatException.java:48)
    at java.lang.Long.parseLong(Long.java:431)
    at java.lang.Long.parseLong(Long.java:468)
    at java.text.DigitList.getLong(DigitList.java:177)
    at java.text.DecimalFormat.parse(DecimalFormat.java:1298)
    at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1589)

2.

Caused by: java.lang.NumberFormatException: For input string: ".10201E.102014E4"
    at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:1224)
    at java.lang.Double.parseDouble(Double.java:510)
    at java.text.DigitList.getDouble(DigitList.java:151)
    at java.text.DecimalFormat.parse(DecimalFormat.java:1303)
    at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1589)

3.

Caused by: java.lang.NumberFormatException: multiple points
    at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:1084)
    at java.lang.Double.parseDouble(Double.java:510)
    at java.text.DigitList.getDouble(DigitList.java:151)
    at java.text.DecimalFormat.parse(DecimalFormat.java:1303)
    at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1936)
    at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1312)

Falsche Ergebnisse :

Sat Oct 22 00:00:00 BST 2011
Thu Jan 22 00:00:00 GMT 1970
Fri Oct 22 00:00:00 BST 2010
Fri Oct 22 00:00:00 BST 2010
Fri Oct 22 00:00:00 BST 2010
Thu Oct 22 00:00:00 GMT 1970
Fri Oct 22 00:00:00 BST 2010
Fri Oct 22 00:00:00 BST 2010
Fri Oct 22 00:00:00 BST 2010
Fri Oct 22 00:00:00 BST 2010

Richtige Ergebnisse :

Fri Oct 22 00:00:00 BST 2010
Fri Oct 22 00:00:00 BST 2010
Fri Oct 22 00:00:00 BST 2010
Fri Oct 22 00:00:00 BST 2010
Fri Oct 22 00:00:00 BST 2010
Fri Oct 22 00:00:00 BST 2010
Fri Oct 22 00:00:00 BST 2010
Fri Oct 22 00:00:00 BST 2010
Fri Oct 22 00:00:00 BST 2010
Fri Oct 22 00:00:00 BST 2010

Ein anderer Ansatz zur sicheren Verwendung von DateFormats in einer Umgebung mit mehreren Threads besteht darin, eine ThreadLocalVariable zum Speichern des DateFormat Objekts zu verwenden. Dies bedeutet, dass jeder Thread eine eigene Kopie hat und nicht warten muss, bis andere Threads sie freigeben. Das ist wie:

public class DateFormatTest {

  private static final ThreadLocal<DateFormat> df = new ThreadLocal<DateFormat>(){
    @Override
    protected DateFormat initialValue() {
        return new SimpleDateFormat("yyyyMMdd");
    }
  };

  public Date convert(String source) throws ParseException{
    Date d = df.get().parse(source);
    return d;
  }
}

Hier ist ein guter Beitrag mit mehr Details.

Ich würde eine Datenbeschädigung erwarten - z. B. wenn Sie zwei Daten gleichzeitig analysieren, könnte ein Anruf durch Daten eines anderen verschmutzt werden.

Es ist leicht vorstellbar, wie dies passieren könnte: Beim Parsen muss häufig ein bestimmter Status für das beibehalten werden, was Sie bisher gelesen haben. Wenn zwei Threads im selben Status trampeln, treten Probleme auf. Zum Beispiel wird DateFormatein calendarFeld vom Typ Calendarverfügbar gemacht und der Code SimpleDateFormateiniger Methodenaufrufe calendar.set(...)und anderer Aufrufe betrachtet calendar.get(...). Dies ist eindeutig nicht threadsicher.

Ich habe nicht genau untersucht, warum DateFormates nicht threadsicher ist, aber für mich ist es genug zu wissen, dass es so ist , ohne Synchronisation unsicher - die genaue Art und Weise von nicht-Sicherheit könnte auch zwischen den Versionen ändern.

Persönlich würde ich die Parser aus verwenden Joda Zeit statt, wie sie sind Thread - sicher - und Joda Zeit ist ein viel besseres Datum und Uhrzeit API zu beginnen :)

Wenn Sie Java 8 verwenden, können Sie verwenden DateTimeFormatter.

Ein aus einem Muster erstellter Formatierer kann so oft wie nötig verwendet werden, ist unveränderlich und threadsicher.

Code:

LocalDate date = LocalDate.now();
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
String text = date.format(formatter);
System.out.println(text);

Ausgabe:

2017-04-17

Grob gesagt, dass Sie keine DateFormatals Instanzvariable eines Objekts definieren sollten, auf das viele Threads zugreifen, oder static.

Datumsformate werden nicht synchronisiert. Es wird empfohlen, für jeden Thread separate Formatinstanzen zu erstellen.

Für den Fall, dass Foo.handleBar(..)mehrere Threads auf Ihr zugreifen, anstatt:

public class Foo {
    private DateFormat df = new SimpleDateFormat("dd/mm/yyyy");

    public void handleBar(Bar bar) {
        bar.setFormattedDate(df.format(bar.getStringDate());  
    }
}

du solltest benutzen:

public class Foo {

    public void handleBar(Bar bar) {
        DateFormat df = new SimpleDateFormat("dd/mm/yyyy");
        bar.setFormattedDate(df.format(bar.getStringDate());  
    }
}

Außerdem haben Sie in allen Fällen keine static DateFormat

Wie von Jon Skeet bemerkt, können Sie sowohl statische als auch gemeinsam genutzte Instanzvariablen haben, falls Sie eine externe Synchronisation durchführen (dh synchronizedum Aufrufe an die DateFormat)

Datumsformate werden nicht synchronisiert. Es wird empfohlen, für jeden Thread separate Formatinstanzen zu erstellen. Wenn mehrere Threads gleichzeitig auf ein Format zugreifen, muss es extern synchronisiert werden.

Dies bedeutet, dass Sie ein Objekt von DateFormat haben und von zwei verschiedenen Threads auf dasselbe Objekt zugreifen und die Formatmethode für dieses Objekt aufrufen. Beide Threads geben zur gleichen Zeit dieselbe Methode für dasselbe Objekt ein, damit Sie es als gewonnen visualisieren können führt nicht zu einem korrekten Ergebnis

Wenn Sie mit DateFormat arbeiten müssen, sollten Sie etwas tun

public synchronized myFormat(){
// call here actual format method
}

• Referenz

Daten sind beschädigt. Gestern habe ich es in meinem Multithread-Programm bemerkt, wo ich ein statisches DateFormatObjekt hatte und es format()für Werte aufgerufen habe, die über JDBC gelesen wurden. Ich hatte eine SQL-Select-Anweisung, bei der ich dasselbe Datum mit unterschiedlichen Namen las ( SELECT date_from, date_from AS date_from1 ...). Solche Aussagen wurden in 5 Threads für verschiedene Daten in der WHEREKlasse verwendet. Die Daten sahen "normal" aus, unterschieden sich jedoch im Wert - während alle Daten aus demselben Jahr stammten, änderten sich nur Monat und Tag.

Andere Antworten zeigen Ihnen, wie Sie solche Korruption vermeiden können. Ich habe meine DateFormatnicht statisch gemacht, jetzt ist sie Mitglied einer Klasse, die SQL-Anweisungen aufruft. Ich habe auch statische Version mit Synchronisation getestet. Beide funktionierten gut ohne Leistungsunterschied.

Die Spezifikationen von Format, NumberFormat, DateFormat, MessageFormat usw. wurden nicht als threadsicher konzipiert. Außerdem ruft die Analysemethode die Methode auf Calendar.clone()und wirkt sich auf die Kalender-Footprints aus, sodass viele Threads, die gleichzeitig analysiert werden, das Klonen der Kalenderinstanz ändern.

Weitere Informationen sind Fehlerberichte wie dieser und jener mit Ergebnissen des DateFormat-Thread-Sicherheitsproblems.

In der besten Antwort gab dogbane ein Beispiel für die Verwendung von parseFunktionen und deren Ursachen . Unten finden Sie einen Code, mit dem Sie die formatFunktion überprüfen können.

Beachten Sie, dass Sie unterschiedliche Ergebnisse erhalten, wenn Sie die Anzahl der Ausführenden (gleichzeitige Threads) ändern. Aus meinen Experimenten:

• Belassen Sie newFixedThreadPool5, und die Schleife schlägt jedes Mal fehl.
• Auf 1 gesetzt und die Schleife funktioniert immer (offensichtlich, da alle Aufgaben tatsächlich einzeln ausgeführt werden)
• Auf 2 gesetzt und die Schleife hat nur eine Chance von ca. 6% zu arbeiten.

Ich vermute YMMV abhängig von Ihrem Prozessor.

Die formatFunktion schlägt fehl, indem die Zeit eines anderen Threads formatiert wird. Dies liegt daran, dass die interne formatFunktion ein calendarObjekt verwendet, das zu Beginn der formatFunktion eingerichtet wurde. Und das calendarObjekt ist eine Eigenschaft der SimpleDateFormatKlasse. Seufzer...

/**
 * Test SimpleDateFormat.format (non) thread-safety.
 *
 * @throws Exception
 */
private static void testFormatterSafety() throws Exception {
    final SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    final Calendar calendar1 = new GregorianCalendar(2013,1,28,13,24,56);
    final Calendar calendar2 = new GregorianCalendar(2014,1,28,13,24,56);
    String expected[] = {"2013-02-28 13:24:56", "2014-02-28 13:24:56"};

    Callable<String> task1 = new Callable<String>() {
        @Override
        public String call() throws Exception {
            return "0#" + format.format(calendar1.getTime());
        }
    };
    Callable<String> task2 = new Callable<String>() {
        @Override
        public String call() throws Exception {
            return "1#" + format.format(calendar2.getTime());
        }
    };

    //pool with X threads
    // note that using more then CPU-threads will not give you a performance boost
    ExecutorService exec = Executors.newFixedThreadPool(5);
    List<Future<String>> results = new ArrayList<>();

    //perform some date conversions
    for (int i = 0; i < 1000; i++) {
        results.add(exec.submit(task1));
        results.add(exec.submit(task2));
    }
    exec.shutdown();

    //look at the results
    for (Future<String> result : results) {
        String answer = result.get();
        String[] split = answer.split("#");
        Integer calendarNo = Integer.parseInt(split[0]);
        String formatted = split[1];
        if (!expected[calendarNo].equals(formatted)) {
            System.out.println("formatted: " + formatted);
            System.out.println("expected: " + expected[calendarNo]);
            System.out.println("answer: " + answer);
            throw new Exception("formatted != expected");
        /**
        } else {
            System.out.println("OK answer: " + answer);
        /**/
        }
    }
    System.out.println("OK: Loop finished");
}

Wenn mehrere Threads eine einzelne DateFormat-Instanz bearbeiten / darauf zugreifen und die Synchronisation nicht verwendet wird, können verschlüsselte Ergebnisse erzielt werden. Dies liegt daran, dass mehrere nichtatomare Operationen den Status ändern oder den Speicher inkonsistent sehen können.

Dies ist mein einfacher Code, der zeigt, dass DateFormat nicht threadsicher ist.

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;

public class DateTimeChecker {
    static DateFormat df = new SimpleDateFormat("EEE MMM dd kk:mm:ss z yyyy", Locale.ENGLISH);
    public static void main(String args[]){
       String target1 = "Thu Sep 28 20:29:30 JST 2000";
       String target2 = "Thu Sep 28 20:29:30 JST 2001";
       String target3 = "Thu Sep 28 20:29:30 JST 2002";
       runThread(target1);
       runThread(target2);
       runThread(target3);
   }
   public static void runThread(String target){
       Runnable myRunnable = new Runnable(){
          public void run(){

            Date result = null;
            try {
                result = df.parse(target);
            } catch (ParseException e) {
                e.printStackTrace();
                System.out.println("Ecxfrt");
            }  
            System.out.println(Thread.currentThread().getName() + "  " + result);
         }
       };
       Thread thread = new Thread(myRunnable);

       thread.start();
     }
}

Da alle Threads dasselbe SimpleDateFormat-Objekt verwenden, wird die folgende Ausnahme ausgelöst.

Exception in thread "Thread-0" Exception in thread "Thread-2" Exception in thread "Thread-1" java.lang.NumberFormatException: multiple points
at sun.misc.FloatingDecimal.readJavaFormatString(Unknown Source)
at sun.misc.FloatingDecimal.parseDouble(Unknown Source)
at java.lang.Double.parseDouble(Unknown Source)
at java.text.DigitList.getDouble(Unknown Source)
at java.text.DecimalFormat.parse(Unknown Source)
at java.text.SimpleDateFormat.subParse(Unknown Source)
at java.text.SimpleDateFormat.parse(Unknown Source)
at java.text.DateFormat.parse(Unknown Source)
at DateTimeChecker$1.run(DateTimeChecker.java:24)
at java.lang.Thread.run(Unknown Source)
java.lang.NumberFormatException: multiple points
at sun.misc.FloatingDecimal.readJavaFormatString(Unknown Source)
at sun.misc.FloatingDecimal.parseDouble(Unknown Source)
at java.lang.Double.parseDouble(Unknown Source)
at java.text.DigitList.getDouble(Unknown Source)
at java.text.DecimalFormat.parse(Unknown Source)
at java.text.SimpleDateFormat.subParse(Unknown Source)
at java.text.SimpleDateFormat.parse(Unknown Source)
at java.text.DateFormat.parse(Unknown Source)
at DateTimeChecker$1.run(DateTimeChecker.java:24)
at java.lang.Thread.run(Unknown Source)
java.lang.NumberFormatException: multiple points
at sun.misc.FloatingDecimal.readJavaFormatString(Unknown Source)
at sun.misc.FloatingDecimal.parseDouble(Unknown Source)
at java.lang.Double.parseDouble(Unknown Source)
at java.text.DigitList.getDouble(Unknown Source)
at java.text.DecimalFormat.parse(Unknown Source)
at java.text.SimpleDateFormat.subParse(Unknown Source)
at java.text.SimpleDateFormat.parse(Unknown Source)
at java.text.DateFormat.parse(Unknown Source)
at DateTimeChecker$1.run(DateTimeChecker.java:24)
at java.lang.Thread.run(Unknown Source)

Wenn wir jedoch unterschiedliche Objekte an unterschiedliche Threads übergeben, wird der Code fehlerfrei ausgeführt.

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;

public class DateTimeChecker {
    static DateFormat df;
    public static void main(String args[]){
       String target1 = "Thu Sep 28 20:29:30 JST 2000";
       String target2 = "Thu Sep 28 20:29:30 JST 2001";
       String target3 = "Thu Sep 28 20:29:30 JST 2002";
       df = new SimpleDateFormat("EEE MMM dd kk:mm:ss z yyyy", Locale.ENGLISH);
       runThread(target1, df);
       df = new SimpleDateFormat("EEE MMM dd kk:mm:ss z yyyy", Locale.ENGLISH);
       runThread(target2, df);
       df = new SimpleDateFormat("EEE MMM dd kk:mm:ss z yyyy", Locale.ENGLISH);
       runThread(target3, df);
   }
   public static void runThread(String target, DateFormat df){
      Runnable myRunnable = new Runnable(){
        public void run(){

            Date result = null;
            try {
                result = df.parse(target);
            } catch (ParseException e) {
                e.printStackTrace();
                System.out.println("Ecxfrt");
            }  
            System.out.println(Thread.currentThread().getName() + "  " + result);
         }
       };
       Thread thread = new Thread(myRunnable);

       thread.start();
   }
}

Das sind die Ergebnisse.

Thread-0  Thu Sep 28 17:29:30 IST 2000
Thread-2  Sat Sep 28 17:29:30 IST 2002
Thread-1  Fri Sep 28 17:29:30 IST 2001

Dies wird verursachen ArrayIndexOutOfBoundsException

Abgesehen von dem falschen Ergebnis kommt es von Zeit zu Zeit zu einem Absturz. Dies hängt von der Geschwindigkeit Ihrer Maschine ab. In meinem Laptop passiert es durchschnittlich einmal in 100.000 Anrufen:

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

ExecutorService executorService = Executors.newFixedThreadPool(2);
Future<?> future1 = executorService.submit(() -> {
  for (int i = 0; i < 99000; i++) {
    sdf.format(Date.from(LocalDate.parse("2019-12-31").atStartOfDay().toInstant(UTC)));
  }
});

executorService.submit(() -> {
  for (int i = 0; i < 99000; i++) {
    sdf.format(Date.from(LocalDate.parse("2020-04-17").atStartOfDay().toInstant(UTC)));
  }
});

future1.get();

Die letzte Zeile sollte die verschobene Executor-Ausnahme auslösen:

java.lang.ArrayIndexOutOfBoundsException: Index 16 out of bounds for length 13
  at java.base/sun.util.calendar.BaseCalendar.getCalendarDateFromFixedDate(BaseCalendar.java:453)
  at java.base/java.util.GregorianCalendar.computeFields(GregorianCalendar.java:2394)
  at java.base/java.util.GregorianCalendar.computeFields(GregorianCalendar.java:2309)
  at java.base/java.util.Calendar.complete(Calendar.java:2301)
  at java.base/java.util.Calendar.get(Calendar.java:1856)
  at java.base/java.text.SimpleDateFormat.subFormat(SimpleDateFormat.java:1150)
  at java.base/java.text.SimpleDateFormat.format(SimpleDateFormat.java:997)
  at java.base/java.text.SimpleDateFormat.format(SimpleDateFormat.java:967)
  at java.base/java.text.DateFormat.format(DateFormat.java:374)