Lock object: method call object

Lock object: bytecode pair of the current class

Lock object: bytecode object

Lock object: implementation class object

Fair lock: The thread at the front of the waiting queue gets the lock first.

Unfair lock: a random thread gets the lock, causing thread starvation problem

public boolean tryLock (long timeout, TimeUnit unit)

After waiting for a period of time, try to acquire the lock. If it is not acquired, it returns false, and if it is acquired, it returns true (waiting continuously to grab the lock will block the thread until the lock is acquired and the waiting time has expired)

synchronized and ReentrantLock are both exclusive locks

synchronized and ReentrantLock are both reentrant locks

synchronized and ReentrantLock are both pessimistic locks

Synchronized locking and unlocking are completed by jvm and cannot be controlled by the user, while ReentrantLock locking and unlocking are controlled by the user.

ReentrantLock is a reentrant lock. You need to manually release the lock several times after locking it, but sync is completed automatically.

synchronized cannot respond to interrupts. It will wait until it can get the lock. However, ReentrantLock can use tryLock to respond to interrupts. If it cannot get the lock for a period of time, it will not take it. There is no need to block and wait.

Writing cannot be done concurrently

Reading and writing are not concurrent

Reading can be done concurrently

Lock downgrade means downgrading from a write lock to a read lock. When the current thread owns the write lock, the process of acquiring the read lock again and subsequently releasing the write lock is lock downgrading.

lock object .wait ()

lock object . notify ( )

Lock object . notifyAll ( )

reentrantLock . newCondition ( ) . await ( )

condition. signal ( )

condition. signalAll ( )

More detailed than synchronized, you can specify a waiting thread to wake up

Solution: Use notifyAll or signalAll to wake up all threads. Threads that do not meet the conditions will still enter the waiting state.

new FutureTask<String>(callable)

ArrayBlockingQueue: A bounded blocking queue composed of an array structure

LinkedBlockingQueue: A bounded (but the default size is integer.MAX_VALUE) blocking queue composed of a linked list structure

PriorityBlockingQueue: Unbounded blocking queue that supports priority sorting

DelayQueue: Delayed unbounded blocking queue implemented using priority queue

SynchronousQueue: A blocking queue that does not store elements, that is, a queue with a single element

LinkedTransferQueue: unbounded blocking queue composed of linked list

LinkedBlockingDeque: a two-way blocking queue composed of a linked list

throw an exception

special value

block

time out

Executors.newFixedThreadPool()

Executors.newSingleThreadExecutor()

Executors.newCachedThreadPool();

Executors.newScheduledThreadPool();

Executors.newSingleThreadScheduledExecutor();

The threads created by the thread tool class will cause a large number of threads to accumulate, leading to OOM

corePoolSize number of core threads

maximumPoolSize maximum number of threads

keepAliveTime non-core thread survival time

TimeUnit survival time unit

BlockingQueue thread waiting queue

The first five parameters can also customize a thread pool

ThreadFactory thread factory

RejectedExecutionHandler rejection strategy

Default rejection policy, throw exception directly

Handed over to the thread in the current thread pool for execution

Discard it directly without processing or throwing an exception.

Discard the oldest thread in the queue, which is the frontmost thread in the queue, and then add the new thread to it.

Only thread tasks that implement the Runnable interface can be passed in

Thread tasks that implement the Callable interface can be passed in

main memory

working memory

atomicity

visibility

Orderliness

visibility

Orderliness

visibility

Orderliness

Compare and Swap. Compare and swap means CAS is an optimistic locking algorithm that solves multi-thread concurrency security issues.

Memory address A

old value B

new value C

Its function is to compare the contents of the specified memory address A with the given old value B. If they are equal, replace its contents with the new value C provided in the instruction; if they are not equal, the update fails.

Lock

Semaphore

CountDownLatch

CyclicBarrier

Achieved through AQS. The specific usage is to implement its template method by inheriting AQS, and then use the subclass as the internal class of the synchronization component

The shared resource variable state is 0 and the lock is available. If it is 1, it means that the lock is occupied.

FIFO (first-in-first-out) thread wait queue

tryAcquire(int): exclusive mode. Try to obtain the resource, return true if successful, false if failed

tryRelease(int): exclusive mode. Try to release the resource, returning true if successful, false if failed.

tryAcquireShared(int): sharing method. Try to get resources. A negative number indicates failure; 0 indicates success, but there are no remaining available resources; a positive number indicates success, and there are remaining resources.

tryReleaseShared(int): Sharing mode. Try to release the resource. If it is allowed to wake up the subsequent waiting node after the release, it returns true, otherwise it returns false.

sHeldExclusively(): Whether the thread is occupying resources exclusively. Only when condition is used do you need to implement it.

Locking and unlocking are actually AQS using CAS to modify its state attributes.

The wake queue is called Unsafe's park() and unpark()

1. Come up with compareAndSetState and try it out.

2. Unsuccessful acquisition acquire(1);

acquire(1); Because there is no random grabbing due to fair locking, acquire(1) is used for queuing.

1. tryAcquire; if (!hasQueuedPredecessors() && compareAndSetState(0, acquires)) queue first

2. acquireQueued:

Lock downgrade means downgrading from a write lock to a read lock. When the current thread owns the write lock, the process of acquiring the read lock again and subsequently releasing the write lock is lock downgrading.

1. There is no thread competition, and the lock mark bit in the object header is marked as a biased lock.

2. If there is thread competition, upgrade the biased lock to a lightweight lock

3. If a thread spins ten times without grabbing the lock, it will be upgraded to a heavyweight lock.

Core threads = number of CPUs * 2, non-core threads = number of CPUs * 4