How to use threads in java

How to use threads in java: First create a thread, you can use the inherited Thread class or implement the Runnable interface to create a thread; after the thread is created, then write different methods for different threads; finally call start() You can use the thread by starting the thread.

Thread (English: thread) is the smallest unit that the operating system can perform calculation scheduling. It is included in the process and is the actual operating unit in the process. A thread refers to a single sequential control flow in a process. Multiple threads can run concurrently in a process, and each thread performs different tasks in parallel. It is also called lightweight processes in Unix System V and SunOS, but lightweight processes refer more to kernel threads, while user threads are called threads.

If you want to use threads, you need to create threads. Now let’s take a look at how to create threads.

There are two main ways to implement thread programming: one is to inherit the Thread class, and the other is to implement the Runnable interface.

Inherit the Thread class

Before learning how to implement threads, let’s first take a look at the structure of the Thread class, as follows:

public class Thread implements Runnable

From the above source The code can be found that the Thread class implements the Runnable interface and has a polymorphic relationship between them.

In fact, the biggest limitation of using the method of inheriting the Thread class to implement multi-threading is that it does not support multiple inheritance. Because the characteristic of the Java language is single-root inheritance, so in order to support multiple inheritance, the Runnable interface can be implemented. , while implementing and inheriting. However, the properties of threads created in these two ways are the same when working, and there is no essential difference.

The Thread class has the following two common construction methods:

public Thread(String threadName)
public Thread()

The syntax format of inheriting the Thread class to implement threads is as follows:

public class NewThreadName extends Thread
{    //NewThreadName 类继承自 Thread 类
    public void run()
    {
        //线程的执行代码在这里
    }
}

Implement Runnable interface

If the thread class to be created already has a parent class, you cannot inherit the Thread class at this time, because Java does not support multiple inheritance, so you need to implement the Runnable interface to deal with such situations.

The syntax format for implementing the Runnable interface is as follows:

public class thread extends Object implements Runnable

A program that implements the Runnable interface will create a Thread object and associate the Runnable object with the Thread object. The Thread class has the following two constructors related to Runnable:

public Thread(Runnable r);
public Thread(Runnable r,String name);

Use either of the above two constructors to associate a Runnable object with a Thread instance. The basic steps to start a thread using the Runnable interface are as follows.

Create a Runnable object.

Use the constructor method with a Runnable object as a parameter to create a Thread instance.

Call the start() method to start the thread.

When creating a thread by implementing the Runnable interface, developers first need to write a class that implements the Runnable interface, and then instantiate an object of this class, thus creating a Runnable object. Next create a Thread instance using the corresponding constructor method. Finally, use this instance to call the start() method of the Thread class to start the thread,

The above is the detailed content of How to use threads in java. For more information, please follow other related articles on the PHP Chinese website!