Java 基础知识- 创建线程的几种方式

news2024/9/22 11:29:10

大家好我是苏麟 , 今天聊聊创建线程的几种方式 .

创建线程的几种方式

1. 继承Thread类实现多线程

/**
 * @className: ThreadTest
 * @author: SL 苏麟
 **/
public class ThreadTest extends Thread{
    public static void main(String[] args) {
        ThreadTest threadTest = new ThreadTest();
        threadTest.start();
    }

    @Override
    public void run() {
        System.out.println("线程运行中");
    }
}

2. 实现Runnable接口

/**
 * @className: ThreadTest
 * @author: SL 苏麟
 **/
public class ThreadTest implements Runnable{
    public static void main(String[] args) {
        ThreadTest threadTest = new ThreadTest();
        Thread thread = new Thread(threadTest);
        thread.start();
    }

    @Override
    public void run() {
        System.out.println("线程运行中");
    }
}

3. 实现Callable接口（此线程有返回值）

/**
 * @className: ThreadTest
 * @author: SL 苏麟
 **/
public class ThreadTest implements Callable<String> {
    public static void main(String[] args) throws Exception{
        ThreadTest threadTest = new ThreadTest();
        FutureTask<String> futureTask = new FutureTask<>(threadTest);
        System.out.println(threadTest.call());
    }


    @Override
    public String call() throws Exception {
        return "线程运行中";
    }
}

4. 线程池实现

/**
 * @className: ThreadTest
 * @author: SL 苏麟
 **/
public class ThreadTest {
    public static void main(String[] args) throws Exception {
        ThreadPoolExecutor
                threadPoolExecutor = new ThreadPoolExecutor(2, 5, 100, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(5));

        for (int i = 0; i < 10; i++) {
            threadPoolExecutor.execute(() -> {
                System.out.println("线程运行中");
            });
        }
    }
}

public class ThreadTest extends Thread{
    public static void main(String[] args) throws Exception {
        ThreadPoolExecutor
                threadPoolExecutor = new ThreadPoolExecutor(2, 5, 100, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(5));

        for (int i = 0; i < 10; i++) {
            threadPoolExecutor.execute(new ThreadTest());
        }
    }
    @Override
    public void run() {
        System.out.println("线程运行中");
     }
}

7 个参数代表的含义如下：

参数 1：corePoolSize
线程数，线程池中始终存活的线程数。

参数 2：maximumPoolSize
最大线程数，线程池中允许的最大线程数，当线程池的任务队列满了之后可以创建的最大线程数。

参数 3：keepAliveTime
最大线程数可以存活的时间，当线程中没有任务执行时，最大线程就会销毁一部分，最终保持核心线程数量的线程。

参数 4：unit:
单位是和参数 3 存活时间配合使用的，合在一起用于设定线程的存活时间，参数 keepAliveTime 的时间单位有以下 7 种可选：
TimeUnit.DAYS：天
TimeUnit.HOURS：小时
TimeUnit.MINUTES：分
TimeUnit.SECONDS：秒
TimeUnit.MILLISECONDS：毫秒
TimeUnit.MICROSECONDS：微妙
TimeUnit.NANOSECONDS：纳秒

参数 5：workQueue
一个阻塞队列，用来存储线程池等待执行的任务，均为线程安全，它包含以下 7 种类型：
ArrayBlockingQueue：一个由数组结构组成的有界阻塞队列。
LinkedBlockingQueue：一个由链表结构组成的有界阻塞队列。
SynchronousQueue：一个不存储元素的阻塞队列，即直接提交给线程不保持它们。
PriorityBlockingQueue：一个支持优先级排序的无界阻塞队列。
DelayQueue：一个使用优先级队列实现的无界阻塞队列，只有在延迟期满时才能从中提取元素。
LinkedTransferQueue：一个由链表结构组成的无界阻塞队列。与SynchronousQueue类似，还含有非阻塞方法。
LinkedBlockingDeque：一个由链表结构组成的双向阻塞队列。
较常用的是 LinkedBlockingQueue 和 Synchronous，线程池的排队策略与 BlockingQueue 有关。

参数 6：threadFactory
线程工厂，主要用来创建线程，默认为正常优先级、非守护线程。

参数 7：handler
拒绝策略，拒绝处理任务时的策略，系统提供了 4 种可选：

AbortPolicy：拒绝并抛出异常。
CallerRunsPolicy：使用当前调用的线程来执行此任务。
DiscardOldestPolicy：抛弃队列头部（最旧）的一个任务，并执行当前任务。
DiscardPolicy：忽略并抛弃当前任务。

5. 匿名内部类实现

public class ThreadTest {
    public static void main(String[] args) throws Exception {
        new Thread() {
            public void run() {
                System.out.println("线程运行中");
            }
        }.start();
    }
}

public class ThreadTest {
    public static void main(String[] args) throws Exception {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程运行中");
            }
        }).start();
    }
}

执行流程