Thread,Runnable,ExecutorService线程池控制下线程量

本文通过一个具体的Java代码示例,展示了如何使用线程池来提高程序的并发性能。通过创建固定大小的线程池,并利用Souprint类实现Runnable接口,实现了任务的并行执行。代码中还演示了如何向线程池提交任务,以及如何关闭线程池。

Thread线程池简单手工搞一波写个理解下

public class Souprint extends Thread implements Runnable {

        private Integer sysPint;

        public Souprint(Integer pint) {
            this.sysPint = pint;
        }

        @Override
        public void run() {

            try {
                System.out.println("参数:"+sysPint + "线程打印 ThreadName:"+Thread.currentThread().getName()+" ID:"+Thread.currentThread().getId());
                Thread.sleep(3);
                System.out.println("休眠后 线程打印 ThreadName:"+Thread.currentThread().getName()+" ID:"+Thread.currentThread().getId());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }


    @Test
    public void testThead() {
        //创建一个线程池
        ExecutorService exe = Executors.newFixedThreadPool(4);
        String[] str = new String[]{"1", "2", "3", "4"};
        for (String s : str) {
            int sssss = Integer.parseInt(s);
            System.out.println(sssss);
            exe.execute(new Thread(new Souprint(sssss)));
        }
        exe.shutdown();
    }
### Callable `Callable` 是 Java 中的一个接口,它代表着一个可以返回结果的任务。该接口中只有一个 `call()` 方法,此方法可以抛出异常,并且有返回值,返回值的类型由泛型指定。通常,`Callable` 任务会和线程池一起使用,通过线程池的 `submit()` 方法提交任务,会返回一个 `Future` 对象,用于获取任务的执行结果。示例代码如下: ```java import java.util.concurrent.*; class MyCallable implements Callable<Integer> { @Override public Integer call() throws Exception { return 1 + 2; } } public class CallableDemo { public static void main(String[] args) throws ExecutionException, InterruptedException { ExecutorService executor = Executors.newSingleThreadExecutor(); Callable<Integer> callable = new MyCallable(); Future<Integer> future = executor.submit(callable); Integer result = future.get(); System.out.println("结果: " + result); executor.shutdown(); } } ``` ### Runnable `Runnable` 也是 Java 中的一个接口,它代表着一个可以在单独线程中执行的任务。`Runnable` 接口只有一个 `run()` 方法,该方法没有返回值,也不能抛出受检查异常。实现 `Runnable` 接口的类可以作为参数传递给 `Thread` 类的构造函数,或者提交给线程池执行。示例代码如下: ```java class MyRunnable implements Runnable { @Override public void run() { System.out.println("Runnable 任务执行"); } } public class RunnableDemo { public static void main(String[] args) { MyRunnable myRunnable = new MyRunnable(); Thread thread = new Thread(myRunnable); thread.start(); } } ``` ### 线程 线程是程序执行流的最小单元,一个进程可以包含多个线程。在 Java 中,创建线程有两种常见方式:继承 `Thread` 类和实现 `Runnable` 接口。继承 `Thread` 类需要重写 `run()` 方法,实现 `Runnable` 接口也需要实现 `run()` 方法。继承 `Thread` 类的示例代码如下: ```java class MyThread extends Thread { @Override public void run() { System.out.println("线程执行"); } } public class ThreadDemo { public static void main(String[] args) { MyThread myThread = new MyThread(); myThread.start(); } } ``` ### 线程池 线程池是一种线程管理机制,它可以预先创建一定数量的线程,当有任务提交时,从线程池中获取线程来执行任务,任务执行完毕后线程不会销毁,而是返回到线程池中等待下一个任务。使用线程池可以减少线程创建和销毁的开销,提高系统的性能和稳定性。Java 提供了 `ExecutorService` 接口和 `Executors` 工具类来创建和管理线程池。常见的线程池创建方法有: - `Executors.newSingleThreadExecutor()`:创建一个只有一个线程的线程池,所有提交的任务按顺序执行[^3]。 - `Executors.newCachedThreadPool()`:创建一个可缓存的线程池,如果线程超过 60 秒内没有执行,将被终止并从池中删除[^3]。 - `Executors.newFixedThreadPool(int nThreads)`:创建一个拥有固定线程数线程池,如果没有任务执行,线程会一直等待[^3]。 - `Executors.newScheduledThreadPool(int corePoolSize)`:创建一个用来调度即将执行的任务的线程池[^3]。 - `Executors.newSingleThreadScheduledExecutor()`:创建一个只有一个线程,用来调度任务在指定时间执行的线程池[^3]。 示例代码如下: ```java import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; class MyTask implements Runnable { @Override public void run() { System.out.println("线程池任务执行"); } } public class ThreadPoolDemo { public static void main(String[] args) { ExecutorService executor = Executors.newFixedThreadPool(2); MyTask myTask = new MyTask(); executor.submit(myTask); executor.submit(myTask); executor.shutdown(); } } ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值