Wenn die Größe eines Arrays geändert wird kann es sein das das gesamte Array im Speicher verschoben wird. Auch hierbei muss also synchronisiert werden, um heimtückische (weil selten auftretende) Fehler zu vermeiden. Man hängt vermeindlich nur hinten etwas an, aber auch das erste Element wird im Speicher verschoben.

Reine Lesezugriffe müssen natürlich nicht synchronisiert werden.
Neben den CritialSections gibt es noch andere Möglichkeiten der Synchronisation (Mutex, Semaphore, Events, Messages..) wo der eine Thread dem anderen klar sagt "ich bin fertig und warte jetzt bis du fertig bist".

genau sowas verhindern dieses TMultiSync-Dinger

sie erlauben gleichzeitige Lesezugriffe, aber nur wenn in diesem Moment nicht schreibend zugegriffen wird
oder sie erlauben nur einen Schreibzugriff und sonst nix.

somit ist sichergestellt, daß immer nur einer ändert
und man nicht lesen kann, wärend geändert wird.

Ok, so langsam kapiere ich wie das Memorymanagement funktioniert. Ich habe mich schon immer gefragt, wie es funktioniert, ein array dynamisch zu vergrößern, wenn am Ende des arrays kein Platz mehr ist...

Diese Umkopiererei will ich eigentlich vermeiden.

Wenn mein Pointerarray statisch ist (=vordefinierte Länge), dann müsste es doch fix im Speicher liegen, oder? Die Pointer(=dynamische Arrays) zeigen dann auf nil oder auf dynamische Arrays fixer Länge.
Bsp:

markieren

Delphi-Quellcode:

type
  Tx: array of char;
x: array[0..100] of Tx;

Wenn ich z.B. setlength(x[50],100) mache, würde das die restlichen Arrays x[i] (sofern allokiert) im Speicher fix lassen oder würden die ggf. auch umkopiert werden?

P.S. Hab in Delphi6 TMultiReadExclusiveWriteSynchronizer gefunden. Der scheint ein geeignetes Werkzeug für meine Anwendung, oder?

Gruß Thomas

Nur x[50] kann umkopiert werden. Der Speichermanager weiß ja gar nicht, wo sich Referenzen zu den anderen Speicherblöcken befinden.

Ok, das ginge also. Das mit dem statischen Array ist allerdings unschön, weil ich a priori gar nicht weiß, wie viele Datenblöcke kommen werden und es halt unschön ist ein überlanges Array von Pointern vorzuhalten.

Was gibt es denn noch für Möglichkeiten, dynamisch wachsende sequentiell schreib- und lesbare Datenstrukturen zu realisieren? Ich könnte mir so etwas wie eine verkettete Liste, d.h. jeder Datenblock enthält einen Pointer auf den nächsten Datenblock vorstellen. Wie könnte ich solche Strukturen in Delphi dynamisch erzeugen/vergrößern?

Verkettete Listen sind für Aufgaben mit mehreren Threads richtig genial. Man kann dort nämlich völlig ohne Locks auskommen. Windows stellt zum Beispiel Funktionen für einen Stack zur Verfügung, der mit beliebig vielen zugreifenden Threads immer konsistent bleibt. Queues lassen sich auch auf diese Weise implementieren, das ist allerdings ein bisschen komplizierter. Ich habe das auch mal gemacht, der Code ist allerdings ungetestet und komplett in Assembler. Falls es dich interessiert kann ich die Unit hochladen.

Was spricht jetzt eigentlich gegen Arrays? Gut, du brauchst immer irgendein Lock, aber in den meisten Fällen ist das vernachlässigbar.

Auch verkettete Listen müssen abgesichert werden!
Aber dort kann man es so einrichten, daß man jedes Element einzeln absichert und nicht die ganze Liste auf einmal ... so lassen sich viele Zugriffe an verschiedenen Stellen womöglich besser optimieren, da sie sich so nicht gegenseitig stören.

Du kannst verkettete Listen so aufbauen, dass du keine Locks, sondern nur Compare-and-Swap brauchst.

Zitat von Apollonius:

Du kannst verkettete Listen so aufbauen, dass du keine Locks, sondern nur Compare-and-Swap brauchst.

Compare-and-Swap/InterlockedExchange zähle ich mit zum Absichern.

drum hab ich auch nicht looken/sperren sondern "absichern" gesagt