当前位置：首页 > 文章列表 > 文章 > java教程 > Java多线程创建与启动技巧详解

Java多线程创建与启动技巧详解

2025-09-04 19:01:53 0浏览收藏

想要掌握Java多线程编程？本教程将带你从零开始，深入了解如何在Java中创建和启动多线程，并分享多线程编程中的实用技巧。文章详细讲解了两种创建线程的方式：继承Thread类和实现Runnable接口，并推荐使用Runnable接口以获得更大的灵活性。同时，针对多线程执行顺序的控制，提供了join()、wait()/notify()、CountDownLatch等多种解决方案。更重要的是，文章还深入探讨了如何避免多线程中的死锁问题，以及如何根据CPU核心数和任务类型（CPU密集型或IO密集型）选择合适的线程池大小，并通过ExecutorService进行线程池管理，助力你编写出高效稳定的Java多线程程序。

Java中创建多线程推荐实现Runnable接口，因其避免单继承限制且更灵活；通过start()启动线程，直接调用run()不创建新线程；控制执行顺序可用join()、wait()/notify()、CountDownLatch等；避免死锁需按序获取锁、使用定时锁或资源排序；线程池大小应根据CPU核心数、任务类型（CPU或IO密集型）合理设置，通常IO密集型设为CPU核心数的2倍，并通过ExecutorService管理线程池。

java使用教程怎样创建和启动多线程 java使用教程的多线程编程操作技巧

在Java中，创建和启动多线程主要有两种方式：继承Thread类和实现Runnable接口。选择哪种方式取决于你的具体需求，但通常推荐使用实现Runnable接口的方式，因为它更灵活，避免了Java单继承的限制。

解决方案

继承Thread类:
- 创建一个继承自Thread的类。
- 重写run()方法，将线程要执行的任务代码放在run()方法中。
- 创建Thread类的实例。
- 调用start()方法启动线程。
```
class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread running: " + Thread.currentThread().getName());
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        thread1.start(); // 启动线程，而不是直接调用run()
    }
}
```
直接调用run()方法，其实只是在当前线程（main线程）中执行了run()方法里的代码，并没有创建新的线程。必须调用start()方法，才能真正启动一个新的线程，并执行run()方法。
实现Runnable接口:
- 创建一个类，实现Runnable接口。
- 实现run()方法，将线程要执行的任务代码放在run()方法中。
- 创建Runnable接口的实现类的实例。
- 创建一个Thread类的实例，并将Runnable接口的实现类的实例作为参数传递给Thread类的构造方法。
- 调用Thread类的start()方法启动线程。
```
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Thread running: " + Thread.currentThread().getName());
    }
}

public class Main {
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread thread2 = new Thread(runnable);
        thread2.start();
    }
}
```
使用Runnable接口的方式，可以将线程的任务代码和线程的创建分离，更符合面向对象的设计原则。

如何控制多线程的执行顺序？

控制多线程的执行顺序是一个常见的问题，Java提供了多种机制来实现，例如join(), wait(), notify(), notifyAll(), CountDownLatch, CyclicBarrier, Semaphore等。

join()方法: 可以使一个线程等待另一个线程执行完毕。例如，线程A调用线程B的join()方法，那么线程A会等待线程B执行完毕后再继续执行。

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            System.out.println("Thread 1 started");
            try {
                Thread.sleep(1000); // 模拟耗时操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 1 finished");
        });

        Thread thread2 = new Thread(() -> {
            System.out.println("Thread 2 started");
            try {
                thread1.join(); // 等待thread1执行完毕
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 2 finished");
        });

        thread1.start();
        thread2.start();
    }
}

在这个例子中，thread2会等待thread1执行完毕后再开始执行。

wait(), notify(), notifyAll()方法: 这些方法是Object类的方法，用于线程间的通信和同步。 wait()使线程进入等待状态，直到被notify()或notifyAll()唤醒。 notify()唤醒一个等待的线程，notifyAll()唤醒所有等待的线程。这些方法必须在synchronized块中使用。

public class Main {
    private static final Object lock = new Object();
    private static boolean flag = false;

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 1 started");
                try {
                    while (!flag) {
                        lock.wait(); // 等待flag变为true
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 1 finished");
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 2 started");
                flag = true;
                lock.notify(); // 唤醒等待的线程
                System.out.println("Thread 2 finished");
            }
        });

        thread1.start();
        try {
            Thread.sleep(100); // 确保thread1先启动
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread2.start();
    }
}

在这个例子中，thread1会等待thread2设置flag为true并唤醒它。

CountDownLatch: CountDownLatch允许一个或多个线程等待其他线程完成操作。它维护了一个计数器，计数器初始化为一个正整数。每当一个线程完成任务后，计数器的值就会减1。当计数器的值为0时，所有等待的线程都会被释放。

import java.util.concurrent.CountDownLatch;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(2); // 初始化计数器为2

        Thread thread1 = new Thread(() -> {
            System.out.println("Thread 1 started");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 1 finished");
            latch.countDown(); // 计数器减1
        });

        Thread thread2 = new Thread(() -> {
            System.out.println("Thread 2 started");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 2 finished");
            latch.countDown(); // 计数器减1
        });

        Thread thread3 = new Thread(() -> {
            try {
                latch.await(); // 等待计数器变为0
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 3 started after Thread 1 and Thread 2 finished");
        });

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

在这个例子中，thread3会等待thread1和thread2都执行完毕后再开始执行。

如何避免多线程中的死锁问题？

死锁是多线程编程中常见的问题，它指的是两个或多个线程互相等待对方释放资源，导致所有线程都无法继续执行的情况。

避免死锁的一些常见策略：

避免嵌套锁: 尽量避免在一个synchronized块中获取另一个锁。如果必须获取多个锁，应该按照相同的顺序获取，避免形成循环等待。

使用定时锁: 使用tryLock()方法尝试获取锁，可以设置超时时间。如果在指定时间内无法获取锁，就放弃获取，避免永久等待。

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

public class Main {
    private static Lock lock1 = new ReentrantLock();
    private static Lock lock2 = new ReentrantLock();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            try {
                if (lock1.tryLock()) {
                    try {
                        System.out.println("Thread 1 acquired lock1");
                        Thread.sleep(100); // 模拟耗时操作
                        if (lock2.tryLock()) {
                            try {
                                System.out.println("Thread 1 acquired lock2");
                                // 执行操作
                            } finally {
                                lock2.unlock();
                            }
                        } else {
                            System.out.println("Thread 1 failed to acquire lock2, releasing lock1");
                            // 释放lock1
                        }
                    } finally {
                        lock1.unlock();
                    }
                } else {
                    System.out.println("Thread 1 failed to acquire lock1");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread thread2 = new Thread(() -> {
            try {
                if (lock2.tryLock()) {
                    try {
                        System.out.println("Thread 2 acquired lock2");
                        Thread.sleep(100); // 模拟耗时操作
                        if (lock1.tryLock()) {
                            try {
                                System.out.println("Thread 2 acquired lock1");
                                // 执行操作
                            } finally {
                                lock1.unlock();
                            }
                        } else {
                            System.out.println("Thread 2 failed to acquire lock1, releasing lock2");
                            // 释放lock2
                        }
                    } finally {
                        lock2.unlock();
                    }
                } else {
                    System.out.println("Thread 2 failed to acquire lock2");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        thread1.start();
        thread2.start();
    }
}

在这个例子中，如果一个线程无法获取所有需要的锁，它会释放已经获取的锁，避免死锁。

使用资源排序: 为所有资源分配一个唯一的编号，线程按照编号的顺序获取资源，避免形成循环等待。
使用死锁检测工具: 一些工具可以帮助检测死锁，例如Java的ThreadMXBean。

如何选择合适的线程池大小？

线程池的大小对程序的性能有很大的影响。如果线程池太小，可能会导致任务排队等待，降低程序的响应速度。如果线程池太大，可能会导致过多的线程切换，增加系统的开销。

选择合适的线程池大小需要考虑多个因素，例如CPU核心数、任务的类型（CPU密集型还是IO密集型）、任务的执行时间等。

CPU密集型任务: 对于CPU密集型任务，线程池的大小可以设置为CPU核心数+1。额外的线程可以防止CPU在某个线程阻塞时空闲。
IO密集型任务: 对于IO密集型任务，线程池的大小可以设置为CPU核心数的两倍甚至更多。由于IO操作通常比较耗时，因此需要更多的线程来处理并发的IO请求。
使用Runtime.getRuntime().availableProcessors()获取CPU核心数: 可以使用Runtime.getRuntime().availableProcessors()方法来获取当前系统的CPU核心数。
```
int cpuCores = Runtime.getRuntime().availableProcessors();
int threadPoolSize = cpuCores * 2; // IO密集型任务
```

使用ExecutorService创建线程池: 可以使用ExecutorService接口和其实现类来创建线程池，例如ThreadPoolExecutor和FixedThreadPool。

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

public class Main {
    public static void main(String[] args) {
        int cpuCores = Runtime.getRuntime().availableProcessors();
        int threadPoolSize = cpuCores * 2;
        ExecutorService executor = Executors.newFixedThreadPool(threadPoolSize);

        for (int i = 0; i < 10; i++) {
            int taskNumber = i;
            executor.submit(() -> {
                System.out.println("Task " + taskNumber + " running in thread: " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000); // 模拟耗时操作
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

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

在这个例子中，创建了一个固定大小的线程池，线程池的大小是CPU核心数的两倍。

选择合适的线程池大小是一个需要不断尝试和调整的过程。可以通过监控程序的性能，例如CPU利用率、响应时间等，来调整线程池的大小，以达到最佳的性能。

到这里，我们也就讲完了《Java多线程创建与启动技巧详解》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于死锁避免,Java多线程,线程池大小,ExecutorService,Runnable接口的知识点！

死锁避免 Java多线程线程池大小 ExecutorService Runnable接口