线程的等待和睡眠，线程池创建和使用

最新推荐文章于 2024-07-18 13:49:42 发布
最新推荐文章于 2024-07-18 13:49:42 发布
阅读量2.7k 收藏 2
点赞数 2
文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55691752/article/details/121862362
版权

目录

线程的等待

线程的睡眠

等待wait（）和睡眠sleep（）区别

实现案例：让一个线程进入等待状态，五秒后由另一个线程唤醒

生产者和消费者模式

生产者和消费者之间的问题

阻塞队列

 线程池

线程池的使用

顶层接口：executor

executors

线程池的优化配置

优化配置

线程池实现原理

首先通过构造方法创建一个线程池

 然后通过execute方法判断核心线程数是否大于线程数，大于创建非核心线程，小于创建非核心线程

 然后通过addWorker方法，创建任务加入HashSet（所有任务都保存在HashSet中）

 通过runWorker执行任务 循环调用 getTask得到任务，task.run（）执行任务

如果队列为空就进入阻塞。

总结

线程的等待

Object类中的方法

wait（），让当前线程进入等状态，直到被通知。

wait（long），设置等待时间，知道被通知或者等待时间结束。

notify，通知，随机通知一个线程

notifyAll（），通知所有线程

线程的睡眠

sleep（时间毫秒），让线程睡眠一段时间，时间结束后自动唤醒。

等待wait（）和睡眠sleep（）区别

wait（）由锁对象调用，sleep（）由当前线程调用。

wait（）可以被其他线程通知唤醒，sleep（）只能等待睡眠时间结束。

wait（）等待会释放锁，sleep（）不会释放锁。

实现案例：让一个线程进入等待状态，五秒后由另一个线程唤醒

public class AAA {
    //执行线程
    public synchronized void threadA(){
            System.out.println("线程A开始执行");
            for (int i = 0; i <100 ; i++) {
                if(i==50){
                    try {
                        System.out.println("线程进入等待");
                        this.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("执行了"+i);
            }
    }
    //唤醒线程
    public synchronized void threadB(){
            System.out.println("唤醒线程");
            this.notify();
    }

    public static void main(String[] args) {
        AAA aaa = new AAA();
        new Thread(()->{
            aaa.threadA();
        }).start();
        try {
            Thread.sleep(5000);
            aaa.threadB();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

生产者和消费者模式

        生产者:某些程序/进程/线程创建数据，就是生产者。

        消费者：某些程序/进程/线程消耗数据，就是消费者。

生产者和消费者之间的问题

        高耦合，生产者和消费者联系紧密，不利于系统的维护和拓展。

        忙闲不均，生产者和消费者速度不一致，导致系统资源浪费。

        并发性能低，同时能处理的请求量小。

例如：包子铺，老板（生产者）做一个包子递给客户（消费者），没有客户就等待不做。当多个客户来买包子得等待。

解决方案：加一个缓冲区（蒸笼）。老板可以提前做一定数量的包子放进蒸笼，不用等待客户来。客户也可以直接从蒸笼拿，不用等老板做。当蒸笼没有包子在通知老板做。

案例实现：

import java.util.ArrayList;

public class StreamDemo2 {
    //包子上限
    public static final int MAX_BAO = 100;

    class Baozi {
        private int id;

        public Baozi(int id) {
            this.id = id;
        }

        @Override
        public String toString() {
            return "包子" + id;
        }
    }


    //缓冲区
    ArrayList<Baozi> streams = new ArrayList<>(MAX_BAO);

    //生产包子
    public synchronized void makeBao() {
        if (streams.size() == 100) {
            try {
                //生产者进入等待
                System.out.println(Thread.currentThread().getName()+"包子数量到达上线，老板进入等待");
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else {
            //通知生产者做包子
            this.notifyAll();
        }
        Baozi baozi = new Baozi(streams.size()+1);
        streams.add(baozi);
        System.out.println("做了" + baozi);
    }

    //消费包子
    public synchronized void shopBao() {
        if (streams.size() == 0) {
            System.out.println("包子买完，顾客进入等待");
            try {
                //消费者进入等待
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else {
            //通知消费者拿包子
            this.notifyAll();
        }
        if(streams.size()>0){
            Baozi baozi = streams.remove(0);
            System.out.println("顾客消费了" + baozi);
        }
    }

    public static void main(String[] args) {
        StreamDemo2 streamDemo2 = new StreamDemo2();
        //一个线程做包子
        new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                streamDemo2.makeBao();
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        //十个线程来买包子
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                //一个线程买十个包子
                for (int j = 0; j <10 ; j++) {
                    streamDemo2.shopBao();
                }
            }).start();
        }
    }
}

上面我们是通过手动让线程等待和通知，太过麻烦。有没有简便的方式呢？

阻塞队列

应用了生产者和消费者模式的集合，可以根据数据的状态自动帮我们对线程执行等待或通知。

BlockingQueue 接口

  • put 添加数据，达到上限会自动让线程等待

  • take 取并删除数据，数据空了会自动让线程等待

实现类

ArrayBlockingQueue 类 数据结构为数组

LinkedBlockingQueue类 链表结构

用ArrayBlockingQueue实现上面案例：

import java.util.concurrent.ArrayBlockingQueue;

public class SteamDemo {

    static class Baozi {
        private int id;

        public Baozi(int id) {
            this.id = id;
        }

        @Override
        public String toString() {
            return "包子" + id;
        }
    }
    public static void main(String[] args) {
        //阻塞队列
        ArrayBlockingQueue<Baozi> queue = new ArrayBlockingQueue<>(100);

        new Thread(()->{
            for (int i = 0; i < 200; i++) {
                Baozi baozi = new Baozi(queue.size()+1);
                try {
                    queue.put(baozi);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("生产了"+baozi);
            }
        }).start();

        for (int i = 0; i <5 ; i++) {
            new Thread(()->{

                for (int j = 0; j <40 ; j++) {
                    try {
                        Baozi baozi=queue.take();
                        System.out.println("吃了"+baozi);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
}

 线程池

         线程，是一种宝贵的资源，每个线程执行完指令就会销毁。如果有大量的任务需要处理，那么大量的线程创建和销毁会对资源消耗非常严重。

        线程池：对线程进行回收利用。线程池会保存一定量的线程，线程执行完任务后，会回到线程池中，等待下一个任务，节省系统资源，提升性能。

线程池的使用

顶层接口：executor

方法：execute（Runnalbe）

继承executor

添加线程池管理方法，如：shutdown，shoudownNow

executors

一个提供创建线程池方法的工具类

主要创建线程池的几个方法

newCachedTreadPool（）创建长度不限的线程池
newFixedThreadPool (int)创建固定长度的线程池
newSingleThreadExecutor()创建单一个数的线程
newScheduledThreadPool(int)创建可以调度的线程

实现方法：

import java.time.LocalDateTime;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ThreadPool {
    //创建长度不限的线程池
   public void poolA(){
       ExecutorService service = Executors.newCachedThreadPool();
       for (int i = 0; i <10 ; i++) {
           int n =i;
           service.execute(()->{
               System.out.println(Thread.currentThread().getName()+"执行了任务"+n);
           });
       }
       service.shutdown();
   }
    //创建固定长度线程池
    public void poolB(){
       ExecutorService service = Executors.newFixedThreadPool(2);//线程池里的线程数
        for (int i = 0; i <10 ; i++) {
            int n =i;
            service.execute(()->{
                System.out.println(Thread.currentThread().getName()+"执行了任务"+n);
            });
        }
        service.shutdown();
    }
    //创建单一个数线程池
    public void poolC(){
       ExecutorService service = Executors.newSingleThreadExecutor();
        for (int i = 0; i <10 ; i++) {
            int n =i;
            service.execute(()->{
                System.out.println(Thread.currentThread().getName()+"执行了任务"+n);
            });
        }
        service.shutdown();
    }
    //创建可调度的线程
    public void poolD(){
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);
        //调度的线程，一秒后执行，三秒执行依次，时间单位秒
        scheduledExecutorService.scheduleAtFixedRate(()->{
            System.out.println(Thread.currentThread().getName()+"执行了"+ LocalDateTime.now());},1,3, TimeUnit.SECONDS);
        }
    public static void main(String[] args) {
        new ThreadPool().poolD();
    }
}

线程池的优化配置

首先。来了解线程池构造方法里参数的含义：

corePoolSize 核心线程数，创建线程池后自带线程，不会进行销毁

maximunPoolSize 最大线程数

keepAliveTime 存活时间，非核心线程能够闲置的时间，超过后被销毁

timeUnit 时间单位

blockingQueue 阻塞队列，存放任务（Runnbale）的集合

 

优化配置

核心线程数可以设置为cpu内核*N（N和任务执行需要时间和并发量相关）

最大线程数可以设置为核心线程数，避免线程频繁的创建和销毁

如果非核心线程存在，可以将核心线程数设置大一点

阻塞队列用LinkedBlockingQueue,链表增删快

线程池实现原理

线程池是对线程的回收利用，不让其销毁，那线程池是怎么做到的呢？

可以看底层源码：

首先通过构造方法创建一个线程池

 然后通过execute方法判断核心线程数是否大于线程数，大于创建非核心线程，小于创建非核心线程

 然后通过addWorker方法，创建任务加入HashSet（所有任务都保存在HashSet中）

 通过runWorker执行任务 循环调用 getTask得到任务，task.run（）执行任务

如果队列为空就进入阻塞。

 更多细节可以去看看源码，这里只截图了一部分。

总结

1.线程的等待和通知（是干什么，谁来调用）

2.wait和sleep的区别

3.生产者和消费者模式（是什么，解决什么问题，如何实现的，项目中有哪些应用）

4.阻塞队列（了解）

5.线程池（作用，有哪几种线程池，线程池的创建有哪些参数，如何优化，实现原理（看源码、画图、归纳））

菗煙/~荰峎暨莫
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
线程任务之线程中断、线程等待、线程睡眠
不再更新，新博客 chgl16.space
02-14 755
1. 线程中断   Thread类提供了一种线程可以中断其他线程的机制。当一个线程被中断时，它会抛出java.lang.InterruptedException异常。这一机制由下面三种方法构成。 一个线程在未正常结束之前, 被强制终止是很危险的. 因为它可能带来完全预料不到的严重后果. 也因此Thread.suspend, Thread.stop等方法都弃用了。那么不能直接把一个线程搞挂掉, 但...
Java多线程-四种线程池创建方式
p812438109的专栏
01-15 6264
一）线程池简介 1、减少线程的频繁创建、销毁。 2、可有效的使用和管理线程，提升资源重复使用率，避免资源不足引起的一些问题。 二）newFixedThreadPool 原理：创建一个固定数量大小的线程池，当线程任务数超过固定大小时，未执行的线程任务进行阻塞队列，等待线程池调度。 示例： import java.util.concurrent.ExecutorService; i...
线程基础：Java多线程的创建休眠与等待
GoodManS的CSDN
08-28 288
详细解释了线程的一些基础内容，包括线程的创建、线程的休眠和等待。
java 创建线程池的几种方式
最新发布
精神小牛马
07-18 1300
java线程池创建的几种方式和运用
深入Thread.sleep
热门推荐
Zero
08-10 2万+
一直都说，Threed.sleep是不会释放锁，而wait是释放锁的(对象锁)，现理论上来分析一下啊。由于CPU分配的每个线程的时间片极为短暂(一般为几十毫秒)，所有CPU通过不停地切换线程执行，这样就给程序员一种错觉，以为多个线程是在同时执行。sleep就是正在执行的线程主动让出cpu，cpu去执行其他线程，在sleep指定的时间过后，cpu才会回到这个线程上继续往下执行，如果当前线程进入了同步锁
线程等待及休眠
qq_44773719的博客
12-30 612
1.线程等待 join() 有时，我们需要等待一个线程完成它的工作后，才能进行自己的下一步工作。 public class JoinTest { public static void main(String[] args) throws InterruptedException { Thread thread = new Thread(new Runnable() { ...
操作系统(第三节) --- 线程等待/休眠/状态及 Runnable 和 Callable 的简单使用及原理
Fug_Lee的博客
03-11 841
关于线程和进程的基本概念☛操作系统中线程和进程的概念理解 这篇文章已经有了很详细的解释, 接下来主要来讲讲线程等待与线程休眠 / 线程的几种状态 / Runnable 和 Callable 与 Thread 的概念和区别及 Executor 框架是什么样的.
Java线程等待、睡眠、中断
Scott
02-12 1078
参考资料：java线程与并发编程实践 线程状态 NEW：该状态下线程还没有执行 RUNNABLE：该状态下线程正在JVM中执行 BLOCKED：该状态下线程阻塞并等待一个监听锁 WAITING：该状态下线程无限期等待 TIMED_WAITING：该状态下线程在指定时间内等待 TERMINATED：改状态下线程已退出 线程的睡眠和中断 /** * 线程的睡眠和中断 */...
线程、多线程和线程池面试专题.docx
11-15
3. wait()方法：释放obj的锁，导致当前的线程等待，直到其他线程调用此对象的notify()或notifyAll()方法。 五、线程阻塞的原因 1. 线程执行了Thread.sleep(int millsecond)方法，放弃CPU，睡眠一段时间，一段时间...
13【线程等待、线程状态、线程池、File类、递归】
緑水長流*z
08-05 3925
一、线程的等待与唤醒 1.1 线程的等待 1.1.1 等待与随机唤醒 public final void wait()：让当前线程进入等待状态，并且释放锁对象。 注意：wait方法是锁对象来调用，调用wait()之后将释放当前锁，并且让当前锁对象对应的线程处于等待（Waiting）状态； public final native void notify()：随机唤醒一条锁对象对应线程中的一条（此线程必须是睡眠状态） 注意：notify()也是锁对象来调用，并不是当前线程对象调用 因为wait需
多线程——线程池和计时器Timer的基本使用
qq_45337431的博客
08-13 1541
有非常的多的任务需要多线程来完成，且每个线程执行时间不会太长，这样会频繁的创建和销毁线程。频繁创建和销毁线程会比较耗性能。如果有了线程池就不要创建更多的线程来完成任务，因为线程可以重用。 线程池用维护者一个队列，队列中保存着处于等待（空闲）状态的线程。不用每次都创建新的线程。 和线程池相关的接口和类存在java.util.concurrent并发包中。 接口: Executor：线程池的核心接...
线程池使用介绍用程序可以有多个线程，这些线程在休眠状态中需要耗费大量时间来等待事件发生。其他线程可能进入睡眠状态，并且仅定期被唤醒以轮循更改或更新状态信息，然后再次进入休眠状态
09-20
应用程序可以有多个线程，这些线程在休眠状态中需要耗费大量时间来等待事件发生。其他线程可能进入睡眠状态，并且仅定期被唤醒以轮循更改或更新状态信息，然后再次进入休眠状态。为了简化对这些线程的管理，.NET框架为每个进程提供了一个线程池，一个线程池有若干个等待操作状态，当一个等待操作完成时，线程池中的辅助线程会执行回调函数。线程池中的线程由系统管理，程序员不需要费力于线程管理，可以集中精力处理应用程序任务。 线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程.每个线程都使用默认的堆栈大小,以默认的优先级运行,并处于多线程单元中.如果某个线程在托管代码中空闲(如正在等待某个事件),则线程池将插入另一个辅助线程来使所有处理器保持繁忙.如果所有线程池线程都始终保持繁忙,但队列中包含挂起的工作,则线程池将在一段时间后创建另一个辅助线程但线程的数目永远不会超过最大值.超过最大值的线程可以排队,但他们要等到其他线程完成后才启动
JAVA线程池的几种使用方式以及线程同步详解
yingziisme的博客
10-07 4744
JAVA创建线程的方法 继承Thread类 public class MyThread extends Thread { @Override public void run(){ // do something } } 实现Runnable接口 public class MyRunnable implements Runnable{ @Ove...
线程的睡眠和等待的区别（sleep 与 wait）？
weixin_41980692的博客
04-27 2012
sleep是Thread类中的方法，wait是Object类的方法， sleep不会释放对象锁，wait会释放对象锁。 sleep可以在任何地方用，wait()只能在synchronized方法或块中使用。 sleep一定要传入参数，wait不传参数的时候是进入无限等侍，要使用notife才能唤醒。 ...
线程(4)，等待，休眠，状态
shadow___h的博客
06-08 363
线程等待 线程之间是并发执行的关系 多个线程之间，谁先执行，谁后执行，谁执行到那里让cpu运行，我们是无法是控制的，只能让系统的内核去控制 但是我们可以控制用jion方法来让那个线程去先结束 jion方法，执行jion方法线程就会阻塞，一直到等到对应线程的jion方法执行完才会执行，join方法存在的意义就是为了控制线程结束得先后顺序 2.线程休眠 就是让正在的运行的线程去休息一会，等段时间在执行 sleep就是让对应线程的PCB从就绪队列进入到阻塞队列 线程状态 NEW Thre.
线程的休眠与等待 区别（转）
xcl2004911的专栏
07-25 5131
关于线程间的交互和共享数据通常有轮询和通知机制。一下举例说明：Thread1和Thread2共享一块数据ShareData，Thread1使用数据，Thread2更新数据。当Thread1使用数据时发现数据没有更新就可以先休眠（sleep（））一段时间然后再去判断是否更新，如此反复直到数据可用，这就是所述的轮询机制。可以看出轮询机制需要不断的轮询数据状态，很耗费资源；当采用通知机制时过程是这样的，
多线程（Thread类、线程创建、中断、等待、休眠）
weixin_63426509的博客
09-02 809
全面概述了多线程Thread，线程创建，等待，休眠，堵塞，状态等概念，并用实例解释了线程的创建线程是轻量级进程，一个进程可能包含一个者多个线程。进程频繁的创建消耗的资源比创建线程大家更大，所以引入了线程的概念。
线程的sleep
weixin_30687587的博客
05-16 130
Thread.sleep(n); 作用是让当前线程睡眠n毫秒，以便执行其他线程，如果没有其他线程，那睡眠n毫秒后，继续执行。 如果n=0，Sleep(0)是指CPU交出当前线程的执行权，让CPU去执行其他线程。也就是放弃当前线程的时间片，转而执行其他线程。 一般来说以下情况应该使用sleep(0) 1.当前线程比较耗时比较占CPU资源，可以在结尾处加上Sleep(0), 这样...
API基础第九天
dyr_080508的博客
02-17 449
API基础第九天
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值