线程（2）

最新推荐文章于 2022-12-04 11:24:21 发布

LIUEUX

最新推荐文章于 2022-12-04 11:24:21 发布

阅读量256

点赞数 1

文章标签： p2p linq .net

本文链接：https://blog.csdn.net/weixin_60475929/article/details/122546284

版权

线程池

概述

线程池就是一个可以复用线程的技术

不使用线程池的问题：

线程池实现的API，参数说明

常见的面试问题

线程池处理Runnable任务

参数七新任务拒绝策略

package com.itxue.d7_threadpool;

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+"输出了"+"Hello World"+i);

            }
        try {
            System.out.println("本任务与线程绑定了，线程进入休眠");
            Thread.sleep(100000000);

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

package com.itxue.d7_threadpool;

import java.util.concurrent.*;

//自定义一个线程池对象，并测试其特性
public class ThreadPoolDemo1 {
    public static void main(String[] args) {
        /*
        public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)
         */
        ExecutorService pool = new ThreadPoolExecutor(3,5,6, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
//        2.给任务线程池处理
        Runnable target = new MyRunnable();
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);

        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);

//        创建临时线程
        pool.execute(target);
        pool.execute(target);

//关闭线程池（开发中，一般不使用）
        pool.shutdownNow();//立即关闭，即使任务没有完成，丢失任务
        pool.shutdown();//等任务完成之后才可以关闭
    }
}

线程池处理Callable任务

ExecutorService的常用方法

package com.itxue.d7_threadpool;

import java.util.concurrent.Callable;

public class MyCallable implements Callable {
    private int n;
    public MyCallable(int n){
        this.n = n;
    }

    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }

        return Thread.currentThread().getName()+"输出1-"+n+"的和为："+sum;
    }
}

package com.itxue.d7_threadpool;

import java.util.concurrent.*;

public class ThreadDemo2 {
    public static void main(String[] args) throws Exception{
        /*
        public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)
         */
            ExecutorService pool = new ThreadPoolExecutor(3,5,6, TimeUnit.SECONDS,
                    new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
                    new ThreadPoolExecutor.AbortPolicy());
//        2.给任务线程池处理
        Future<String> f1 = pool.submit(new MyCallable(100));
        Future<String> f2 = pool.submit(new MyCallable(200));
        Future<String> f3 = pool.submit(new MyCallable(300));
        Future<String> f4 = pool.submit(new MyCallable(400));

//        String rs1 = f1.get();
//        System.out.println(rs1);


        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());

    }
}

Executors工具类实现线程池

Executors使用可能存在的陷阱

总结

定时器

是一种控制任务延时调用，或者周期调用的技术

作用：闹钟，定时邮件发送

定时器的实现

方式一：Timer

package com.itxue.d8_timer;

import javax.xml.bind.SchemaOutputResolver;
import java.util.Timer;
import java.util.TimerTask;

//Timer定时器的使用和了解
public class TimeDemo1 {
    public static void main(String[] args) {
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行一次");
            }
        },3000,2000);
    }
}

Timer定时器的特点和存在的问题

方式二：ScheduledExecutorsService

package com.itxue.d8_timer;

import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class TimerDemo2 {
    public static void main(String[] args) {
        ScheduledExecutorService timer = new ScheduledThreadPoolExecutor(3);


        timer.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行输出：AAA");
                try {
                    Thread.sleep(40000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },0,2,TimeUnit.SECONDS);
        timer.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行输出：BBB");
            }
        },0,2,TimeUnit.SECONDS);
    }
    }