java线程创建的四种方式

谁借莪１个温暖的怀抱￠ 2024-03-23 17:31 13阅读 0赞

Java线程创建的四种方式包括：

继承Thread类：

javaCopy codepublic class MyThread extends Thread {
        @Override
        public void run() {
            // 线程执行的代码
        }
    }
    // 创建线程并启动
    MyThread myThread = new MyThread();
    myThread.start();

实现Runnable接口：

javaCopy codepublic class MyRunnable implements Runnable {
        @Override
        public void run() {
            // 线程执行的代码
        }
    }
    // 创建线程并启动
    MyRunnable myRunnable = new MyRunnable();
    Thread thread = new Thread(myRunnable);
    thread.start();

实现Callable接口：

javaCopy codepublic class MyCallable implements Callable<Integer> {
        @Override
        public Integer call() throws Exception {
            // 线程执行的代码
            return 1;
        }
    }
    // 创建线程并启动
    MyCallable myCallable = new MyCallable();
    ExecutorService executorService = Executors.newSingleThreadExecutor();
    Future<Integer> future = executorService.submit(myCallable);

使用线程池：

javaCopy codeRunnable myRunnable = new Runnable() {
        @Override
        public void run() {
            // 线程执行的代码
        }
    };
    // 创建线程池并执行任务
    ExecutorService executorService = Executors.newFixedThreadPool(10);
    executorService.execute(myRunnable);

使用匿名内部类：

javaCopy codeThread thread = new Thread() {
        @Override
        public void run() {
            // 线程执行的代码
        }
    };
    // 启动线程
    thread.start();

使用Lambda表达式：

javaCopy codeThread thread = new Thread(() -> {
        // 线程执行的代码
    });
    // 启动线程
    thread.start();

使用线程工厂：

javaCopy codeThreadFactory threadFactory = Executors.defaultThreadFactory();
    Thread thread = threadFactory.newThread(() -> {
        // 线程执行的代码
    });
    // 启动线程
    thread.start();

**目录**

Java线程创建的四种方式

1. 使用Thread类

2. 实现Runnable接口

3. 使用Callable和Future

4. 使用线程池

总结

--------------------

线程（Thread）是操作系统能够进行运算调度的最小单位。它是进程内的一个实体，是进程的执行流程。一个进程可以拥有多个线程，这些线程共享进程的资源（如内存空间、文件描述符等），但每个线程有自己的执行栈和局部变量。 线程的创建、销毁和切换由操作系统负责管理，线程之间可以并发执行，互不干扰。相较于进程，线程的创建和切换开销较小，能够更高效地利用计算机的资源。 线程可以分为用户级线程和内核级线程两种类型：

1.  用户级线程：由用户空间的线程库实现和管理，操作系统对其无感知，线程的创建、销毁和调度都由用户程序控制。用户级线程的优点是轻量级，切换快速，但缺点是无法充分利用多核处理器的优势。
2.  内核级线程：由操作系统内核管理，线程的创建、销毁和调度都由操作系统控制。内核级线程的优点是能够充分利用多核处理器的优势，但缺点是线程切换开销较大。 线程的应用广泛，它可以用于并发编程、多任务处理、提高程序的响应速度和资源利用率等。在编程中，可以使用线程来实现并行计算、异步编程、任务分发等功能。然而，线程之间的共享数据和资源访问需要注意同步和互斥的问题，以避免数据竞争和死锁等并发问题。

### Java线程创建的四种方式 ###

在Java中，线程是用于实现多任务并发执行的重要工具。创建线程的方式有多种，本文将介绍Java线程创建的四种常用方式。

### 1. 使用Thread类 ###

Java中的Thread是用于实现多线程编程的类，它提供了创建线程、启动线程和控制线程行为的方法。下面将详细介绍Thread的历史和原理。 历史： Thread最早是在Java 1.0版本中引入的，并且属于Java的核心类库。在此之前，实现多线程编程需要依赖操作系统提供的原生线程机制，而Java的引入使得开发者可以更方便地实现多线程编程。 原理： Thread的原理涉及到Java虚拟机（JVM）和操作系统之间的交互。在Java中，每当我们创建一个Thread对象并调用其start()方法时，JVM会启动一个新的线程来执行run()方法中的代码。 在底层，JVM会将Thread对象映射到操作系统的原生线程上。每个操作系统都有自己的线程调度器，负责在不同的线程之间进行调度。当一个线程被调度到CPU上执行时，它会执行run()方法中的代码，当run()方法执行完毕或者调用了线程的interrupt()方法时，线程会退出。 Thread类提供了一系列方法来控制线程的行为，包括：

1.  start()方法：用于启动线程，使其进入就绪状态，等待被调度执行。
2.  run()方法：线程的主体方法，包含了线程要执行的代码逻辑。
3.  sleep()方法：使线程进入休眠状态，暂停一段时间。
4.  join()方法：等待其他线程执行完毕后再继续执行。
5.  interrupt()方法：中断线程的执行。
6.  yield()方法：让出当前线程的CPU执行时间，让其他线程有机会执行。
7.  setPriority()方法：设置线程的优先级。 多线程的并发执行可以提高程序的性能和响应能力，但也会带来线程安全问题。因此，在多线程编程中，我们需要注意线程同步、互斥和共享资源的访问。 总结： Thread是Java中用于实现多线程编程的类，它通过与操作系统原生线程的交互来实现线程的创建、启动和控制。Thread提供了一系列方法来控制线程的行为，包括启动线程、休眠、等待其他线程、中断线程等。多线程编程可以提高程序的性能和响应能力，但需要注意线程安全问题。

Java提供了Thread类来创建线程。可以通过继承Thread类并重写run()方法来创建线程。具体步骤如下：

javaCopy codeclass MyThread extends Thread {
        public void run() {
            // 线程执行的代码
        }
    }
    public class Main {
        public static void main(String[] args) {
            MyThread thread = new MyThread();
            thread.start();
        }
    }

### 2. 实现Runnable接口 ###

在Java中，`Runnable`是一个接口，用于表示可以被多线程执行的任务。通过实现`Runnable`接口，我们可以将一个任务封装成一个线程，并通过`Thread`类来启动和管理这个线程。

### 历史 ###

在Java早期版本中，线程的创建和管理是通过继承`Thread`类来实现的。开发者需要继承`Thread`类，并重写其`run()`方法来定义线程的执行逻辑。然而，这种方式存在一些问题，比如继承关系的限制，无法实现多重继承等。为了解决这些问题，Java引入了`Runnable`接口。

### 原理 ###

`Runnable`接口的定义如下：

javaCopy codepublic interface Runnable {
        public abstract void run();
    }

可以看到，`Runnable`接口只包含了一个`run()`方法，该方法需要被实现类重写以定义具体的任务逻辑。 使用`Runnable`接口创建线程的步骤如下：

1.  创建一个实现了`Runnable`接口的类，并重写`run()`方法，定义线程的执行逻辑。
2.  创建一个`Thread`对象，将上述实现了`Runnable`接口的类实例作为构造函数参数传入。
3.  调用`Thread`对象的`start()`方法，启动线程。 当调用`start()`方法后，JVM会在内部创建一个新的线程，并在新线程上调用`Runnable`对象的`run()`方法。这样，线程就开始执行`Runnable`对象中定义的任务逻辑。 相比于继承`Thread`类，使用`Runnable`接口的方式具有以下优势：
4.  降低耦合性：使用接口可以将任务与线程分离，提高代码的可维护性和可扩展性。
5.  提高代码复用性：可以实现多个任务类，通过传入不同的`Runnable`对象创建不同的线程，实现代码的复用。
6.  避免单继承限制：通过实现接口，可以继续继承其他类，避免了单继承的限制。 需要注意的是，`Runnable`接口只定义了线程的执行逻辑，并不负责线程的创建和管理。线程的创建和管理仍然需要通过`Thread`类来完成。 总结： `Runnable`接口是Java中用于表示可被多线程执行的任务的接口。通过实现`Runnable`接口，我们可以将一个任务封装成一个线程，并通过`Thread`类来启动和管理这个线程。相比于继承`Thread`类，使用`Runnable`接口的方式降低了耦合性，提高了代码复用性，并避免了单继承的限制。

除了继承Thread类，还可以实现Runnable接口。通过实现Runnable接口并重写run()方法，可以创建线程。具体步骤如下：

javaCopy codeclass MyRunnable implements Runnable {
        public void run() {
            // 线程执行的代码
        }
    }
    public class Main {
        public static void main(String[] args) {
            MyRunnable runnable = new MyRunnable();
            Thread thread = new Thread(runnable);
            thread.start();
        }
    }

### 3. 使用Callable和Future ###

Callable和Future是Java多线程编程中的两个重要概念，用于实现多线程任务的执行和结果的获取。下面将详细介绍Callable和Future的历史和原理。 历史： Callable和Future最早是在Java 5版本中引入的，并且属于Java并发包的一部分。在此之前，Java中的多线程编程主要使用Thread和Runnable接口来实现。但是，Thread和Runnable只能执行任务并返回void，无法获取任务的返回结果。为了解决这个问题，Java引入了Callable和Future接口，使得开发者可以在多线程任务执行完成后获取任务的返回结果。 原理： Callable接口是一个泛型接口，它定义了一个call()方法，该方法可以返回一个值。我们可以将需要执行的任务封装成一个实现了Callable接口的类。当我们需要执行这个任务时，可以通过创建一个ExecutorService线程池来提交Callable任务。 Future接口是一个泛型接口，它表示一个异步计算的结果。当我们提交一个Callable任务给ExecutorService线程池时，会返回一个Future对象。通过Future对象，我们可以获取任务的执行状态和结果。Future接口提供了一系列的方法，如isDone()用于判断任务是否执行完成，get()用于获取任务的结果（会阻塞直到任务完成），cancel()用于取消任务的执行等。 在执行Callable任务时，ExecutorService线程池会将任务分配给一个空闲的线程进行执行。当任务执行完成后，线程池会将任务的结果封装在Future对象中。我们可以通过调用Future的get()方法来获取任务的结果，如果任务还未完成，get()方法会阻塞当前线程直到任务完成。 Callable和Future的组合可以实现以下功能：

1.  提交任务并获取返回结果：通过将任务封装成Callable对象，提交给线程池并获取返回的Future对象，可以异步执行任务并在需要时获取任务的返回结果。
2.  控制任务的执行：通过调用Future的cancel()方法可以取消任务的执行，通过调用get()方法设置超时时间可以控制任务的执行时间。 总结： Callable和Future是Java并发包中的两个重要概念，用于实现多线程任务的执行和结果的获取。Callable表示一个可执行的任务，通过实现Callable接口并提供call()方法来封装任务。Future表示一个异步计算的结果，通过调用Future的方法可以获取任务的执行状态和结果。Callable和Future的组合可以实现异步执行任务并获取结果的功能，提供了更灵活和高效的多线程编程方式。

Java 5引入了Callable和Future接口，用于创建可返回结果的线程。具体步骤如下：

javaCopy codeimport java.util.concurrent.Callable;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.Future;
    class MyCallable implements Callable<Integer> {
        public Integer call() throws Exception {
            // 线程执行的代码
            return 42;
        }
    }
    public class Main {
        public static void main(String[] args) throws Exception {
            ExecutorService executor = Executors.newSingleThreadExecutor();
            Future<Integer> future = executor.submit(new MyCallable());
            Integer result = future.get();
            executor.shutdown();
        }
    }

### 4. 使用线程池 ###

创建线程池是一种更加灵活和高效的方式。可以通过ThreadPoolExecutor类来创建线程池。具体步骤如下：

javaCopy codeimport java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    public class Main {
        public static void main(String[] args) {
            ExecutorService executor = Executors.newFixedThreadPool(5);
            for (int i = 0; i < 10; i++) {
                Runnable worker = new MyRunnable();
                executor.execute(worker);
            }
            executor.shutdown();
        }
    }

通过使用线程池，可以管理线程的生命周期，避免频繁地创建和销毁线程，提高性能和资源利用率。

### 总结 ###

Java线程的创建方式有很多种，本文介绍了其中的四种常用方式：使用Thread类、实现Runnable接口、使用Callable和Future、使用线程池。根据实际需求和场景，选择合适的方式来创建线程。在多线程编程中，需要注意线程的同步和协调，以确保线程的安全性和正确性。熟练掌握线程的创建和管理，对于开发高效、稳定的多线程应用程序至关重要。