Egyszálú végrehajtás
Az oldal jelenlegi verzióját még nem ellenőrizték tapasztalt közreműködők, és jelentősen eltérhet a 2019. május 22-én felülvizsgált
verziótól ; az ellenőrzések 4 szerkesztést igényelnek .
Az egyszálú végrehajtás ( eng. Single Threaded Execution vagy eng. Critical Section [1] ) egy párhuzamos tervezési minta , amely megakadályozza a versengő metódushívást, ezáltal megtiltja ennek a metódusnak a párhuzamos végrehajtását.
Motívumok
- Az osztály olyan metódusokat tartalmaz, amelyek frissítik vagy beállítják az osztálypéldányváltozók vagy osztályváltozók értékeit.
- A módszer olyan külső erőforrásokat kezel, amelyek egyszerre csak egy műveletet támogatnak.
- Az osztálymetódusokat különböző szálak hívhatják meg párhuzamosan.
- Nincs időkorlát, amely megkövetelné, hogy a metódus azonnal végrehajtódjon, amint meghívják.
Következmények
- + Menetbiztonságot nyújt
- − A teljesítmény csökkenhet
- − Reteszelés lehetséges
Megvalósítási példa
C# példa
a rendszer használatával ;
a System.Threading használatával ;
névtér Digital_Patterns.Concurrency.Single_Thread_Execution
{
/// <summary>
/// A <see cref="TrafficSensor"/> osztály példányai egy forgalom /// forgalomérzékelőhöz vannak társítva
, amely rögzíti egy adott hely elhaladását a
// // egy forgalmi sáv.
/// </summary>
class TrafficSensor
{
private static Int32 mID = 0 ;
privát ITrafficObserver _observer ;
public Boolean IsRun { get ; készlet ; }
privát Int32_id ; _
/// <summary>
/// Konstruktor
/// </summary>
/// <param name="observer">Objektum, amely jelzi, hogy
/// az objektumhoz társított forgalomérzékelő
/ // elhaladó autót észlel .</param>
public TrafficSensor ( ITrafficObserver megfigyelő )
{
_id = ++ mID ;
_observer = megfigyelő ;
IsRun = igaz ;
új szál ( Futtatás ). Indítás ();
}
/// <summary>
/// Általános logika az objektum szálához
/// </summary>
private void Run ()
{
while ( IsRun )
{
motorSensor ();
}
}
privát statikus Véletlen mRnd = új Véletlenszerű ();
/// <summary>
/// Ez a metódus meghívja az objektum észlelési metódusát, amikor /// a hozzá tartozó forgalomérzékelő
/// elhaladó autót észlel
/// </summary> private void motorSensor () { //TODO Valami szál . Alvás ( mRnd . Következő ( 1000 )); msg = Rendszer _ _ tükrözés . MethodInfo . Get CurrentMethod (). név ; Konzol . WriteLine ( String . Formátum ( @"{0} {1} +1" , _id , msg ));
észlel ();
}
/// <summary>
/// Ezt a módszert a <see cref="motitorSensor"/> metódus hívja
///, hogy jelentse a jármű elhaladását
/// az objektum megfigyelőjének
/// </summary >
private void detect ()
{
_observer . vehiclePassed ();
}
/// <summary>
/// Az osztályoknak implementálniuk kell ezt a felületet,
/// hogy a <see cref="TrafficSensor"/> objektum tájékoztassa őket az elhaladó
/// járművekről
/// </summary>
nyilvános felület ITrafficObserver
{
/ // <summary>
/// Akkor hívják, ha a <see cref="TrafficSensor"/> //>
egy elhaladó járművet észlel.
/// </summary>
void vehiclePassed ();
}
}
}
a rendszer használatával ;
névtér Digital_Patterns.Concurrency.Single_Thread_Execution
{
/// <summary>
/// A <see cref="TrafficSensorController"/> osztály példányai tárolják az aktuális /// a
kapcsolódó forgalomérzékelők /// mellett elhaladó járművek számát.
példa.
/// </summary>
osztály TrafficSensorController : TrafficSensor . ITrafficObserver
{
private Int32 _vehicleCount = 0 ;
/// <összefoglaló>
/// Ezt a módszert akkor hívják meg, ha a forgalom
/// jármű mozgásérzékelője egy autó elhaladását érzékeli. Eggyel növeli
/// a gépszámlálót.
/// </summary>
public void vehiclePassed ()
{
lock ( this )
{
++ _vehicleCount ;
}
}
/// <summary>
/// Nullára állítja az autószámlálót
/// </summary>
/// <returns></returns>
public Int32 GetAndClearCount ()
{
lock ( this )
{
Int32 count = _vehicleCount ;
_vehicleCount = 0 ;
visszatérési szám ;
}
}
}
}
a rendszer használatával ;
a System.Threading használatával ;
névtér Digital_Patterns.Concurrency.Single_Thread_Execution
{
/// <summary>
/// A <see cref="TrafficTransmitter"/> osztály példányai felelősek azért, hogy
/// olyan értéket adjanak át, amely meghatározza az ezen áthaladó autók számát
/// út percenként.
/// </summary>
class TrafficTransmitter
{
private TrafficSensorController _conrtoller ;
privát szál _myThread ;
public Boolean IsRun { get ; készlet ; }
/// <summary>
/// Konstruktor
/// </summary>
/// <param name="conrtoller">A <see cref="TrafficSensorController"/>-től ez az objektum
/// megkapja a számláló értékét áthaladt
/ // autók száma</param>
public TrafficTransmitter ( TrafficSensorController conrtoller )
{
_conrtoller = conrtoller ;
_myThread = új szál ( Futtatás );
IsRun = igaz ;
_myThread . Indítás ();
}
/// <summary> ///
Az időintervallumban áthaladt gépek számának számlálójának átadása ///
/// </summary> private void Run () { while ( IsRun ) { Thread . Alvás ( 10000 ); Átvitel ( _conrtoller . GetAndClearCount ()); } }
private void Átvitel ( Int32 count )
{
//TODO Valami
var msg = Rendszer . tükrözés . MethodInfo . Get CurrentMethod (). név ;
Konzol . WriteLine ( String . Formátum ( @"{0} {1}" , msg , count ));
}
}
}
a rendszer használatával ;
a Digital_Patterns.Concurrency.Single_Thread_Execution használatával ;
névtér Digital_Patterns
{
class Program
{
static void Main ( string [] args )
{
var controller = new TrafficSensorController ();
var adó = new TrafficTransmitter ( vezérlő );
Konzol . WriteLine ( @"Nyomja meg bármelyik gombot az indításhoz, és nyomja meg újra a befejezéshez" );
Konzol . ReadKey ();
var sensor1 = új TrafficSensor ( vezérlő );
var sensor2 = új TrafficSensor ( vezérlő );
Konzol . ReadKey ();
érzékelő1 . IsRun = false ;
érzékelő2 . IsRun = false ;
adó . IsRun = false ;
Konzol . writeLine ();
}
}
}
Linkek
- Mark grand. Minták a Java-ban 1. kötet: UML-lel illusztrált, újrafelhasználható tervezési minták katalógusa. - Wiley & Sons, 1998. - 480 p. — ISBN 0471258393 . (lásd az összefoglalót (angol) )