Analyze the principles of multithreading in Java

Anyone who has studied Java knows that Java is one of the few languages ​​that centrally supports multi-threading. Most languages ​​intelligently run a single program block and cannot run multiple different program blocks at the same time. Java The multi-threading mechanism makes up for this shortcoming. It allows different program blocks to run together, which can make the program run more smoothly and achieve the purpose of multi-tasking:

##1. The concepts of threads and processes

The current operating system is a multi-tasking operating system. Multithreading is a way to achieve multitasking.

A process is a dynamic execution process of a program, which refers to an application running in memory. Each process has its own independent memory space, and multiple threads can be started in one process. For example, in Windows systems, a running exe is a process. A thread refers to an execution flow in a process, and multiple threads can run in a process. For example, many threads can run in the java.exe process. Threads always belong to a process, and multiple threads in a process share the memory of the process. "Simultaneous" execution is human perception, execution is actually rotated between threads.

　

2. Implementation of threads in Java

There are two ways to achieve multi-threading in Java, one is to integrate the Thread class, and the other is to implement Runnable interface. Let’s look at the creation principle of threads inherited from the Thread class:

First define a thread class. This class must inherit from the Thread class, and the run() method must be explicitly overridden.

For example:

class MyThread extends Thread{

　　public void run(){ //覆写Thread类中的run方法此方法是线程中

　　线程主体; 的主体

　　}

Then define a main class, instantiate the object of the thread class, and initiate the command to start the thread

Such as:

public class ThreadText{

　　public stataic void main(String args[]){

　　MyThread m1=new MyThread();//实例化对象

　　m1.start();//启动多线程

　　}

　　};

Implement the Runnable interface:

First define A thread class inherits from the Runnable interface

For example:

class MyThread implements Runnable{

　　public void run(){ //覆写Runnable接口中的run方法

　　线程主体;

　　}

Then define a main class, instantiate the object of the thread class, and initiate the command to start the thread

For example ：

public class ThreadText{

　　public stataic void main(String args[]){

　　MyThread m1=new MyThread();//实例化Runnable子类对象

　　Thread t1=new Thread(m1);//实例化Thread类对象

　　t1.start();//启动多线程

　　}

　　};

　
3. Several states of threads

In Java, threads usually have five states, creation, ready, running, blocking and die.

The first is to create a state. When the thread object is generated, the start method of the object is not called, which means the thread is in the creation state.

The second is the 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, and it is in the ready state at this time. After the thread runs, it will also be in the ready state after returning from waiting or sleeping.

The third is the running status. 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.

The fourth is the 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.

The fifth is the state of death. 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.

The above is the detailed content of Analyze the principles of multithreading in Java. For more information, please follow other related articles on the PHP Chinese website!