当前位置：首页 > 文章列表 > 文章 > java教程 > Java中多线程如何实现掌握Java创建线程的三种实现方式

Java中多线程如何实现掌握Java创建线程的三种实现方式

2025-07-01 19:02:30 0浏览收藏

文章不知道大家是否熟悉？今天我将给大家介绍《Java中多线程如何实现掌握Java创建线程的三种实现方式》，这篇文章主要会讲到等等知识点，如果你在看完本篇文章后，有更好的建议或者发现哪里有问题，希望大家都能积极评论指出，谢谢！希望我们能一起加油进步！

Java中实现多线程主要有三种方式：1.继承Thread类，通过重写run()方法实现，但受限于Java单继承机制；2.实现Runnable接口，将其实例作为Thread构造器参数，更灵活且支持多接口实现；3.使用ExecutorService线程池，通过线程池管理线程，提高性能并避免频繁创建销毁线程的开销。选择Runnable接口而非Thread类的主要原因是避免单继承限制，并实现执行逻辑与线程对象的解耦，符合面向对象设计原则。解决线程安全问题的方法包括：使用synchronized关键字控制同步方法或代码块；利用Lock接口（如ReentrantLock）提供更灵活锁机制；采用原子类（如AtomicInteger）通过CAS算法实现无锁化操作；以及使用并发容器（如ConcurrentHashMap）保障线程安全的数据结构访问。线程池的核心参数有corePoolSize（核心线程数）、maximumPoolSize（最大线程数）、keepAliveTime（空闲线程存活时间）、unit（时间单位）、workQueue（任务队列）、threadFactory（线程工厂）和rejectedExecutionHandler（拒绝策略），合理配置这些参数可优化资源使用和任务调度。避免死锁的常见方法包括避免一个线程同时持有多个锁、获取锁时设置超时机制以防止无限等待，以及借助工具（如jstack）进行死锁检测与分析，确保线程资源正确释放和程序稳定运行。

Java中多线程的实现，简单来说，就是让你的程序能够同时做多件事情，而不是一件一件按顺序来。这有点像你一边听音乐，一边写代码，两不耽误。

创建线程主要有三种方式：继承Thread类、实现Runnable接口、使用ExecutorService线程池。

继承Thread类

直接继承Thread类，重写run()方法。这个run()方法里放的就是你想要线程执行的任务。这种方式比较简单直接，但有个缺点，Java是单继承的，如果你的类已经继承了其他类，就不能再继承Thread了。

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("线程执行中...");
    }

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // 启动线程
    }
}

实现Runnable接口

实现Runnable接口，然后将实现了Runnable接口的类的实例作为Thread构造器的参数。这种方式更灵活，因为你可以实现多个接口，不受单继承的限制。

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable线程执行中...");
    }

    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start(); // 启动线程
    }
}

使用ExecutorService线程池

使用ExecutorService线程池来管理线程。线程池可以重用线程，避免频繁创建和销毁线程的开销，提高性能。

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

public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5); // 创建一个固定大小的线程池

        for (int i = 0; i < 10; i++) {
            int taskNumber = i; // 避免闭包问题
            executor.submit(() -> {
                System.out.println("线程 " + Thread.currentThread().getName() + " 执行任务 " + taskNumber);
            });
        }

        executor.shutdown(); // 关闭线程池
    }
}

为什么选择Runnable接口而不是Thread类？

这是个经典问题。主要原因还是Java的单继承特性。如果你的类需要继承其他的类，那么就只能选择实现Runnable接口。另外，实现Runnable接口可以更好地解耦，将线程的执行逻辑和线程本身分离，更符合面向对象的设计原则。

线程安全问题怎么解决？

多线程编程最头疼的就是线程安全问题。多个线程同时访问共享资源，可能会导致数据不一致或者程序崩溃。常见的解决方案包括：

使用synchronized关键字： synchronized可以修饰方法或者代码块，保证同一时刻只有一个线程可以访问被synchronized修饰的代码。
```
public synchronized void increment() {
    count++;
}
```

使用Lock接口： Lock接口提供了比synchronized更灵活的锁机制，例如ReentrantLock。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Counter {
    private int count = 0;
    private Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock(); // 必须在finally块中释放锁
        }
    }
}

使用原子类： java.util.concurrent.atomic包下提供了一系列的原子类，例如AtomicInteger、AtomicLong等，它们使用CAS（Compare and Swap）算法来实现原子操作，可以避免使用锁。
```
import java.util.concurrent.atomic.AtomicInteger;

public class Counter {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet();
    }
}
```
使用并发容器： java.util.concurrent包下提供了一系列的并发容器，例如ConcurrentHashMap、ConcurrentLinkedQueue等，它们是线程安全的，可以直接在多线程环境下使用。

线程池的核心参数有哪些？

线程池的核心参数主要有：

corePoolSize： 核心线程数，线程池中始终保持的线程数量，即使它们是空闲的。
maximumPoolSize： 最大线程数，线程池中允许的最大线程数量。
keepAliveTime： 线程空闲时间，当线程池中的线程数量超过corePoolSize时，多余的空闲线程的存活时间。
unit： keepAliveTime的时间单位。
workQueue： 任务队列，用于存放等待执行的任务。
threadFactory： 线程工厂，用于创建线程。
rejectedExecutionHandler： 拒绝策略，当任务队列已满且线程池中的线程数量达到maximumPoolSize时，新提交的任务的处理方式。

理解这些参数对于正确配置线程池至关重要，可以避免线程过多导致系统资源耗尽，或者线程过少导致任务积压。

如何避免死锁？

死锁是指两个或多个线程互相等待对方释放资源，导致所有线程都无法继续执行的情况。避免死锁的常见方法包括：