Afkortingen en conventies. Variabelen en voorwaardelijke instructie

De voorwaardelijke variabele kan worden gebruikt om de bovengenoemde synchronisatierelaties te implementeren: start-start (CC), finish-start (FS), start-finish (SF) en finish-finish (FF). Deze relatie kan bestaan ​​tussen threads van dezelfde of verschillende processen. Lijsten 5.4 en 5.5 tonen voorbeelden van het implementeren van FS- en FF-synchronisatierelaties. Elk voorbeeld definieert twee mutexen. Eén mutex wordt gebruikt om de toegang tot gedeelde gegevens te synchroniseren en de andere wordt gebruikt om de uitvoering van code te synchroniseren.

// Lijst 5.4. FS-synchronisatierelaties tussen:

// twee draden

pthread_t ThreadA, ThreadB;

pthread_cond_t Gebeurtenis;

leegte * arbeider1(nietig * X) (

voor (int Count = l; Count

pthread_mutex_lock (& ​​​​mutex);

pthread_mutex_unlock (& ​​​​mutex);

als (Getal == 50) (

pthread_cond_signal (& Gebeurtenis);

leegte * arbeider2(nietig * X) (

pthread_mutex_lock (& ​​​​EventMutex);

pthread_cond_wait (& Gebeurtenis, & EventMutex);

voor (int Aantal = 1; Aantal

pthread_mutex_lock (& ​​​​mutex);

Getal = Getal + 20;

pthread_mutex_unlock (& ​​​​mutex);

cout "" De uitvoering van de worker2-functie is beëindigd. " "Einde; retour (0);

int hoofd(int argc, char * argv) (

pthread_mutex_init (& Mutex, NULL);

pthread_mutex_init (& EventMutex, NULL);

pthread_cond_init (& Gebeurtenis, NULL);

pthread_create (& ThreadA, NULL, workerl, NULL);

pthread_create (& ThreadB, NULL, worker2, NULL);

Listing 5.4 toont een voorbeeld van een FS-synchronisatie-implementatie. ThreadA kan pas worden beëindigd als ThreadB is gestart. Als Nummer 50 wordt, meldt ThreadA dit aan ThreadB. Het kan nu doorgaan met de uitvoering tot het einde.ThreadB kan niet beginnen met de uitvoering totdat het een signaal van ThreadA ontvangt. ThreadB gebruikt een EventMutex-object samen met de voorwaardelijke variabele Event. Het Mutex-object wordt gebruikt om de toegang te synchroniseren om de waarde van de gedeelde variabele Number te schrijven. Een taak kan meerdere mutexen gebruiken om verschillende gebeurtenissen te synchroniseren en toegang te krijgen tot kritieke secties.

Een voorbeeld van de implementatie van FF-synchronisatierelaties wordt getoond in Listing 5.5.

// Lijst 5.5. FF-synchronisatierelaties tussen // twee threads

pthread_t ThreadA, ThreadB;

pthread_mutex_t Mutex, EventMutex;

pthread_cond_t Gebeurtenis;

void * workerl (ongeldig * X) (

voor (int Count = l; Count

pthread_mu tex_lock (& ​​​​mutex);

pthread_mutex_unlock (& ​​​​mutex);

cout "" workerl: nummer is "

pthread_mutex_lock (& ​​​​EventMutex), -

cout "" De workerl-functie is in behandeling. "" Endl;

pthread_cond_wait (& Gebeurtenis, & EventMutex);

pthread_mutex_unlock (& ​​​​EventMutex);

void * worker2 (void * X) (

voor (int Count = l; Count

pthread_mutex_lock (& ​​​​mutex);

Getal = Getal * 2;

pthread_mutex_unlock (& ​​​​mutex);

cout "" worker2: nummer is "" Nummer "endl;

pthread_cond_signal (& Gebeurtenis);

cout "" Functie worker2 stuurde een signaal "" endl;return (0);

int hoofd (int argc, char * argv) (

pthread_mutex_init (& Mutex, NULL);

pthread_mutex_init (& EventMutex, NULL);

pthread_cond_init (& Gebeurtenis, NULL);

pthread_create (& ThreadA, NULL, workerl, NULL);

pthread_create (& ThreadB, NULL, worker2, NULL);

In Listing 5.5 kan ThreadA niet eindigen totdat ThreadB is voltooid. ThreadA moet 10 keer herhalen en ThreadB moet 100 keer herhalen. ThreadA voltooit zijn iteraties vóór ThreadB, maar wacht totdat ThreadB aangeeft dat het is voltooid.

CC- en SF-timingsrelaties kunnen niet op deze manier worden geïmplementeerd. Deze methoden worden gebruikt om de poriën te synchroniseren ik ben uitvoertijd ik ben processen.

TAU - theorie van automatische besturing

TS - technisch systeem

ОУ - besturingsobject

UU - bedieningsapparaat

SU - besturingssysteem

IO - uitvoerend orgaan

IU - uitvoerend apparaat

D - sensor

OS - feedback

PC - overdrachtsverhouding

PF - overdrachtsfunctie

APFC - amplitude-fase frequentierespons

Frequentierespons - amplitude-frequentiekarakteristiek

LAFC - logaritmische amplitude-frequentiekarakteristiek

Fase-frequentiekarakteristiek - fase-frequentiekarakteristiek

2. Symbolen van basisvariabelen en functies

x(t) - ingangssignaal van CS-element, uitgangssignaal van OS en CS (gecontroleerde waarde)

ja(t) Is het uitgangssignaal van het CS-element, het ingangssignaal van het besturingssysteem (besturingsactie)

x s ( t) Is de instelling invloed van het besturingssysteem?

z(t) Is het storende effect op het besturingssysteem?

(t) - foutsignaal (mismatch) in het besturingssysteem

1(t) - actie in één stap

(t) - enkele impulsactie

x m ,ja m- amplitudewaarden van signalen x(t) en ja(t)

P - Laplace-operator, differentiatie-operator

 - circulaire frequentie, Fourier-transformatie-operator

x(P) - continu signaalbeeld x(t) volgens Laplace

x(J) - continue signaalweergave x(t) volgens Fourier

k - PC-link (of link-verbindingen)

W(P) - PF-link (of verbinding van links)

W(J) - AFC van een link (of verbinding van links)

EEN() - AFC van een link (of verbinding van links)

 () - fase-frequentiekarakteristiek van een link (of verbinding van links)

F ( R) - PF van gesloten regelsysteem

H(t) - tijdelijke functie (karakteristiek) van een link of besturingssysteem

met wie(t) - impuls (gewicht) functie (karakteristiek) van een link of CS

INVOERING

Automatische controle theorie (TAU)- een wetenschappelijke discipline, met als onderwerp informatieprocessen die plaatsvinden in besturingssystemen van technische en technologische objecten. TAU onthult de algemene werkingspatronen van automatische systemen van verschillende fysieke aard en ontwikkelt op basis van deze patronen de principes voor het bouwen van hoogwaardige controlesystemen.

Bij het bestuderen van regelprocessen in TAU abstraheren ze van de fysieke en ontwerpkenmerken van systemen en in plaats daarvan: echte systemen overweeg hun adequate wiskundige modellen. Hoe nauwkeuriger (vollediger) het wiskundige model overeenkomt met de fysieke processen die plaatsvinden in een echt systeem, hoe perfecter het geprojecteerde controlesysteem zal zijn.

De belangrijkste onderzoeksmethoden bij TAU zijn wiskundige modellering, theorie van gewone differentiaalvergelijkingen, operationele calculus en harmonische analyse. Laten we ze allemaal even kort bekijken.

Methode van wiskundige modellering, een combinatie van een breed scala aan methoden en technieken voor het beschrijven en presenteren van fysieke objecten en verschijnselen, kan voorwaardelijk, schematisch worden weergegeven met behulp van de meest gebruikte techniek - een grafische afbeelding van een eenvoudig object met één ingangssignaal x(t) en één uitgangssignaal ja(t), in de vorm van een rechthoek (Fig. B. 1, een). Symbool EEN binnen de rechthoek betekent een wiskundige operator (functie, integraal, enz.) Die de invoer- en uitvoersignalen verbindt die in de tijd veranderen.

Rijst. IN 1. Schematische weergave van wiskundige methoden die worden gebruikt in TAU

Theorie van gewone differentiaalvergelijkingen, gericht op de fysieke aspecten en toepassingen van de verkregen oplossingen, dient als de belangrijkste methodologische basis van TAU, en de gewone differentiaalvergelijkingen zelf zijn de meest algemene en volledige vorm van wiskundige beschrijving van elementen en controlesystemen. Differentiaalvergelijkingen relateren in de tijd variërende input- en outputvariabelen en hun afgeleiden. In het eenvoudigste geval heeft de differentiaalvergelijking de vorm

verdorie(t)/dt=F[x(t),ja(t)]. (IN 1)

Operationele rekenmethode, die is gebaseerd op de Laplace-transformatie

(IN 2)

stelt u in staat differentiaalvergelijkingen te algebraiseren - ga naar de zogenaamde operatorvergelijkingen die afbeeldingen verbinden x(P) en ja(P) van de ingangs- en uitgangssignalen via de overdrachtsfunctie W(P) (afb. B. 1, B)

W(P)=ja(P)/x(P). (OM 3 UUR)

Harmonische analysemethode is gebaseerd op de uit de wiskunde bekende Fouriertransformatie, die de vorm heeft

(OM 4)

Met behulp van de Fourier-transformatie (V. 4) worden de afbeeldingen gevonden x(J) en ja(J) ingangs- en uitgangssignalen x(t) en ja(t) karakteriseren van de frequentiespectra van deze signalen. De Fourier-afbeeldingen zijn gekoppeld (Figuur B. 1, v) frequentie overdrachtsfunctie

W(J) = Y (j ) / X (j ). (OM 5 UUR)

Alle vier methoden, hierboven kort weergegeven, vormen het wiskundige apparaat van TAU. Op basis hiervan is een complex van "eigen" methoden van TAU ontwikkeld, gepresenteerd in deze cursus.

TAU vormt samen met de theorie van constructie en werking van elementen van besturingssystemen (sensoren, regelaars, actuatoren), een bredere tak van wetenschap - automatisering. Automatisering is op zijn beurt een van de takken van technische cybernetica. Technische cybernetica bestudeert complexe geautomatiseerde controlesystemen voor technologische processen (APCS) en ondernemingen (APCS), gebouwd met behulp van controlecomputers (CFM).

Technische cybernetica, samen met biologische en sociaaleconomische, is een integraal onderdeel van cybernetica, dat de oprichter, de Amerikaanse wiskundige N. Wiener, in 1948 definieerde als de wetenschap van management en communicatie in technische systemen en levende organismen.

De eerste industriële regelaars verschenen tussen 1765 en 1804. (I. Polzunov, J. Watt, J. Jacquard).

De eerste theoretische studies van regelgevers verschenen in de periode 1868-1893. (J. Maxwell, I. Vyshnegradsky, A. Stodola). De Russische wetenschapper en ingenieur I.A.Vyshnegradskiy voerde een aantal wetenschappelijk onderzoek, waarin de stoommachine en zijn regelaar eerst door wiskundige methoden werden geanalyseerd als een enkel dynamisch systeem. De werken van A.A. Andronov, V.S. Kulebakin, I.N. Voznesensky, B.V. Boelgakov, A.A. Feldbaum, B.N. Petrov, N.N. Krasovsky speelden een belangrijke rol bij de vorming van de Russische school van TAU , AA Voronova, Ya. Z. Tsypvakina, .VS Pugachekina ..

De ontwikkeling van de moderne regeltheorie vanuit de zogenaamde "klassieke" regeltheorie, gebaseerd op de vier bovengenoemde fundamentele onderzoeksmethoden van TAU, en de vorming van de nieuwste methoden worden schematisch geïllustreerd in Fig. IN 2.

Rijst. IN 2. Ontwikkeling van de inhoud en methodologie van managementtheorie

Momenteel, TAU, samen met nieuwste secties algemene managementtheorie (operationeel onderzoek, systeemtechniek, speltheorie, wachtrijtheorie) speelt een belangrijke rol bij het verbeteren en automatiseren van het beheer van technologische processen en industrieën.

Voorwaardelijke variabelen

Een voorwaardevariabele (condvar - afkorting van voorwaardevariabele) wordt gebruikt om een ​​thread voor elke voorwaarde te blokkeren tijdens de uitvoering van een kritiek gedeelte van de code. De voorwaarde kan zo complex zijn als u wilt en is niet afhankelijk van de voorwaardelijke variabele. Een conditievariabele moet echter altijd worden gebruikt in combinatie met een mutex om op een conditie te testen.

Voorwaardelijke variabelen ondersteuning volgende functies::

Wachten op een voorwaardelijke variabele (wait) ( pthread_cond_wait ());

Enkele stream deblokkeren (signaal) ( pthread_cond_signal ())

Meerdere streams deblokkeren (uitzending) ( pthread_cond_broadcast ()),

Laten we een voorbeeld geven typisch gebruik voorwaardelijke variabele:

pthread_mutex_lock (& ​​​​m); - ...

terwijl (! willekeurige voorwaarde) (

pthread_cond_wait (& cv, & m);

pthread_mutex_unlock (& ​​m);

In dit voorbeeld vindt het vastleggen van de mutex plaats voordat de voorwaarde wordt gecontroleerd. De aangevinkte voorwaarde is dus alleen van toepassing op de huidige thread. Doei gegeven voorwaarde is waar, dit gedeelte van codeblokken op de wachtaanroep totdat een andere thread een enkele of meerdere thread-deblokkeringsbewerking uitvoert op een voorwaardelijke variabele.

Herhalingslus in het bovenstaande voorbeeld is om twee redenen vereist. Aanvankelijk, posix-normen garanderen niet de afwezigheid van vals ontwaken (bijvoorbeeld in systemen met meerdere processors). Ten tweede, als een andere thread de voorwaarde wijzigt, moet u deze opnieuw testen om er zeker van te zijn dat de wijziging aan de geaccepteerde criteria voldoet. Wanneer een wachtende thread wordt geblokkeerd, wordt de mutex die is gekoppeld aan de voorwaardelijke variabele atomair vrijgegeven door de functie pthread_cond_wait () zodat een andere thread een cruciaal deel van de programmacode kan invoeren.

Een thread die een enkele thread ontgrendelt, ontgrendelt de thread met hoogste prioriteit die in de wachtrij staat voor een voorwaardelijke variabele. Een ontgrendelingsbewerking met meerdere threads ontgrendelt alle threads die in de wachtrij staan ​​op een voorwaardelijke variabele. De mutex die is gekoppeld aan de voorwaardelijke variabele wordt vrijgegeven door de atomair gedeblokkeerde thread met de hoogste prioriteit. Na het verwerken van een kritiek gedeelte van de code, moet deze thread de mutex vrijgeven.

Een ander soort bewerking die wacht op een voorwaardelijke variabele ( pthread__cond_timedwair ()) kunt u een time-out instellen. Aan het einde van deze periode kan de wachtende thread worden gedeblokkeerd.

Belemmeringen

Een barrière is een synchronisatiemechanisme waarmee u het werk van verschillende op elkaar inwerkende threads zo kunt coördineren dat elk ervan stopt bij setpunt wachtend op de rest van de threads voordat hij verder gaat met zijn werk.

In tegenstelling tot de functie pthreadjoin () waarin een draad wacht tot een andere draad is voltooid, dwingt de barrière de draden voldoen aan v een bepaald punt... Nadat het opgegeven aantal draden de ingestelde barrière heeft bereikt, alle deze threads zullen deblokkeren en hun werk voortzetten. De barrière wordt gemaakt met behulp van de functie pthread_barrier_init ():

#erbij betrekken

pthread_barrier_init (pthread_barrier_t * barrier, const pthread_barrierattr_t * attr, unsigned int count);

Als resultaat van het uitvoeren van deze code wordt een barrière gemaakt op het opgegeven adres (de wijzer naar de barrière staat in het barrière-argument) en met de attributen die zijn ingesteld door het attr-argument. Het argument count specificeert het aantal threads dat pthread_barrier_wait () moet aanroepen.

Nadat de barrière is gemaakt, roept elke thread de functie pthread_barrier_wait () aan, waarmee de voltooiing van deze actie wordt aangegeven:

#erbij betrekken

int pthread_barrier_wait (pthread_barrier_t "barrière);

Wanneer de thread de functie aanroept pthread_barrier_wait (), het blokkeert tot het aantal threads dat is opgegeven door de functie pthread_barrier_init (), zal de functie niet aanroepen pthread_jbarrier_wait () en wordt dienovereenkomstig niet geblokkeerd. Na het opgegeven aantal threads roept de functie pthread_barrier_wait (), ze ontgrendelen allemaal tegelijkertijd.

#erbij betrekken

#erbij betrekken

#erbij betrekken

#erbij betrekken

pthread_barrier_t barrière; // synchronisatie-object van het type "barrière"

main () // negeer argumenten

time_t now; // maak een barrière met een tellerwaarde van 3

pthread_barrier_init (& barrière, NULL, 3); // start twee threads - threadl en thread2

pthread_create (NOLL, NOLL, threadl, NULL); // threads threadl en thread2 worden uitgevoerd

pthread_create (NDLL, NDLL, thread2, NDLL); // wacht op voltooiing

printf ("hoofd () wachten op barrière bij% s ", ctime (& nu));

pthread_barrier_wait (& barrier); // na dit punt worden alle drie de threads beëindigd

printf ("barrière in mainO gedaan op% s", ctime (& nu));

threadl (ongeldig * niet gebruikt)

tijd nu); // voer berekeningen uit

printf ("threadl vanaf% s", ctime (& nu)); // pause

pthread_barrier_wait (& barrier); // na dit punt worden alle drie de threads beëindigd

printf ("barrière in threadl () gedaan op% s", ctime (& nu));

thread2 (ongeldig * niet__gebruikt)

tijd nu); // voer berekeningen uit

printf ("thread2 beginnend bij% s", ctime (& nu)); // pause

pthread_barrier_wait (& barrière);

// na dit punt zijn alle drie de threads klaar

printf ("barrière in thread2 () gedaan op% s", ctime (& nu));

In het voorbeeld uit de lijst creëert de hoofdthread een barrière, waarna het begint met het tellen van het aantal geblokkeerde threads op de synchronisatiebarrière. V deze zaak het aantal gesynchroniseerde threads is ingesteld op 3: hoofd () thread, thread1 () en thread2 ().

Thread1 () en thread2 () worden gestart. Voor de duidelijkheid is er een pauze in de stream gezet om het rekenproces te simuleren. Om synchronisatie uit te voeren, blokkeert de hoofdthread op de barrière en wacht op een deblokkering die plaatsvindt nadat de andere twee threads niet op deze barrière zijn aangesloten.

Hangende sloten

Sleepon-sloten werken op dezelfde manier als voorwaardelijke variabelen, op enkele details na. Zoals voorwaardelijke variabelen die wachten op vergrendelingen ( pthread_sleepon_lock ()) kan worden gebruikt om een ​​thread te blokkeren totdat een voorwaarde waar wordt (vergelijkbaar met het wijzigen van de waarde van een geheugenlocatie). Maar in tegenstelling tot voorwaardelijke variabelen (die voor elke geteste voorwaarde moeten bestaan), worden lopende vergrendelingen toegepast op één mm.text en een dynamisch gecreëerde voorwaardelijke variabele, ongeacht het aantal geteste voorwaarden. Het maximale aantal voorwaardelijke variabelen is uiteindelijk gelijk aan Maximaal nummer geblokkeerde draden.

Voorwaardelijke variabelen

Voorwaardelijke variabele is een semafoor die wordt gebruikt om een ​​gebeurtenis aan te geven die heeft plaatsgevonden. Een of meer processen (of threads) van andere processen of threads kunnen wachten op een signaal dat er een gebeurtenis heeft plaatsgevonden. U moet het verschil begrijpen tussen voorwaardelijke variabelen en de hierboven besproken mutex-semaforen. Het doel van de mutex-semafoor en lees-/schrijfvergrendelingen is om gegevenstoegang te synchroniseren, terwijl conditievariabelen doorgaans worden gebruikt om een ​​reeks bewerkingen te synchroniseren. Bij deze gelegenheid, in zijn boek UNIX-netwerkprogrammering W. Richard Stevens verwoordde het heel goed: “ Mutexen moeten worden gebruikt voor blokkeren, niet voor wachten ».

In listing 4.6 bevatte de consumentenstroom een ​​lus:

15 while (TextFiles.empty ())

De "consumenten"-thread herhaalde de lus tot de wachtrij Tekstbestanden er waren elementen. Deze lus kan worden vervangen door een voorwaardelijke re m ergeren. De producententhread informeert de consument met een signaal dat items in de wachtrij zijn geplaatst. De consumententhread kan wachten tot het een signaal ontvangt en gaat dan verder met het verwerken van de wachtrij.

De voorwaardelijke variabele is van het type pthread_cond_t. Dit zijn de soorten bewerkingen die het kan uitvoeren:

initialisatie;

Verwoesting;

Verwachting;

Wachten met een tijdslimiet;

Adresseerbare signalering;

Algemeen alarm;

Initialisatie- en vernietigingsbewerkingen worden uitgevoerd door conditievariabelen, vergelijkbaar met die van andere mutexen. Klasse functies pthread_cond_t, die deze bewerkingen implementeren, staan ​​​​vermeld in de tabel. 5.7.

Tabel 5.7. Functies van de klasse pthread_cond_t die de bewerkingen van voorwaardelijke variabelen implementeren

Voorwaardelijke variabelen worden gebruikt in combinatie met mutexen. Als u een mutex probeert te vergrendelen, wordt de thread of het proces geblokkeerd totdat de mutex wordt vrijgegeven. Na het deblokkeren zal de thread of het proces de mutex ontvangen en zijn werk voortzetten. Wanneer u een voorwaardelijke variabele gebruikt, moet deze aan een mutex zijn gebonden.

pthread_mutex_lock (& ​​​​mutex);

pthread_cond_wait (& EventMutex, & Mutex);

pthread_mutex_unlock (& ​​​​mutex);

Dus een taak doet een poging om de mutex te vergrendelen. Als de mutex al is vergrendeld, is deze taak geblokkeerd. Na ontgrendeling zal de taak de mutex vrijgeven Mutex en tegelijkertijd wacht het op een signaal voor de voorwaardelijke variabele EventMutex . Als de mutex niet is vergrendeld, wacht de taak voor onbepaalde tijd op een signaal. Bij het wachten met een tijdslimiet, zal de taak wachten op een signaal binnen het gespecificeerde tijdsinterval. Als deze tijd verstrijkt voordat de taak een signaal ontvangt, retourneert de functie een foutcode. De taak zal dan opnieuw de mutex opvragen.

Door adressignalering uit te voeren, meldt een taak een andere thread of proces dat er een gebeurtenis heeft plaatsgevonden. Als een taak wacht op een signaal voor een bepaalde voorwaardelijke variabele, wordt die taak ontgrendeld en ontvangt een mutex. Als meerdere taken tegelijk wachten op een signaal voor een bepaalde voorwaardelijke variabele, wordt er maar één ontgrendeld. De rest van de taken wachten in de wachtrij en worden gedeblokkeerd volgens de gebruikte planningsstrategie. Wanneer een globale signaleringsbewerking wordt uitgevoerd, ontvangen alle taken die wachten op een signaal voor de gespecificeerde conditievariabele een melding. Wanneer meerdere taken zijn ontgrendeld, strijden ze om het eigendom van de mutex volgens de gebruikte planningsstrategie. In tegenstelling tot de wachtbewerking, claimt de signaleringstaak geen eigendom van de mutex, hoewel dit wel zou moeten.

De voorwaardelijke variabele heeft ook een attribuutobject, waarvan de functies in de tabel worden vermeld. 5.8.

Tabel 5.8. Attribuut object accessor functies voor een voorwaardelijke variabele van het pthread_cond_t type

Int pthread_condattr_init(pthread_condattr_t * attr) Initialiseert het voorwaardelijke variabele attribuutobject gespecificeerd door attr naar standaardwaarden voor alle implementatie-gedefinieerde attributen;

Int pthread_condattr_destroy(pthread_condattr_t * attr); Vernietigt het voorwaardelijke variabele attribuutobject gespecificeerd door de attr parameter. Dit object kan opnieuw worden geïnitialiseerd door pthread_condattr_init () aan te roepen

Int pthread_condattr_setpshared(pthread_condattr_t * attr, int pshared);

Int pthread_condattr_getpshared(const pthread_condattr_t * beperk attr, int * beperk pshared); Stelt het procesgedeelde attribuut in of retourneert het attribuutobject van een voorwaardelijke variabele. gegeven door de parameter attr. De parameter pshared kan de volgende waarden bevatten:

PTHREAD_PROCESS_SHARED(staat lees-schrijfvergrendelingen toe die worden gedeeld door alle threads die toegang hebben tot het geheugen dat is toegewezen aan deze voorwaardelijke variabele, zelfs als de threads tot verschillende processen behoren);

PTHREAD_PROCESS_PRIVATE(Voorwaardelijke variabele wordt gedeeld tussen threads van hetzelfde proces)

Int pthread_condattr_setclock(pthread_condattr_t * attr, clockid_t clock_id);

Int pthread_condattr_getclock(const pthread_condattr_t * beperk attr, clockid_t * beperk klok_id); Stelt een attribuut in of geeft het terug klok het attribuutobject van de voorwaardelijke variabele gespecificeerd door de parameter attr... Attribuut klok is de identificatie van de klok die wordt gebruikt om de tijdslimiet te meten in de functie pthread_cond_timedwait (). Standaard gebruikt het klokkenmerk de systeemklok-ID.

Aankondiging

Variabele Is een hoeveelheid die een naam en betekenis heeft. Variabelen worden gedeclareerd met het woord var: var x = 12, y; Hier worden twee variabelen met de namen x en y geïntroduceerd, de waarde 12 wordt naar de variabele x geschreven en de variabele y is niet gedefinieerd, dat wil zeggen het traceercommando trace (y); retourneert undefined (ongedefinieerde waarde). De opdracht trace (z) levert hetzelfde resultaat op; omdat de variabele z helemaal niet bekend is. Om een ​​bestaande variabele te onderscheiden van een onbekende, kun je een speciale nul schrijven nul: var y = null;

Als het type van de variabele niet expliciet is opgegeven, kan deze elke waarde aannemen. Bijvoorbeeld:

Bij het declareren is het echter beter om het type variabele expliciet te specificeren. Hierdoor kunnen veel fouten worden gedetecteerd nog voordat het programma wordt uitgevoerd. Er zijn drie eenvoudige soorten:

• Nummer - nummer;
• Tekenreeks - tekenreeks;
• Boolean is een booleaanse waarde.

Als u een waarde van het verkeerde type naar een variabele probeert te schrijven, ontvangt u onmiddellijk een foutmelding wanneer het programma wordt vertaald (dat wil zeggen, wanneer het wordt vertaald in machinecodes), en niet tijdens runtime. Code als deze geeft bijvoorbeeld een foutmelding:

Variabele zichtbaarheid

Er zijn drie soorten variabelen: Globale variabelen worden gedeclareerd met de _global specificatie: _global .x = 12; Merk op dat u het woord var hier niet hoeft te gebruiken, dergelijke variabelen worden behandeld als eigenschappen van het _global object. De variabele x, die hierboven is gedeclareerd, is toegankelijk vanuit elke functie en vanuit de code van elke clip, gewoon op naam.

Als er meerdere variabelen met dezelfde naam in het bereik zijn, wordt eerst de lokale variabele doorzocht, dan de huidige clipvariabele en pas daarna de globale variabele.

Variabelen van andere clips zijn niet "zichtbaar"; om ernaar te verwijzen, moet u expliciet de bovenliggende clip specificeren:

Mc.x = 1; _root .x = 12; _ouder .x = 123;

Opdracht

Gebruik het = teken om een ​​nieuwe waarde aan een variabele toe te kennen. Links ervan schrijf je de naam van de variabele, en rechts - de uitdrukking: a = 4 * (c + 2) + 3 / (r - 4 * w) + d% 3; Het *-teken staat voor vermenigvuldiging, het /-teken voor deling en% geeft de rest van de deling aan.

In een uitdrukking worden rekenkundige bewerkingen in de volgende volgorde uitgevoerd:

• acties tussen haakjes;
• vermenigvuldigen, delen en de rest nemen (van links naar rechts);
• optellen en aftrekken (van links naar rechts).

Tekenreeksen kunnen worden "aaneengeschakeld" met de operator +:

Nee = 20; s = "Vasya" + "ging wandelen." ; qq = "Object" + nee; Als er gegevens van verschillende typen bij de uitdrukking betrokken zijn, vindt er een automatische conversie plaats naar hetzelfde type. Dus in de laatste regel wordt de regel Object20 naar de variabele qq geschreven.

Operators ++ ( increment, waarbij de variabele met 1 wordt verhoogd en - ( verlagen, waardoor de variabele met 1) wordt verlaagd. Operators

ik ++; k-; hetzelfde betekenen als i = i + 1; k = k - 1; Er is ook een verkorte notatie voor rekenkundige bewerkingen: a + = 20; b- = c-d; c * = a + b; d / = 2 * c; f% = 12; Deze code kan worden vervangen door de volgende operatoren in "normale" vorm: a = a + 20; b = b - (c - d); c = c * (a + b); d = d / (2 * c); f = f% 12

Voorwerpen

Een object is iets dat eigenschappen en methoden heeft. In het milieu Flash er zijn ingebouwde objecten (bijvoorbeeld Array, MovieClip, Key). Bovendien kun je je eigen objecten bouwen: var car = new Object (); auto.v = 10; auto.jaar = 1998; In het milieu Flash u kunt objectgeoriënteerd programmeren gebruiken, dat wil zeggen, uw eigen objectklassen maken, deze voorzien van eigenschappen en methoden (zie onderwerp 13).

Het belangrijkste kenmerk van objecten is de zogenaamde referentieadressering. Dat wil zeggen, bij het declareren