The creation of threads in Java is common in three basic forms:

1. Inherit the Thread class and override the run() method of this class

Inherit the Thread class and override the run() method of this class

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0 ;i < 50;i++) {
            System.out.println(Thread.currentThread().getName() + "：" + i);
        }
    }
    public static void main(String[] args) {
        for (int i = 0;i<50;i++) {
            //調(diào)用Thread類的currentThread()方法獲取當(dāng)前線程
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 10) {
                new MyThread().start();
                new MyThread().start(); 
            }
        }
    }
}

Running result:

...
main 48
main 49
Thread-0：0
Thread-0：1
Thread-0：2
Thread-0：3
Thread-0：4
Thread-1：0
...

It can be seen from the result:

1. There are three threads: main, Thread-0, Thread-1;

2. The values ??of member variables i output by the two threads Thread-0 and Thread-1 are not continuous (i here are instance variables rather than local variables). Because: when implementing multi-threading by inheriting the Thread class, the creation of each thread requires the creation of a different subclass object, resulting in the two threads Thread-0 and Thread-1 not being able to share the member variable i;

3, The execution of the thread is preemptive, and it does not say that Thread-0 or Thread-1 always occupies the CPU (this is also related to the thread priority. Here, Thread-0 and Thread-1 have the same thread priority. Knowledge about thread priority is not available here. Expand)

(Learning video recommendation: java video tutorial)

2. Create a thread class by implementing the Runnable interface

Define a class that implements the Runnable interface; create an instance object obj of this class; pass obj as a constructor parameter to the Thread class instance object. This object is the real thread object.

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0 ;i < 50 ;i++) {
            System.out.println(Thread.currentThread().getName()+"：" +i);
        }
    }

    public static void main(String[] args) {
       for (int i = 0;i < 50;i++) {
            System.out.println(Thread.currentThread().getName() + "：" +i);
            if (i == 10) {
                MyRunnable myRunnable = new MyRunnable();
                new Thread(myRunnable).start();
                new Thread(myRunnable).start();
            }
        }
        //java8 labdam方式
         new Thread(() -> {
            System.out.println(Thread.currentThread().getName());
        },"線程3").start();
    }
}

Running results:

...
main：46
main：47
main：48
main：49
Thread-0：28
Thread-0：29
Thread-0：30
Thread-1：30
...

1. The member variable i output by thread 1 and thread 2 is continuous, which means that by creating threads in this way, multiple threads can share thread classes. Instance variables, because multiple threads here use the same target instance variable. However, when you run the above code, you will find that the results are actually not continuous. This is because when multiple threads access the same resource, if the resource is not locked, thread safety issues will occur;

2. Java8 can use lambda method to create multi-threads.

3. Create threads through Callable and Future interfaces

Create a Callable interface implementation class and implement the call() method, which will serve as the thread execution body, and the The method has a return value, and then create an instance of the Callable implementation class; use the FutureTask class to wrap the Callable object, which encapsulates the return value of the call() method of the Callable object; use the FutureTask object as the target of the Thread object to create and start a new Thread; call the get() method of the FutureTask object to obtain the return value after the execution of the child thread ends.

public class MyCallable implements Callable<Integer> {
    private int i = 0;
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            sum += i;
        }
        return sum;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 創(chuàng)建MyCallable對(duì)象
        Callable<Integer> myCallable = new MyCallable();
        //使用FutureTask來(lái)包裝MyCallable對(duì)象
        FutureTask<Integer> ft = new FutureTask<Integer>(myCallable);
        for (int i = 0;i<50;i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
            if (i == 30) {
                Thread thread = new Thread(ft);
                thread.start();
            }
        }
        System.out.println("主線程for循環(huán)執(zhí)行完畢..");
        Integer integer = ft.get();
        System.out.println("sum = "+ integer);
    }
}

The return value type of the call() method is consistent with the type in <> when creating the FutureTask object.

Related tutorial recommendations: java quick start

The above is the detailed content of Creation and startup of java multi-threading. For more information, please follow other related articles on the PHP Chinese website!