1. How to prevent deadlock?

Four necessary conditions for deadlock:

Mutual exclusion condition: The process does not allow other processes to access the allocated resources. If other processes access the resources, they can only Wait until the process occupying the resource releases the resource after completing use

Request and retention conditions: After the process obtains a certain resource, it makes a request for other resources, but the resource may be occupied by other processes. This matter The request is blocked, but the resource obtained by itself is retained.

Nondeprivation condition: refers to the resource that the process has obtained. It cannot be deprived before the use is completed, and can only be released after use.

Loop waiting conditions: refers to the formation of a head-to-tail loop waiting resource relationship between several processes after a deadlock occurs in a process.

These four conditions are the necessary conditions for deadlock. , as long as a deadlock occurs in the system, these conditions must be true, and as long as one of the above conditions is not met, a deadlock will not occur.

Understanding the reasons for deadlock, especially the four necessary conditions for deadlock, you can avoid, prevent and eliminate deadlock to the greatest extent possible.

Therefore, in terms of system design, process scheduling, etc., pay attention to how to prevent these four necessary conditions from being established, how to determine a reasonable resource allocation algorithm, and to avoid processes permanently occupying system resources.

In addition, it is also necessary to prevent the process from occupying resources while it is in a waiting state. Therefore, the allocation of resources must be properly planned.

(Video tutorial recommendation: java video)

2. What is ThreadLocal? What are the usage scenarios?

Thread local variables are variables limited to the thread. They belong to the thread itself and are not shared among multiple threads. Java provides the ThreadLocal class to support thread local variables, which is a way to achieve thread safety. But be especially careful when using thread-local variables in a managed environment (such as a web server), where the lifetime of the worker thread is longer than the lifetime of any application variables. Once any thread-local variable is not released after the work is completed, the Java application is at risk of memory leaks.

3. Tell me about the underlying implementation principle of synchronized?

Synchronized can ensure that when a method or code block is running, only one method can enter the critical section at the same time. It can also ensure the memory visibility of shared variables.

Every object in Java can be used as a lock, which is the basis for synchronized to achieve synchronization:

Common synchronization method, the lock is the current instance object

Static synchronization method, lock It is the class object of the current class

Synchronized method block, and the lock is the object in the brackets

4. What is the difference between synchronized and volatile?

The essence of volatile is to tell the jvm that the value of the current variable in the register (working memory) is uncertain and needs to be read from the main memory; synchronized locks the current variable and only the current thread can When accessing this variable, other threads are blocked.

volatile can only be used at the variable level; synchronized can be used at the variable, method, and class levels.

volatile can only realize the modification visibility of variables and cannot guarantee atomicity; while synchronized can guarantee the modification visibility and atomicity of variables.

Volatile will not cause thread blocking; synchronized may cause thread blocking.

Variables marked volatile will not be optimized by the compiler; variables marked synchronized can be optimized by the compiler.

5. What is the difference between synchronized and Lock?

First of all, synchronized is a built-in keyword in java. At the jvm level, Lock is a java class;

synchronized cannot determine whether the lock status is acquired, but Lock can determine whether the lock is acquired;

synchronized will automatically release the lock (a thread will release the lock after executing the synchronization code; b thread will release the lock if an exception occurs during execution), Lock needs to be released manually in finally (the unlock() method releases the lock), Otherwise, it is easy to cause thread deadlock;

Use the synchronized keyword for two threads 1 and 2. If the current thread 1 obtains the lock, thread 2 will wait. If thread 1 is blocked, thread 2 will wait forever, and the Lock lock will not necessarily wait. If the lock cannot be obtained, the thread can end without waiting;

synchronized locks can be repeated Enterable, uninterruptible, and unfair, while Lock locks are reentrant, judgeable, and fair (both are possible);

Lock locks are suitable for synchronization problems with a large amount of synchronized code, and synchronized locks are suitable for small amounts of code. Synchronization issues.

(Related tutorial recommendations: Introduction to java development)

6. What is the difference between synchronized and ReentrantLock?

synchronized is the same keyword as if, else, for, and while, and ReentrantLock is a class. This is the essential difference between the two. Since ReentrantLock is a class, it provides more and more flexible features than synchronized. It can be inherited, can have methods, and can have various class variables. The scalability of ReentrantLock compared to synchronized is reflected in several points:

ReentrantLock can set the waiting time for acquiring locks, thus avoiding deadlocks

ReentrantLock can obtain information about various locks

ReentrantLock can flexibly implement multiple notifications

In addition, the locking mechanisms of the two are actually different: ReentrantLock calls the Unsafe park method to lock at the bottom, while synchronized should operate on the mark word in the object header.

7. Tell me about the principle of atomic?

The basic characteristic of the classes in the Atomic package is that in a multi-threaded environment, when multiple threads operate on a single variable (including basic types and reference types) at the same time, they are exclusive, that is, when When multiple threads update the value of this variable at the same time, only one thread can succeed, and the unsuccessful thread can continue to try like a spin lock until the execution is successful.

The core methods in the Atomic series of classes will call several local methods in the unsafe class. One thing we need to know first is the Unsafe class, whose full name is: sun.misc.Unsafe. This class contains a large number of operations on C code, including many direct memory allocations and calls to atomic operations. The reason why it is marked as non Safe, I am telling you that a large number of method calls in this will have security risks, and you need to use it with caution, otherwise it will lead to serious consequences. For example, when allocating memory through unsafe, if you specify certain areas, it may lead to something similar to C. The pointer crosses the boundary to other processes.

Recommended tutorial: java interview questions

The above is the detailed content of 2020 New Java Interview Questions-Multi-Threading (4). For more information, please follow other related articles on the PHP Chinese website!