2020 New Java Interview Questions - Multithreading (2)

1. What are the states of threads?

Threads usually have five states, created, ready, running, blocked and dead.

1. Creation state

When the thread object is generated, the start method of the object is not called. This means that the thread is in the creation state.

2. Ready state

When the start method of the thread object is called, the thread enters the ready state, but at this time the thread scheduler has not set the thread as the current thread. It is now in a ready state. After the thread runs, it will also be in the ready state after returning from waiting or sleeping.

3. Running state

The thread scheduler sets the thread in the ready state as the current thread. At this time, the thread enters the running state and starts running the code in the run function.

4. Blocking state

When a thread is running, it is suspended, usually to wait for a certain time to occur (for example, a certain resource is ready) before continuing to run. Sleep, suspend, wait and other methods can cause thread blocking.

5. Death state

If the run method of a thread ends or the stop method is called, the thread will die. For a thread that has died, the start method can no longer be used to make it ready.

(Related video tutorial recommendations: java video)

2. What is the difference between sleep() and wait()?

1. sleep(): The method is a static method of the thread class (Thread), which allows the calling thread to enter sleep state and gives execution opportunities to other threads. After the sleep time is over, the thread becomes ready. The state competes with other threads for CPU execution time. Because sleep() is a static method, it cannot change the object's machine lock. When the sleep() method is called in a synchronized block, although the thread goes to sleep, the object's machine lock is not released, and other threads still cannot access this object.

2. wait(): wait() is a method of the Object class. When a thread executes the wait method, it enters a waiting pool related to the object and releases the object's machine lock at the same time. To enable other threads to access, you can wake up waiting threads through the notify and notifyAll methods.

3. What is the difference between notify() and notifyAll()?

If a thread calls the wait() method of an object, the thread will be in the waiting pool of the object, and the threads in the waiting pool will not compete for the object's lock.

When a thread calls the object's notifyAll() method (wakes up all wait threads) or the notify() method (wakes up only one wait thread randomly), the awakened thread will enter the object's lock pool. , the threads in the lock pool will compete for the object lock. That is to say, after calling notify, only one thread will enter the lock pool from the waiting pool, and notifyAll will move all threads in the object waiting pool to the lock pool to wait for lock competition.

Threads with high priority have a high probability of competing for the object lock. If a thread does not compete for the object lock, it will remain in the lock pool. Only when the thread calls the wait() method again will it Will return to the waiting pool. The thread that competes for the object lock will continue to execute until the synchronized code block is executed, and it will release the object lock. At this time, the threads in the lock pool will continue to compete for the object lock.

4. What is the difference between thread run() and start()?

Each thread completes its operation through the method run() corresponding to a specific Thread object. The method run() is called the thread body. Start a thread by calling the start() method of the Thread class.

start() method to start a thread, truly realizing multi-threaded operation. At this time, there is no need to wait for the run method body code to be executed, and you can directly continue to execute the following code; at this time, the thread is in the ready state and is not running. Then the method run() is called through the Thread class to complete its running status. The method run() here is called the thread body, which contains the content of the thread to be executed. The Run method ends and the thread is terminated. The CPU then schedules other threads.

The run() method is in this thread. It is just a function in the thread, not multi-threaded. If you call run() directly, it is actually equivalent to calling an ordinary function. If you directly use the run() method, you must wait for the run() method to complete execution before executing the following code. Therefore, there is still only one execution path and there is no thread at all. characteristics, so the start() method should be used instead of the run() method during multi-thread execution.

(Recommended tutorial: java introductory program)

5. What are the ways to create a thread pool?

1. newFixedThreadPool(int nThreads)

Create a fixed-length thread pool. Whenever a task is submitted, a thread is created until the maximum number of thread pools is reached. At this time The thread size will no longer change. When a thread terminates due to an unexpected error, the thread pool will replenish a new thread.

2. newCachedThreadPool()

Create a cacheable thread pool. If the size of the thread pool exceeds the processing demand, idle threads will be automatically recycled. When demand increases, new threads can be automatically added. There is no limit to the size of the thread pool.

3. newSingleThreadExecutor()

This is a single-threaded Executor. It creates a single worker thread to perform tasks. If this thread ends abnormally, a new one will be created to replace it; it The characteristic is to ensure that tasks are executed serially according to the order in the queue.

4. newScheduledThreadPool(int corePoolSize)

Creates a fixed-length thread pool and performs tasks in a delayed or scheduled manner, similar to Timer.

For more interview questions, please pay attention to the java interview questions column.

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