CSC/ECE 517 Fall 2009/wiki2 14 conc patterns - Revision history

Knrajwan: /* Producer/Consumer Pattern */

2009-10-10T01:38:57Z

Producer/Consumer Pattern

← Older revision		Revision as of 01:38, 10 October 2009
Line 251:		Line 251:

	In the above example, Specialist class is a producer which produces objects that are consumed by Consumer objects asynchronously. A Producer object could produce an object when all Consumer objects are busy processing other objects. In this case, the objects are pushed in the queue which acts as a buffer for objects produced by Specialist class. The objects remain there until a Consumer object pulls them out of the queue. If the queue is empty, the Consumer object waits until the Producer adds new object to the queue. The relationship between Producer-Consumer and Queue is depicted in the diagram below:[5]		In the above example, Specialist class is a producer which produces objects that are consumed by Consumer objects asynchronously. A Producer object could produce an object when all Consumer objects are busy processing other objects. In this case, the objects are pushed in the queue which acts as a buffer for objects produced by Specialist class. The objects remain there until a Consumer object pulls them out of the queue. If the queue is empty, the Consumer object waits until the Producer adds new object to the queue. The relationship between Producer-Consumer and Queue is depicted in the diagram below:[5]

	[[Image:Producer-consumer.jpg\|Producer-Consumer Classes]]		[[Image:Producer-consumer.jpg\|Producer-Consumer Classes]]

Knrajwan: /* Producer/Consumer Pattern */

2009-10-10T01:38:34Z

Producer/Consumer Pattern

← Older revision		Revision as of 01:38, 10 October 2009
Line 250:		Line 250:
	}		}

	In the above example, Specialist class is a producer which produces objects that are consumed by Consumer objects asynchronously. A Producer object could produce an object when all Consumer objects are busy processing other objects. In this case, the objects are pushed in the queue which acts as a buffer for objects produced by Specialist class. The objects remain there until a Consumer object pulls them out of the queue. If the queue is empty, the Consumer object waits until the Producer adds new object to the queue.		In the above example, Specialist class is a producer which produces objects that are consumed by Consumer objects asynchronously. A Producer object could produce an object when all Consumer objects are busy processing other objects. In this case, the objects are pushed in the queue which acts as a buffer for objects produced by Specialist class. The objects remain there until a Consumer object pulls them out of the queue. If the queue is empty, the Consumer object waits until the Producer adds new object to the queue. The relationship between Producer-Consumer and Queue is depicted in the diagram below:[5]

	The relationship between Producer-Consumer and Queue is depicted in the diagram below:[5]
	[[Image:Producer-consumer.jpg\|Producer-Consumer Classes]]		[[Image:Producer-consumer.jpg\|Producer-Consumer Classes]]

923638: /* Concurrency Patterns */

2009-10-09T23:41:32Z

Concurrency Patterns

← Older revision		Revision as of 23:41, 9 October 2009
Line 29:		Line 29:
	In [http://en.wikipedia.org/wiki/Software_engineering software engineering], a [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) design pattern] is a general reusable solution to a commonly occurring problem in [http://en.wikipedia.org/wiki/Software_design software design]. A design pattern is not a finished design that can be transformed directly into code. It is a description or template for how to solve a problem that can be used in many different situations. Design patterns can thus, speed up the development process by providing tested, proven development paradigms, help prevent subtle issues that can cause major problems and improve code readability for coders and architects familiar with the patterns.[4]		In [http://en.wikipedia.org/wiki/Software_engineering software engineering], a [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) design pattern] is a general reusable solution to a commonly occurring problem in [http://en.wikipedia.org/wiki/Software_design software design]. A design pattern is not a finished design that can be transformed directly into code. It is a description or template for how to solve a problem that can be used in many different situations. Design patterns can thus, speed up the development process by providing tested, proven development paradigms, help prevent subtle issues that can cause major problems and improve code readability for coders and architects familiar with the patterns.[4]

	Developing [http://en.wikipedia.org/wiki/Multithreading multi-threaded] applications is hard since incorrect use of [http://en.wikipedia.org/wiki/Lock_(computer_science) locks] can cause subtle and pernicious errors. Likewise, developing multi-threaded reusable components is hard since it can be time-consuming to customize ~~[http://en.wikipedia.org/wiki/Software_component#Software_component~~ components] to support new, more efficient locking strategies.[7] Concurrency Patterns are design patterns that help developers avoid common problems when programming multi-threaded components and applications. The adjacent figure gives a list of concurrency design patterns that will be discussed below.		Developing [http://en.wikipedia.org/wiki/Multithreading multi-threaded] applications is hard since incorrect use of [http://en.wikipedia.org/wiki/Lock_(computer_science) locks] can cause subtle and pernicious errors. Likewise, developing multi-threaded reusable components is hard since it can be time-consuming to customize components to support new, more efficient locking strategies.[7] Concurrency Patterns are design patterns that help developers avoid common problems when programming multi-threaded components and applications. The adjacent figure gives a list of concurrency design patterns that will be discussed below.

923638: /* Concurrency Patterns */

2009-10-09T23:39:56Z

Concurrency Patterns

← Older revision		Revision as of 23:39, 9 October 2009
Line 27:		Line 27:
	[[Image:con_pattern.jpg\|thumb\|Concurrency Design Patterns]]		[[Image:con_pattern.jpg\|thumb\|Concurrency Design Patterns]]

	In [http://en.wikipedia.org/wiki/Software_engineering software engineering], a [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) design pattern] is a general reusable solution to a commonly occurring problem in [http://en.wikipedia.org/wiki/Software_design software design]. A design pattern is not a finished design that can be transformed directly into code. It is a description or template for how to solve a problem that can be used in many different situations. Design patterns can thus, speed up the development process by providing tested, proven ~~[http://en.wikipedia.org/wiki/Programming_paradigm~~ development paradigms], help prevent subtle issues that can cause major problems and improve code readability for coders and architects familiar with the patterns.[4]		In [http://en.wikipedia.org/wiki/Software_engineering software engineering], a [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) design pattern] is a general reusable solution to a commonly occurring problem in [http://en.wikipedia.org/wiki/Software_design software design]. A design pattern is not a finished design that can be transformed directly into code. It is a description or template for how to solve a problem that can be used in many different situations. Design patterns can thus, speed up the development process by providing tested, proven development paradigms, help prevent subtle issues that can cause major problems and improve code readability for coders and architects familiar with the patterns.[4]

	Developing [http://en.wikipedia.org/wiki/Multithreading multi-threaded] applications is hard since incorrect use of [http://en.wikipedia.org/wiki/Lock_(computer_science) locks] can cause subtle and pernicious errors. Likewise, developing multi-threaded reusable components is hard since it can be time-consuming to customize [http://en.wikipedia.org/wiki/Software_component#Software_component components] to support new, more efficient locking strategies.[7] Concurrency Patterns are design patterns that help developers avoid common problems when programming multi-threaded components and applications. The adjacent figure gives a list of concurrency design patterns that will be discussed below.		Developing [http://en.wikipedia.org/wiki/Multithreading multi-threaded] applications is hard since incorrect use of [http://en.wikipedia.org/wiki/Lock_(computer_science) locks] can cause subtle and pernicious errors. Likewise, developing multi-threaded reusable components is hard since it can be time-consuming to customize [http://en.wikipedia.org/wiki/Software_component#Software_component components] to support new, more efficient locking strategies.[7] Concurrency Patterns are design patterns that help developers avoid common problems when programming multi-threaded components and applications. The adjacent figure gives a list of concurrency design patterns that will be discussed below.

923638: /* Thread-Safe Programming */

2009-10-09T23:38:32Z

Thread-Safe Programming

← Older revision		Revision as of 23:38, 9 October 2009
Line 4:		Line 4:
	== Thread-Safe Programming ==		== Thread-Safe Programming ==

	In computer programming, a [http://en.wikipedia.org/wiki/Thread_(computer_science) thread] is an instance of the program running on behalf of some user or [http://en.wikipedia.org/wiki/Process_(computing) process].[1] Thread-safe describes a program portion or routine that functions correctly during simultaneous execution by multiple threads. A thread-safe piece of code can be called from multiple threads simultaneously without "clobbering" shared data or creating "[http://en.wikipedia.org/wiki/Race_condition race conditions]".[2]		In [http://en.wikipedia.org/wiki/Computer_programming computer programming], a [http://en.wikipedia.org/wiki/Thread_(computer_science) thread] is an instance of the program running on behalf of some user or [http://en.wikipedia.org/wiki/Process_(computing) process].[1] Thread-safe describes a program portion or routine that functions correctly during simultaneous execution by multiple threads. A thread-safe piece of code can be called from multiple threads simultaneously without "clobbering" shared data or creating "[http://en.wikipedia.org/wiki/Race_condition race conditions]".[2]

	For example, suppose that an application creates several threads, each of which makes a call to the same library routine which, in turn, accesses/modifies a global structure or location in memory. As each thread calls this routine, it is possible that they may try to modify this global structure/memory location at the same time. If the routine does not employ some sort of [http://en.wikipedia.org/wiki/Synchronization_(computer_science) synchronization] constructs to prevent data corruption, then it is not thread-safe. This is depicted below:[2]		For example, suppose that an application creates several threads, each of which makes a call to the same library routine which, in turn, accesses/modifies a global structure or location in memory. As each thread calls this routine, it is possible that they may try to modify this global structure/memory location at the same time. If the routine does not employ some sort of [http://en.wikipedia.org/wiki/Synchronization_(computer_science) synchronization] constructs to prevent data corruption, then it is not thread-safe. This is depicted below:[2]

923638: /* Thread-Specific Storage pattern */

2009-10-09T23:33:14Z

Thread-Specific Storage pattern

← Older revision		Revision as of 23:33, 9 October 2009
Line 143:		Line 143:
	}		}

	If recv returns -1 the code checks that errno != EWOULDBLOCK and prints an error message if this is not the case (e.g., if errno == EINTR), otherwise it processes the buffer it receives.		If recv returns -1 the code checks that errno != EWOULDBLOCK and prints an error message if this is not the case (e.g., if errno == EINTR), otherwise it processes the buffer it receives. When the “global error variable” approach shown above is used in multi-threaded systems, race conditions can cause an errno value set by a method in one thread to be interpreted erroneously by applications in other threads.[9]

	When the “global error variable” approach shown above is used in multi-threaded systems, race conditions can cause an errno value set by a method in one thread to be interpreted erroneously by applications in other threads.

	'''Solution: Thread-Specific Storage'''		'''Solution: Thread-Specific Storage'''

923638: /* Thread-Specific Storage pattern */

2009-10-09T23:32:20Z

Thread-Specific Storage pattern

← Older revision		Revision as of 23:32, 9 October 2009
Line 118:		Line 118:

	The Thread-Specific Storage pattern alleviates several problems with multi-threading performance such as the overhead of acquiring and releasing locks and programming complexity. It improves performance and simplifies multithreaded applications by allowing multiple threads to use one logically global access point to retrieve thread-specific data without incurring locking overhead for each access.		The Thread-Specific Storage pattern alleviates several problems with multi-threading performance such as the overhead of acquiring and releasing locks and programming complexity. It improves performance and simplifies multithreaded applications by allowing multiple threads to use one logically global access point to retrieve thread-specific data without incurring locking overhead for each access.
	This pattern should be applied to multi-threaded applications that frequently access objects that are logically global but physically specific to each thread.		This pattern should be applied to multi-threaded applications that frequently access objects that are logically global but physically specific to each thread.[9]

	For instance, when an error occurs in a system call, [http://en.wikipedia.org/wiki/Operating_system operating systems] like [http://en.wikipedia.org/wiki/Unix UNIX] and [http://en.wikipedia.org/wiki/Windows_API Win32] use a standard variable ''errno'' to report the problem. Consider the following typical C code fragment that receives buffers from a [http://en.wikipedia.org/wiki/Berkeley_sockets non-blocking TCP socket]:		For instance, when an error occurs in a system call, [http://en.wikipedia.org/wiki/Operating_system operating systems] like [http://en.wikipedia.org/wiki/Unix UNIX] and [http://en.wikipedia.org/wiki/Windows_API Win32] use a standard variable ''errno'' to report the problem. Consider the following typical C code fragment that receives buffers from a [http://en.wikipedia.org/wiki/Berkeley_sockets non-blocking TCP socket]:[9]

	// One global errno per-process.		// One global errno per-process.
Line 149:		Line 149:
	'''Solution: Thread-Specific Storage'''		'''Solution: Thread-Specific Storage'''

	The Thread-specific storage pattern allows sequential methods within a thread to access thread-specific objects atomically without incurring locking overhead for each access. Also, system developers can make the use of thread-specific storage completely transparent at the source-code level via [http://en.wikipedia.org/wiki/Abstraction_(computer_science) data abstraction] or [http://en.wikipedia.org/wiki/Macro_(computer_science) macros]. It is also highly portable. For example, the following code illustrates how errno is defined on [http://www.sun.com/software/solaris/ Solaris 2.x]:		The Thread-specific storage pattern allows sequential methods within a thread to access thread-specific objects atomically without incurring locking overhead for each access. Also, system developers can make the use of thread-specific storage completely transparent at the source-code level via [http://en.wikipedia.org/wiki/Abstraction_(computer_science) data abstraction] or [http://en.wikipedia.org/wiki/Macro_(computer_science) macros]. It is also highly portable. For example, the following code illustrates how errno is defined on [http://www.sun.com/software/solaris/ Solaris 2.x]:[9]

	// A thread-specific errno definition (typically defined in <sys/errno.h>).		// A thread-specific errno definition (typically defined in <sys/errno.h>).
Line 165:		Line 165:
	}		}

	When the REENTRANT flag is enabled the errno symbol is defined as a macro that invokes a helper function called errno, which returns a [http://en.wikipedia.org/wiki/Pointer_(computing) pointer] to the thread-specific value of errno. This pointer is [http://cslibrary.stanford.edu/106/ dereferenced] by the macro so that it can appear on either the left or right side of an assignment operator.		When the REENTRANT flag is enabled the errno symbol is defined as a macro that invokes a helper function called errno, which returns a [http://en.wikipedia.org/wiki/Pointer_(computing) pointer] to the thread-specific value of errno. This pointer is [http://cslibrary.stanford.edu/106/ dereferenced] by the macro so that it can appear on either the left or right side of an assignment operator.[9]

	===Balking Pattern===		===Balking Pattern===

923638: /* Double-Checked Locking Pattern */

2009-10-09T23:29:30Z

Double-Checked Locking Pattern

← Older revision		Revision as of 23:29, 9 October 2009
Line 60:		Line 60:
	===Double-Checked Locking Pattern===		===Double-Checked Locking Pattern===

	The Double-checked locking design pattern is used when an application has one or more [http://en.wikipedia.org/wiki/Critical_section critical sections] of code that must execute sequentially; when multiple threads can potentially attempt to execute the critical section simultaneously; when the critical section is executed just once and when acquiring a lock on every access to the critical section causes excessive overhead.		The Double-checked locking design pattern is used when an application has one or more [http://en.wikipedia.org/wiki/Critical_section critical sections] of code that must execute sequentially; when multiple threads can potentially attempt to execute the critical section simultaneously; when the critical section is executed just once and when acquiring a lock on every access to the critical section causes excessive overhead.[8]

	Many familiar design patterns such as [http://en.wikipedia.org/wiki/Singleton_pattern Singleton] that work well for sequential programs contain subtle assumptions that do not apply in the context of concurrency. Consider the following implementation of the Singleton pattern:		Many familiar design patterns such as [http://en.wikipedia.org/wiki/Singleton_pattern Singleton] that work well for sequential programs contain subtle assumptions that do not apply in the context of concurrency. Consider the following implementation of the Singleton pattern:[8]

	class Singleton		class Singleton
Line 88:		Line 88:
	'''The Solution: Double-Checked Locking'''		'''The Solution: Double-Checked Locking'''

	A common way to implement a critical section is to add a static [http://en.wikipedia.org/wiki/Mutual_exclusion Mutex] to the class which ensures that the allocation and initialization of the Singleton occurs atomically. A [http://en.wikipedia.org/wiki/Guard_(computing) Guard] class is used to ensure that every access to Singleton::instance will automatically acquire and release the lock as follows:		A common way to implement a critical section is to add a static [http://en.wikipedia.org/wiki/Mutual_exclusion Mutex] to the class which ensures that the allocation and initialization of the Singleton occurs atomically. A [http://en.wikipedia.org/wiki/Guard_(computing) Guard] class is used to ensure that every access to Singleton::instance will automatically acquire and release the lock as follows:[8]

	class Singleton		class Singleton
Line 113:		Line 113:
	};		};

	The first thread that acquires the lock will construct Singleton and assign the pointer to instance_. All threads that subsequently call instance will find instance_!= 0 and skip the initialization step. The second check prevents a race condition if multiple threads try to initialize the Singleton simultaneously. Thus, the Double-Checked Locking pattern provides advantages of minimized locking and prevention of race conditions.		The first thread that acquires the lock will construct Singleton and assign the pointer to instance_. All threads that subsequently call instance will find instance_!= 0 and skip the initialization step. The second check prevents a race condition if multiple threads try to initialize the Singleton simultaneously. Thus, the Double-Checked Locking pattern provides advantages of minimized locking and prevention of race conditions.[8]

	===Thread-Specific Storage pattern===		===Thread-Specific Storage pattern===

923638: /* Concurrency Patterns */

2009-10-09T23:26:31Z

Concurrency Patterns

← Older revision		Revision as of 23:26, 9 October 2009
Line 25:		Line 25:

	==Concurrency Patterns==		==Concurrency Patterns==
			[[Image:con_pattern.jpg\|thumb\|Concurrency Design Patterns]]

	In [http://en.wikipedia.org/wiki/Software_engineering software engineering], a [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) design pattern] is a general reusable solution to a commonly occurring problem in [http://en.wikipedia.org/wiki/Software_design software design]. A design pattern is not a finished design that can be transformed directly into code. It is a description or template for how to solve a problem that can be used in many different situations. Design patterns can thus, speed up the development process by providing tested, proven [http://en.wikipedia.org/wiki/Programming_paradigm development paradigms], help prevent subtle issues that can cause major problems and improve code readability for coders and architects familiar with the patterns.[4]		In [http://en.wikipedia.org/wiki/Software_engineering software engineering], a [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) design pattern] is a general reusable solution to a commonly occurring problem in [http://en.wikipedia.org/wiki/Software_design software design]. A design pattern is not a finished design that can be transformed directly into code. It is a description or template for how to solve a problem that can be used in many different situations. Design patterns can thus, speed up the development process by providing tested, proven [http://en.wikipedia.org/wiki/Programming_paradigm development paradigms], help prevent subtle issues that can cause major problems and improve code readability for coders and architects familiar with the patterns.[4]

	~~[[Image:con_pattern.jpg\|thumb\|Concurrency Design Patterns]]~~

	Developing [http://en.wikipedia.org/wiki/Multithreading multi-threaded] applications is hard since incorrect use of [http://en.wikipedia.org/wiki/Lock_(computer_science) locks] can cause subtle and pernicious errors. Likewise, developing multi-threaded reusable components is hard since it can be time-consuming to customize [http://en.wikipedia.org/wiki/Software_component#Software_component components] to support new, more efficient locking strategies.[7] Concurrency Patterns are design patterns that help developers avoid common problems when programming multi-threaded components and applications. The adjacent figure gives a list of concurrency design patterns that will be discussed below.		Developing [http://en.wikipedia.org/wiki/Multithreading multi-threaded] applications is hard since incorrect use of [http://en.wikipedia.org/wiki/Lock_(computer_science) locks] can cause subtle and pernicious errors. Likewise, developing multi-threaded reusable components is hard since it can be time-consuming to customize [http://en.wikipedia.org/wiki/Software_component#Software_component components] to support new, more efficient locking strategies.[7] Concurrency Patterns are design patterns that help developers avoid common problems when programming multi-threaded components and applications. The adjacent figure gives a list of concurrency design patterns that will be discussed below.

923638: /* Concurrency Patterns */

2009-10-09T23:25:59Z

Concurrency Patterns

← Older revision		Revision as of 23:25, 9 October 2009
Line 27:		Line 27:
	In [http://en.wikipedia.org/wiki/Software_engineering software engineering], a [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) design pattern] is a general reusable solution to a commonly occurring problem in [http://en.wikipedia.org/wiki/Software_design software design]. A design pattern is not a finished design that can be transformed directly into code. It is a description or template for how to solve a problem that can be used in many different situations. Design patterns can thus, speed up the development process by providing tested, proven [http://en.wikipedia.org/wiki/Programming_paradigm development paradigms], help prevent subtle issues that can cause major problems and improve code readability for coders and architects familiar with the patterns.[4]		In [http://en.wikipedia.org/wiki/Software_engineering software engineering], a [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) design pattern] is a general reusable solution to a commonly occurring problem in [http://en.wikipedia.org/wiki/Software_design software design]. A design pattern is not a finished design that can be transformed directly into code. It is a description or template for how to solve a problem that can be used in many different situations. Design patterns can thus, speed up the development process by providing tested, proven [http://en.wikipedia.org/wiki/Programming_paradigm development paradigms], help prevent subtle issues that can cause major problems and improve code readability for coders and architects familiar with the patterns.[4]

	~~Developing~~ [~~http://en.wikipedia.org/wiki/Multithreading multi-threaded] applications is hard since incorrect use of~~ [~~http~~:~~//en~~.wikipedia.org/wiki/Lock_(computer_science) locks] can cause subtle and pernicious errors. Likewise, developing multi-threaded reusable components is hard since it can be time-consuming to customize [http://en.wikipedia.org/wiki/Software_component#Software_component components] ~~to support new, more efficient locking strategies.[7~~] ~~Concurrency Patterns are design patterns that help developers avoid common problems when programming multi-threaded components and applications.~~		[[Image:con_pattern.jpg\|thumb\|Concurrency Design Patterns]]

	The adjacent figure gives a list of concurrency design patterns that will be discussed below. ~~[[Image:con_pattern.jpg\|thumb\|Concurrency Design Patterns]]~~		Developing [http://en.wikipedia.org/wiki/Multithreading multi-threaded] applications is hard since incorrect use of [http://en.wikipedia.org/wiki/Lock_(computer_science) locks] can cause subtle and pernicious errors. Likewise, developing multi-threaded reusable components is hard since it can be time-consuming to customize [http://en.wikipedia.org/wiki/Software_component#Software_component components] to support new, more efficient locking strategies.[7] Concurrency Patterns are design patterns that help developers avoid common problems when programming multi-threaded components and applications. The adjacent figure gives a list of concurrency design patterns that will be discussed below.