设计模式-10-并发型设计模式

并发型设计模式并发型设计模式并发型设计模式并发型设计模式常见并发型设计模式Monitor Object设计模式Half-Sync/Half-Async设计模式Leader/Followers设计模式 Active Object设计模式Thread-Specific Storage 设计模式The Monitor Object PatternThis pattern synchronizes concurrent method execution to ensure that only one method at a time runs within an objectIt also allows an objects methods to cooperatively schedule their execution sequences2.*usesuses *Monitor ObjectMonitor Objectsync_method1()sync_methodN()Monitor LockMonitor Lockacquire()release()ClientClientMonitor ConditionMonitor Conditionwait()notify()notify_all()SolutionApply the Monitor Object design pattern (P2) to synchronize the queue efficiently & conveniently Its instructive to compare Monitor Object pattern solutions with Active Object pattern solutionsThe key tradeoff is efficiency vs. flexibilityMonitor Object Pattern Dynamics: MonitorObject: MonitorLock: MonitorConditionsync_method1()wait()dowork(): ClientThread1: ClientThread2acquire()dowork()acquire()sync_method2()release()notify()dowork()release()the OS thread schedulerautomatically suspendsthe client threadthe OS threadschedulerautomatically resumes the clientthread & thesynchronizedmethodthe OS thread scheduleratomically reacquiresthe monitor lockthe OS thread scheduleratomically releasesthe monitor lock1.Synchronized method invocation & serialization2.Synchronized method thread suspension3.Monitor condition notification4.Synchronized method thread resumptionThe Half-Sync/Half-Async PatternSyncServiceLayerAsyncService LayerQueueingLayerSync Service 1Sync Service 2Sync Service 3ExternalEvent SourceQueueAsync ServiceThe Half-Sync/Half-Async architectural pattern decouples async & sync service processing in concurrent systems, to simplify programming without unduly reducing performanceSolutionApply the Half-Sync/Half-Async architectural pattern (P2) to scale up server performance by processing different HTTP requests concurrently in multiple threads This solution yields two benefits:1.Threads can be mapped to separate CPUs to scale up server performance via multi-processing2.Each thread blocks independently, which prevents a flow-controlled connection from degrading the QoS that other clients receiveThis pattern defines two service processing layersone async & one syncalong with a queueing layer that allows services to exchange messages between the two layers: External EventSource: Async Service: Queuenotificationread()enqueue()message: Sync Servicework()messageread()messagework()notificationHalf-Sync/Half-Async Pattern DynamicsThe pattern allows sync services, such as HTTP protocol processing, to run concurrently, relative both to each other & to async services, such as event demultiplexingThe Leader/Followers PatternThis pattern eliminates the need for& the overhead ofa separate Reactor thread & synchronized request queue used in the Half-Sync/Half-Async patternThe Leader/Followers architectural pattern (P2) provides an efficient concurrency model where multiple threads take turns sharing event sources to detect, demux, dispatch, & process service requests that occur on the event sourcesHandlesHandle SetsConcurrent HandlesIterative HandlesConcurrent Handle SetsUDP Sockets + WaitForMultipleObjects()TCP Sockets + WaitForMultpleObjects()Iterative Handle SetsUDP Sockets + select()/poll()TCP Sockets + select()/poll()Handleusesdemultiplexes*Handle Sethandle_events()deactivate_handle()reactivate_handle()select()Event Handlerhandle_event ()get_handle()Concrete Event Handler Bhandle_event ()get_handle()Concrete Event Handler Ahandle_event ()get_handle()Thread Pooljoin()promote_new_leader()synchronizerLeader/Followers Pattern Dynamics: ConcreteEvent Handlerjoin()handle_event(): ThreadPool : HandleSetjoin()thread2 sleepsuntil it becomesthe leadereventthread1 sleepsuntil it becomesthe leaderdeactivate_handle()join()Thread1Thread2handle_events()reactivate_handle()handle_event()eventthread2waits for anew event,thread1processescurrenteventdeactivate_handle()handle_events()new_leader()1.Leader thread demuxing2.Follower thread promotion3.Event handler demuxing & event processing4.Rejoining the thread poolpromote_Supporting OO Async Communication (1/2)ContextSome clients want to invoke remote operations, continue their work, & retrieve the results at a later point in timeProblemUsing the explicit message-passing API of the Messaging pattern can reduce type-safety & performanceSimilar to motivation for Proxy pattern.ClientServerRequest messagesRequest messagesReply messagesSupporting OO Async Communication (2/2)SolutionApply the Active Object design pattern (P2) to decouple method invocation from method execution using a strongly-typed OO programming modelA proxy provides an interface that allows clients to access methods of an objectA concrete method request is created for every method invoked on the proxyA scheduler receives the method requests & dispatches them on the servant when they become runnableAn activation list maintains pending method requestsA servant implements