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

Today, I will talk to you about the basics of multithreaded debugging in Java, which may not be understood by many people. In order to let everyone know more, Xiaobian summarizes the following contents for everyone. I hope you can gain something according to this article.

Multithreaded debugging basics

The most valuable debugging tools are thread-centric. Most Java errors are related to thread interaction. Multithreaded debugging allows developers to view execution in each thread running in an application.

Because of the variability of execution order, finding errors in multithreaded applications is much more difficult than in nonthreaded cases. Debugging these applications can be very simple if instructions can be executed in the same predictable order. Of course, this would violate the goal of multithreading. As a result, many IDE debuggers do little in this case because stepping code slows the debugging process and prevents re-creation of error events.

Types of multithreaded errors

Here are a few common multithreaded coding issues to keep an eye on:

Access violations. This problem occurs when two or more threads attempt to access the same memory location.

Deadlock. For example, Thread1 locks ResourceA and Thread2 locks ResourceB. Thread1 then tries to lock on to ResourceB and waits for ResourceB to become available. Meanwhile, Thread2 tries to lock on to ResourceA and waits for ResourceA to become available. Result: Deadlock. One way to prevent deadlocks is not to let processes sleep while locks are set. You can also use synchronization() to ensure that critical parts of the code are accessed by only one thread at a time.

Data contention error. Data contention conditions lock applications, which can happen quite often, such as double-clicking the left mouse button. Data is often corrupted in cases of data contention. To prevent this error, make variables inaccessible to multiple threads. Tools are available to analyze this problem and flag variables where data contention errors may occur.

Synchronization error. This problem can occur with garbage collection. Java automatically handles garbage collection. At this point, all threads go from running to pending.

Use synchronized() method

Different versions of the JVM may also implement thread priority differently, which can affect thread synchronization. We recommend that you test threaded code on multiple operating systems to verify that it is truly cross-platform.

The synchronized() method creates a block of code that simulates locking. The code depicted in the synchronization method allows only one process to run it at a time. But don't use too many synchronized calls because they directly affect code performance. In effect, synchronization stops multithreading.

The following code example uses the synchronization method. This code adds an element to the table by resetting the maximum column size of the table in the instance variable. You can see that multiple threads updating the same variable value can cause damage. Using synchronization helps mitigate this problem.

/** Synchronized method to add an element to a table **/

public void addElement( Patient newPatient )

{

synchronized ( lock )

{

Log query = incomingPatient.getLog();

results = query.getAllSearchResults();

for ( int k = 0; k < results.length; k++)

{

.... // add to table

setMaxColSize(MyTable);

tableContents.add(MyTable);

}

}

}

Avoid multithreading errors

There are ways to avoid terrible thread errors:

If you rely on thread priority to keep threads synchronized, it's important to test the JVM's various classes. Beware of the possibility that two threads assign to both long and double variables simultaneously. The nasty result is that a change in one thread may change a variable, and a second thread may change the same variable again. Consider assigning those variable types synchronously.

Never use the stop() method. In fact, Java 2 opposes this approach. It stops the process immediately, but does not clean up, which causes many problems, including deadlocks and memory locks. Thread should always be terminated by returning from the run() method.

Do not restart stopped threads. The run() method is not called, and the isAlive() method reports an error indicating that the thread is actually dead.

Do not monopolize the CPU. If part of the program monopolizes the CPU, you should run the yield() method, which gives other threads a chance to run as well. See this small example:

double answer = 0;

for (int i=0; i

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.