Java学习-----如何创建线程

在多线程编程中，创建线程是实现并发操作的基础。不同的编程语言和开发环境提供了多种创建线程的方式，每种方式都有其独特的原理、作用、优缺点。下面将详细介绍几种常见的创建线程的方式。​

（一）继承 Thread 类​

在 Java 中，Thread 类是线程操作的核心类，继承 Thread 类创建线程是一种基础方式。通过创建一个继承 Thread 类的子类，并重写其 run () 方法，然后实例化该子类对象，调用 start () 方法即可启动线程。​

Thread 类实现了 Runnable 接口，其中 run () 方法是线程的执行体。当调用 start () 方法时，Java 虚拟机会为该线程分配 CPU 资源等，使其进入就绪状态，当得到 CPU 时间片后，就会执行 run () 方法中的代码。​这种方式可以方便地创建线程，通过重写 run () 方法定义线程要执行的任务，实现线程的并发执行。​

Thread的优点主要有：​实现简单，直接继承 Thread 类，重写 run () 方法即可，无需额外实现接口。​

而缺点则主要有：Java 是单继承机制，一个类继承了 Thread 类后，就不能再继承其他类，灵活性较差。​

下面用一个案例简单的实现一下该继承方式：

class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("线程" + Thread.currentThread().getName() + "执行：" + i);
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.setName("线程1");
        thread.start();
    }
}

​

在上述代码中，MyThread 类继承了 Thread 类，并重写了 run () 方法，在 run () 方法中定义了线程要执行的循环打印任务。在 main 方法中，创建了 MyThread 类的实例，设置线程名称后调用 start () 方法启动线程，线程启动后会执行 run () 方法中的内容。​

（二）实现 Runnable 接口​​

实现 Runnable 接口创建线程，是让一个类实现 Runnable 接口，并重写其 run () 方法，然后将该类的实例作为参数传递给 Thread 类的构造方法，最后调用 Thread 对象的 start () 方法启动线程。​

Runnable 接口中只包含一个 run () 方法，它定义了线程要执行的任务。当将实现了 Runnable 接口的对象传递给 Thread 类后，Thread 类的 run () 方法会调用该对象的 run () 方法，从而实现线程的执行。​这种方式可以让多个线程共享同一个实现了 Runnable 接口的对象，从而共享资源，提高资源的利用率。​

其优缺点主要为：​

优点：一个类可以同时实现多个接口，不影响其继承其他类，灵活性高；多个线程可以共享一个 Runnable 实例，适合多个线程处理同一份资源的场景。​

缺点：相对于继承 Thread 类，实现过程稍显复杂，需要多一步将 Runnable 实例传递给 Thread 类的操作。​

还是一样，用一个简单的案例来实现一下这个方法：

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

public class RunnableTest {
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread thread1 = new Thread(runnable, "线程1");
        Thread thread2 = new Thread(runnable, "线程2");
        thread1.start();
        thread2.start();
    }
}

​

上述代码中，MyRunnable 类实现了 Runnable 接口，重写了 run () 方法。在 main 方法中，创建了 MyRunnable 实例，然后将其作为参数分别传递给两个 Thread 对象，设置不同的线程名称后启动线程。两个线程会共享 MyRunnable 实例，共同执行 run () 方法中的任务。​

（三）实现 Callable 接口​

Callable 接口是 Java 5 中引入的，与 Runnable 接口类似，但它可以返回线程执行的结果，并且可以抛出异常。实现 Callable 接口创建线程时，需要与 FutureTask 类配合使用。​

Callable 接口中的 call () 方法是线程的执行体，该方法有返回值且可以抛出异常。FutureTask 类实现了 Future 接口和 Runnable 接口，它可以接收 Callable 对象作为参数。当将 FutureTask 对象传递给 Thread 类并启动线程后，线程会执行 call () 方法，执行结果会被 FutureTask 保存，通过 FutureTask 的 get () 方法可以获取该结果。​​这种方式适合需要获取线程执行结果的场景，能够方便地处理线程执行过程中可能出现的异常。​

Callable优缺点​主要有

优点：可以获取线程执行结果，能抛出异常，功能更强大；同样遵循面向接口编程思想，不影响类的继承，灵活性高。​

缺点：实现过程相对复杂，需要结合 FutureTask 类使用，获取结果的 get () 方法可能会阻塞当前线程。​

下面是其的一个简单案例

​

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 5; i++) {
            sum += i;
            System.out.println("线程" + Thread.currentThread().getName() + "执行：" + i);
        }
        return sum;
    }
}

public class CallableTest {
    public static void main(String[] args) {
        MyCallable callable = new MyCallable();
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread thread = new Thread(futureTask, "线程1");
        thread.start();
        try {
            int result = futureTask.get();
            System.out.println("线程执行结果：" + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

在该案例中，MyCallable 类实现了 Callable接口，重写了 call () 方法，该方法计算 1 到 5 的和并返回。创建 FutureTask 对象时将 MyCallable 实例传入，再将 FutureTask 对象作为参数创建 Thread 对象并启动线程。通过 futureTask.get () 方法可以获取 call () 方法的返回结果，该方法会阻塞当前线程直到获取到结果。​

（四）使用线程池​

线程池是一种线程管理机制，它预先创建一定数量的线程，当有任务需要执行时，从线程池中取出一个线程来执行任务，任务执行完成后，线程不会被销毁，而是返回到线程池中等待下一个任务。使用线程池创建线程，其实是从线程池中获取线程来执行任务。​

线程池内部维护了一个线程队列和任务队列。当提交任务时，如果线程池中有空闲线程，则立即执行任务；如果没有空闲线程，且当前线程数量未达到线程池的最大容量，则创建新线程执行任务；如果达到最大容量，则将任务放入任务队列等待，当有线程空闲时，再从任务队列中取出任务执行。​线程池可以减少线程的创建和销毁带来的开销，提高系统的性能和资源利用率，同时可以对线程进行统一管理和控制。​

线程池的优缺点主要有：​

优点：降低资源消耗，提高响应速度，便于线程管理（如控制最大并发数等）。​

缺点：线程池的参数设置需要根据实际情况进行调整，设置不当可能会影响性能；对于一些简单的任务，使用线程池可能会增加一定的复杂性。​

下面是一个简单的线程池实现：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class MyTask implements Runnable {
    private int taskId;

    public MyTask(int taskId) {
        this.taskId = taskId;
    }

    @Override
    public void run() {
        System.out.println("任务" + taskId + "由线程" + Thread.currentThread().getName() + "执行");
    }
}

public class ThreadPoolTest {
    public static void main(String[] args) {
        // 创建一个固定大小为3的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 5; i++) {
            executorService.submit(new MyTask(i));
        }
        // 关闭线程池
        executorService.shutdown();
    }
}

在上面的代码中，我们通过 Executors.newFixedThreadPool (3) 创建了一个固定大小为 3 的线程池。然后循环提交 5 个 MyTask 任务到线程池，线程池会从内部的线程中分配线程来执行这些任务。任务执行完成后，线程会返回到线程池中。最后调用 shutdown () 方法关闭线程池。​