
	Where results make sense

Topic: Concurrency pattern

Related Topics

Behavioral pattern

Structural pattern

Fundamental pattern

Read write lock pattern

Scheduler pattern

Creational pattern

Design pattern (computer science)

Proxy pattern

Balking pattern

Interface pattern

Pattern mining

Facade pattern

Lazy initialization pattern

Immutable pattern

Double checked locking pattern

	Enterprise Software Pattern Synopses
		One of the applications of the Object Replication pattern is to ensure that an object is near its accessors.
		The Virtual Proxy pattern, described in Volume 1, may be used by an implementation of the Persistence Layer pattern to defer the fetching of objects that are part of a more complex object but may not be needed for some uses of the complex object.
		The CRUD pattern is used by the Persistence Layer Pattern.
	www.mindspring.com /~mgrand/pattern_synopses3.htm (4614 words)

	Journal of Science & Technology
		The pattern language is structured as a linear list consisting of these four design spaces: starting at the Finding Concurrency space, followed by the Algorithm Structure space, possibly passing through the Supporting Structures space, and at last leading to actual code with the Implementation Mechanisms design space patterns.
		These patterns are those for which the decomposition of the data is the major organizing principle in understanding the concurrency.
		This pattern represents a "thread-safe" implementation of the familiar queue abstract data type (ADT), that is, an implementation of the queue ADT that maintains the correct semantics even when used by concurrently-executing units of execution.
	www.ust.edu /sj/Synthesizing.htm (3550 words)

	Computer Science: Publication: Process Oriented Design for Java: Concurrency for All
		Concurrency is thought to be an advanced topic - much harder than serial computing which, therefore, needs to be mastered first.
		A process-oriented design pattern for concurrency is presented with a specific binding for Java.
		Concurrency for all (and for everyday use) in the design and implementation of most kinds of computer system is both achievable and necessary
	www.cs.kent.ac.uk /pubs/2002/1383 (272 words)

	Design Pattern Synopses from Patterns in Java, Volume 1 Second Edition
		The Filter pattern is a special case of the Decorator pattern, where a data source or data sink object is wrapped to add logic to the handling of a data stream.
		The Composite pattern also allows the objects in the tree to be manipulated in a consistent manner, by requiring all of the objects in the tree to have a common superclass or interface.
		The Decorator pattern extends the functionality of an object in a way that is transparent to its clients, by implementing the same interface as the original class and delegating operations to the original class.
	www.markgrand.com /pattern_synopses1_2ed.html (5418 words)

	Applying Patterns to Develop Extensible ORB Middleware
		Therefore, the Active Object pattern defines a higher-level concurrency abstraction that shields TAO from the complexity of low-level thread facades.
		For instance, the reason the Abstract Factory pattern is used in TAO is to avoid the complexity caused by its extensive use of the Strategy pattern.
		Although the Strategy pattern simplifies the effort required to customize an ORB for specific application requirements and network/end-system characteristics, it is tedious and error-prone to manage a large number of strategy interactions manually.
	www.comsoc.org /ci1/private/1999/apr/Schmidt.html (5940 words)

	Master-Master Row-Level Synchronization (Site not responding. Last check: 2007-10-26)
		This pattern inherits the benefits and liabilities of the Data Replication and the Master-Master Replication patterns, which are not repeated here.
		This pattern is the root pattern of this cluster; it presents the overall architecture for maintaining copies of data.
		This pattern presents the architecture of data replication, which is a particular way of moving copies of data.
	msdn2.microsoft.com /en-us/library/ms998434.aspx (2297 words)

	Books on Pattern-Oriented Software Architecture (Site not responding. Last check: 2007-10-26)
		All patterns present extensive examples and the pattern known uses are presented in various programming languages, including C++, C, and Java.
		The patterns are covered in detail, making use of several examples, and, as in previous POSA volumes, directions are given on how to implement the presented patterns.
		The patterns are grouped by different areas of resource management and hence address the complete lifecycle of resources: resource acquisition, coordination and release.
	www.cs.wustl.edu /~schmidt/POSA (461 words)

	Concurrency Controller Pattern (Site not responding. Last check: 2007-10-26)
		Using this pattern, a programmer can write concurrency controller classes by specifying a set of guarded commands and without using any of the error-prone synchronization primitives in Java.
		We present a modular approach to verification of concurrent programs by separating the verification of the concurrency controllers (behavior verification) from the verification of the threads which use them (interface verification).
		The interface of a concurrency controller is a finite state machine with transitions representing controller actions.
	www.cs.ucsb.edu /~aysu/CCPattern/index.html (327 words)

	Java theory and practice: Concurrency made simple (sort of) (Site not responding. Last check: 2007-10-26)
		Like many other application infrastructure services, concurrency utility classes such as work queues and thread pools are often needlessly rewritten from scratch for every project.
		Concurrent code is hard to write and harder to test -- and even the experts sometimes get it wrong the first time.
		Doug Lea, author of Concurrent Programming in Java (see Resources), has written an excellent free package of concurrency utilities, including locks, mutexes, queues, thread pools, lightweight tasks, efficient concurrent collections, atomic arithmetic operations, and other basic building blocks of concurrent applications.
	www-106.ibm.com /developerworks/java/library/j-jtp1126.html (1945 words)

	PRG Research Report RR-01-22
		This paper presents a pattern of usage for the Unified Modeling Language (UML), intended for the description of systems in which two or more operations may be acting concurrently upon the same object.
		Simple examples are used to demonstrate the application of the pattern: at an implementation level, and at a more abstract, design level.
		The semantics for concurrency within UML is examined, not only to clarify the interpretation of the pattern, but also to explain why the existing provision - concurrent composite states and concurrency attributes - is not applicable.
	web.comlab.ox.ac.uk /oucl/publications/tr/rr-01-22.html (139 words)

	High Performance Web Systems: Our Research
		The components and their collaborations follow several design patterns which are named along the borders of the components.
		Concurrency Strategy: This implements concurrency mechanisms (such as single-threaded, thread-per-request, or thread pool) that can be selected adaptively at run-time, using the State Pattern or pre-determined at initialization-time.
		Configuring the server as to which concurrency strategies are available follows the Service Configurator Pattern.
	www.dre.vanderbilt.edu /JAWS/research.html (2968 words)

	Working with Data and ASP.NET 2.0: ASP.NET Web: The Official Microsoft ASP.NET 2.0 Site
		Without any concurrency policy in place, when two users are simultaneously editing a single record, the user who commits her changes last will override the changes made by the first.
		Optimistic Concurrency - assume that while there may be concurrency conflicts every now and then, the vast majority of the time such conflicts won't arise; therefore, if a conflict does arise, simply inform the user that their changes can't be saved because another user has modified the same data
		When using the DB direct pattern against a DAL that uses optimistic concurrency, the methods must be passed the new and original values.
	www.asp.net /learn/dataaccess/tutorial21vb.aspx?tabid=63 (3451 words)

	Design pattern (computer science) - Wikipedia, the free encyclopedia
		Object-oriented design patterns typically show relationships and interactions between classes or objects, without specifying the final application classes or objects that are involved.
		Developers use the design pattern by introducing in their designs this prototypical micro-architecture, which means that micro-architectures in their designs will have structure and organization similar to the chosen design motif.
		It is further argued by some that the primary contribution of the Design Patterns community (and the Gang of Four book) was the use of Alexander's pattern language as a form of documentation; a practice which is often ignored in the literature.
	en.wikipedia.org /wiki/Design_pattern_(computer_science) (1731 words)

	Publications available online (Site not responding. Last check: 2007-10-26)
		Our initial motivation is twofold: to provide an intuitive semantics of the interaction between concurrency and pattern matching; to define a practical compilation scheme from extended join-definitions into ordinary ones plus ML pattern matching.
		In particular, the well-known (and size-efficient) pattern matching compilation technique using backtracking automata is here introduced for the first time into the world of lazy pattern matching.
		Once given a proper (that is, non-ambiguous) semantics, pattern matching should be compiled in a similar spirit: any value matching a given pattern should be recognized by performing only the minimal number of elementary tests needed to do so.
	pauillac.inria.fr /~maranget/pubs.html (2516 words)

	Application Development Trends - Pattern-Oriented Software Architecture
		The Reactor pattern relies on the principle of "inversion of control" and pushes application or service-handler development to the edges of the design; the reactor itself is responsible for handling indication events.
		The Reactor pattern is not used in isolation.
		In combination, the patterns form a rich pattern language that can describe the detailed, internal workings of server processes concisely and meaningfully; they allow developers and architects to talk in high-level terms about potential designs and their consequences.
	www.adtmag.com /java/article.aspx?id=357 (1476 words)

	dev2dev: Peak performance tuning of CMP 2.0 Entity beans in WebLogic Server 8.1 and 9.0
		Exclusive concurrency means that the container creates, at most, one instance of an entity bean for every primary key value (for example, one row in the table maps to one instance of EJB in the container).
		When applied with read-only concurrency, this setting is simply ignored because bean data is already cached; when applied with exclusive concurrency, this is only going to work if the EJB has exclusive access to the underlying database, which is rarely the case.
		In contrast to the read-mostly pattern, which doesn't provide mechanisms to notify other nodes in the cluster that data was changed on one of the nodes, when a bean with optimistic concurrency is updated, a notification is broadcast to other cluster members, and the cached bean instances are discarded to prevent optimistic conflicts.
	dev2dev.bea.com /lpt/a/458 (6849 words)

	community.java.net - Java Patterns
		A recent post to the discussion suggests you "refactor toward that pattern or away from it depending on whether the pattern's consequences, strengths, and trade-offs are appropiate for the program."
		All the patterns are fully illustrated with UML diagrams and extensive sample code for patterns, strategies and refactorings are included.
		The J2EE Patterns course provides students with a thorough description of software design patterns that can be used with the Java 2 Platform, Enterprise Edition (J2EE platform) technology to effectively solve complex business problems.
	community.java.net /patterns (543 words)

	Peak performance tuning of CMP 2.0 Entity beans in WebLogic Server 8.1 and 9.0
		If no concurrency strategy and caching parameters are specified at all, the default settings that WebLogic Server uses is certainly a sound choice in terms of data consistency, but are rarely the best possible choice in terms of performance of CMP beans.
		An optimistic concurrency with cache between transactions works best for use cases in which there is a "guarantee" of a cache hit.
		The read-mostly pattern doesn't work in the cluster, doesn't prevent lost updates, and in general is more cumbersome to use.
	dev2dev.bea.com /pub/a/2005/11/tuning-cmp-ejbs.html?page=last (2904 words)

	CMSC446 Introduction To Design Patterns Spring 2004 : Syllabus (Site not responding. Last check: 2007-10-26)
		Each pattern represents a best practice solution to a software problem in some context.
		Specific patterns, such as Observer, State, Adapter, Strategy, Decorator and Abstract Factory will be discussed.
		In addition, distributed object frameworks, such as RMI, will be studied for their effective use of design patterns.
	userpages.umbc.edu /~tarr/dp/spr04/misc/syll.html (164 words)

	SwTech.com - Java Concurrency and Threads
		One of the main uses and requirements for concurrency is in the handling of networking and communications while still keeping an app responsive to user input.
		A note by Tom Cargill to identify some parts of the specification of the Java threading model that are incomplete or inconsistent, and try to assist in the preparation of an improved specification.
		Concurrency in GUIs has often been a subject of controversy.
	www.swtech.com /java/threads (1278 words)

	SwTech.com - Design Pattern Books
		A catalogue of design pattern templates for common distributed computing solutions for building enterprise-wide applications and systems, creating Internet applications and integrating legacy applications within a CORBA framework.
		While architecture is important to all application development, it is particularly critical to the success of an enterprise project, where issues such as performance and concurrent multi-user access are paramount.
		The book presents patterns (proven solutions to recurring problems) in enterprise architecture, and the context provided by the author enables the reader to make the proper choices when faced with a difficult design decision.
	www.swtech.com /dpattern/books (613 words)

	Ted Leung on the Air
		Some people liken the pattern matching aspects of Erlang to Prolog, but this is not entirely accurate because Prolog uses unification, which works in “both directions” and not pattern matching, which only works in “one direction”.
		The basic concurrency model of Erlang is a version of the Actor model developed by Carl Hewitt at MIT.
		I think it’s still to early to declare a victory in the concurrency abstraction space, and at this point I think its important for people to be aware of all the possible contenders.
	www.sauria.com /blog (7020 words)

	Active Object - An Object Behavioral Pattern for Concurrent Programming - Lavender, Schmidt (ResearchIndex) (Site not responding. Last check: 2007-10-26)
		Abstract: This paper describes the Active Object pattern, which decouples method execution from method invocation in order to simplify synchronized access to an object that resides in its own thread of control.
		The Active Object pattern allows one or more independent threads of execution to interleave their access to data modeled as a single object.
		A broad class of producer/consumer and reader/writer applications are wellsuited to this model of concurrency.
	citeseer.ist.psu.edu /lavender96active.html (561 words)

	ApriorIT - offshore IT outsourcing services in system programming, advanced software development
		The topic area of concurrency patterns is poorly covered in literature, so this text is called to fill a gap, at least partly.
		Purpose: wraps not-synchronized object (unlike Auto Critical Section object which wraps scope) in critical section so that access to an object could be provided only through an entry in critical section, the leaving from which occurs right after end of access.
		For this purpose it is better to use concurrency container patterns, such as: Buffer Monitor, Object Pool, Question Answer Pool, Blackboard.
	www.apriorit.com /our-articles/criticalresource-concurrency-pattern.html (1878 words)

	Ralph Johnson - Blog (Site not responding. Last check: 2007-10-26)
		But messaging is asynchronous in Erlang, and it is common to send a message to a process and to forget about it, expecting the result to be forwarded to another process.
		In my opinion, it is the concurrent programming aspects of Erlang that make it special, along with its mature implementation and powerful library designed for concurrency and reliability.
		One of the advantages of thinking of RDBMSs as a pattern is that it makes you stop asking "is it a good idea" and start asking "what are its advantages and disadvantages" and "when should we use it instead of its alternatives".
	www.cincomsmalltalk.com /userblogs/ralph/blogView (3873 words)

	Erlang
		In message passing concurrency, we say that there is no shared state.
		Shared state concurrency involves the idea of "mutable state" (literally memory which can be changed).
		I could not drive my car on the highway if I did not intuitively understand the notion of concurrency; pure message-passing concurrency is what we do all the time.
	www.pragmaticprogrammer.com /articles/erlang.html (958 words)

	The Java Specialists' Newsletter
		We look at how to debug a concurrent program by knowing what every thread in the system is doing.
		Brian's book is the most readable on the topic of concurrency in Java, and deals with this difficult subject with a wonderful hands-on approach.
		With this pattern, we should try to convert intrinsic state to extrinsic, to allow sharing of strategy objects.
	www.javaspecialists.eu /archive/archive.jsp (2174 words)

	Class Digester Report (Site not responding. Last check: 2007-10-26)
		A Digester processes an XML input stream by matching a series of element nesting patterns to execute Rules that have been added prior to the start of parsing.
		The key is the matching pattern against the current element stack, and the value is a List containing the Rules for that pattern, in the order that they were registered.
		@param pattern Element matching pattern @param methodName Method name to be called @param paramCount Number of expected parameters (or zero for a single parameter from the body of this element)
	www.indiana.edu /~sit/J2EE/magicdraw/ID00000000002dReport.html (1389 words)

	Concurrent Programming in Java: Design principles and patterns
		JSR 166 defined a J2SE concurrent package with classes similar to those described in this book.
		Java Concurrency Constructs -- HTML versions of parts of sections 1.1, 2.2, and 3.2 describing mechanics.
		Excerpt: Synchronization and the Java Memory Model -- HTML version of main discussion in section 2.2 of how the memory model impacts concurrent programming.
	gee.cs.oswego.edu /dl/cpj (502 words)

Try your search on: Qwika (all wikis)