concurrent - Kenyth Zeng on Diigo

24 Oct 09

15 Sep 09

epoll(7)

www.kernel.org/...epoll.4.html - Preview

io concurrent event linux performance toread

24 Aug 09

Dr. Dobb's | NPTL: The New Implementation of Threads for Linux | August 1, 2005

www.ddj.com/...184406204 - Preview

thread concurrent synchronization POSIX article linux

Linux was late to offer production-level support for true multithreaded development.
interprocess communication, such as signals, pipes, or sockets.
3 more annotations...
- O(1) scheduler
- using clone() to spawn a thread is no longer a heavyweight task.
- Collapsing the kernel identification of all threads to a single Process ID (PID) solved many problems in areas of both functionality and performance. Resource usage is correctly tied to this single PID, making the system view of a multithreaded application accurate.

12 Aug 09

Lesson: Concurrency (The Java™ Tutorials > Essential Classes)

java.sun.com/...index.html - Preview

tutorial java concurrent starred toread

Java theory and practice: Managing volatility

www.ibm.com/...j-jtp06197.html - Preview

java thread article concurrent synchronization best-practice

Volatile variables in the Java language can be thought of as
"synchronized lite"; they require less coding to use than synchronized
blocks and often have less runtime overhead, but they can only be used
to do a subset of the things that synchronized can.
Locks offer two primary features: mutual exclusion and
visibility.
4 more annotations...
- ensuring that changes made to shared data
  prior to releasing a lock are made visible to another thread that
  subsequently acquires that lock -- without the visibility guarantees provided by synchronization, threads could see stale or inconsistent values for shared variables, which could cause a host of serious problems.
- Volatile variables share the visibility features of synchronized, but
  none of the atomicity features.
- In situations where reads greatly outnumber writes, volatile
  variables may also provide a performance advantage over locking.
- could see an up-to-date reference but still observe a partially
  constructed object through that reference.

The volatile keyword in Java

also compared with synchronized

www.javamex.com/...synchronization_volatile.shtml - Preview

java thread toread article concurrent starred synchronization locking

its formal definition actually changed
as of Java 5.
- The value of this variable will never be cached thread-locally: all reads and writes
  will go straight to "main memory";
- Access to the variable acts as though it is enclosed in a synchronized block,
  synchronized on itself.
2 more annotations...
- All cached variables synchronized on access?YesFrom Java 5 onwards
- because accessing a volatile variable never holds a lock, it is not suitable
  for cases where we want to read-update-write as an atomic operation
  (unless we're prepared to "miss an update");

Understanding Java Multithreading and Read-Write Locks, Part 1 — Developer.com

www.developer.com/...951051 - Preview

java thread article locking synchronization concurrent

the heap area may be 'likened' to the main memory, as it is here that the shared data in objects reside, and the operand stack of the thread is not the same as the working memory of the thread.
Each object has a lock associated with it. Critical sections of the code that access a common resource are guarded by monitors (which essentially are synchronized methods or blocks).

Double-checked locking - Wikipedia, the free encyclopedia

en.wikipedia.org/...Double-checked_locking - Preview

java thread wikipedia concurrent synchronization locking

reduce the overhead of acquiring a lock by first testing the locking criterion (the "lock hint") in an unsafe manner; only if that succeeds does the actual lock proceed.
getting a reference to an incompletely initialized object.
3 more annotations...
- synchronizing a method can decrease performance by a factor of 100 or higher
- the code generated by the compiler is allowed to update the shared variable to point to a partially constructed object before A has finished performing the initialization.
- using double-checked locking in J2SE 1.4 (and earlier versions) is that it will often appear to work

VM Spec Threads and Locks

java.sun.com/...Threads.doc.html - Preview

jvm java spec memory thread concurrent starred

Because it is impossible
for one thread to access parameters or local variables of another thread, it does
not matter whether parameters and local variables are thought of as residing in the
shared main memory or in the working memory of the thread that owns them.
Every thread has a working memory in which it keeps its own working copy of variables that it must use or assign. As the thread executes a program, it operates on these working copies. The main memory contains the master copy of every variable. There are rules about when a thread is permitted or required to transfer the contents of its working copy of a variable into the master copy or vice versa.
4 more annotations...
- the operations in main memory on behalf of any one thread are performed in the same order as the corresponding operations by that thread.
- an occurrence of V as an operand of the + operator requires that a single use operation occur on V ; an occurrence of V as the left-hand operand of the assignment operator = requires that a single assign operation occur.
- If the following rules forbid T to perform a required use as its next action, it may be necessary for T to perform a load first in order to make progress.
- treated as if it were two variables of
  32 bits each; wherever the rules require one of these operations, two such operations
  are performed, one for each 32-bit half.

Threads and Locks

java.sun.com/...memory.html - Preview

programming language java thread spec concurrent book starred memory

These threads independently execute code that operates on values and objects residing in a shared main memory.
Each object in Java is associated with a monitor, which a thread can lock or unlock. Only one thread at a time may hold a lock on a monitor.
6 more annotations...
- The synchronized statement (§14.19) computes a reference to an object; it then attempts to perform a lock action on that object's monitor and does not proceed further until the lock action has successfully completed.
- A synchronized method (§8.4.3.6) automatically performs a lock action when it is invoked; its body is not executed until the lock action has successfully completed. If the method is an instance method, it locks the monitor associated with the instance for which it was invoked (that is, the object that will be known as this during execution of the body of the method). If the method is static, it locks the monitor associated with the Class object that represents the class in which the method is defined.
- The Java programming language memory model works by examining each read in an execution trace and checking that the write observed by that read is valid according to certain rules.
- intra-thread semantics.
- Memory that can be shared between threads is called shared memory or heap memory.
- Local variables (§14.4), formal method parameters (§8.4.1) or exception handler parameters are never shared between threads and are unaffected by the memory model.

11 Aug 09

Difference between sleep and wait | Geek Explains: Java, J2EE, Oracle, Puzzles, and Problem Solving!

geekexplains.blogspot.com/...ce-between-sleep-and-wait.html - Preview

java thread concurrent comparison starred blog

both these methods are static, so even if you try to call ‘t.sleep(…)’ on a different thread, it’ll be called on the current thread only and not on the ‘t’ thread

Typical use of the volatile keyword in Java

www.javamex.com/...ion_volatile_typical_use.shtml - Preview

java thread toread article concurrent

So thread A thinks it's fair game
to just cache the value of the variable in a register or in its local memory

Java theory and practice: Thread pools and work queues

www.ibm.com/...j-jtp0730.html - Preview

java thread article best-practice concurrent

One simplistic model for building a server application would be to create a new thread each time a request arrives and service the request in the new thread.
the overhead of creating a new thread for each request is
significant
9 more annotations...
- A thread pool offers a solution to both the problem of thread life-cycle overhead and the problem of resource thrashing.
- Another common threading model is to have a single background thread and task queue for tasks of a certain type.
- thread-per-task and the single-background-thread
- prevent the submitting thread from blocking.
- notify() causes many fewer context switches,
  which is important in a server application.
- thread leakage
- all pool threads are executing tasks that are blocked waiting for the results of another task on the queue, but the other task cannot run because there is no unoccupied thread available.
- Don't queue tasks that wait synchronously for results from other tasks.
- Be careful when using pooled threads for potentially long-lived operations.

18 Jun 09

Erlang开发及应用

www.slideshare.net/...erlang-1601410 - Preview

Erlang concurrent slides programming language opensource

06 Jun 09

谷奥——探寻谷歌的奥秘 (http://google.org.cn) » 来自Google I/O 2009现场的Google Wave讲座

google.org.cn/...gle-io-2009-session-about-wave - Preview

Google Wave code video api programming GWT concurrent tutorial starred

04 Jun 09

What is Optimistic Locking vs. Pessimistic Locking [Archive] - DBAsupport.com Forums

www.dbasupport.com/...t-7282.html - Preview

concurrent database discussion starred comparison performance

only for that current session
*Most* people implement this, instead, through a single column, usually called timestamp. This column is used *for no other purpose* than implementing optimistic concurrency.

30 May 09

Google Wave Data Model and Client-Server Protocol ‎(Google Wave Federation Protocol)‎

www.waveprotocol.org/...nternal-client-server-protocol - Preview

protocol data Google Wave CS concurrent OT

Stand-off annotations are pointers into the XML document and are independent of the XML document structure. They are used to represent text formatting, spelling suggestions and hyper-links.
There are currently two types of documents: text documents, used to represent the rich text messages in a wavelet (casually known as blips), and data documents which are typically invisible to the user (for example, tags).
8 more annotations...
- The unit of sharing is a wavelet. In the first version of this protocol, all participants on a wavelet have full access to modify the contents and participant list of that wavelet.
- Heterogeneous sharing within a wave is achieved by having differing participant lists on wavelets within the wave. Currently, the two primary uses of this are user-data and private replies.
- the wavelet state to be consistent throughout the system
- The client is responsible for ordering the operations that were received from the server before applying them to its local copy of the wavelet copy.
- according to a version number provided by the server.
- wavelets are grouped into a "wave-view", which is the set of wavelets on a wave visible to a given user.
- A snapshot - the serialized state of the wavelet
- When client-server communications fail, the client and server need to agree on a common state of the wavelet upon reconnecting.

29 May 09

Operational transformation - Wikipedia, the free encyclopedia

OT underlies Google Wave

en.wikipedia.org/...Operational_transformation - Preview

wikipedia collaboration concurrent framework theory Operational Transformation OT Google Wave starred toread

Operational transformation (OT) is a theoretical framework of concurrency control that has been continuously researched in the context of group editing, a subfield of computer supported cooperative work (CSCW). OT typically replicates the shared document at all sites and allows any user to edit any part of the document at any time. Local editing operations are executed often without being delayed or blocked. Remote operations are transformed before execution to repair inconsistencies. The lockfree, nonblocking property of OT makes the local response time not sensitive to networking latencies. As a result, OT is particularly good for implementing group editing in the Web/Internet context.
OT was initially proposed for merging text documents represented as a sequence of characters
7 more annotations...
- generic merge framework.
- a set of transformation functions. These functions merge concurrent modifications in serializing two concurrent operations. These functions are specific to a particular type of replicated data like string of characters, XML document or file system.
- $o p 2$ may depend on effects of execution of $o p 1$ .
- When two operations are not causally connected by a precedence relation, they are concurrent.
- $op_1 \circ T(op_2,op_1) \equiv op_2<br/> \circ T(op_1,op_2)$
- $T(op_3, op_1 \circ T(op_2,op_1)) = T(op_3, op_2 \circ T(op_1,op_2))$

Google Wave Operational Transform ‎(Google Wave Federation Protocol)‎

www.waveprotocol.org/...operational-transform - Preview

protocol Google Wave concurrent starred

Waves are hosted XML documents that allow seamless and low latency concurrent modifications.
Wave uses Operational transformation (OT) as the theoretical framework of concurrency control.
22 more annotations...
- Collaborative document editing means multiple editors being able to edit a shared document at the same time.. Live and concurrent means being able to see the changes another person is making, keystroke by keystroke.
- do not offer a seamless live concurrent editing experience, as merge failures can occur.
- Wave stands as a solution that offers both live concurrent editing and rich text document support.
- Wave's core technology allows live concurrent modifications of XML documents which can be used to represent any structured content including system data that is shared between clients and backend systems.
- Wave OT replicates the shared document at all sites
- Optimistic UI means user actions are executed and displayed locally to the user immediately without waiting for the server to respond.
- A Wave is a collection of Wavelets. A Wavelet is a collection of documents. A document consists of an XML document and some annotations. A Wavelet is where concurrent modification takes place. A Wavelet is the object on which OT is applied.
- This document will detail the extensions Wave made to the basic theory of OT and how Wave operations support rich text documents. Most importantly, this document details how we have designed Wave operations to transform large numbers of operations efficiently and how they allow efficient look up into any point of a Wavelet's history.
- the client and server can traverse through the state space via different OT paths to the same convergent state depending on when they receive the other parties operations.
- One short coming of this is the server needs to carry a state space for every connected client
- Wave OT modifies the basic theory of OT by requiring the client to wait for acknowledgement from the server before sending more operations.
- Whilst the client is waiting for the acknowledgement, it caches operations produced locally and sends them in bulk later.
- inferred server path
- Non document operations are for tasks such as adding or removing a participant to a Wavelet.
- The document operation consists of a sequence of ordered document mutations. The mutations are applied in sequence as you traverse the document linearly.
- In Wave, every 16-bit Unicode code unit (as used in javascript, JSON, and Java strings), start tag or end tag in an XML document is called an item.
- write transformation function
- Wave document operations consist of the following mutation components:
  skip
  insert characters
  insert element start
  insert element end
  insert anti-element start
  insert anti-element end
  delete characters
  delete element start
  delete element end
  delete anti-element start
  delete anti-element end
  set attributes
  update attributes
  commence annotation
  conclude annotation

20 May 09

trunk/reference/Concurrent Parallel and Distributed - Code Search

左边有不少有价值的文章

www.google.com/p - Preview

async concurrent distributed io comet starred

Kenyth Zeng's Library tagged concurrent → View Popular

Concurrency (computer science) - Wikipedia, the free encyclopedia

epoll(7)

Dr. Dobb's | NPTL: The New Implementation of Threads for Linux | August 1, 2005

Lesson: Concurrency (The Java™ Tutorials > Essential Classes)

Java theory and practice: Managing volatility

The volatile keyword in Java

Understanding Java Multithreading and Read-Write Locks, Part 1 — Developer.com

Double-checked locking - Wikipedia, the free encyclopedia

VM Spec Threads and Locks

Threads and Locks

Difference between sleep and wait | Geek Explains: Java, J2EE, Oracle, Puzzles, and Problem Solving!

Typical use of the volatile keyword in Java

Java theory and practice: Thread pools and work queues

Erlang开发及应用

谷奥——探寻谷歌的奥秘 (http://google.org.cn) » 来自Google I/O 2009现场的Google Wave讲座

What is Optimistic Locking vs. Pessimistic Locking [Archive] - DBAsupport.com Forums

Google Wave Data Model and Client-Server Protocol ‎(Google Wave Federation Protocol)‎

Operational transformation - Wikipedia, the free encyclopedia

Google Wave Operational Transform ‎(Google Wave Federation Protocol)‎

trunk/reference/Concurrent Parallel and Distributed - Code Search

Selected Tags

Related Tags

Sponsored Links

Top Contributors

Groups interested in concurrent

Collaboration

PEERS ONLINE INTERACTION FRAMEWORK

Designing an Academic Poster