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

This article mainly introduces the example analysis of Java interview questions, which is very detailed and has certain reference value. Friends who are interested must finish it!

The topics are as follows:

Public class TestSync2 implements Runnable {int b = 100; synchronized void M1 () throws InterruptedException {b = 1000; Thread.sleep (500); / 6 System.out.println ("b =" + b);} synchronized void m2 () throws InterruptedException {Thread.sleep (250); / / 5 b = 2000;} public static void main (String [] args) throws InterruptedException {TestSync2 tt = new TestSync2 (); Thread t = new Thread (tt); / / 1 t.start (); / / 2 tt.m2 () / / 3 System.out.println ("main thread b =" + tt.b); / / 4} @ Override public void run () {try {M1 ();} catch (InterruptedException e) {e.printStackTrace ();}

What is the output of the program?

Program output result

Main thread b=2000b=1000

Or

Main thread b=1000b=1000

Investigate the knowledge points

Synchronize instance lock.

Memory visibility under concurrency.

In java, multithreaded programs are the most difficult to understand and debug, and many times the execution results are not as we imagined. So multithreading in java is particularly difficult. I vaguely remember that when I took the C language level 2 in college, what was the question + + and many other priorities matched together to ask the final output result? this kind of question wanted to test some operator priority and associativity questions. That back is fine, but java multithreading still needs to be well understood. Backrest is not good.

Here's a brief analysis:

This topic involves 2 threads (main thread main, child thread), keywords related to synchronized, Thread.sleep.

The synchronized keyword is still quite complex (maybe sometimes it is not understood properly, so the above topic may be a little misunderstood). Its function is to achieve thread synchronization (there are many ways to achieve thread synchronization, but it is just one of the other things that will be discussed in a later article. We need to study some of the implementations of Doug Lea). Its job is to lock the code that needs synchronization. So that only one thread at a time can enter the synchronization block (which is actually a pessimistic strategy) to ensure that the thread only remembers security.

The usage of the general keyword synchronized

Specify a locked object: lock a given object that needs to be alive before entering the synchronization code.

Act directly on the instance method: it is equivalent to locking the current instance and obtaining the lock of the current instance before entering the synchronization code.

Acting directly on static methods: it is equivalent to locking the current class and acquiring the lock of the current class before entering the synchronization code.

The above code, synchronized usage, actually belongs to the second case. Act directly on the instance method: it is equivalent to locking the current instance and obtaining the lock of the current instance before entering the synchronization code.

Possible misunderstandings

1. Due to the lack of understanding of synchronized, because most of the time, we multithreading is to operate a synchronized method, when two threads call two different synchronized methods, it does not matter, this idea is misleading. Act directly on the instance method: it is equivalent to locking the current instance and obtaining the lock of the current instance before entering the synchronization code.

two。 If one calls the synchronized method. It doesn't matter to call a normal method, and there is no waiting relationship between the two.

These are very useful for the following analysis.

Thread.sleep

Causes the current thread (that is, the thread that called the method) to suspend execution for a period of time, giving other threads a chance to continue execution, but it does not release the object lock. That is, if synchronized synchronization is fast, other threads still cannot access the shared data. Note that this method catches exceptions and is useful for later analysis.

Analysis process

Java is executed from the main method. It is said that there are two threads, but it is useless to change the thread priority here. The priority is only when the two programs have not been executed. Now, as soon as the code is executed, the main thread main has been executed. For the attribute variable int b = 100, there is no visibility problem due to the use of synchronized (there is no need to use the volatile declaration), when performing step 1 (Thread t = new Thread (tt); / / 1) the thread is in the new state and has not yet started working. When the 2 steps are executed (t.start (); / 2) when the start method is called, the thread is actually started and enters the runnable state. The runnable state indicates that it can be executed and everything is ready, but it does not mean that it must be executed on the cpu, and whether the scheduling of the service cpu is really executed or not. Here, when performing the three steps, the lock must be acquired first (because the start needs to call the native method, and everything is ready after the use is completed, but it does not mean that it must be executed on top of the cpu, and whether the scheduling that depends on the service cpu is actually executed before the run method is called and the M1 method is executed). In fact, the Thread.sheep in the two synchronized methods actually doesn't matter, it is estimated to increase the difficulty for confusion. When the 3 steps are executed, the child thread is actually ready very quickly, but because of the existence of synchronized and acting on the same object, the child thread has to wait. Because the execution order in the main method is sequential, it must be completed after step 3 execution to step 4, and because the 3-step execution is complete, the child thread can execute M1. There is a multi-thread who gets the problem first, if the 4 steps get first, then main thread bread2000, if the child thread M1 gets it, the b may have been assigned to 1000 or output before the 4 steps are assigned, the possible result is main thread bread1000 or main thread bread2000. Here, if the 6 steps are removed, then the b = execution is first and the main thread b = is uncertain. But since the six steps exist, main thread b = is in the front anyway, so it is equal to 1000 or 2000 depending on the situation, and then the bust 1000 must be fixed.

Some suggestions on multithreading

Thread is also very precious, so it is recommended to use thread pool, thread pool is used a lot, and it is especially important to be ready to share later.

Give the thread a name. When the online cpu is high, you need to use the advanced jstack, which is much more convenient if you have a name.

Multithreading needs to pay special attention to thread safety issues, and you also need to know whether those threads in jdk are safe, so that there will be no inexplicable problems when using them.

There are some tips to share in the follow-up articles slowly, multithreading is particularly important, but also very difficult, I hope you also pay more attention to it.

Some debugging skills of multithreading

Because of the breakpoint, all threads need to stop when they pass through the breakpoint, causing this point to stop constantly, which is very uncomfortable. There is a conditional breakpoint in eclispe, so it is convenient to stop when the condition is met.

The above is all the contents of the article "sample Analysis of Java interview questions". Thank you for reading! Hope to share the content to help you, more related knowledge, welcome to follow the industry information channel!

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.