Brief description of the state of the thread

From:

Introduction to the state of the thread

Multithreading (multithreading) refers to the technology that realizes the concurrent execution of multiple threads from software or hardware.Computers with multi-threading capabilities have hardware support to be able to execute more than one thread at a time, thereby increasing overall processing performance.Systems with this capability include symmetric multiprocessors, multicore processors, and chip-level multiprocessing or simultaneous multithreading processors.In a program, these independently running program fragments are called "threads", and the concept of programming using it is called "multi-threading"
Multi-threading advantages:
1. The use of threads can put the tasks in the program that take up a long time into the background for processing.
2. The user interface can be more attractive. For example, if the user clicks a button to trigger the processing of certain events, a progress bar can pop up to display the processing progress.
3. The running speed of the program may be accelerated.
4. Threads are more useful in the realization of some waiting tasks, such as user input, file reading and writing, and network sending and receiving data.In this case, some precious resources such as memory usage can be released.
5. Multithreading technology also plays a pivotal role in IOS software development

The following author describes the brief description of the state of threads in java, as follows:

Thread includes the following 5 states:

1. New state (New): After the thread object is created, it enters the new state, such as: Thread thread = new Thread()
2. Ready state (Runnable): Also known as "executable state".After the thread object is created, other threads call the start() method of the object to start the thread.For example, thread.start().A thread in a ready state may be scheduled for execution by the CPU at any time
3. Running state (Running): The thread obtains the CPU permission to execute.It should be noted that a thread can only enter the running state from the ready state
4. Blocked state (Blocked): The blocked state is that the thread gives up the right to use the CPU for some reason and temporarily stops running.Until the thread enters the ready state, there is no chance to go to the running state.There are three blocking situations: 1. Waiting for blocking -- By calling the thread's wait() method, the thread waits for the completion of a job.2. Synchronous blocking - the thread fails to acquire the synchronized synchronization lock (because the lock is occupied by other threads), it will enter the synchronous blocking state 3. Other blocking - by calling the thread's sleep() or join() or issuing an IWhen a /O request is made, the thread will enter the blocking state.When the sleep() state times out, join() waits for the thread to terminate or times out, or when the I/O processing is complete, the thread re-enters the ready state
5. Dead state (Dead): the thread finishes executing or exits the run() method due to an exception, and the thread ends its life cycle