二、并发编程与多线程-2.2、多线程（上）

最新推荐文章于 2024-11-09 12:43:52 发布

吃海鲜的骆驼

最新推荐文章于 2024-11-09 12:43:52 发布

阅读量1.2k

点赞数 42

分类专栏：并发编程与多线程文章标签： java 面试

本文链接：https://blog.csdn.net/weixin_61769871/article/details/141904117

版权

并发编程与多线程专栏收录该内容

7 篇文章 0 订阅

订阅专栏

2.2、多线程（上）

2.2.1、实现线程有哪些方式？它们之间有什么区别？

答：
实现线程其实就是定义任务类，任务类中定义线程要执行的逻辑。再根据这个任务类创建任务对象，任务对象交给线程对象去处理。有如下三种方式可以实现线程，第四种用线程池的方式严格来说应该属于处理线程任务的方式，而不是实现线程的方式。

继承Thread类：创建一个继承自Thread类的子类，重写其run()方法来定义线程的执行逻辑。然后通过创建该子类的实例来创建并启动线程。优点：编写简单，适用于简单的线程需求。缺点：由于Java不支持多重继承，因此无法继承其他类。

示例：
// 定义子线程类
public class MyThread extends Thread {
    @Override
    public void run() {
        // 定义线程的执行逻辑
        System.out.println("Thread running");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread(); // 创建任务对象
        thread.start(); // 启动线程
    }
}

实现Runnable接口：创建一个实现了Runnable接口的类，并实现其run()方法。然后通过创建该类的实例，并将其作为参数传递给Thread类的构造方法，来创建并启动线程。优点：支持多个接口的实现，避免了类的单继承限制。缺点：相对于继承Thread类，编写稍微复杂一些。

示例：
// 定义任务类
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 定义线程的执行逻辑
        System.out.println("Runnable running");
    }
}

public class Main {
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable(); // 创建任务对象
        Thread thread = new Thread(runnable); // 将runnable对象传递给Thread的构造方法
        thread.start(); // 启动线程
    }
}

使用Callable和Future：实现Callable接口，代表一个具有返回值的线程任务，通过Future来获取执行任务逻辑后的结果。优点：可以获得线程任务的执行结果。缺点：相对于前两种方式，使用稍微复杂一些。

示例1：
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class CallableTask implements Callable<String> {
    @Override
    public String call() throws Exception {
        Thread.sleep(2000); // 模拟任务执行时间
        return "任务执行完成";
    }

    public static void main(String[] args) {
        // 创建Callable任务对象
        Callable<String> callable = new CallableTask();
        // 创建FutureTask对象，并将Callable任务对象作为参数传入
        FutureTask<String> futureTask = new FutureTask<>(callable);
        // 创建Thread对象，并将FutureTask对象作为参数传入
        Thread thread = new Thread(futureTask);
        // 启动线程
        thread.start();
        try {
            // 获取任务执行结果
            String result = futureTask.get();
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

实现Callable接口的任务类创建的任务对象也可以直接交给线程池来处理，当然上面的两种方式也都可以交给线程池来处理。

示例2：
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
// 创建任务类
public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        // 定义线程的执行逻辑
        return "Callable result";
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newSingleThreadExecutor(); // 创建线程池对象
        MyCallable callable = new MyCallable(); // 创建任务对象
        Future<String> future = executorService.submit(callable); // 提交Callable任务给线程池
        String result = future.get(); // 获取线程任务的执行结果
        System.out.println(result);
        executorService.shutdown(); // 关闭线程池
    }
}

使用线程池：通过Executors类创建一个线程池，然后将Runnable或Callable对象提交给线程池来执行。当然现在的开发规范中要求改用ThreadPoolExecutor来创建线程池对象。优点：可以对线程进行复用，减少线程创建和销毁的开销。同时可以控制线程的数量和线程池的工作队列。缺点：相对于直接创建线程，需要额外的线程池管理。

示例：
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
// 定义任务类
public class MyTask implements Runnable {
    private String name;

    public MyTask(String name) {
        this.name = name;
    }
    
    // 线程的执行逻辑
    @Override
    public void run() {
        System.out.println("Task " + name + " running");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Task " + name + " completed");
    }
}

public class Main {
    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                2,  // 核心线程数
                5,  // 最大线程数
                1,  // 线程空闲时间
                TimeUnit.SECONDS,  // 时间单位
                new LinkedBlockingQueue<>(),  // 任务队列
                Executors.defaultThreadFactory(),  // 线程工厂
                new ThreadPoolExecutor.AbortPolicy()  // 拒绝策略，线程池已满时的处理策略
        );
        for (int i = 0; i < 10; i++) {
            MyTask task = new MyTask("Task " + i); // 创建任务对象
            executor.execute(task);  // 提交任务给线程池执行
        }
        executor.shutdown();  // 关闭线程池
    }
}
在上述示例中，我们使用ThreadPoolExecutor创建了一个线程池，配置了核心线程数为2，最大线程数为5，线程空闲时间为1秒。任务队列使用了LinkedBlockingQueue，线程工厂使用了默认的线程工厂，拒绝策略使用了默认的AbortPolicy。
我们提交了10个任务给线程池执行，线程池会自动管理线程的创建和回收，并按照一定的调度策略执行任务。
注意，最后需要调用shutdown方法关闭线程池，以释放资源。

2.2.2、什么是守护线程？它有什么特点？

答：
守护线程（daemon thread）是在程序运行过程中在后台提供服务的线程。守护线程的特点是当所有的非守护线程结束时，守护线程会自动退出，不会等待所有任务都执行完成。它通常被用于执行一些后台任务，如垃圾回收、内存监视等。
守护线程其实就是一个线程对象，调用setDaemon()方法，设置为true即可
守护线程的作用是为其他线程的运行提供支持，不会阻止程序的正常结束。当程序中只有守护线程时，JVM 将自动退出。

示例：
public class DaemonThreadExample {
    public static void main(String[] args) {
        // 创建一个守护线程
        Thread daemonThread = new Thread(new DaemonRunnable());
        // 将线程设置为守护线程
        daemonThread.setDaemon(true);
        // 启动守护线程
        daemonThread.start();

        // 主线程执行任务
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程正在执行任务...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static class DaemonRunnable implements Runnable {
        @Override
        public void run() {
            while (true) {
                System.out.println("守护线程正在运行...");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
在这个示例中，我们创建了一个守护线程`DaemonRunnable`，它会每隔一秒输出一条信息。我们将这个线程设置为守护线程并启动它。然后，主线程会执行一些任务，每隔一秒输出一条信息。当主线程执行完任务后，程序会自动结束，不会等待守护线程的完成。守护线程会在后台持续运行，直到程序退出。

2.2.3、BLOCKED和WAITING这两种线程状态有什么区别？

答：
BLOCKED和WAITING状态都属于线程的阻塞等待状态；
BLOCKED状态是多线程竞争synchronized同步锁的时候，没有竞争到锁资源的线程会被阻塞等待，此时的线程就是BLOCKED状态，直到它获得所需的锁才能进入Running状态。如下图：
在这里插入图片描述
WAITING状态表示线程的等待状态，在这种状态下，线程需要等待某个线程的特定操作才会被唤醒。当一个线程调用了Object的wait()方法、Thread的join()方法或LockSupport的park()方法时，它将进入Waiting状态。这些方法被用于线程之间的协调和通信。线程进入Waiting状态时，它会释放它当前持有的锁，这意味着其他线程可以获取这个锁并继续执行。在Waiting状态下，线程是被动的，它会等待其他线程的通知或者等待一定时间后自动唤醒。

// 线程进入waiting状态并被唤醒的示例：
public class WaitingExample {
    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();

        Thread waitingThread = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("Waiting thread is waiting...");
                    lock.wait(); // 线程进入Waiting状态，等待被唤醒
                    System.out.println("Waiting thread is awake");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread notifyingThread = new Thread(() -> {
            synchronized (lock) {
                try {
                    Thread.sleep(2000); // 等待2秒，模拟其他处理
                    lock.notify(); // 唤醒等待的线程
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        waitingThread.start();
        notifyingThread.start();

        waitingThread.join();
        notifyingThread.join();
    }
}
在示例中，有两个线程：waitingThread和notifyingThread。
waitingThread在synchronized块内调用lock.wait()方法，使线程进入Waiting状态，并释放锁。
notifyingThread在synchronized块内调用lock.notify()方法，唤醒等待的线程。
当notifyingThread调用lock.notify()方法后，waitingThread会被唤醒，并继续执行。
输入结果类似于：
Waiting thread is waiting...
Waiting thread is awake

扩展：
这两种线程状态的区别：

Blocked状态是线程试图获取锁的结果，而Waiting状态是线程主动调用等待方法后的状态。
Blocked状态是可以被其他线程唤醒的，一旦获取到锁就可以进入Running状态；而Waiting状态需要等待其他线程的通知或等待时间到达，才能被唤醒进入Running状态。
Blocked状态是和锁相关的，而Waiting状态是和线程的等待相关的。