multithreading vs concurrency in java

false. 6. Break rules. When a thread calls interrupt on another thread, it must be executed before the interrupt call is detected by the interrupted thread. 7. Finalizer rules. The constructor of the object must be completed before the finalizer of the object is started. 8. transitivity. If operation A is performed before action B, action B is performed before Operation C, then action A must be performed before Operation C. Double check lock /** * Double check plus lock, uns

operations of lock, unlock, read, load, assign, use, store, and write are atomic, 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

consistent memory view of the delay, and another potential cost of excessive synchronization is It limits the ability of the VM to optimize code execution If a variable class is to be used concurrently, the class should be made thread-safe, with internal synchronization, which can be significantly more concurrent than locking the entire object externally, otherwise, do not synchronize internally If you synchronize classes internally, you can use different methods to achieve high

Java concurrency deadlock instance, java dead instance 1 package com.thread.test.thread; 2 3 /** 4 * Created by windwant on 2016/6/3. 5 */ 6 public class MyTestDeadLock { 7 public void run() { 8 MyThread mt = new MyThread(); 9 new Thread(mt, "zhangsan").start();10 new Thread(mt, "lisi").start();11 }12 13 class MyThread impl

is mainly two: Enhance the memory semantics of volatile. The old memory model allows volatile variables to be re-ordered with ordinary variables. JSR-133 strictly restricts the reordering of volatile variables and ordinary variables, so that volatile write-read and lock-release-fetches have the same memory semantics. Enhances final memory semantics. In the old memory model, the value of reading the same final variable multiple times may be different. To do this, JSR-133 added two r

, a hunger-like phenomenon will occur and the thread will stop.No Wait (wait-free)No lock requires only one thread to complete the operation within a finite step, while no waiting is further extended on a lock-free basis. It requires all threads to be completed in a limited number of steps, so that they do not cause hunger problems. If you limit the upper limit of this step, you can further decompose the no wait to have no waiting and the number of threads regardless of the few, the difference b

Java concurrency and GC, java concurrent GC 1. synchronized Re-entry scenario: Class of the inheritance relationship, subclass calls the method of the parent class ---------- thread security Methods with synchronized keywords call each other ---------- thread security 2. volatile Purpose: The variable is visible in multiple threads. When the variable value is cha

[Practical Java high concurrency programming design 4] Arrays can also be unlocked: AtomicIntegerArray, java concurrent programming practice pdf In addition to providing basic data types, JDK also prepares arrays and other composite structures for us. The available atomic arrays include AtomicIntegerArray, AtomicLongArray, and AtomicReferenceArray, which respecti

ConcurrenthashmapConcurrenthashmap is composed of the segment array structure and the HASHENTRY array structure.A concurrenthashmap contains a segment array, the structure of segment is similar to HashMap, is an array and a list structure, a segment contains a hashentry array, Each hashentry is an element of a linked list structure, and each segment guardian is an element of the Hashentry array, and when the data for the Hashentry array is modified, it must first obtain its corresponding segment

Java concurrency: counters of thread synchronization mechanism Exechanger, java counters Section 1 CountDownLatch (1) first recognized CountDownLatch (2) Detail CountDownLatch CountDownLatch is implemented by a counter. The initial value of the counter is the number of threads. Every time a thread completes its own task, the counter value is reduced by 1. Wh

. Different threads cannot directly access variables in the working memory of other threads, so the value delivery of shared variables needs to be done through main memory. The root cause of Java concurrency problemsAssume that thread A and thread B colleagues access the member variable x of an object. When thread a needs to manipulate variable A, a copy is copied to the working memory of thread A.