多线程6

最新推荐文章于 2024-10-06 20:16:20 发布
最新推荐文章于 2024-10-06 20:16:20 发布
阅读量428 收藏 18
点赞数 10
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Shootingmemory/article/details/137675146
版权
本文详细介绍了Java中的线程池，包括ExecutorService的几种创建方式，线程池的构成要素，如任务队列和提交方法。还探讨了如何在MyThreadPool中实现线程数量动态调整，以及定时器的使用和优化，以避免忙等和资源消耗。
摘要由CSDN通过智能技术生成

线程池 

标准库中的线程池

     ExecutorService service=Executors.newCachedThreadPool();//根据任务数目，自动进行扩容 
     Executors.newFixedThreadPool(4);//创建固定线程数目的线程池
     Executors.newSingleThreadExecutor();//创建一个只包含单个线程的线程池
     Executors.newScheduledThreadPool(4);//创建一个固定的线程数，但是任务演示执行的线程池。

 线程池的应用

    public static void main(String[] args) {
        ExecutorService service=Executors.newCachedThreadPool();//根据任务数目，自动进行扩容
      for (int i=0;i<10000;i++) {
         
          service.submit(new Runnable() {
              @Override
              public void run() {
                  System.out.println( i+ Thread.currentThread().getName());
              }
          });

      }

上述中 i  存在问题，这是变量捕获问题，i一直在改变不能在print中使用，所以更改代码如下

   public static void main(String[] args) {
        ExecutorService service=Executors.newCachedThreadPool();//根据任务数目，自动进行扩容
      for (int i=0;i<10000;i++) {
          int id=i;
          service.submit(new Runnable() {
              @Override
              public void run() {
                  System.out.println( id+ Thread.currentThread().getName());
              }
          });

      }

创建线程池

一个线程池要包含哪些东西？

1）有若干个线程

2)有任务队列.(使用Runnable即可)

3)提供submit方法



import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.BlockingQueue;

class  MyThreadPool{
    private BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(1000);

    public  MyThreadPool(int n){
    for (int i=0;i<n;i++){
        Thread t=new Thread(()->{
         while (true) {
             try {
                 Runnable runnable = queue.take();
                 runnable.run();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
        });
        t.start();
    }
    }
    void subimt(Runnable runnable) throws InterruptedException {
        queue.put(runnable);
    }
}
public class Test1 {
    public static void main(String[] args) {
        MyThreadPool threadPool=new MyThreadPool(10);

        for(int i=0;i<1000;i++){

            int id=i;
            try {
                threadPool.subimt(new Runnable() {
                    @Override
                    public void run() {
                        System.out.println( id+ Thread.currentThread().getName());
                    }
                });
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

        }
    }

}

main线程的任务是先是创建对象，通过调用MyThreadPoll的构造方法来创建n个线程，然后各个线程进入无限循环，然后等到有任务进入，然后通过sbimt方法添加到任务队列queue，然后到任务队列，任务队列将其分布到各个线程最后达到线程池的作用。


import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.BlockingQueue;

class  MyThreadPool2{
    private BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(1000);
        private  int maxPoolSize=50;
        private List<Thread> threadList=new ArrayList<>();
    public  MyThreadPool2(int n,int maxPoolSize){
            this.maxPoolSize=maxPoolSize;
        for (int i=0;i<n;i++){
            Thread t=new Thread(()->{
                while (true) {
                    try {
                        Runnable runnable = queue.take();
                        runnable.run();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            t.start();
        threadList.add(t);
        }
    }
    void subimt(Runnable runnable) throws InterruptedException {
            //此处进行判定，判定说当前任务队列的元素个数，是否比较长
        //如果队列元素比较长，说明已有的线程，不太能处理过来了、创建新的线程即可，
        // 如果队列不是很长，没必要创建新的线程.
        queue.put(runnable);
        if(queue.size()>=500&& threadList.size()<maxPoolSize ){

                Thread t=new Thread(()->{
                    while (true) {
                        try {
                            Runnable take = queue.take();
                            runnable.run();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                });
                t.start();
            }

    }
}
public class Test2 {
    public static void main(String[] args) {
        MyThreadPool2 threadPool2=new MyThreadPool2(20.10);

        for(int i=0;i<1000;i++){

            int id=i;
            try {
                threadPool2.subimt(new Runnable() {
                    @Override
                    public void run() {
                        System.out.println( id+ Thread.currentThread().getName());
                    }
                });
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

        }
    }

}

可以将线程数加入对应的队列，然后就可以实现最大线程的限制，但是最大线程的限制条件在submit函数中应用

实现拒绝策略的核心，在submit这里

2）submit的时候，先判定当前任务队列元素是否已经比较多了（自行设定一个阈值，比如，900)

3）如果确实比较多了，就根据刚才构造时指定的拒绝策略，执行不同的逻辑，

a）直接抛出异常，

b）直接在submit中调用Runnable的run.

c)删除队列的队首元素 (可以一次删多个，也不一定是一个)

d）丢弃当前元素，不添加到队列中.

定时器

定时器，就是“闹钟"效果

指定一个任务（Runnable)，并且指定一个时间(3000ms)，此时这个任务不会立即执行，而是在时间到达之后，再去执行。

定时器的应用

第一个参数是一个抽象类，本质上还是实现了Runnable.就把它当做Runnable来使用即可.


import java.util.Timer;
import java.util.TimerTask;

public class Test3 {
    public static void main(String[] args) {
        Timer timer=new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(3000);
            }
        },3000);
    }
}

线程不会结束，由于Timer中包含了前台宪政，阻止了进程的结束。

(TimerTasktask,longdelay）

表示"多长时间之后”执行.以当前执行schedule的时刻为基准，继续等delay时间之后再去进一步的执行.

创建定时器

需求：

1）能够延时执行任务/指定时间执行任务

2）能够管理多个任务

1.定义一个类，表示一个任务(Runnable)
class MyTimerTask{
    private  Runnable runnable;
    private long time;
    public  MyTimerTask(Runnable runnable){
        this.runnable=runnable;
        this.time=System.currentTimeMillis()+time;
    }
    public void run(){
        runnable.run();
    }
    public  long getTime(){
        return time;
    }
}
2.通过一定的数据结构，保存多个任务，
class MyTimer{
    private List<MyTimerTask> taskList=new ArrayList<>();
    public void schedule(Runnable runnable,long delay){
        MyTimerTask timerTask=new MyTimerTask(runnable,delay);
        taskList.add(timerTask);

    }
}

 这样会造成不停的扫描操作，这样会消耗太多资源，可以应用优先级队列。

可以把这些任务通过优先级队列保存起来.按照时间作为优先级的先后的标准就可以做到，队首元素就是时间最靠前的任务

class MyTimer{
    private PriorityQueue<MyTimerTask> taskList=new PriorityQueue<>();
    public void schedule(Runnable runnable,long delay){
        MyTimerTask timerTask=new MyTimerTask(runnable,delay);
        taskList.add(timerTask);

    }
}
3.还需要有一个线程，来负责执行这里的任务.(在指定的时间去执行）

构造方法中，创建一个线程，用新的线程来执行队列中的任务，

public MyTimer(){
        Thread thread=new Thread(()->{
           while (true){
               if(taskList.size()==0){
                   continue;
               }
               MyTimerTask timerTask=taskList.peek();
               long curTime=System.currentTimeMillis();
               if(curTime>=timerTask.getTime()){
                   taskList.poll();
               }else {
                   continue;
               }
           }
        });
    }

优化，会有线程安全所以要加锁，要不然会出现重复扫描的问题。

import java.util.ArrayList;
import java.util.List;
import java.util.PriorityQueue;

class MyTimerTask{
    private  Runnable runnable;
    private long time;
    public  MyTimerTask(Runnable runnable, long delay){
        this.runnable=runnable;
        this.time=System.currentTimeMillis()+delay;
    }
    public void run(){
        runnable.run();
    }
    public  long getTime(){
        return time;
    }
}
class MyTimer{
    Object o=new Object();
    private PriorityQueue<MyTimerTask> taskList=new PriorityQueue<>();
    public void schedule(Runnable runnable,long delay){
        synchronized (o) {
            MyTimerTask timerTask = new MyTimerTask(runnable, delay);
            taskList.add(timerTask);
        }
    }
    public MyTimer(){

        Thread thread=new Thread(()->{
           while (true) {
               synchronized (o) {
                   if (taskList.size() == 0) {
                       continue;
                   }
                   MyTimerTask timerTask = taskList.peek();
                   long curTime = System.currentTimeMillis();
                   if (curTime >= timerTask.getTime()) {
                       taskList.poll();
                   } else {
                       continue;
                   }
               }
           }
        });
        }
    }

}

现在存在忙等状态

上述代码就会短时间内循环很多次.上述操作都是在王"空转”一直在持续消耗cpu，但是没有真正执行任务。

 try {
                           o.wait(curTime-timerTask.getTime());
                       } catch (InterruptedException e) {
                           throw new RuntimeException(e);
                       }

此处应用wait方法不用sleep

1.notify唤醒wait，属于常规编程手法（处理正常业务流程）通过interrupt唤醒sleep，非常规手法.(处理异常业务流程）

2.sleep会抱锁，wait不会抱锁

这个代码中，不太适合直接使用PriorityBlockingQueue

只能处理，队列为空时候的阻塞，如果使用上述阻塞版本，还需要通过额外的锁对象和wait来实现针对时间未到的情冰

比较肯定要写构造方法：如下

最终写出的个人task如下：

import java.util.ArrayList;
import java.util.List;
import java.util.PriorityQueue;

class MyTimerTask implements Comparable<MyTimerTask>{
    private  Runnable runnable;
    private long time;
    public  MyTimerTask(Runnable runnable, long delay){
        this.runnable=runnable;
        this.time=System.currentTimeMillis()+delay;
    }
    public void run(){
        runnable.run();
    }
    public  long getTime(){
        return time;
    }

    @Override
    public int compareTo(MyTimerTask o) {
        return (int) (this.time-o.time);
    }
}
class MyTimer{
    Object o=new Object();
    private PriorityQueue<MyTimerTask> taskList=new PriorityQueue<>();
    public void schedule(Runnable runnable,long delay){
        synchronized (o) {
            MyTimerTask timerTask = new MyTimerTask(runnable, delay);
            taskList.add(timerTask);
        }
    }
    public MyTimer(){

        Thread thread=new Thread(()->{
           while (true) {
               synchronized (o) {
                   if (taskList.size() == 0) {
                       continue;
                   }
                   MyTimerTask timerTask = taskList.peek();
                   long curTime = System.currentTimeMillis();
                   if (curTime >= timerTask.getTime()) {
                       taskList.poll();
                   } else {
                       try {
                           o.wait(curTime-timerTask.getTime());
                       } catch (InterruptedException e) {
                           throw new RuntimeException(e);
                       }
                   }
               }
           }
        });
        }
    }

}
public class Test4 {
    public static void main(String[] args) {

    }
}

Shootingmemory
关注
c++多线程简单实现
Ember的博客
08-17 6361
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录一、线程和多线程线程多线程二、c++中的多线程实现1.简介2.具体实现三、代码示例四、问题 一、线程和多线程 线程 线程是操作系统能够进行运算调度的最小单位，被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。 多线程 简单来说线程就是调度和分配的基本单位，因此引入多线程的概念自然也就是提高了调度和分配的效率，从而提高了程序的运行效率。多线程的
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
Delphi多线程总结
疯流人物
10-23 2746
多线程总体认识 当前程序是一个进程, 进程只是一个工作环境, 线程是工作者; 每个进程都会有一个启动线程(或叫主线程), 也就是说: 大量的编码都是写给这个主线程的; ExitThread(0); 退出主线程; 系统不允许一个没有线程的进程存在, 所以程序就退出了. ExitThread 函数的参数是一个退出码, 这个退出码是给之后的其他函数用的, 这里随便给个无符号整数即可. ...
C# 异步 多线程
wokao253615105的专栏
02-24 4759
转载自https://www.cnblogs.com/doforfuture/p/6293926.html C#中 Thread，Task，Async/Await，IAsyncResult 的那些事儿！ 说起异步，Thread，Task，async/await，IAsyncResult 这些东西肯定是绕不开的，今天就来依次聊聊他们 ...
【多线程】线程池
王佑辉的博客
04-04 5622
3.keepAliveTime：多余的空闲线程的存活时间，当前线程池数量超过corePoolSize时，当空闲时间达到keepAliveTime时，多余空闲线程会被销毁直到只剩下corePoolSize个线程为止。7.handler：拒绝策略，表示当队列满了并且工作线程-大于等于线程池的数量最大线程数（maxinumPoolSize）时如何来拒绝请求执行的runnable的策略。6.threadFactory：表示生成线程池中工作线程的线程工厂，用于创建线程一般用默认的即可。
Qt多线程
qq292263211的博客
06-02 4166
Qt多线程有两种方法： 1、定义一个QThread的派生类，重写run函数，run函数中的程序就是新线程中要执行的内容。在主线程中实例化该类，调用start函数，就可以实现多线程。 2、定义一个QObject的派生类，把要在新线程中执行的内容写在一个槽函数中，然后把该派生类的对象传给QThread对象的moveToThread函数，用一个信号和槽函数绑定，当信号触发时，槽函数中的内容就会在子线程执行。 第一种方法 首先定义一个QThread的派生类 #ifndef MTHREAD_H #define M
gdb多线程调试
春夜喜雨的专栏
02-23 3002
使用gdb调试多线程时，和调试单线程时类似，但是需要附加使用几个命令来协助进行线程切换。
多线程与多进程区别
Gefangen的博客
08-15 3417
至于”数据共享、同步“、“编程、调试”、“可靠性”这几个维度的所谓的“复杂、简单”应该怎么取舍，只能说：没有明确的选择方法。保证指令原子的指向不被打断，Linux系统提供了一些常用操作的原子指令，，包括原子整数操作和原子位操作，必须为atuomic_t类型的整数（32位的整数，24位数据，8bits的锁）信号的处理是进程中所有线程共享的（注意：如果信号的默认处理是终止该进程那么即是把信号传给某个线程也一样会将进程杀掉）；进程中的所有信息对该进程的所有线程都是共享的；...
kafka多线程消费
u013433591的博客
12-28 4905
kafka 多线程消费、__consumer_offsets
Java - 多线程
热门推荐
了解➔熟悉➔掌握➔精通
03-23 3万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net 引 如果对什么是线程、什么是进程仍存有疑惑，请先Google之，因为这两个概念不在本文讨论的范围之内。 用多线程只有一个目的，那就是更好的利用CPU的资源，因为所有的多线程代码都可以用单线程来实现。说这个话其实只有一半对，因为反应”多角色”的程序...
Linux多线程
2021dragon的博客
02-12 7370
文章目录Linux线程概念什么是线程线程的优点线程的缺点线程异常线程用途Linux进程VS线程进程和线程进程的多个线程共享关于进程线程的问题Linux线程控制POSIX线程库创建线程线程终止线程等待分离线程Linux线程互斥进程线程间的互斥相关背景概念互斥量mutex互斥量的接口互斥量实现原理探究可重入VS线程安全概念常见的线程不安全的情况常见的线程安全的情况常见的不可重入的情况常见的可重入的情况可重入与线程安全联系可重入与线程安全区别常见锁概念死锁死锁的四个必要条件避免死锁Linux线程同步条件变量同步概
Qt界面多线程opencv调用摄像头
05-09
本代码是在qt平台下opencv利用多线程调用摄像头进行实时的视频显示在gui界面上，利用的时QThread的方法，是本人用了一年时间在维护的代码，需要的可以前来下载。当然我这也有qt上位机部分的代码，有需要的可以在评论...
QT中利用TCP协议实现了一个多线程的文件互传系统
06-09
在QT框架下，利用TCP协议实现一个多线程的文件互传系统是一项常见的任务，它涉及到网络编程、多线程处理以及文件操作等多个方面。本文将深入探讨这些关键知识点。 首先，TCP（Transmission Control Protocol）是一...
Android多线程文件夹下载及断点续传
08-07
在Android开发中，进行大文件下载时，为了提高效率并充分利用设备资源，通常会采用多线程下载技术。此外，为了提升用户体验，断点续传功能也显得尤为重要，尤其是在网络不稳定或者用户中断下载后，可以从上次停止的...
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1249
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 938
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
JDK1.0主要特性
最新发布
FoolRabbit的专栏
10-06 366
JDK1.0主要特性。
字符函数和字符串函数和内存函数
Java_fenxiang的博客
10-05 707
strtok函数原型与功能概述在 C 语言中，strtok函数的原型为char *strtok(char *str, const char *delim)。它的主要功能是将字符串str按照delim中指定的分隔符进行分割，返回被分割出来的子字符串。工作原理首次调用：当第一次调用strtok时，需要将待分割的字符串str作为...
Java中的break、continue和return语句
weixin_73230994的博客
10-05 380
break语句用于终止某个语句块的执行，一般使用在switch或者循环【for, while ,do-while】（提前退出或结束循环不是终止程序）1.continue语句用于结束本次循环，继续执行下一次循环2.continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环，这个和前面的标签的使用规则一样。
Linux多线程编程指南
"Linux多线程编程手册" 在计算机科学领域，多线程编程是一种方法，通过这种方法，一个应用程序可以同时执行多个线程，从而提高效率和响应性。特别是在Linux环境中，多线程编程是实现并发处理和充分利用多核处理器的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值