How to create multithreading in java? (detailed)

The content of this article is about how to create multi-threading in Java? (Details), it has certain reference value. Friends in need can refer to it. I hope it will be helpful to you.

What is a thread:

A thread is an entity in the process. It is a basic unit that is independently scheduled and dispatched by the system. The thread itself does not own system resources, only It is an indispensable resource during operation, but it can share all the resources owned by the process with other threads belonging to the same process.

On the surface, it is multi-threading, but it is actually a fast execution of the CPU in turns.

##Multi-threading (parallel and concurrency)

1. Parallel: two tasks are performed at the same time, that is, while task A is executing, task B is also executing (multi-core required)

2. Concurrency: Both tasks are requested to run, and the processor can only accept one task, so the two tasks are scheduled to be executed in turn. Since the time interval is very short, it makes people feel that both tasks are running

Multi-threading (the principle of running java program)

The java command will start the jvm, which is equivalent to starting An application (a process). The process will automatically start the "main thread", and the main thread will call the main method

Is starting the jvm single-threaded?

No, it is multi-threaded. At least the garbage collection thread and the main thread will be started

It can be verified through the following code that the main thread and the garbage collection thread are competing for resources from each other

public class TestThread {

    public static void main(String[] args) {
        //4.创建Thread的子类对象
        MyThread myThread = new MyThread();

        //5.启动线程，注意这里使用的是start而不是run方法
        myThread.start();

        for (int i = 0; i < 10000; i ++) {
            System.out.println("This is main thread");
        }
    }


}

//1.继承Thread
class MyThread extends  Thread{

    //2.重写run方法
    @Override
    public void run() {
        super.run();
        //3.线程方法中要执行的代码，可以根据自己的需求填写
        for(int i = 0 ; i < 10000 ; i ++ ) {
            System.out.println("This is MyThread thread ");
        }
    }
}

How to create multi-threads in java

(1) Inherit the Thread class and call the start method

Thread implements the Runnable interface

To implement multi-threading, you must become a subclass of thread and override the run method. Note that when starting a thread, it is not the run method but the start method that is called. If the run method is called, it is equivalent to a normal method and does not open the thread

public class Thread implements Runnable

public class TestThread {

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        //注意这里使用的是start而不是run方法
        myThread.start();

        for (int i = 0; i < 10000; i ++) {
            System.out.println("This is main thread");
        }
    }
}
class MyThread extends  Thread{
    @Override
    public void run() {
        super.run();

        for(int i = 0 ; i < 10000 ; i ++ ) {
            System.out.println("This is MyThread thread ");
        }
    }
}

(2) Implement the runnable interface and rewrite the run method

There is only one method in Runnable, run(), The thread startup method exists in Thread,

then when we finally start the thread, we must start the thread through the subclass object of Thread

public class TestRunnable {

    public static void main(String[] args) {
        //4.创建Thread的子类对象
        Runnable myRunnable = new MyRunnable();

        //5.启动线程,创建Thread并把runnable的子类作为构造参数
        new Thread(myRunnable).start();

        for (int i = 0; i < 10000; i ++) {
            System.out.println("This is main thread");
        }
    }

}
//1.实现runnable接口
class MyRunnable implements Runnable {

    //2.重写run方法
    @Override
    public void run() {
        //3.线程方法中要执行的代码，可以根据自己的需求填写
        for(int i = 0 ; i < 10000 ; i ++ ) {
            System.out.println("This is MyRunnable thread ");
        }
    }
}

implement the Callable interface

To implement threads, in addition to inheriting thread and runnable, you can also implement the Callable interface. The Callable interface provides a call() method that can be used as a thread execution body, which has the same function as run(). But the call() method has more return values ​​than the run() method, and the call() method can declare the exception thrown. So how do we start the Callable thread? Because the Callable interface is not a sub-interface of the Runnable interface, the Callable object cannot be used as a construction parameter of Thread. Java provides another interface, the RunnableFuture interface, which implements Runnable, Future

1. implementation

   Callableinterface

2. Write the

   call method, which is equivalent to the run method in thread. The difference is that the call method allows a return value

3. Pass the Callable implementation class object as a construction parameter to FutureTask to create a FutureTask object.

4. Pass the FutureTask object as a construction parameter to Thread and start the thread

public class CallableDemo {

    public static void main(String[] args) {
        //3.把Callable实现类对象作为构造参数传入FutureTask创建FutureTask对象。
        FutureTask<UUID> futureTask = new FutureTask<UUID>(new MyCallable());
        //4.把FutureTask对象作为构造参数传入Thread，并开启线程
        new Thread(futureTask).start();
        try {
            System.out.println(futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

//1. 实现**Callable**接口
class MyCallable implements Callable<UUID> {

    //2.重写**call**方法，相当于thread中的run方法。不同的是call方法允许有返回值
    @Override
    public UUID call() throws Exception {
        //生成随机数
        return UUID.randomUUID();
    }
}

Inherit Thread to realize the difference between Runnable and Callable

From the source code implementation

Inherit Thread

The subclass rewrites the run() method in Thread and calls the start() method. The jvm will automatically call the subclass's run()

Implementing Runnable

new Thread(myRunnable) puts the reference of runnable in the constructor of Thread, and then passes it to the member variable target of thread. In the Thread run() method, it is determined that if the target is not empty, the run method of the subclass is called

    public void run() {
    if (this.target != null) {
        this.target.run();
    }

Implements the Callable interface

Implements the Callable interface and overrides the Call() method, and can Provides thread return values ​​and can also throw exceptions. Finally, it is passed to the member variable target of Thread through the implementation class FutureTask of Runnable's sub-interface RunnableFuture.

In terms of use and expansion

Inherit Thread

1. Advantages: Directly call the start() method in thread, very simple

2. Disadvantages: Java only supports single inheritance. If a subclass inherits thread, it cannot inherit other classes

Implement Runnable

1. Advantages: java can implement many things

2. Disadvantages: The code writing is complicated and start() cannot be called directly

implementation of Callable

1. Advantages: Java can be implemented in multiple ways, can throw exceptions, and can have return values

2. Disadvantages: Code writing is complicated

The above is the detailed content of How to create multithreading in java? (detailed). For more information, please follow other related articles on the PHP Chinese website!