【JAVA线程实现】

1. 前言

线程是程序执行流的最小单元，它是程序的执行路径。在多线程编程中，一个进程内可以有多个线程同时执行，共享进程的资源，从而提高程序的执行效率。进程是操作系统进行资源分配的基本单位，线程是独立调度和分派的基本单位。

2. 实现线程的七种方法

2.1. 继承Thread类

Java中的Thread类是所有线程的超类，它实现了Runnable接口，并重写了run()方法，通过继承Thread类，并重写run()方法，可以实现自定义线程

public class MyThread extends Thread {  
    public void run() {  
        // 线程执行的代码  
        System.out.println("继承Thread类");
    }  
    public static void main(String[] args) {
			MyThread myThread = new MyThread();  
			myThread.start(); // 启动线程
	}
}

2.2. 匿名内部类继承Thread类

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread() {
            @Override
            public void run() {
            	// 线程执行的代码
                System.out.println("匿名内部类继承Thread类");
            }
        };
        thread.start();
    }
}

2.3. 实现Runnable接口

Java中的Runnable接口只有一个run()方法，通过实现Runnable接口，可以实现自定义线程，使用实现Runnable接口的方式，可以避免Java不支持多重继承的问题

public class MyRunnable implements Runnable {  
    public void run() {  
    	// 线程执行的代码
        System.out.println("实现Runnable接口");
    }  
    public static void main(String[] args) {
		MyRunnable myRunnable = new MyRunnable();  
		Thread thread = new Thread(myRunnable); // 创建线程对象，并将Runnable对象作为参数传递给Thread构造函数  
		thread.start(); // 启动线程
	}
}

2.4. 匿名内部类实现Runnable接口

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
            	// 线程执行的代码
                System.out.println("匿名内部类实现Runnable接口");
            }
        });
        thread.start();
    }
}

2.5. 使用Lambda表达式

Java 8引入了Lambda表达式，可以使用Lambda表达式实现Runnable接口，实现自定义线程，使用Lambda表达式可以更简洁地实现多线程编程

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
        	// 线程执行的代码
           System.out.println("使用Lambda表达式");
        });
        thread.start();
    }
}

2.6. 实现Callable接口和FutureTask包装器

Callable接口和FutureTask包装器可以用于创建有返回值的线程，Callable接口类似于Runnable接口，但它可以返回值，FutureTask是Callable的一个实现类，可以用来保存Callable的返回值

public class MyCallable implements Callable<Integer> {  
    public Integer call() throws Exception {  
        // 线程执行的代码，并返回结果  
        return 82;  
    }
    public static void main(String[] args) {
		MyCallable myCallable = new MyCallable();  
		FutureTask<Integer> futureTask = new FutureTask<>(myCallable); // 创建FutureTask对象，并将Callable对象作为参数传递给FutureTask构造函数  
		Thread thread = new Thread(futureTask); // 创建线程对象，并将FutureTask对象作为参数传递给Thread构造函数  
		thread.start(); // 启动线程  
		Integer result = futureTask.get(); // 获取线程执行的结果
	}  
}

2.7. 使用ThreadPoolExecutor实现线程池

• ExecutorService是Java中的一个高级线程池框架，它可以管理线程的创建、执行和销毁，Future是ExecutorService的一个返回值，可以用来获取执行任务的返回值
• 但是现在已经不建议使用ExecutorService，它只是对ThreadPoolExecutor中特定的数据进行了封装，现在建议使用原生ThreadPoolExecutor去创建我们所需的线程池
• 这里我就简单使用ExecutorService做演示，具体线程池实现可去【JAVA线程池】中查看

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
public class MyPool {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newCachedThreadPool();
        pool.submit(new Runnable() {
            @Override
            public void run() {
                //执行业务逻辑
                for(int i = 1; i <= 5; i++) {
                    System.out.println("线程:" + Thread.currentThread().getName() + "执行了任务" + i + "~");
                }
            }
        });
        pool.submit(new Runnable() {
            @Override
            public void run() {
                //执行业务逻辑
                for(int i = 6; i <= 10; i++) {
                    System.out.println("线程:" + Thread.currentThread().getName() + "执行了任务" + i + "~");
                }
            }
        });
        pool.submit(new Runnable() {
            @Override
            public void run() {
                //执行业务逻辑
                for(int i = 11; i <= 15; i++) {
                    System.out.println("线程:" + Thread.currentThread().getName() + "执行了任务" + i + "~");
                }
            }
        });
    }
}