Thread-Synchronisierungsfrage

[RBS2002]

Hi,

ist im Prinzip nur eine Verständnissfrage: Ich habe eine interne Speicherprozedur die sich, mit Hilfe von Quartz, zeitgesteuert jeden Tag um 0 Uhr über eine Funktion eine Kopie (Deep Copy per Serialisierung) der aktuellen Daten holt und diese in eine XML Datei abspeichert. Muss ich in der Zeit der Serialisierung, also des Kopiervorganges, Schreib und Lesevorgänge durch andere Threads verhindern (es geht in dem Fall speziell um Listen) oder wäre das unproblematisch?

MfG RBS2002

Habe mal ein kleines Programm programmiert mit dem ich das ganze nachvollziehen konnte. Als der Thread in die Liste geschrieben hat kam immer ein Nullpointer raus, erst als nichts geschrieben wurde hat er die Meldung "Erfolgreich" abgegeben. Vielleicht kennt jemand dafür eine Lösung, deswegen das Programm das ich schnell geschrieben habe:

Copy Konstruktor:

public class Copy {

    public static Object clone(Object copyObject) {
        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream(4096);
            ObjectOutputStream oos = new ObjectOutputStream(baos);
            oos.writeObject(copyObject);
            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bais);
            Object deepCopy = ois.readObject();
            return deepCopy;
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }
}

Frame:

public class Frame extends JFrame{

    private Data daten;
    private JTextArea text;
    private JButton hole_kopie;
    private JButton beende_schreiben;
    private Fuellen fill;

    public Frame() {
        this.setLayout(new BorderLayout());
        this.add(beende_schreiben = new JButton("Beende schreiben"),BorderLayout.NORTH);
        this.add(new JScrollPane(text = new JTextArea()),BorderLayout.CENTER);
        this.add(hole_kopie = new JButton("Hole Daten"),BorderLayout.SOUTH);
        daten = new Data();

        beende_schreiben.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent arg0) {
                fill.stop();
            }
        });

        hole_kopie.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent arg0) {
                try{
                ArrayList clone = (ArrayList) Copy.clone(daten.getListe());
                if(clone!=null){
                text.append("Kopieren erfolgreich");
                }
                }catch(Exception ex){
                    text.append(ex.getMessage()+"\n");
                }
            }
        });

        fill = new Fuellen(daten);
        fill.start();

        this.setSize(500,500);
        this.setLocationRelativeTo(null);
        this.setVisible(true);
    }
    
}

"Datenobjekt"

public class Data {
    
    private ArrayList liste;

    public Data() {
        liste = new ArrayList();
    }

    public ArrayList getListe() {
        return liste;
    }

}

Der Schreib-Thread

public class Fuellen implements Runnable{

    private Data data;
    private Thread t;

    public void start(){
        t = new Thread(this);
        t.start();
    }

    public void stop(){
        if(t!=null){
            t = null;
        }
    }

    public Fuellen(Data data) {
        this.data = data;
    }

    public void run() {
        while(t != null){
            data.getListe().add("Schreibe einfach nur");
            System.out.println("Schreibe");
        }
    }

}

 

[Spacerat]

Man kann die Liste, die gespeichert werden soll vor dem Schreibvorgang kopieren. Diese Kopie kann (muss aber nicht) unabhängig vom Original synchronisiert werden. Was dann viel wichtiger wäre ist, das jedes einzelne Element in der Liste vorm Schreiben synchroniziert wird.

public void writeList(List<? extends Object> list)
{
  List<? extends Object> tmp = new ArrayList<? extends Object>();
  synchronized(list) {
    tmp.addAll(list);
  }
  // ...
  // ... ObjektOutput öffnen
  // ...
  Iterator<? extends Object)> i = tmp.iterator();
  Object o;
  while(i.hasNext()) {
    o = i.next();
    synchronized(o) {
      // ...
      // ... Schreibvorgang Element
      // ...
    }
  }
  // ...
  // ... ObjektOutput schliessen
  // ...
}

"tmp" erhält alle Elemente der Liste "list" (keine Kopien dieser Elemente) und kann sich während des Schreibvorganges nicht mehr ändern. Da aber ein anderer Thread existierende Elemente in "list" verändern kann, müssen eben diese Elemente einzeln synchronisiert werden. Leider ist nicht abzusehen, welche Änderungen noch mitgespeichert werden (Änderungen im hinteren Teil von "list") und welche nicht (Änderungen im vorderen Teil von "list"). Elemente die nach einem Aufruf von "writeList()" während des Schreibvorganges hinzugefügt werden werden nicht mitgespeichert während Elemente die entfernt werden noch mitgespeichert werden. So wie "writeList()" dort oben steht, darf "list" keine Nullobjekte beinhalten.

 

[RBS2002]

okay, vielen Dank

Hier mal der Quellcode der bei mir genauso gut funktioniert (ich bekam bisher nur Erfolgsmeldungen) und auch genau so wie ich es haben will (eine zentrale Datenquelle, gibt nur Kopien raus):

public class Data {
    
    private ArrayList liste;
    private Lock locked = new ReentrantLock();

    public Data() {
        liste = new ArrayList();
    }

    public ArrayList getListe() {
        locked.lock();
        ArrayList arraylist = (ArrayList)Copy.clone(liste);
        locked.unlock();
        return arraylist;
    }
}