【线程】Java多线程代码案例（2）

晚渔声2024-11-29 11:04

【线程】Java多线程代码案例（2）

一、定时器的实现

1.1Java标准库定时器
java 复制代码 
import java.util.Timer;
import java.util.TimerTask;

public class ThreadDemo5 {
    public static void main(String[] args) throws InterruptedException {
        Timer timer =new Timer();

        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("1000");
            }
        },1000);

        System.out.println("hello main");
    }
}
1.2 定时器的实现

首先考虑，定时器中都需要都需要实现哪些元素呢？

  1. 需要有一个线程，负责掐时间
  2. 还需要有一个队列，能够保存所有添加进来的任务，这个队列要带有阻塞功能
    因为这个任务，要先执行时间小的，再执行时间大的。此处我们可以实现一个优先级队列。那么时间小的任务就始终排在第一位，我们只需要关注队首元素是否到时间，如果队首没有到时间，那么后续其他元素，也一定没有到时间。

首先定义任务类，包含要执行的任务和时间

java 复制代码 
class MyTimerTask implements Comparable<MyTimerTask>{
    //执行时间
    private long time;
    //持有一个Runnable
    private Runnable runnable;

    public MyTimerTask(Runnable runnable,long delay){
        this.time=System.currentTimeMillis()+delay;
        this.runnable=runnable;
    }

    //实际要执行的任务
    public void run(){
        runnable.run();
    }

    public long getTime() {
        return time;
    }

    @Override
    //因为要加入优先级队列，必须能比较
    public int compareTo(MyTimerTask o) {
        return (int)(this.time-o.time);
    }
}

定义计时器

java 复制代码 
class MyTimer{
	//持有一个线程负责计时
	private Thread t=null;
	//优先级队列
	private PriorityQueue<MyTimerTask> queue =new PriorityQueue<>();
	//前面实现阻塞队列的逻辑，加锁
	private Object locker =new Object();
	//添加任务
	public void schedule(Runnable runnable,long delay){}
	//构造方法
	//注意执行任务并不需要我们写一个方法在main()函数中调用
	//这个是到时间自动执行的
	public MyTimer(){
		t=new Thread(()->{
			while(true){
				//到时间执行任务的逻辑
			}
		});
	}
}

那接下来我们就来分别实现这里的schedule方法和构造函数中执行任务的逻辑：
schedule()：

java 复制代码 
public void schedule(Runnable runnable,long delay){
	//入队列和出队列都需要打包成"原子性"的操作，加锁实现
	synchronized(locker){
		//新建任务
		MyTimerTask task=new MyTimerTask(runnable,delay);
		//加入队列
		queue.offer(task);
		//参考前面阻塞队列的实现，当队列为空时wait(),加入元素后notify()
		locker.notify();
	}
}

构造方法：

java 复制代码 
public MyTimer(){
	t=new Thread(()->{
		while(true){
			try{
				synchronized(locker){
				while(queue.isEmpty()){
					//阻塞直到加入新的任务后被notify()唤醒
					locker.wait();
				}
				//查看队首元素
				//peek不会将元素弹出
				MyTimerTask task=queue.peek;
				if(System.currentTimeMillis() >= task.getTime()){
					queue.poll();
					task.run();
				}else{
					//阻塞，释放锁（允许继续添加任务）
					//设置最大阻塞时间，阻塞到这个时间到了
					locker.wait(task.getTime()-System.currentTimeMillis());
				}
			}catch (InterruptedException e) {
               break;
            }
		}
	});	
	//启动线程
	t.start();
}

写到这里，就大功告成了，我们在main()函数中试验看一下运行结果：

java 复制代码 
public class ThreadDemo5{
    public static void main(String[] args) {
        MyTimer timer=new MyTimer();
        timer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(3000);
            }
        },3000);
        timer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(2000);
            }
        },2000);
        timer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(1000);
            }
        },1000);
        
        Thread.sleep(4000);
        timer.cancel();
    }
}

这里我们再加一个方法，我们希望任务执行完成后，能够主动结束这个线程：

java 复制代码 
public void cancel(){
	t.interrupt();
}

这里需要考虑线程被提前唤醒抛出的异常，因此在构造方法中将捕获异常的操作改为break;

计时器完整代码：

java 复制代码 
import java.util.PriorityQueue;

class MyTimerTask implements Comparable<MyTimerTask>{
    //执行时间
    private long time;
    //持有一个Runnable
    private Runnable runnable;

    public MyTimerTask(Runnable runnable,long delay){
        this.time=System.currentTimeMillis()+delay;
        this.runnable=runnable;
    }

    //实际要执行的任务
    public void run(){
        runnable.run();
    }

    public long getTime() {
        return time;
    }

    @Override
    public int compareTo(MyTimerTask o) {
        return (int)(this.time-o.time);
    }
}

class MyTimer{
    //持有一个线程负责计时
    private Thread t=null;
    //任务队列------>优先级队列
    private PriorityQueue<MyTimerTask> queue =new PriorityQueue<>();
    //锁对象
    private Object locker=new Object();

    public void schedule(Runnable runnable,long delay){
        synchronized (locker) {
            //新建任务
            MyTimerTask task = new MyTimerTask(runnable, delay);
            //加入队列
            queue.offer(task);
            locker.notify();
        }
    }
    public void cancel(){
        t.interrupt();
    }
    public MyTimer(){
        t = new Thread(() -> {
            while (true) {
                try {
                    synchronized (locker) {
                        while (queue.isEmpty()) {
                            //阻塞
                            locker.wait();
                        }
                        //查看队首元素
                        MyTimerTask task = queue.peek();
                        if (System.currentTimeMillis() >= task.getTime()) {
                            queue.poll();
                            task.run();
                        } else {
                            //阻塞
                            locker.wait(task.getTime()-System.currentTimeMillis());
                        }
                    }
                } catch (InterruptedException e) {
                    break;
                }
            }
        });
        t.start();
    }
}
public class ThreadDemo5{
    public static void main(String[] args) throws InterruptedException {
        MyTimer timer=new MyTimer();
        timer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(3000);
            }
        },3000);
        timer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(2000);
            }
        },2000);
        timer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(1000);
            }
        },1000);

        Thread.sleep(4000);
        timer.cancel();
    }
}

二、线程池的实现

2.1 线程池

最初我们提到线程这个概念，其实是一个"轻量级进程"。他的优势在于无需频繁地向系统申请/释放内存，提高了效率。但是随着线程的增多，频繁地创建/销毁线程也是一个很大的开销。解决方案有两种：

  1. 轻量级线程（协程），Java 21中引入了虚拟线程，就是这个东西。协程主要在Go语言中有较好的运用。
  2. 其次就是引入线程池的概念，无需频繁创建/销毁线程，而是一次性的创建好许多线程，每次直接取用，用完了放回线程池中。

为什么从线程池里取线程，会比从系统中申请更高效。

本质上在于去线程池里取线程，是一个用户态的操作，而向系统申请线程是一个内核态的操作。

还是以去银行取钱为例，向系统申请线程，就相当于找工作人员，在柜台取钱（工作人员收到请求后可能不会立即给你取钱），相对低效；而从线程池中取用线程，则相当于从ATM机里面取钱（从ATM机里面取钱是可以立即取到的），相对高效。

2.2 Java标准库中的线程池

这里我们可以细看一下这里的参数：

  1. corePoolSize(核心线程数)
    一个线程池里，最少要有多少个线程，相当于正式工，不会被销毁。
  2. maximumPoolSize(最大线程数)
    一个线程池里，最多要有多少个线程，相当于临时工，一段时间不干活就被销毁。
  3. keepAliveTime
    临时工允许的空闲时间，超过这个时间，就被销毁。
  4. unit
    keepAliveTime的时间单位
  5. BlockingQueue workQueue
    传递任务的阻塞队列
  6. threadFactory
    创建线程的工厂，参与具体的创建线程的工作。
    这里涉及到工厂模式，试想这样的代码能否运行：
java 复制代码 
class Point{
	//笛卡尔坐标系
	public point(double x,double y){...}
	//极坐标系
	public point(double r,double a){...}
}

像这样的代码是无法运行的。因为他们具有相同的方法名和参数列表，无法完成重载。那如果确实想完成这样的操作，该怎么做呢?

java 复制代码 
class Point{
	public static Point makePointByXY(double x, double y){
		Point p=new Point();
		p.setX(x);
		p.setY(y);
		return p;
	}
	public static Point makePointByRA(double r,double a){
		Point p=new Point();
		p.setR(r);
		p.setA(a);
		return p;
	}
}
Point p=Point.makePointByXY(x,y);
Point p=Point.makePointByRA(r,a);

总的来说，通过静态方法封装new操作，在方法内部设定不同的属性完成对象的初始化，构造对象的过程，就是工厂模式。

  1. RejectedExecutionHandler handler
    拒绝策略。如果这里的阻塞队列满了，此时要添加任务，就需要有一个应对策略。
策略 含义 备注
AbortPolicy() 超过负荷，抛出异常 所有任务都不做了
CallerRunsPolicy() 调用者负责处理多出来的任务 所有任务都要做，新加的任务由添加任务的线程做
DiscardOldestPolicy() 丢弃队列中最老的任务 不做最老的任务
DiscardPolicy() 丢弃新来的任务 不做最新的任务

由于ThreadPoolExecutor本身用起来比较复杂，因此标准库还提供了一个版本，把ThreadPoolExecutor给封装了一下。Executors 工厂类，通过这个类来创建不同的线程池对象（内部把ThreadPoolExecutor创建好了并且设置了不同的参数）

大致有这么几种方法：

方法 用途
newScheduleThreadExecutor() 创建定时器线程，延时执行任务
newSingleThreadExecutor() 只包含单个线程的线程池
newCachedThreadExecutor() 线程数目能够动态扩容
newFixedThreadExecutor() 线程数目固定
java 复制代码 
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadDemo6 {
    public static void main(String[] args) {
        ExecutorService service=Executors.newFixedThreadPool(4);
        service.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello");
            }
        });
    }
}

那么，对于一个多线程任务，创建多少个线程合适呢？

  1. 如果任务都是CPU密集型的（大部分时间在CPU上执行），此时线程数不应超过逻辑核心数；
  2. 如果任务都是IO密集型的（大部分时间在等待IO），此时线程数可以远远超过逻辑核心数；
  3. 由于实际的任务都是两种任务混合型的，一般通过实验的方式来得到最合适的线程数。
2.3 线程池的实现

我们可以实现一个简单的线程池（固定线程数目的线程池），要完成以下任务：

  1. 提供构造方法，指定创建多少个线程；
  2. 在构造方法中，创建线程；
  3. 有一个阻塞队列，能够执行要执行的任务；
  4. 提供submit()方法，添加新的任务
java 复制代码 
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

class MyThreadPoolExecutor{
    private List<Thread> threadList=new ArrayList<>();

    //阻塞队列
    private BlockingQueue<Runnable> queue=new ArrayBlockingQueue<>(10);

    public MyThreadPoolExecutor(int n){
        for(int i=0;i<n;i++){
            Thread t=new Thread(()-> {
                while (true) {
                    try {
                        //take操作也带有阻塞
                        Runnable runnable = queue.take();
                        runnable.run();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            });
            t.start();
            threadList.add(t);
        }
    }

    public void submit(Runnable runnable) throws InterruptedException {
        //put操作带有阻塞功能
        queue.put(runnable);
    }
}
public class ThreadDemo6 {
    public static void main(String[] args) throws InterruptedException {
       MyThreadPoolExecutor executor=new MyThreadPoolExecutor(4);
       for(int i=0;i<1000;i++){
           int n=i;
           executor.submit(new Runnable() {
               @Override
               public void run() {
                   System.out.println("执行任务："+n+",当前线程："+
                           Thread.currentThread().getName());
               }
           });
       }
    }
}

运行结果 ：

相关推荐
李小白662 分钟前
Map和Set(上)
java·数据结构
sunly_8 分钟前
Flutter：encrypt插件 AES加密处理
java·javascript·flutter
啦啦右一11 分钟前
SpringMVC |（一）SpringMVC概述
java·后端·spring
坚定信念，勇往无前12 分钟前
springboot aop @Pointcut 的 12 种用法
java·spring boot·spring
皮克斯的进化之路12 分钟前
什么是Spring IOC和Spring AOP？
java·后端·spring
余衫马21 分钟前
基于 JNI + Rust 实现一种高性能 Excel 导出方案（上篇）
开发语言·rust·excel
老牛源码24 分钟前
Z2400027基于Java+SpringBoot+Mysql+thymeleaf引擎的图书馆管理系统的设计与实现 代码 论文
java·spring boot·mysql
小哈里27 分钟前
【后端开发】Go语言编程实践，Goroutines和Channels，基于共享变量的并发，反射与底层编程
开发语言·后端·golang·编程·并发
多多*28 分钟前
后端 Java发送邮件 JavaMail 模版 20241128测试可用
java·开发语言·数据库
刘大浪31 分钟前
IDEA 2024 Maven 设置为全局本地仓库，避免新建项目重新配置maven
java·maven·intellij-idea
热门推荐
01Docker 夺命连环 15 问02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04如何识别手机是否有灵动岛（dynamic island）05玄机平台应急响应—webshell查杀06PyTorch机器学习实现液态神经网络07文件或文件夹名称中有空格如何批量去除08软件工程从理论到实践客观题汇总(头歌第一章至第八章)09Coze扣子平台完整体验和实践（附国内和国际版对比）10基于微信小程序的自习室预约系统的设计与实现