[C++] Synchronize met parameters

[IJnte]

Ik ben nog steeds lekker bezig met het uitzoeken van Threads. Ik ben al een heel stuk wijzer geworden van de werking van Threads. Echter ik loop tegen een probleem aan:

Ik ben bezig met een programmatje wat straks een 2 tal(of later meer) apparaten moet aansturen via de SCSI bus. Dit aansturen is verder geen probleem meer. Mijn programma is nu single threaded helemaal klaar. Ik moet het alleen nu nog maken voor 2 apparaten. Daarvoor ben ik al een hele tijd bezig met het uitzoeken van Threads. Ik heb diverse programmatjes gemaakt waar diverse onderdelen die bij threads komen kijken getest kunnen worden(denk aan suspend, resume, CriticalSection,Synchronize).
Bij het scannen van de SCSI bus worden het aaantal apparaten gescant. Voor elk apparaat wordt een nieuwe thread aangemaakt( zijn overigens allemaal dezelfde Threads, dus dezelfde class).
Ik heb nu een functie gemaakt die data stuurt naar het apparaat. Dit wordt nu via Synchronize(WriteData) aangeroepen. Nu wil ik graag een parameter meegeven aan Synchronize, b.v. Synchronize(WriteData,0,2). Ik heb nog nergens kunnen vinden of dit mogelijk is. Ik weet daarom ook niet of het kan.
Wat een andere optie kan zijn, is het van te voren(dus voor synchronize) de variabelen declareren. Op deze manier:

C++:

Target_Id = 2;
Host_Adapter = 10;

for(int x = 0; x <=10;x++)
{
Synchronize(WriteData);
}

In WriteData worden dan de Globale variabelen gebruikt. Echter ik kan me voorstellen dat als een 2e apparaat ook op dat moment gebruik maakt van de variabelen Targert_Id en Host_Adapter.
Hoe kan ik er voor zorgen dat via Synchronize (want dat maakt het Thread-Safe) een parameter meegestuurd kan worden?

[curry684]

Waar de n**k komt die Synchronize functie vandaan en waarom zou die dingen threadsafe maken?

[Coca-Cola]

Als ik het goed bergijp wil jij ervoor zorgen dat de globale variabelen die de ene thread gebruikt niet tegelijkertijd door een andere thread verandert kunnen worden?
Ik weet niet precies welke threads jij gebruikt, maar ik heb wat ervaring met PThreads en daar kan je een zogeheten Mutex variabele maken, en die kan je locken als 'ie gebruikt wordt in een thread, dan kan íe dus door een andere niet gebruikt worden. Als je er dan klaar mee bent dan unlock je 'm. Andere threads kan je dan laten wachten tot ze vrij zijn, of andere werk laten verichten terwijl ze wachten, wat jij wil.
Waar je in dit soort gevallen wel voor op moet passen is dat je niet in een zgn. deadlock terecht komt (als 2 threads op elkaar aan het wachten zijn en beide dan niet verder kunnen bv.)

[ Voor 15% gewijzigd door Coca-Cola op 26-11-2004 12:22 ]

[IJnte]

curry684 schreef op vrijdag 26 november 2004 @ 12:11:
Waar de n**k komt die Synchronize functie vandaan en waarom zou die dingen threadsafe maken?

Soz, ik gebruik C++ Builder 6.0 en ik maak gebruik van TThread. Als ik het goed gelezen heb, maak je met Synchronize een stukje code Thread safe(correct me if wrong). Ik heb er nog een hele zut code voorstaan(gewoon een standaard Thread object in C++), maar ik denk niet dat dit interesant is.
Straks moet al het I/O via deze threads lopen. Ik wil niet dat data door elkaar heen komt te lopen. Vandaar dat ik Synchronize gebruik. Ik wil hier ook Critical Sections in gaan maken, maar daar ben ik nog voor aan het studeren

[ Voor 19% gewijzigd door IJnte op 26-11-2004 12:51 ]

[curry684]

Euj Synchronize is geen pure synchronizatie, maar plaatst een User APC (Asynchronous Procedure Call) in de main thread. Pak gewoon TCriticalSection, roep Lock aan als je iets threadsafe moet benaderen, en Unlock als je klaar bent. Wel even exceptions tussendoor catchen zodat je niet vergeet te unlocken, anders knoopt de toko zich op.

[schoene]

Je kan Synchronize niet oproepen met extra parameters. je zal bvb properties aan je thread moeten toevoegen om die data op te slaan.

[ Voor 53% gewijzigd door schoene op 26-11-2004 13:57 ]

[IJnte]

mmm Ik ben er nu al een poosje mee bezig. Wat ik nu heb gedaan is het volgende (misschien wel ontzettend dom hoor):

Ik heb In plaats van een Synchronize functie een nieuwe Thread aangemaakt. In het mainform wordt er gewacht totdat die thread klaar is met uitvoeren. Hierover ben ik nog aan het denken (Event, en WaitForSingleObject). Ik krijg het alleen niet fatsoenlijk voor elkaar om variabelen te delen tussen de 2 threads die ik heb lopen. Dit is erg vervelend. Heeft iemand hier misschien tips voor? Ik ben nog druk aan het zoeken hoe dit werkt, maar ik loop momenteel daar gewoon op vast.

[farlane]

IJnte schreef op donderdag 02 december 2004 @ 16:24:
Ik krijg het alleen niet fatsoenlijk voor elkaar om variabelen te delen tussen de 2 threads die ik heb lopen.

In zun simpelste vorm een global die je benadert en locked met een critical section ( Zoals curry al aangaf )

[Verwijderd]

Het is voor mij al weer enige tijd geleden dat ik iets met threads gedaan heb, maar volgens mij gaf ik toen een pointer mee de thread in die verwees naar de data die ik wilde gebruiken in die thread. En op het moment dat je die data echt gebruikt in een thread hem te locken zoals eerder is beschreven.

Global variable is nu eenmaal niet echt het mooiste.

[IJnte]

Het werken met Critical Sections is denk ik niet het probleem. Ik heb een voorbeeld gemaakt zoals die in het "Borland C++ Builder 6 Developers Guide" is gemaakt. Ik snap hoe dit werkt gelukkig.
Het volgende moet eigenlijk gebeuren:

Ik heb nu een single threaded programma wat een apparaat op de SCSI bus aanstuurt dmv ASPI. Dit werkt allemaal vlekkeloos nu. Nu wordt nog 1 apparaat aangestuurd, maar ik wil er b.v. 2 aankunnen sturen. Het zal dus een I/O proces zijn. Elk apparaat moet dezelfde data krijgen, dus het zijn 2 identieke threads, met alleen een paar parameters (zoals SCSI ID en Blockgrote van data) die ingesteld moeten worden aan de hand van het type apparaat wat er aan hangt. Dit werkt allemaal perfect... Single Threaded.
Ik denk dat ik nu al wel 4 weken bezig ben, stukje bij beetje Threads te begrijpen. Ik heb erg veel progies voor mezelf gemaakt om met Threads te leren werken.

Echter het uitwisselen van Threads, en b.v. het wachten op een thread lukt mij gewoon weg niet. Ik heb gezocht, en heb iets gevonden maar dit werkt niet. Dit topic verklaart dat er een Wait() functie in TThread zit. Echter als ik dit in mijn programma gebruik dan wordt vrolijk verklaard dat Wait() geen onderdeel uitmaakt van TThread. Ik snap het dus even niet meer..
Wie kan mij wat meer uitleggen over het wachten op een thread, en eventueel een goede oplossing/tip geven voor mijn programma?

[.oisyn]

curry684 schreef op vrijdag 26 november 2004 @ 13:10:
Wel even exceptions tussendoor catchen zodat je niet vergeet te unlocken, anders knoopt de toko zich op.

En dus gooi je daarvoor een lock object op de stack wat bij construction de lock en bij destructon de unlock doet, zodat het automatisch exception safe is (en je bovendien ook niet per ongeluk zelf de unlock kunt vergeten)

[IJnte]

.oisyn schreef op donderdag 02 december 2004 @ 19:26:
[...]


En dus gooi je daarvoor een lock object op de stack wat bij construction de lock en bij destructon de unlock doet, zodat het automatisch exception safe is (en je bovendien ook niet per ongeluk zelf de unlock kunt vergeten)

Tot zover begrijp ik het gelukkig . Echter, hoe kan ik op een nette manier op een Thread wachten. Ik krijg dat Wait() niet voor elkaar.. WaitFor() werkt ook niet, omdat ik het niet voor elkaar krijg een andere thread in een thread aan te roepen . Ik ben al effies aan et zoeken, maar ik kan het gewoon niet vinden