Methods to create and run java threads

The Java thread class is also an object class, and its instances all inherit from java.lang.Thread or its subclasses. You can create a thread in java in the following way:

Tread thread = new Thread();

To execute the thread, you can call the start() method of the thread:

thread.start();

In the above example, we did not Write the running code for the thread, so the thread terminates after calling this method.

There are two ways to write code that is executed when a thread is running: one is to create an instance of the Thread subclass and override the run method, and the second is to implement the Runnable interface when creating the class. Next we will explain these two methods in detail:

Create a subclass of Thread

Create an instance of the Thread subclass and override the run method. The run method will call the start() method be executed afterwards. Examples are as follows:

public class MyThread extends Thread {  public void run(){    System.out.println("MyThread running");  }}

You can create and run the above Thread subclass in the following way

MyThread myThread = new MyThread();myTread.start();

The start method will return immediately once the thread is started, without waiting for the run method to complete execution. . It is as if the run method is executed on another CPU. When the run method is executed, the string MyThread running will be printed.

You can also create an anonymous subclass of Thread as follows:

Thread thread = new Thread(){  public void run(){    System.out.println("Thread Running");  }};thread.start();

When the run method of the new thread is executed, the computer will print out the string "Thread Running".

Implementing the Runnable interface

The second way to write thread execution code is to create a new instance of a class that implements the java.lang.Runnable interface. The methods in the instance can be called by the thread. An example is given below:

public class MyRunnable implements Runnable {  public void run(){   System.out.println("MyRunnable running");  }}

In order to enable the thread to execute the run() method, the instance object of MyRunnable needs to be passed in the constructor of the Thread class. An example is as follows:

Thread thread = new Thread(new MyRunnable());thread.start();

When the thread is running, it will call the run method that implements the Runnable interface. In the above example, "MyRunnable running" will be printed.

Similarly, you can also create an anonymous class that implements the Runnable interface, as shown below:

Runnable myRunnable = new Runnable(){  public void run(){    System.out.println("Runnable running");  }}Thread thread = new Thread(myRunnable);thread.start();

Create a subclass or implement the Runnable interface?

There is no definite answer as to which of the two methods is better, they can both meet the requirements. In my personal opinion, I prefer to implement the Runnable interface. Because the thread pool can effectively manage threads that implement the Runnable interface, if the thread pool is full, new threads will be queued for execution until the thread pool is free. If threads are implemented by implementing a Thread subclass, this will be more complicated.

Sometimes we have to combine the two ways of implementing the Runnable interface and the Thread subclass at the same time. For example, an instance that implements a Thread subclass can execute multiple threads that implement the Runnable interface. A typical application is the thread pool.

Common mistake: calling the run() method instead of the start() method

A common mistake made when creating and running a thread is to call the thread's run() method instead of the start() method , as shown below:

Thread newThread = new Thread(MyRunnable());newThread.run();  //should be start();

At first you won’t feel anything wrong, because the run() method is indeed called as you expected. However, in fact, the run() method is not executed by the new thread just created, but by the current thread that created the new thread. That is, executed by the thread that executes the above two lines of code. If you want the created new thread to execute the run() method, you must call the start method of the new thread.

Thread name

When creating a thread, you can give the thread a name. It helps us differentiate between different threads. For example: If multiple threads write to System.out, we can easily find out which thread is outputting through the thread name. An example is as follows:

MyRunnable runnable = new MyRunnable();Thread thread = new Thread(runnable, "New Thread");thread.start();System.out.println(thread.getName());

It should be noted that because MyRunnable is not a subclass of Thread, the MyRunnable class does not have a getName() method. You can get the reference of the current thread in the following way:

Thread.currentThread();

Therefore, you can get the name of the current thread through the following code:

String threadName = Thread.currentThread().getName();

Thread code example:
Here is a small example . First, output the name of the thread executing the main() method. This thread is allocated by the JVM. Then start 10 threads and name them 1~10. Each thread exits after outputting its own name.

public class ThreadExample { public static void main(String[] args){    System.out.println(Thread.currentThread().getName());     for(int i=0; i<10; i++){        new Thread("" + i){           public void run(){            System.out.println("Thread: " + getName() + "running");           }        }.start();     } }}

It should be noted that although the order of starting threads is orderly, the order of execution is not orderly. In other words, thread No. 1 is not necessarily the first thread to output its name to the console. This is because threads execute in parallel rather than sequentially. The Jvm and the operating system determine the execution order of threads, and it is not necessarily consistent with the startup order of threads.

Related recommendations:

Simple code example of Java thread-safe counter

##Instance analysis of synchronization and asynchronousness of objects in Java threads

Wait/notify for communication between Java threads

The above is the detailed content of Methods to create and run java threads. For more information, please follow other related articles on the PHP Chinese website!