当前位置：首页 > article >正文

java面试--线程总结

article 2024/11/17 6:51:14

Java中有几种方式来创建线程执行任务，分别是什么？

1、继承Thread类

public class MyThread extends Thread{
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
    @Override
    public void run() {
        System.out.println("Hello");
    }
}

总结：重写的是run()方法，而不是start方法，但是占用继承的名额，Java中的类是单继承的。

延伸：java中的接口可以多继承

2、实现Runnable接口

public class MyThread extends Thread{
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
    @Override
    public void run() {
        System.out.println("Hello");
    }
}

总结：实现Runnable接口，实现run()方法，使用依然要用到Thread，此方式更常用

有时候，我们会直接使用匿名内部类的方式或Lambda表达式的方式（如下）；

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

3、实现Callable接口

public class MyCallable implements Callable<String> {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String> futureTask = new FutureTask<>(new MyCallable());
        Thread thread = new Thread(futureTask);
        thread.start();
        String result = futureTask.get();
        System.out.println(result);
    }
    @Override
    public String call() {
        return "Hello MyCallable";
    }
}

总结：实现Callable接口，实现call()方法，得使用Thread+futureTask配合，这种方式支持拿到异步执行的任务结果。

4、利用线程池来创建线程

public class MyExecutor implements Runnable {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        executorService.execute(new MyExecutor());
    }
    @Override
    public void run() {
        System.out.println("Hello MyExecutor");
    }
}

总结：实现Callable接口或者Runnable接口都可以，有ExecutorService来创建线程。
注意：工作中，不建议使用Executors来创建线程池。

总结：
以上集中方式，底层都是基于Runnable。

为什么不建议使用Executors来创建线程池？

1、FixedThreadPool
当我们使用Executors创建FixedThreadPool时，对应的构造方法为：

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

发现创建的队列为LinkedBlockingQueue，是一个无界阻塞队列，如果使用该线程池执行任务，任务过多时就会不断的添加到队列中，任务越多占用的内存就越多，最终可能耗尽内存，导致OOM（全称“Out Of Memory”,内存溢出,通俗理解就是内存不够啦）。

2、SingleThreadExecutor
当我们使用Executors创建SingleThreadExecutor时，对应的构造方法为：

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }