mastering concurrency programming with java 8

synchronized code block), they compete. If one of the threads acquires the object lock, it will continue to execute, and after it exits the synchronized code block, releasing the lock, the other threads that have been awakened will continue to compete to acquire the lock, continuing until all the awakened threads have executed. Deep Understanding: If the thread calls the object's Wait () method, the thread is in the object's wait pool, waiting for the thread in the pool to not compete for the

safety.Copyonwritearraylist is suitable for reading and writing less scenes, for him to read the operation does not need to lock, read and write occurs at the same time will not be blocked, as long as the writing occurs at the same time only need to synchronize.During a write operation, it replicates once, then modifies it on the copied copy, and finally replaces the original data with the copy.3. Data sharing channel: BlockingqueueIt is an interface that is commonly used to share data between

1000,atomicxx is atomic, and the specific method can see the API itself.Let's take a look at the Incrementandget () method: Public Final int Incrementandget () { for (;;) { int current = get (); int Next = current + 1; if (Compareandset (current, next)) return next; } }As described on the face of the CAS algorithm, keep trying until successful, enter Compareandset (): Public Final boolean compareandset (intint update) { re

as value.After reading the set method, look at the Get () method: Public T Get () { = thread.currentthread (); = Getmap (t); if NULL ) { = map.getentry (this); if NULL ) return (T) e.value; } return Setinitialvalue (); }Very concise and clear, from the map to get value, nothing to say, want to know more detailed can see the source code.In addition, because the Threadlocals reference is inside thread, thread does not

If each component is already thread-safe in a composite object, it needs to be added with an additional "thread-safe layer", depending on the situation.Final can modify an attribute that is not copied, as long as it is assigned to a static code block or constructor.Stand-alone state variablesWe can also delegate the security of threads to multiple state variables, as long as they are independent of each other, that is, the combined class does not add any invariants to the multiple state variable

Reprint Please indicate the source: http://blog.csdn.net/ns_code/article/details/17465497 Introduction to the executor framework After Java 5, concurrent programming introduced a new stack of APIs to start, dispatch, and manage threads. The executor framework, which is introduced in Java 5, uses a thread pool mechanism within the java.util.cocurrent package that

sharing the object in multiple threads).Note that the object itself will not escape at the time of publication.Private one object;Control the access path of the object;Plus the appropriate locking mechanism.Instance closure is one of the simplest ways to build a thread-safe class, and it also gives you more flexibility in the choice of lock strategies. Instance closures allow different state variables to be protected by different locks, while other forms of locking require the same lock through

that are completely unrelated to it.The fourth method, usingcombination (composition)The way.Public class ImprovedlistThe improvedlist adds an extra layer of locking through its own built-in lock. It does not care whether the underlying list is thread-safe, and even if the list is not thread-safe or modifies its yoke, improved provides a consistent locking mechanism for thread safety. Although the additional synchronization layer can cause slight performance loss, improvedlist is more robust t

, the implementation is slightly different, such as a synchronous lock to ensure that the lock is re-read from memory into the data refresh cache, release the lock when the data is written back to memory to ensure that the data is visible, and the volatile variable is simply read and write memory.The volatile keyword prevents instructions from being reordered by providing a "memory barrier", in order to implement volatile memory semantics, the compiler inserts a memory barrier in the instruction

method so that only one thread can access the state of the container at a time.Although the synchronization container class is thread-safe, in some cases additional client locks are required to protect the composite operation.Concurrent ContainersJAVA5.0 provides a variety of concurrent containers to improve the performance of the synchronization container. Synchronization containers serialize all access to the container state to achieve their thread safety, and the cost of this approach is to

classCompletionservicetest { Public Static voidMain (string[] args)throwsinterruptedexception, executionexception {executorservice executor= Executors.newfixedthreadpool (10);//Create a thread pool with 10. ThreadsCompletionservice Completionservice =NewExecutorcompletionservice (executor); for(inti = 1; I ) { Final intresult =i; Completionservice.submit (Newcallable () { PublicObject Call ()throwsException {thread.sleep (NewRandom (). Nextint (5000));//leave the current thread dor

A problem may occur when multiple threads access the same variable . Here I use two threads to access an int count variable at the same time, so that they are at the same time +1. At the same time let the thread sleep 1 seconds, each thread executes 10 times, finally should output 20 is right, because count++ is not atomic operation, here need to do concurrency, such as with Syn ... What keywords, of course, there are other ways. Back there.Here in or

concurrent containers to improve the performance of the synchronization container. Concurrenthashmap instead of HashMap, its internal through the segmented lock, to improve the efficiency of concurrent reading and writing Copyonwritearraylist, the underlying array is duplicated whenever the container is modified, so there is some overhead, so only if the iteration is much more than the modify operation, you should use the Executor frameProvides a standard when a method decoupl

Visibility: Multiple threads can share access and manipulate the same variables, but one thread changes to a shared variable, and the other thread doesn't have to see it right away, or even never see it. Because it involves registers and cache levels.Solution: Using the volatile keyword Using the Synchronized keyword 5, synchronizedSynchronized can be used to modify an instance method of a class (protect this), a static method (a protected class object), a code block (arbitrar

Volatile provides a weak synchronization mechanism to ensure that variable updates are notified to other threads. Volatile variables are not cached in registers or invisible to other processors, so the most recent write value is always returned when reading a volatile variable. You can imagine the following semantics, but volatile is a more lightweight synchronization mechanism.volatile can only ensure visibility, but it does not guarantee atomicity. In other words, it cannot be used in composit

Status of Threads: New, Runnable, Blocked, waiting, Timed waiting, Terminated1. RUNNABLE, corresponding to the "Ready" and "running" states, that is, in the ready and running state of the thread in the Java.lang.Thread is displayed as "RUNNABLE"2. BLOCKED, corresponding to the "blocking" state, this thread needs to obtain a lock to continue execution, and this lock is currently held by other threads, so entered a passive wait state, until the lock was grabbed, will again enter the "Ready" state3

(); If the element is not empty else {//Gets the delay time long delay = First.getdelay (nanoseconds); If the delay time is reached, return and remove the team first element if (delay Poll method with timeout (important): /** * Gets and removes the first element of the team, the method blocks until the queue contains an element that reaches the delay time or times out * * @return The first element of the team, or null * @throws interruptedexception block

to define more information that you need.Extended ThreadpoolexecutorThreadpoolexecutor has some life cycle methods: BeforeExecute, AfterExecute, and terminated. These methods can be overridden to implement statistical and monitoring functions.The parallelization of recursive algorithmWhat kind of situation can be parallel?For example, for the loop to do something, and these things are independent of each other. Then these things can actually be done in parallel (for loop is serial execution).Th

1. Basic threading Mechanism　　Defining tasks Public classLiftOffImplementsrunnable{protected intCountdown = 10; Private Static intTaskcount = 0; Private Final intid = taskcount++; PublicLiftOff () {} PublicLIFTOFF (intCountdown) { This. Countdown =Countdown; } PublicString status () {return"#" +id+ "(" + (Countdown>0?countdown: "liftoff!") +"). "; } @Override Public voidrun () { while(countdown-->0) {System.out.println (status ()); Thread.yield (); } }}　　Using the thread c

, you can make Mutableinteger a thread-safe class, as follows: Public class synchronizedinteger { privateint value; Public int Get () { return value; } Public void Set (int value) { this. Value = value; } } The set and get methods are synchronized, with the same object lock, so that the Get method can see the change in the value of the set method, so that the value of values obtained each time t