java concurrency book

Previous blog "Dead java Concurrency"-in-depth analysis of the volatile implementation principle has described the characteristics of volatile: volatile visibility; For a volatile read, you can always see the final write of this variable; volatile atomicity; volatile is atomic for a single read/write (32-bit long, Double), except for composite operations, such as i++; A "memory barrier" is

ThreadPoolExecutor thread execution service for Java concurrency and java multi-thread concurrent execution 1 package com. thread. test. thread; 2 3 import java. util. concurrent. executorService; 4 import java. util. concurrent. define blockingqueue; 5 import

Sophomore semester, just after teaching C + + began to question what they have learned.We spent more than a year, learned C, learned C + +, learned the data structure but why I can do is only limited to brush OJ it? (Of course, OJ Brush is not much) is not as good as reading medium students can at least use flash to make a game out. Then accidentally saw the roommate's book, and had always heard that Java o

Preface Recently found that sometimes after reading a book, time is easy to forget, reading does not summarize the effect of a large discount, it is intended to write this series of articles, one is to tidy up the main points in the book, to help their digestion and understanding; the second is to encourage themselves to read more thinking. The article will not explain the contents of the

lock: When multiple threads are waiting for the same lock, they must be queued in the order in which they are requested, while non-fair locks do not guarantee this, and any thread that waits for a lock has a chance to acquire a lock when the lock is released. Synchronized locks are not fair when locked, Reentrantlock is also an unfair lock by default, but you can require a fair lock by constructing method Reentrantlock (ture).3. Locks can bind multiple conditions: The Reentrantlock object can b

pl1700-Practical Java High concurrency program designLearning to be early, drip records, learning is progress!Essay background: In a lot of times, many of the early friends will ask me: I am from other languages transferred to the development of the program, there are some basic information to learn from us, your frame feel too big, I hope to have a gradual tutorial or video to learn just fine. For learning

, but for 64-bit data types long and double, A loose rule is defined in the model that allows the virtual machine to divide the read and write operations of 64-bit data that are not volatile-modified into two 32-bit operations. Thus, if there are multiple threads sharing a long or double type of variable that is not declared volatile, and both are read and modified, some threads may read a value that is neither the original nor the other thread to modify the value that is worth representing the

Java Concurrency structureOriginal link: http://gee.cs.oswego.edu/dl/cpj/mechanics.htmlContent Thread Synchronous Monitor ThreadA thread is a sequence of calls that are executed independently, and the threads of the same process share some system resources (such as file handles) at the same time to access the object resources (memory resources) created by the same process. The Java.lan

. There is more discussion of this content in hunger and equity.Call Unlock () in the Finally statementIt is important to call unlock () in the finally statement if lock is used to protect the critical section and the critical section is likely to throw an exception. This ensures that the lock object can be unlocked so that other threads can continue to lock it. The following is an example:Lock.lock (); Try { //docritical sections code, //which may throw exception finally { lock.unlock

administrator.Add: Refer to Administrator's registration function.Delete: According to the administrator's ID to delete, the deletion needs to determine whether the ID number exists, the presence of delete and prompt the user to delete the results, otherwise prompt the user ID The number does not exist and is re-entered. Modification: First, according to the user ID number to query the user information, and then modify, modify the same need to judge the input information, the success of the mo

An article reads Java concurrency and thread security, and understands java concurrent threads I. Preface For a long time, I have been trying to analyze the essence of Java thread security. However, I had to put it on hold because I had some micro-points that I couldn't understand, all the points are connected in a ser

Java concurrency: thread pool, saturation policy, customization, expansion, java thread I. Preface When we need to use a thread, we can create a new thread and explicitly call the start () method of the thread. This is very easy to implement, but there are defects in some scenarios: if you need to execute multiple tasks at the same time (that is, the number of co

write operation is volatile also called a variable rule before the next read Operation volatile . Any operation within a thread must be called after the start () Call of this thread, also known as the thread initiation rule. A thread terminates the rule before all operations on a thread are terminated. The end operation of an object must also be called an object finalization rule after the object is constructed. Transitivity I strongly recommend that you read the 16th chapt

A lot of information on the web when describing the Java memory model, will introduce a main memory, and then each worker thread has its own working memory. The data is in main memory and there is a copy in the working RAM. There is a variety of atomic operations between working memory and main storage to synchronize. The following figure comes from this blog But because of the evolving Java version, th

The following information is transferred from http://tutorials.jenkov.com/java-concurrency/volatile.html (using Google Translate):The Java volatile keyword is used to mark Java variables as "stored in primary storage". More precisely, this means that each read volatile variable is read from the main memory of the compu