The Concurrency Viewpoint

Size: px

Start display at page:

Download "The Concurrency Viewpoint"

Warren Richards
5 years ago
Views:

1 The Concurrency Viewpoint

2 View Relationships The Concurrency Viewpoint 2

3 The Concurrency Viewpoint Definition: The Concurrency Viewpoint: describes the concurrency structure of the system and maps functional elements to concurrency units to clearly identify: the parts of the system that can execute concurrently and how this is coordinated and controlled Applicability: All information systems with a number of concurrent threads of execution The Concurrency Viewpoint 3

4 The Concurrency Viewpoint 4

5 Information systems and Control systems Historically, information systems were designed to operate with little or no concurrency, running via batch mode on large central computers. Today s information systems often have little or no batch processing and are inherently concurrent, because of: distributed systems, increasing workloads, cheap multiprocessor hardware, etc. In contrast, control systems have always been inherently concurrent and event-driven, given their need to react to external events in order to perform control operations. As information systems became more concurrent and eventdriven, they started to take on a number of characteristics traditionally associated with control systems. The information systems community has naturally adapted proven concurrency techniques from the control systems community. The Concurrency Viewpoint 5

6 Activities to achieve concurrency To design the concurrency structure, you need to: Create a process model and a state model: The process model shows the planned process, thread, and interprocess communication structure; The state model describes the set of states that runtime elements can be in and the valid transitions between those states. Use analysis techniques to ensure that the planned concurrency scheme is sound. The Concurrency Viewpoint 6

7 Hidden Concurrency Not all information-based systems really benefit from a Concurrency view. Some information systems have little concurrency. Others, while exhibiting concurrent behavior, use the facilities of underlying frameworks and containers to hide the concurrency model in use: Databases concurrent multi-user operation usually mandatory Application servers allow to run multiple systems concurrently Containers for example, Servlets containers automatically starts a new thread upon new client request; EJB container creates new bean instances for each new thread Frameworks for example, Java SE 7 Fork/Join framework New paradigms have concurrency built-in for example, Agent Technology based systems run each agent on a separate thread For example: Akka The Concurrency Viewpoint 7

8 Concerns Process/Thread Structure Mapping of Functional Elements to Processes/Threads Interprocess Communication Mechanisms (IPC) State Management Synchronization and Integrity (ensuring Consistency) Supporting Scalability Startup and Shutdown Process/Thread Failure Reentrancy (= thread-safety) The Concurrency Viewpoint 8

9 Interprocess Communication Mechanisms (IPC) Procedure call mechanisms: remote procedure call (RPC) or some sort of invocation of remote functionality Messaging mechanisms: queuing: first in, first out queue structure publish/subscribe: the consumers indicate the types of messages that they are interested in and publishers distribute messages to all interested consumers Data-sharing mechanisms: shared memory, distributed caches, client/server databases, shared file storage. The Concurrency Viewpoint 9

10 System-Level Concurrency Models It shows how functional elements are mapped to processes/threads, and typically contains the following items: Processes: The term process refers to an operating system process, that is, an address space that provides an execution environment for one or more independent threads of execution. The processes are normally assumed to be isolated from each other so that if one process wants to affect the execution of another, it must use an interprocess communication mechanism. Process groups: abstraction that allows less important concurrency concerns to be deferred until subsystem design Threads: Threads are normally represented in process models via a decomposition of a process. Interprocess communication: often processes do need to interact in order to coordinate their execution, request services from each other, and pass information among themselves The Concurrency Viewpoint 10

11 System-Level Concurrency Models: UML Notation UML has a notion of an active object/component ipc inter-process communication The Concurrency Viewpoint 11

12 System-Level Concurrency Models: Informal Notation The Concurrency Viewpoint 12

13 System-Level Concurrency Models: Activities Map the Functional Elements to the Processes/Threads Concurrency adds complexity to the system and adds significant overhead to inter-element communication when it must cross process boundaries. Concurrency should be introduced only where it is actually needed for distribution, scalability, isolation, or other reasons Protect Shared Resources Locking/synchronization Define the IPC Mechanisms to Use Better still is using a library or framework to avoid having to deal with a lot of this complexity yourself The Concurrency Viewpoint 13

14 System-Level Concurrency Models: Activities Assign Priorities to Threads and Processes Analyze Deadlocks Presence of shared resources => possibility of deadlock There is a number of modeling and analysis techniques to try to spot potential deadlocks Petri Net Analysis Analyze Contention Contention occurs when more than one task requires a shared resource concurrently The Concurrency Viewpoint 14

15 State Models A state model is used to describe: the set of states that a system s functional runtime elements can be in and the valid transitions between the states The Concurrency Viewpoint 15

16 Common Problems: Race Condition A race condition is problematic behavior that results from unexpected dependence on the relative timing of events It usually occurs when two or more tasks are attempting to perform the same action concurrently. The tasks race for the resource, and the first one to reach the appropriate point in the program code wins and performs the action Race conditions are problematic only when they are unplanned because the system has not been designed to cope with more than one task performing the action concurrently. In these cases, information can be corrupted or lost, and the system can behave in unpredictable ways The Concurrency Viewpoint 16

17 Race Condition The Concurrency Viewpoint 17

18 System level versus Use case level concurrency System level concurrency: Process structure + IPC mechanisms Use case level concurrency: Threads Concurrency patterns Producer-Consumer, Pipeline, Work pool, Map-Reduce, Fork- Join, etc. The Concurrency Viewpoint 18

19 Concurrency Pattern: Fork/Join The Concurrency Viewpoint 19

Concurrency pattern: Pipeline https://msdn.microsoft.

20 Concurrency pattern: Pipeline The Concurrency Viewpoint 20

21 Concurrency pattern: Pipeline The Concurrency Viewpoint 21

22 Concurrency pattern: Pipeline The Concurrency Viewpoint 22

23 Concurrency pattern: Pipeline The Concurrency Viewpoint 23

Chapter 4: Threads. Overview Multithreading Models Thread Libraries Threading Issues Operating System Examples Windows XP Threads Linux Threads

Chapter 4: Threads. Overview Multithreading Models Thread Libraries Threading Issues Operating System Examples Windows XP Threads Linux Threads Chapter 4: Threads Overview Multithreading Models Thread Libraries Threading Issues Operating System Examples Windows XP Threads Linux Threads Chapter 4: Threads Objectives To introduce the notion of a