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.

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

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 ");
        }
    }
}

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 ");
        }
    }
}

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 ");
        }
    }
}

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();
    }
}

Copy after login

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

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

1. Advantages: java can implement many things

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

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!