Java多线程

Java线程的创建方式？

1. 继承Thread类

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread is running");
    }

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
}

2. 实现Runnable接口

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable is running");
    }

    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
    }
}

3. 实现Callable接口和使用FutureTask

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

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "Callable result";
    }

    public static void main(String[] args) {
        MyCallable myCallable = new MyCallable();
        FutureTask<String> futureTask = new FutureTask<>(myCallable);
        Thread thread = new Thread(futureTask);
        thread.start();

        try {
            System.out.println("Result: " + futureTask.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

4. 使用线程池

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

public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        for (int i = 0; i < 5; i++) {
            executorService.execute(() -> {
                System.out.println("Thread pool task is running");
            });
        }

        executorService.shutdown();
    }
}

5. 使用Lambda表达式 (Java 8及以上)

public class LambdaExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> System.out.println("Lambda thread is running"));
        thread.start();
    }
}

Java多线程的生命周期是什么

在Java中，线程的生命周期包括多个状态，每个状态表示线程在其生命周期中的不同阶段。线程的生命周期状态主要包括：

1. 新建（New）
2. 就绪（Runnable）
3. 运行（Running）
4. 阻塞（Blocked）
5. 等待（Waiting）
6. 超时等待（Timed Waiting）
7. 终止（Terminated）

sleep和wait方法的区别

Thread.sleep()和Object.wait()是Java中用于控制线程行为的两种方法，但它们有着显著的区别。

Thread.sleep()方法

1. 定义：Thread.sleep(long millis)是一个静态方法，属于Thread类。
2. 作用：使当前线程进入休眠状态，暂停执行一段时间（以毫秒为单位）。
3. 锁状态：调用sleep方法时，线程不会释放它所持有的任何锁。
4. 唤醒：在指定的时间到期后，线程会自动从休眠状态中醒来并继续执行，不需要其他线程显式唤醒它。
5. 异常：sleep方法会抛出InterruptedException，如果线程在休眠期间被中断。
6. 使用场景：通常用于暂停线程的执行，模拟延迟或让出CPU时间片

Object.wait()方法

1. 定义：wait()是一个实例方法，属于Object类。
2. 作用：使当前线程等待，直到另一个线程调用该对象的notify()或notifyAll()方法来唤醒它。
3. 锁状态：调用wait方法时，线程必须持有该对象的监视器锁，并且会释放该锁，进入等待状态。
4. 唤醒：线程必须被其他线程显式唤醒，调用notify()或notifyAll()方法，或者在超时等待的情况下，时间到期后自动唤醒。
5. 异常：wait方法会抛出InterruptedException，如果线程在等待期间被中断。
6. 使用场景：通常用于线程间通信，协调线程之间的执行顺序。

Java线程池的原理

Java线程池是一种管理和复用线程的机制，旨在提高应用程序的性能和资源利用效率。线程池通过减少线程创建和销毁的开销来提高系统的响应速度和吞吐量，并且可以有效管理和控制线程的数量，防止过多的线程导致系统资源耗尽。

线程池的基本原理

1. 线程复用：线程池在初始化时创建一定数量的线程，这些线程在任务执行完毕后不会被销毁，而是被回收并重新用于执行新的任务。
2. 任务队列：当所有线程都在忙碌时，新提交的任务会被放入任务队列中，等待空闲线程来执行。
3. 线程管理：线程池可以根据需要动态调整线程的数量，创建新线程或销毁空闲线程，以应对任务量的变化。
4. 资源控制：通过限制线程的数量，线程池可以防止系统资源（如CPU、内存）被过度消耗。

使用线程池的好处

1. 提高性能和响应速度

• 减少线程创建和销毁的开销：每次创建和销毁线程都需要消耗系统资源。线程池通过复用线程，减少了这些开销，从而提高了系统的性能和响应速度。
• 快速响应任务：线程池中已有的线程可以立即执行新任务，而不需要等待新的线程创建完成。

2. 更好的资源管理

• 控制并发线程的数量：线程池可以限制并发执行的线程数量，防止系统资源（如CPU、内存）被过度消耗，避免由于过多线程导致的资源耗尽。
• 任务排队：线程池内部维护一个任务队列，当所有线程都在忙碌时，新任务会被放入队列中等待执行，这样可以平滑地处理任务高峰。

3. 简化并发编程

• 简化线程管理：开发者不需要手动创建、管理和销毁线程，减少了并发编程的复杂性和出错的可能性。
• 统一的任务提交接口：通过统一的接口（如execute和submit方法）提交任务，简化了任务管理和执行。

4. 提高系统稳定性

• 避免资源枯竭：通过限制线程数量和任务队列长度，线程池可以防止系统资源被耗尽，从而提高系统的稳定性和可靠性。
• 拒绝策略：线程池提供了多种拒绝策略（如AbortPolicy、CallerRunsPolicy等），可以灵活处理任务队列已满时的新任务，避免系统崩溃。

5. 提供定时任务和周期性任务的支持

• 定时任务：ScheduledThreadPoolExecutor可以调度定时任务和周期性任务，简化了定时任务的实现。
• 周期性任务：可以方便地执行周期性任务，而不需要手动管理任务的调度和执行。

6. 更好的性能监控和调优

• 线程池监控：通过ThreadPoolExecutor提供的监控方法（如getPoolSize、getActiveCount、getCompletedTaskCount等），可以方便地监控线程池的状态和性能。
• 调优参数：线程池提供了多个参数（如核心线程数、最大线程数、空闲线程存活时间等），可以根据具体应用场景进行调优，以达到最佳性能。

7. 提高代码的可维护性和可读性

• 模块化设计：通过使用线程池，可以将任务提交和任务执行分离，增强了代码的模块化设计。
• 代码简洁：使用线程池可以减少大量的线程管理代码，使代码更加简洁和易于维护。