Shulou(Shulou.com)06/02 Report--

This article focuses on "Java thread synchronization problem analysis", interested friends may wish to take a look. The method introduced in this paper is simple, fast and practical. Next, let the editor take you to learn "Java thread synchronization problem analysis"!

The basic implementation idea of Java thread synchronization is relatively easy to understand. We can add a lock to the shared resource, which has only one key. Which thread acquires the key has access to the shared resource. In life, we may also encounter such examples. Some automatic lockers are provided outside some supermarkets. Each locker has a lock and a key. People can use lockers with keys, put things in them, lock them, and then take the keys away. In this way, the locker is locked and no one else can access the locker. Of course, real locker keys can be taken away and copied, so don't put valuables in supermarket lockers. So many supermarkets have adopted electronic password locks. )

The model of Java thread synchronization locks looks intuitive. However, there is a serious problem that has not been solved. Where should this synchronization lock be added? Added to shared resources, of course. Readers who are quick to respond are sure to answer first.

Yes, if possible, we certainly try to add synchronization locks to shared resources. Some relatively perfect shared resources, such as file system, database system, etc., provide a relatively perfect synchronous locking mechanism. We don't have to lock these resources separately, they have locks of their own.

However, in most cases, the shared resources we access in the code are relatively simple shared objects. There is no place for us to lock on these objects. Readers may suggest: why not add a new area inside each object for locking? Of course, this kind of design is feasible in theory. The problem is that Java thread synchronization is not very common. If a lock space is opened up inside all objects because of this small probability event, it will bring a great waste of space. the loss outweighs the gain.

Therefore, the design idea of modern programming languages is to add synchronization locks to code segments. To be exact, the synchronization lock is added to the "code snippet that accesses the shared resource". It is important to remember that synchronization locks are added to code snippets.

The synchronization lock is added to the code segment, which solves the problem of space waste mentioned above. But it not only increases the complexity of the model, but also increases the difficulty of our understanding. Now let's take a closer look at the Java thread synchronization model of "synchronization locks on code snippets".

First of all, we have solved the problem of where to add the synchronization lock. We have determined that synchronization locks are not added to shared resources, but to code segments that access shared resources.

Second, the problem we have to solve is what kind of lock we should add to the code segment. This question is the focus of the key point. This is a problem that we should pay particular attention to: different code segments that access the same shared resource should add the same synchronization lock; if you add a different synchronization lock, it does not play the role of synchronization at all and does not make any sense.

That is to say, the synchronization lock itself must be a shared object between multiple threads.

At this point, I believe you have a deeper understanding of "Java thread synchronization problem analysis", might as well come to the actual operation of it! Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.