Example analysis of interview questions about locking in Java

1. The difference between synchronized effects on static methods and non-static methods

Non-static methods:

Lock the object (can be understood as locking the object Memory is locked (note that only this memory, other similar objects will have their own memory locks), at this time, executing the synchronization method of the object in more than one other thread (note: it is the object) will generate mutual exclusion

Static method: equivalent to locking the class (*.class is located in the code area, the static method is located in the static area, the objects generated by this class share this static method, so N objects compete for this memory),

At this time, as long as it is an object generated by this class, mutual exclusion will occur when calling this static method. That is, all objects of this class share a lock.

2. What are the lock types

(1) Optimistic lock & pessimistic lock

(2) Spin lock & non-spin lock

(3) Reentrant lock & non-reentrant lock

(4) No lock&Lightweight lock&Bias lock&Heavyweight lock

(5)Interaction Exclusion lock & shared lock

(6) Fair lock&unfair lock

3. Several ways of thread synchronization

synchronized modification

volatile achieves synchronization (only visibility is guaranteed, not atomicity)

Use local variables ThreadLocal

Use atomic classes (AtomicInteger, AtomicBoolean...)

Use Lock

Use container classes (BlockingQueue, ConcurrentHashMap)

4. The difference between synchronized and lock mechanisms

synchronized originally used CPU pessimistic locking mechanism, that is, the thread obtains an exclusive lock. An exclusive lock means that other threads can only rely on blocking to wait for the thread to release the lock.

Lock uses optimistic locking. The so-called optimistic locking is to complete an operation without locking each time but assuming that there is no conflict. If it fails due to a conflict, it will be retried until it succeeds. The mechanism implemented by optimistic locking is CAS operation (Compare and Swap).

5. Talk about the issue of thread safety

Thread safety is an issue in the field of multi-threading. Thread safety can be simply understood as a method or an instance that can be used in multiple threads. environment without problems.

In Java multi-threaded programming, multiple ways to achieve Java thread safety are provided:

The simplest way is to use the Synchronization keyword

Use java.util. Atomic classes in the concurrent.atomic package, such as AtomicInteger

Use locks in the java.util.concurrent.locks package

Use thread-safe collections ConcurrentHashMap

Use volatile keys words to ensure variable visibility

The above is the detailed content of Example analysis of interview questions about locking in Java. For more information, please follow other related articles on the PHP Chinese website!