Creation and startup of java multi-threading

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++) {
            //调用Thread类的currentThread()方法获取当前线程
            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 {
        // 创建MyCallable对象
        Callable<Integer> myCallable = new MyCallable();
        //使用FutureTask来包装MyCallable对象
        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循环执行完毕..");
        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!