A zero-based understanding of the implementation of java threads and a collection of commonly used methods of threads

What is the difference between thread and process? Answer: A process is an independent running environment, which can be regarded as a program or an application. A thread is a task executed in a process. Threads are a subset of processes. A process can have many threads, and each thread performs different tasks in parallel. Different processes use different memory spaces, and all threads share the same memory space.

1. The difference between threads and processes:

1) Thread: the execution unit responsible for program execution in the process
The thread itself relies on the program to run
The thread is the program The sequential control flow in can only use the resources and environment assigned to the program

2) Process: the executing program
A process contains at least one thread

3) Single thread: There is only one thread in the program. In fact, the main method is a main thread

4) Multi-threading: running multiple tasks in one program
The purpose is to better use CPU resources

2. Thread implementation

1. Inherit the Thread class: Defined in the java.lang package, inheriting the Thread class must override the run() method

class MyThread extends Thread{
    private static int num = 0;    public MyThread(){
        num++;
    }

    @Override    public void run() {
        System.out.println("主动创建的第"+num+"个线程");
    }
}

Create After you have your own thread class, you can create a thread object and then start the thread through the start() method. Note that the run() method is not called to start the thread. The run method only defines the tasks that need to be performed. If the run method is called, it is equivalent to executing the run method in the main thread. There is no difference from ordinary method calls. At this time, there is no A new thread will be created to perform the defined tasks.

public class Test {
    public static void main(String[] args)  {
        MyThread thread = new MyThread();
        thread.start();
    }
}class MyThread extends Thread{
    private static int num = 0;    public MyThread(){
        num++;
    }
    @Override    public void run() {
        System.out.println("主动创建的第"+num+"个线程");
    }
}

In the above code, by calling the start() method, a new thread will be created. In order to distinguish the difference between start() method call and run() method call, please look at the following example:

public class Test {
    public static void main(String[] args)  {
        System.out.println("主线程ID:"+Thread.currentThread().getId());
        MyThread thread1 = new MyThread("thread1");
        thread1.start();
        MyThread thread2 = new MyThread("thread2");
        thread2.run();
    }
}class MyThread extends Thread{
    private String name;    public MyThread(String name){        this.name = name;
    }

    @Override    public void run() {
        System.out.println("name:"+name+" 子线程ID:"+Thread.currentThread().getId());
    }
}

Running results:
The following conclusions can be drawn from the output results:

1) Thread1 and thread2 have different thread IDs, thread2 has the same ID as the main thread, which means that calling the run method does not create a new thread, but runs the run method directly in the main thread, which is different from ordinary method calls. Any difference;

2) Although the start method call of thread1 is called before the run method of thread2, the information related to the run method call of thread2 is output first, indicating that the process of creating a new thread will not block the main thread. subsequent execution.

2. Implement the Runnable interface
In addition to inheriting the Thread class when creating a thread in Java, you can also implement similar functions by implementing the Runnable interface. Implementing the Runnable interface must override its run method.
The following is an example:

public class Test {
    public static void main(String[] args)  {
        System.out.println("主线程ID："+Thread.currentThread().getId());
        MyRunnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
    }
} 
class MyRunnable implements Runnable{
    public MyRunnable() {
    }

    @Override    public void run() {
        System.out.println("子线程ID："+Thread.currentThread().getId());
    }
}

The Chinese meaning of Runnable is "task". As the name suggests, by implementing the Runnable interface, we define a subtask and then hand over the subtask to Thread for execution. Note that this method must use Runnable as a parameter of the Thread class, and then use Thread's start method to create a new thread to perform the subtask. If you call Runnable's run method, no new thread will be created. This ordinary method call makes no difference.

In fact, if you look at the implementation source code of the Thread class, you will find that the Thread class implements the Runnable interface.

In Java, these two methods can be used to create threads to perform subtasks. Which method to choose depends on your own needs. Directly inheriting the Thread class may look simpler than implementing the Runnable interface, but since Java only allows single inheritance, if a custom class needs to inherit other classes, it can only choose to implement the Runnable interface.

3. Use ExecutorService, Callable, and Future to implement multi-threading with returned results.

You will learn about multi-threading later. For now, let’s know this method. Can.

ExecutorService, Callable, and Future objects actually belong to functional classes in the Executor framework. If you want to learn more about the Executor framework, you can visit http://www.javaeye.com/topic/366591, where the framework is explained in detail. The thread that returns the result is a new feature introduced in JDK1.5. It is indeed very practical. With this feature, I no longer need to go through a lot of trouble to get the return value, and even if it is implemented, it may be full of loopholes.

Tasks that can return a value must implement the Callable interface. Similarly, tasks that do not return a value must implement the Runnable interface. After executing the Callable task, you can obtain a Future object. By calling get on the object, you can obtain the Object returned by the Callable task. Combined with the thread pool interface ExecutorService, you can implement the legendary multi-threading that returns results. A complete multi-thread test example with returned results is provided below. It has been verified under JDK1.5 and can be used directly without any problems. The code is as follows:

/**
* 有返回值的线程 
*/ @SuppressWarnings("unchecked")  
public class Test {  public static void main(String[] args) throws ExecutionException,  
    InterruptedException {  
   System.out.println("----程序开始运行----");  
   Date date1 = new Date();  

   int taskSize = 5;  
   // 创建一个线程池  
   ExecutorService pool = Executors.newFixedThreadPool(taskSize);  
   // 创建多个有返回值的任务  
   List list = new ArrayList();  
   for (int i = 0; i < taskSize; i++) {  
    Callable c = new MyCallable(i + " ");  
    // 执行任务并获取Future对象  
    Future f = pool.submit(c);  
    // System.out.println(">>>" + f.get().toString());  
    list.add(f);  
   }  
   // 关闭线程池  
   pool.shutdown();  

   // 获取所有并发任务的运行结果  
   for (Future f : list) {  
    // 从Future对象上获取任务的返回值，并输出到控制台  
    System.out.println(">>>" + f.get().toString());  
   }  

   Date date2 = new Date();  
   System.out.println("----程序结束运行----，程序运行时间【" 
     + (date2.getTime() - date1.getTime()) + "毫秒】");  
}  
}  

class MyCallable implements Callable