imported>Prn Dan Mo |
imported>Prn Dan Mo |
| Line 8: |
Line 8: |
| ===Synchronizers=== | | ===Synchronizers=== |
| ====Mutilthread Synchronization before Java 5==== | | ====Mutilthread Synchronization before Java 5==== |
| Before Java 5, multithreads are supported using the lock mechanism for synchronization. Locks are implemented in | | Before Java 5, multithreads are supported using the lock mechanism for synchronization. |
| Synchronized method. This mechanism “ensures that only one Java thread can execute an object's synchronized methods | | Locks are implemented in Synchronized method. This mechanism “ensures that only one Java |
| at a time” and “also allows | | thread can execute an object's synchronized methods at a time” and “also allows threads |
| | | to wait for resources to become available, and allows the thread that makes resources |
| ====Java 5: Synchronizers====
| | available to notify other threads that are waiting for the resources” [1]. When the |
| In Java 5, the Java concurrent package provides four new classes including: semaphore, countdownlatch, cyclickbarrier, and exchanger, used for data synchronization [5].
| | synchronized keyword is used, the thread which invokes the synchronized method must obtain |
| Semaphore is a counting signal. It maintains a set of permits. The “parking garage” can be a good analogy as an example to explain it. We can think of that the permits in semaphore equals to the capability in a garage. If the permits that have been issued reach the maximum garage capacity, the garage is full. No parking permit can be issued. The garage will have some space for other cars when some permits are returned.
| | a lock for the object which makes this thread the lock holder. The rule of thumb of |
| “CountDownLatch is a synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes. It is initialized with a given count” [6]. Something here that needs to be mentioned that “CountDownLatch is a one-shot phenomenon” [6] meaning that the counter cannot be reused. If you need a counter that can be reset, consider using the CyclicBarrier method stating below.
| | synchronized method is that only one thread can hold this lock at a time. |
| CyclicBarriers is an aid “which allows a set of threads to wait for each other to reach a common barrier point” [6]. CyclicBarriers is useful when a fixed sized group of thread is occasionally but must wait for each other in a program. “The barrier is called cyclic because it can be re-used after the waiting threads are released” [6].
| |
| Exchanger is actually what the word looks like. “It is a synchronization point where two threads can exchange objects. Each thread presents some object on entry to the exchange method and receives the object presented by the other thread on return” [6].
| |
| | |
| ===Concurrent Collections===
| |
| As it is mentioned in the beginning of synchronizer, the lock mechanism is implemented in “synchronized” classes before Java 5 and “synchronized” method will lock the object that’s been accessed by a thread. When an object is locked by one thread, other threads which need to access the same object are going to wait until the object is available. Also, only the resources in the object are protected. Other resources outside the object are not.
| |
| "Synchronized classes can be useful when you need to prevent all access to a collection through a single lock, at the expense of poorer scalability” [5].
| |
| Java realized this issue and therefore enhanced it by supplying some collection implementations such as ConcurrentHashMap, CopyOnWriteArrayList , and CopyOnWriteArraySet. Here only basic concepts will be introduced here due to that this component is a very advanced one in java concurrent package. For more information, please refer to J2SE 5.0 official website for [http://download.oracle.com/javase/1.5.0/docs/api/java/util/concurrent/package-summary.html Package java.util.concurrenct].
| |
| ConcurrentHashMap:
| |
| “It synchronizes different segments in a hash table, not the whole object. Therefore, other threads can still access other segments that are not in synchronization” [7]. So other threads don’t have to wait. This provides the thread safety and also improves balances of the performance.
| |
| CopyOnWriteArrayList:
| |
| “It uses a reference to the state of the array at the point that the iterator was created. This array never changes during the lifetime of the iterator, so interference is impossible” [7]. This means no modification will be allowed when using CopyOnWriteArrayList. Therefore this operation is immutable and also guarantees thread-safety.
| |
| CopyOnWriteArraySet:
| |
| It’s a data structure to protect the data during traversal for modification of the Array. With CopyOnWriteArraySet, any changes in the data structure during traversal results in a copy being made for the modification. However, there is something we have to keep in mind. This is used assuming in that there won’t be too many changes being made. If a lot of possible modifications need to be performed, we are talking a lot of copies as well which could be bad.
| |
| ===Conclusion===
| |
| Capability
| |
| Java 5 still supports the standard concurrent unities which are contained in the previous version and has introduced the new java.util.concurrent package to make our life of concurrent development in Java easier by providing those high-quality implementations for the data synchronization mechanisms [7].
| |
| Advantages
| |
| The benefits of using java.util.concurrent package for developers include [7]
| |
| • Shorter and less messy application code
| |
| • Faster application implementation on schedule
| |
| • More scalable in data synchronization
| |
| • More readability and writ ability for development and debugging
| |
| • Easier maintenance
| |
| Unsolved Issue
| |
| Java concurrent package is not god. The common concurrent programming issue remains unresolved. Java concurrent package still does not ensure there won’t be any deadlock or CPU starvation in an application. It is developers’ responsibilities to take appropriate actions to handle the concurrency and data synchronization in their applications.
| |
| Reference
| |
| [1] Gary Shute, “Java Synchronization”, Available: http://www.d.umn.edu/~gshute/java/synchronization.html
| |
| [2] J2SE API v1.4.2, Available:
| |
| http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Object.html
| |
| [3] “Problems with Java 1.4 synchronization model”, Available:
| |
| http://www.javamex.com/tutorials/synchronization_concurrency_5.shtml
| |
| [4] Garg, V.K., Neeraj Mittal, “A Critique of Java for Concurrent Programming”, IEEE Computer Society, Vol. 6, No. 9, September 2005
| |
| [5] J2SE API v5.0, Available: http://download.oracle.com/javase/1.5.0/docs/api/java/util/concurrent/package-summary.html
| |
| [6] public class: CountDownLatch, Available: http://www.docjar.com/docs/api/java/util/concurrent/CountDownLatch.html
| |
| [7] Qusay Mahmoud, “Concurrent Programming with J2SE 5.0”, 2005, Available: http://java.sun.com/developer/technicalArticles/J2SE/concurrency/
| |
| | |
|
| |
|
|
| |
|
