JavaEE 【知识改变命运】05 多线程（4)

文章目录

  • 单例模式
    • 什么是单例模式
    • 饿汉模式
    • 懒汉模式
    • 多线程- 懒汉模式
      • 分析多线程问题
      • 第一种添加sychronized的方式
      • 第二种添加sychronized的方式
      • 改进第二种添加sychronized的方式（DCL检查锁）
  • 阻塞队列
    • 什么是阻塞队列
    • 什么是消费生产者模型
    • 标准库中的阻塞队列
    • 消息队列应用的场景
    • 自己模拟实现阻塞队列
  • 定时器
    • 标准库中的定时器
    • 实现定时器
  • 工厂模式
  • 线程池
    • 线程池的一些问题
    • 实现一个线程池
    • 创建系统自带的线程池
  • wait和sleep的区别

单例模式

什么是单例模式

  • 单例模式能保证某个类在程序中只存在唯⼀⼀份实例, ⽽不会创建出多个实例
  • 单例模式实现方式很多，最常用饿汉模式和懒汉模式实现

饿汉模式

  • 创建过程：
    – 1. 定义一个static修饰的变量，就可以包子这个变量全局唯一
    – 2.构造方法私有化，防止变量被修改
    – 3.提供一个获取变量的get静态方法，通过类名的方式去调用
public class Singleton {//懒汉模式//创建一个私有静态属性，并且把对象new出来private static Singleton instance =new Singleton();//私有化构造器private Singleton() {}//提供一个公共的静态方法，返回单例对象public static Singleton getInstance() {return instance;}public static void main(String[] args) {Singleton s1 = Singleton.getInstance();Singleton s2 = Singleton.getInstance();System.out.println(s1 == s2); // true}
}
  • 把这种类加载时候就完成对象的初始化的创建方式，就叫”饿汉模式“
  • 这种模式存在的问题是，可能对象创建了但是没有使用，从而导致资源浪费。

懒汉模式

public class SingLetonLazy {//创建一个对象不去new对象private static SingLetonLazy instance;//私有化构造器private SingLetonLazy() {}//提供一个公共的静态方法，返回单例对象public static SingLetonLazy getInstance() {if(instance==null) {instance=new SingLetonLazy();}return instance;}public static void main(String[] args) {SingLetonLazy s1 = SingLetonLazy.getInstance();SingLetonLazy s2 = SingLetonLazy.getInstance();System.out.println(s1 == s2); // true}
}
  • 懒汉模式创建对象，在要获得单例对象的时候，创建，避免了资源的浪费但是存在多线程安全问题。

多线程- 懒汉模式

public class SingLetonLazy {private static SingLetonLazy instance;//私有化构造器private SingLetonLazy() {}//提供一个公共的静态方法，返回单例对象public static SingLetonLazy getInstance() {if(instance==null) {instance=new SingLetonLazy();}return instance;}public static void main(String[] args) {for (int i = 0; i < 10; i++) {Thread t1 =new Thread(()->{try {sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}SingLetonLazy s1 = SingLetonLazy.getInstance();System.out.println(s1);});t1.start();}}
}

在这里插入图片描述
出现了多线程问题。

分析多线程问题

在这里插入图片描述

第一种添加sychronized的方式

public static SingLetonLazy getInstance() {if(instance==null) {synchronized (SingLetonLazy.class){instance=new SingLetonLazy();}}return instance;}

在这里插入图片描述

  • 这种写法不能保证多线程安全

第二种添加sychronized的方式

public static SingLetonLazy getInstance() {synchronized (SingLetonLazy.class){if(instance==null) {instance=new SingLetonLazy();}}return instance;}

在这里插入图片描述

  • 这种写法似乎可以保证多线程安全，但是还是存在一个问题，当一个线程进行这个方法，如果没有初始化，则获取锁进行初始化操作，此时单例对象被第一个线程创建完成，后面的线程以后永远不会在执行new对象的操作，synchronized就没必要添加了，第二次线程开始这个加锁解锁都是无效的操作，lock和unlock对应的锁指令是互斥锁，比较消耗系统资源。
  • 添加锁本质就会消耗很多资源

改进第二种添加sychronized的方式（DCL检查锁）

 private volatile static SingLetonLazy instance;//给共享变量加上volatile

在这里插入图片描述

public static SingLetonLazy getInstance() {//第一次判断是否加锁if(instance==null) {synchronized (SingLetonLazy.class) {判断是否创建了一个对象if (instance == null) {instance = new SingLetonLazy();}}}return instance;}

在这里插入图片描述
在这里插入图片描述

阻塞队列

什么是阻塞队列

  1. 阻塞队列本质还是队列，遵循”先进先出“的原则
  2. 阻塞队列是一种线程安全的数据结构，有以下特征
    – 当队列满的时候，继续入队就会发生阻塞等待，直到队列中有其他线程取出元素后，队列有空位才会再次入队
    – 当队列空的时候，继续出队就会放生阻塞等待，知道队列中有其他线程插入元素时候，队列有元素才会再次出队
  3. 阻塞队列适用于一种典型场景‘消费生产者模型’

什么是消费生产者模型

  1. 生产者消费者模式就是通过一个容器解决消费者和生产者的强耦合问题。
  2. 生产者和消费者不会直接影响，生产者生产的资源直接放入容器（阻塞队列）中，消费者消费的资源，直接从容器（阻塞队列）中拿。从而保证生产者不会生产资源等待消费者消费，消费者也不会等待生产者生产资源。
  3. 阻塞队列相当于一个缓冲区，平衡生产者和消费者的处理能力
    – 比如双11时候，会涌入大量的支付订单，这时候如果服务器直接处理这些订单，可能就会把服务器挤爆，这时候中间设置一个阻塞队列，把产生的大小支付订单扔进阻塞队列里面，然后服务器根据自己的处理能力，从队列里面取出要处理的订单，从而达到削峰的效果，防止服务器被挤爆。
  4. 阻塞队列也能使生产者和消费者之间 解耦
    – 过年期间大家都会包饺子，擀饺子皮相当于生产者，包饺子相当于消费者，中间放个案板，所有的饺子皮都放在案板上，包饺子皮的人直接从案板上取，擀饺子皮的可能是妈妈可能是爸爸可能是我，无论是谁擀饺子皮消费者都不关心，因为都是从案板上取的饺子皮。

标准库中的阻塞队列

  1. 在 Java 标准库中内置了阻塞队列. 如果我们需要在一些程序中使用阻塞队列, 直接使用标准库中的即可.
    – BlockingQueue 是一个接口. 真正实现的类是 LinkedBlockingQueue.
    – put 方法用于阻塞式的入队列, take 用于阻塞式的出队列.
    – BlockingQueue 也有 offer, poll, peek 等方法, 但是这些方法不带有阻塞特性.
  2. 创建一个BlockingQueue
    在这里插入图片描述
    在这里插入图片描述
    – 其中capacity是这个队列的大小。

在这里插入图片描述
– 这里设置一个三个大小的阻塞队列，当第四个元素入队时候就会发生阻塞等待
在这里插入图片描述
– 这里取出三个元素后，队列为空，队列阻塞等待
在这里插入图片描述
在这里插入图片描述
– put和take都会抛出一个InterrupteException异常

  1. 其他补充常问的方法
    在这里插入图片描述
    – add（）
    在这里插入图片描述
    – offer（）
    在这里插入图片描述
    – remove（）
    在这里插入图片描述
    – poll
    在这里插入图片描述

消息队列应用的场景

  1. 解耦
    – 高内聚，低耦合：业务强相关的代码组织在一起，不相关的单独定义便于以后的维护，以为要把重复的代码尽量抽象出来，封装成一个公共方法，在需要的地方直接调用这个方法即可
    – 生产消息的应用程序把消息写进消息队列（生产者），使用消息的应用程序从消息队列里面取出消息（消费者）
    在这里插入图片描述
    在这个模型中，服务器A要时刻感应到服务器B，在调用的过程中双方都要知道对方需要调用的参数和调用方式
    ，在ABC整个调用的链路中秒如果其中一个出现了问题，就会影响整个业务执行
    在这里插入图片描述

  2. 削峰填谷（流量）
    – 针对流量暴增的时候使用消息队列来进行缓冲
    在这里插入图片描述
    在这里插入图片描述
    – 实例：
    在这里插入图片描述

  3. 异步操作
    周末：我和我女朋友取买包子

  • 同步操作：她一直等我买包子回来，开始，中间这个过程啥也不干，同步发出请求后，必须要等待响应才能- 进行下一步操作
  • 异步操作：她让我去之后，在家做点别的事情，比如，做点小菜，熬点稀饭，异步操作，发出请求之后，不需要等待响应，而做其他的事情，等待响应主动通知自己

自己模拟实现阻塞队列

public class MyBlockingDeque {int [] arr;volatile int head=0;volatile int tail=0;volatile int size=0;MyBlockingDeque(int capacity){if(capacity<=0) {throw new RuntimeException("capacity must be positive");}arr = new int[capacity];}public void put(int val) throws InterruptedException {while(size>=arr.length) {synchronized (this){this.wait();}}arr[tail]=val;tail++;if(tail>=arr.length) {tail=0;}size++;synchronized (this){this.notifyAll();}}public synchronized int take() throws InterruptedException {while(size==0) {this.wait();}int val =arr[head];head++;if(head>=arr.length) {head=0;}size--;this.notifyAll();return val;}
}
class Main{public static void main(String[] args) throws InterruptedException {MyBlockingDeque myBlockingDeque = new MyBlockingDeque(10);int i=0;new Thread(()->{while (true){try {sleep(1000);int val = myBlockingDeque.take();System.out.println(Thread.currentThread().getName()+"取出成功"+val);} catch (InterruptedException e) {e.printStackTrace();}}}).start();while (true){myBlockingDeque.put(i);System.out.println(Thread.currentThread().getName()+"添加成功"+i);i++;}}
}

在这里插入图片描述

  • put时候
    在这里插入图片描述
  • take时候
    在这里插入图片描述
  • 我们上锁可以锁代码块也可以方法
    在这里插入图片描述
  • if改为while的原因是防止大量现场
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

定时器

标准库中的定时器

  • 标准库中定义一个TImer类。Timer类的核心方法为schedule
  • schedule包含两个参数，第一个参数指定要执行的代码任务，第二个参数指定多场实际之后执行。
import java.util.Timer;
import java.util.TimerTask;public class Demo_801 {public static void main(String[] args) {// 使用jdk中提供的类，创建一个定器Timer timer = new Timer();//向定时器添加任务timer.schedule(new TimerTask() {@Overridepublic void run() {System.out.println("Hello World!");}},1000);timer.schedule(new TimerTask() {@Overridepublic void run() {System.out.println("任务1");}},1500);timer.schedule(new TimerTask() {@Overridepublic void run() {System.out.println("任务2");}},2000);timer.schedule(new TimerTask() {@Overridepublic void run() {System.out.println("任务3");}},2500);}
}

ctrl+p查看方法的参数列表
在这里插入图片描述
定义自己的任务
在这里插入图片描述
延迟多久执行的任务
在这里插入图片描述
任务具体执行的时间
在这里插入图片描述

实现定时器

  1. 设计思路
  • 用一个类描述任务和执行任务的时间
    – 具体任务逻辑用Runable表示，执行时间可以用一个long型delay表示
  • 组织任务和时间对应的对象
    – 可以考虑用一个阻塞队列，我们选择用PriorityBlockingQueue(),保证扫描任务时候，延时最少的任务先执行

- 提供一个方法，
在这里插入图片描述

  • 提供一个方法，提交任务
    在这里插入图片描述

  • 要有一个线程执行任务
    – 在哪里定义扫描线程？
    –在构造方法里面直接定义线程
    – 1.取出队首元素，2.判断一下任务到执行的时间没有，3，如果到了就执行，4.没有就放回队列
    在这里插入图片描述

  1. 代码实现
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.PriorityBlockingQueue;public class MyTimer {//用一个阻塞队列来组织任务private BlockingQueue<MyTask> queue = new PriorityBlockingQueue<>();private Object lock = new Object();public MyTimer() {//创建线程Thread thread =new Thread(()->{while(true){try {//从队列中取出任务MyTask task=this.queue.take();//判断有没有到执行的时间long currentTime=System.currentTimeMillis();if(currentTime>=task.getTime()){//时间到了执行task.getRunnable().run();} else{//时间没到，将任务放回队列中this.queue.put(task);}} catch (InterruptedException e) {throw new RuntimeException(e);}}});thread.start();}/*** 添加定时任务* @param runnable 任务* @param delay 延时* @throws InterruptedException*/public void schedule(Runnable runnable,long delay) throws InterruptedException {//根据传的参数构造一个MyTask对象MyTask task=new MyTask(runnable,delay);//将这个MyTask对象阻塞放入队列中queue.put(task);}
}//MyTask类，用于封装任务和执行时间
class MyTask implements Comparable<MyTask>{//任务private Runnable runnable;//执行时间private long time;public MyTask(Runnable runnable, long delay) {//增强代码健壮性if(runnable==null){throw new IllegalArgumentException("任务不能为空");}if(delay<0) {throw new IllegalArgumentException("延迟时间不能为负数");}this.runnable = runnable;//计算出任务的执行时间this.time = delay+System.currentTimeMillis();}public Runnable getRunnable() {return runnable;}public long getTime() {return time;}@Overridepublic int compareTo(MyTask o) {if(this.getTime()<o.getTime()){return -1;} else if(this.getTime()==o.getTime()){return 0;}else {return 1;}//万一时间超过了long的范围溢出，怎么办？用上面的比较比较好//return (int)(this.getTime()-o.getTime());}
}
public class Test {public static void main(String[] args) throws InterruptedException {MyTimer timer = new MyTimer();timer.schedule(new Runnable(){@Overridepublic void run() {System.out.println("任务1");}},1000);timer.schedule(new Runnable(){@Overridepublic void run() {System.out.println("任务2");}},500);timer.schedule(new Runnable(){@Overridepublic void run() {System.out.println("任务3");}},2000);//timer.schedule(null,-100);//任务加强健壮性}
}
  • 注意事项：
    – 注意我们要实现Conparable接口指定排序规则
    在这里插入图片描述
    在这里插入图片描述

– 我们要添加校验，防止非法的输入
在这里插入图片描述

– 解决数据可能会溢出的问题，比如设置的时间
在这里插入图片描述

  1. 再次深度优化我们代码
    在这里插入图片描述
  • 以上代码我们存在“忙等”的情况
  • 优化后的代码
    在这里插入图片描述
    – 这里注意一下这个lambda表达式中的this引用的是他所在对象的实例。
  • 新的问题：当任务1在等待时候，这时候如果又put进来一个新的任务，这个等待的时间就有问题。再次优化
    在这里插入图片描述
    每添加新的任务都进行一次唤醒，保证执行的永远是最少延时的任务。
  • 从CPU调度的过程中可以会产生的执行顺序的问题，或当一个线程执行到一半的时间被掉调度走的现象。
    在这里插入图片描述
    这个线程造成的原因就是没有保证原子性。
  • 优化代码
    在这里插入图片描述

在这里插入图片描述

  • 再次观察一种极端情况
    在这里插入图片描述
    – 我们发现当我们把三个任务的延时时间设置为0的时候，结果只执行了任务1，我们进行调试
    在这里插入图片描述
    – 调试之后我们又发现是正常情况，但是运行时候不符合我们的预期结果，这时候我们不要慌，我们用jconsole工具去查看下扫描情况
    在这里插入图片描述
  • 我们发现在MyTimer。java22行出现了问题
  • 在这里插入图片描述

1.创建一个定时器
2.向定时器添加任务1
3.第一个任务被添加到阻塞队列中
4.扫描线程启动，处理第一个任务
5.扫描线程1循环，获得第二个任务时候，队列为空，开始等待，同时扫描线程获得锁
6.主线程向阻塞队列添加任务时候，等待扫描对象的对象，由于扫描线程无法释放锁对象，主线程也就获取不到锁对象，造成相互等待，造成死锁

  • 我们再次优化代码创造一个后台扫描线程，只做定时唤醒操作，定时1秒或者10ms，唤醒一次

在这里插入图片描述
-最终的代码

public class MyTimer {//用一个阻塞队列来组织任务private BlockingQueue<MyTask> queue = new PriorityBlockingQueue<>();private Object lock = new Object();public MyTimer() {//创建线程Thread thread =new Thread(()->{while(true) {try {synchronized (this) {//从队列中取出任务MyTask task = this.queue.take();//判断有没有到执行的时间long currentTime = System.currentTimeMillis();if (currentTime >= task.getTime()) {//时间到了执行task.getRunnable().run();} else {//时间没到，将任务放回队列中long waitTime = task.getTime() - currentTime;this.queue.put(task);this.wait(waitTime);}}} catch (InterruptedException e) {throw new RuntimeException(e);}}});thread.start();//创建守护线程,定时唤醒一次Thread deamonThread=new Thread(()->{synchronized (this) {//唤醒一次this.notifyAll();//每隔100ms唤醒一次try {TimeUnit.MILLISECONDS.sleep(100);} catch (InterruptedException e) {throw new RuntimeException(e);}}});//设置为守护线程deamonThread.setDaemon(true);deamonThread.start();}/*** 添加定时任务* @param runnable 任务* @param delay 延时* @throws InterruptedException*/public void schedule(Runnable runnable,long delay) throws InterruptedException {//根据传的参数构造一个MyTask对象MyTask task=new MyTask(runnable,delay);//将这个MyTask对象阻塞放入队列中queue.put(task);System.out.println("任务添加成功");}
}//MyTask类，用于封装任务和执行时间
class MyTask implements Comparable<MyTask>{//任务private Runnable runnable;//执行时间private long time;public MyTask(Runnable runnable, long delay) {//增强代码健壮性if(runnable==null){throw new IllegalArgumentException("任务不能为空");}if(delay<0) {throw new IllegalArgumentException("延迟时间不能为负数");}this.runnable = runnable;//计算出任务的执行时间this.time = delay+System.currentTimeMillis();}public Runnable getRunnable() {return runnable;}public long getTime() {return time;}@Overridepublic int compareTo(MyTask o) {if(this.getTime()<o.getTime()){return -1;} else if(this.getTime()==o.getTime()){return 0;}else {return 1;}//万一时间超过了long的范围溢出，怎么办？用上面的比较比较好//return (int)(this.getTime()-o.getTime());}
public class Test {public static void main(String[] args) throws InterruptedException {MyTimer timer = new MyTimer();timer.schedule(new Runnable(){@Overridepublic void run() {System.out.println("任务1");}},0);timer.schedule(new Runnable(){@Overridepublic void run() {System.out.println("任务2");}},0);timer.schedule(new Runnable(){@Overridepublic void run() {System.out.println("任务3");}},0);//timer.schedule(null,-100);//任务加强健壮性}
}

工厂模式

  • 先看出现的问题在这里插入图片描述
    我们这里造成了重载参数的相同，但是我们就是要这样的构造方法我们怎么解决呢？

在这里插入图片描述
工厂方法模式。根据不同的业务需求定义不同的方法来获取对象。

线程池

线程池的一些问题

  • 什么是线程池
    1.线程池就是一次创建多个线程，把这些线程放进一个池中，用的时候从池中取出，用完就还回去
  • 为什么要用线程池
    我们首先要明白，线程的创建和销毁都会消耗大量的资源，线程池中的线程当有任务的时候，就会执行任务，没有任务的时候就阻塞等待，并不销毁线程，线程池最⼤的好处就是减少每次启动、销毁线程的损耗。
  • 为什么使用线程池可以提升效率
    少量创建，少量销毁，创建一个线程要分为内核态和用户态，用户态相当于jvm层面，内核太相当于操作系统层面，当我们在jvm层面创建一个线程，就要在操作系统层面创建对应指令，就会消耗大量资源，消耗线程也如此，所以线程池减少了频繁的销毁和创建，用的时候就直接在线程池里面用已经创建多的，从而提升效率。
  • 怎么用？
    – jdk给我们提供了一组针对不同场景的线程池实例
public static void main(String[] args) {//1.用来处理大量短时间的任务的线程池，如果池没有可用的线程将创建线程，如果线程空闲60秒将收回并移除缓存ExecutorService cachedThreadpool= Executors.newCachedThreadPool();//2.创建一个操作无界队列，线程池大小固定的线程池ExecutorService fixedThreadpool= Executors.newFixedThreadPool(5);//可以指定线程数量//3.创建一个操作无界队列，只有一个线程的线程池ExecutorService singleThreadExecutor= Executors.newSingleThreadExecutor();//4.创建一个单线程执行器，可以加时间给定时间后执行或者定期执行ScheduledExecutorService singleThreadScheduledExecutor= Executors.newSingleThreadScheduledExecutor();//5.创建一个指定大小的线程池，可以加时间给定时间后执行或者定期执行ScheduledExecutorService scheduledThreadpool= Executors.newScheduledThreadPool(5);//6.创建一个指定大小（不传参，为当前机器的cpu核数）的线程池，并行处理任务，不保证处理顺序Executors.newWorkStealingPool();
}

Runtime.getRuntime().availableProcessors()
获取系统的cpu核数

实现一个线程池

  • 先构思思路（先描述，再组织）
  1. 用Runable描述任务
  2. 组织管理任务可以使用一个队列，可以使用阻塞队列取实现
  3. 提供一个向队列的添加任务的方法
  4. 创建多个线程，扫描队列里面的任务，有任务时候执行，没有任务时候等待
public class MyExectorService {//定义阻塞队列阻止任务private BlockingQueue<Runnable> queue=new LinkedBlockingQueue(100);private  static Object lock=new Object();public MyExectorService(int threadNum){for (int i = 0; i < threadNum; i++){Thread thread=new Thread(()->{//不停扫描队列while (true) {try {synchronized (lock){Runnable runable=  queue.take();runable.run();}TimeUnit.MILLISECONDS.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}//take()方法会阻塞，直到队列中有任务});//启动线程thread.start();}}/*** 提交任务到线程池中* @param runnable 具体的任务* @throws InterruptedException*/public void sumbit(Runnable runnable) throws InterruptedException {if(runnable==null){throw new IllegalArgumentException("任务不能为空");}//把任务加入队列中queue.put(runnable);}}
class Test1{public static void main(String[] args) throws InterruptedException {MyExectorService myExectorService=new MyExectorService(3);AtomicInteger j= new AtomicInteger();for (int i = 0; i < 10; i++) {myExectorService.sumbit(() -> {System.out.println(Thread.currentThread().getName() + " " + j);j.getAndIncrement();});if(i%3==0){TimeUnit.SECONDS.sleep(1);}}}
}

创建系统自带的线程池

  • 前面jdk提供的线程池比较固定，也就是说我们不能自己定制，但是我们看底层代码时发现，这些线程池都是对ThreadPoolExecutor的封装
    在这里插入图片描述
  • 那我们可以根据ThreadPoolEecutor创建一个自定义线程池

在这里插入图片描述
用现实的两个例子去模拟线程工作的原理
周末去吃饭
在这里插入图片描述
银行办理业务
在这里插入图片描述

  • 线程池的拒绝策略详解
    在这里插入图片描述
    在这里插入图片描述
  • 我们注意一下，3和4是不会抛出异常的，1和2是会抛出异常的，放弃的任务永远都找不回来，所以指定拒绝策略的时候，要关注任务是不是必须要执行，如果必须要执行，就指定“返回调用者”，否则选1，3，4一个即可
public static void main(String[] args) {ThreadPoolExecutor threadPool=new ThreadPoolExecutor(2,5,10, TimeUnit.SECONDS,new LinkedBlockingQueue<>(7),new ThreadPoolExecutor.AbortPolicy());for (int i = 0; i < 100; i++) {int takeI=i;threadPool.submit(new Runnable() {@Overridepublic void run() {System.out.println(Thread.currentThread().getName()+" 执行任务 "+takeI);}});}}
  • 直接拒绝
    实际只执行几个后面的都没执行
    在这里插入图片描述
    在这里插入图片描述
  • 返回给调用者
    有一部分代码返回给调用者main执行了
  public static void main(String[] args) {ThreadPoolExecutor threadPool=new ThreadPoolExecutor(2,5,10, TimeUnit.SECONDS,new LinkedBlockingQueue<>(7),new ThreadPoolExecutor.CallerRunsPolicy());for (int i = 0; i < 100; i++) {int takeI=i;threadPool.submit(new Runnable() {@Overridepublic void run() {System.out.println(Thread.currentThread().getName()+" 执行任务 "+takeI);}});}}

在这里插入图片描述

  • 放弃最早的任务
public static void main(String[] args) {ThreadPoolExecutor threadPool=new ThreadPoolExecutor(2,5,10, TimeUnit.SECONDS,new LinkedBlockingQueue<>(7),new ThreadPoolExecutor.DiscardOldestPolicy());for (int i = 0; i < 100; i++) {int takeI=i;threadPool.submit(new Runnable() {@Overridepublic void run() {System.out.println(Thread.currentThread().getName()+" 执行任务 "+takeI);}});}}

在这里插入图片描述

  • 放弃最新的任务
public static void main(String[] args) {ThreadPoolExecutor threadPool=new ThreadPoolExecutor(2,5,10, TimeUnit.SECONDS,new LinkedBlockingQueue<>(7),new ThreadPoolExecutor.DiscardPolicy());for (int i = 0; i < 100; i++) {int takeI=i;threadPool.submit(new Runnable() {@Overridepublic void run() {System.out.println(Thread.currentThread().getName()+" 执行任务 "+takeI);}});}}

在这里插入图片描述

wait和sleep的区别

1.共同点，让线程休眠一会
2.从实现使用上来说是两种不同的方法
wait是Object类的方法，与锁相关，配合sychronized一起使用，调用wait之后会释放锁
sleep是Thread类的方法，与锁无关
wait可以通过notify和指定直线的方法唤醒，唤醒之后重新竞争锁资源
sleep只能通过超时时间唤醒

  • 补充
    在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/488143.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

海康威视摄像头RTSP使用nginx推流到服务器直播教程

海康威视摄像头RTSP使用nginx推流到服务器直播教程

思路&#xff1a; 之前2020年在本科的时候&#xff0c;由于项目的需求需要将海康威视的摄像头使用推流服务器到网页进行直播。这里将自己半个月琢磨出来的步骤给大家发一些。切勿转载&#xff01;&#xff01;&#xff01;&#xff01; 使用网络摄像头中的rtsp协议---------通…
阅读更多...
美图撕掉蔡文胜标签

美图撕掉蔡文胜标签

卖掉比特币的美图不投机了。 作者|周立青 编辑|杨舟 12月5日&#xff0c;比特币突破10万美元大关&#xff0c;曾花费1亿美元购入虚拟货币的美图宣布已出售所有加密货币。 美图在港交所发布公告称&#xff0c;自2024年11月起&#xff0c;公司已开始出售其持有的加密货币&…
阅读更多...
遥感图像处理一（ENVI5.6 Classic）

遥感图像处理一（ENVI5.6 Classic）

1 实验目的和内容 1.1 实验目的 本次上机旨在了解ENVI软件的基本使用&#xff0c;并对提供的实验数据进行基本的图像合成、图像拉伸、图像分析、图像平滑与锐化和图像融合等操作并分析结果。 1.2 实验内容 1.2.1 图像合成 任选一景遥感影像&#xff0c;进行图像的彩色合成…
阅读更多...
IDEA报错：无效的源发行版、无效的目标发行版

IDEA报错：无效的源发行版、无效的目标发行版

1. 无效的源发行版 创建项目的时候&#xff0c;会遇见这个报错&#xff0c;原因就是编译的JDK版本与发布版本不一致。 解决方法&#xff1a; 1.1. 找到问题所在地 英文&#xff1a;File -> Project Structure ->Project Settings 中文&#xff1a;文件->项目结构 …
阅读更多...
12月11日IO进程线程

12月11日IO进程线程

作业1、创建子父进程&#xff0c;子进程将1.txt内容拷贝到2.txt中&#xff0c;父进程将3.txt内容拷贝到4.txt中。 #include <myhead.h>int main(int argc, const char *argv[]) {//创建子父进程pid_t pidfork();if(pid>0) //父进程{//打开文件1文件2int fd1open(&q…
阅读更多...
基于JAVA的旅游网站系统设计

基于JAVA的旅游网站系统设计

摘要 随着信息技术和网络技术的迅速发展&#xff0c;人们的生活质量和观念也在发生着改变&#xff0c;各地争相发展旅游业&#xff0c;传统的 旅游社已经无法满足人们的需求&#xff0c;旅游网站将突破传统在时间和地域的限制&#xff0c;成为方便、快捷、安全、可靠的旅游 方…
阅读更多...
2021 年“泰迪杯”数据分析技能赛B 题肥料登记数据分析

2021 年“泰迪杯”数据分析技能赛B 题肥料登记数据分析

2021 年“泰迪杯”数据分析技能赛B 题肥料登记数据分析 完整代码请私聊 博主 一、背景 肥料是农业生产中一种重要的生产资料&#xff0c;其生产销售必须遵循《肥料登记管理办法》&#xff0c;依法在农业行政管理部门进行登记。各省、自治区、直辖市人民政府农业行政主管部门主…
阅读更多...
ChatGPT 4：解锁AI文案、绘画与视频创作新纪元

ChatGPT 4：解锁AI文案、绘画与视频创作新纪元

文章目录 AI文案&#xff1a;激发文字的魅力&#xff0c;重塑营销与传播AI绘画&#xff1a;解锁艺术的无限可能&#xff0c;激发创意灵感AI视频&#xff1a;重塑视频创作流程&#xff0c;提升制作效率GPTs&#xff1a;构建个性化AI应用&#xff0c;赋能各行各业《ChatGPT 4 应用…
阅读更多...
Android 10、11、12存储适配相关

Android 10、11、12存储适配相关

AndroidQ(10)分区存储完美适配 - 简书前言 最近时间在做AndroidQ的适配&#xff0c;截止到今天AndroidQ分区存储适配完成&#xff0c;期间出现很多坑&#xff0c;目前网上的帖子大部分都是概述变更内容&#xff0c;接下来的几篇帖子都是对分区存储实际...https://www.jianshu.c…
阅读更多...
22. Three.js案例-创建旋转的圆环面

22. Three.js案例-创建旋转的圆环面

22. Three.js案例-创建旋转的圆环面 实现效果 知识点 WebGLRenderer (WebGL渲染器) THREE.WebGLRenderer 是Three.js中最常用的渲染器&#xff0c;用于将场景渲染到WebGL画布上。 构造器 new THREE.WebGLRenderer(parameters) 参数类型描述parametersObject可选参数对象&…
阅读更多...
如何绕过IP禁令

如何绕过IP禁令

网站、游戏和应用程序可以屏蔽特定IP地址&#xff0c;从而阻止使用该IP地址的任何人访问其服务。这称为IP禁令。管理员可以出于多种原因&#xff08;例如发出过多请求或可疑活动&#xff09;屏蔽IP地址。但是&#xff0c;这些禁令会使收集数据或访问在线内容变得更加困难。 一…
阅读更多...
LinkedList与链表 和 链表面试题

LinkedList与链表 和 链表面试题

一. ArrayList 与 LinkedList 的优缺点&#xff1a; ArrayList 在任意位置删除或插入元素时&#xff0c;就需要把后面的所有元素整体往前或者往后移动&#xff0c;时间复杂度为O(n)&#xff0c;效率较低&#xff0c;但是适合需要频繁访问元素的情况。空间不够会涉及到自动扩容&…
阅读更多...
手机实时提取SIM卡打电话的信令声音--社会价值(一、方案解决了什么问题)

手机实时提取SIM卡打电话的信令声音--社会价值(一、方案解决了什么问题)

手机实时提取SIM卡打电话的信令声音 --社会价值(一、方案解决了什么问题) 一、前言 这段时间&#xff0c;我们在技术范围之外陷入了一个自证或者说下定义的怪圈&#xff0c;即要怎么样去介绍或者描述&#xff1a;我们是一个什么样的产品。它在当前这个世界上&#xff0c;处于…
阅读更多...
康谋方案 | 多源相机数据采集与算法集成测试方案

康谋方案 | 多源相机数据采集与算法集成测试方案

目录 一、相机组成 二、多源相机采集与测试方案 三、应用案例分享 四、结语 在智能化技术快速发展当下&#xff0c;图像数据的采集与处理逐渐成为自动驾驶、工业等领域的一项关键技术。高质量的图像数据采集与算法集成测试都是确保系统性能和可靠性的关键。随着技术的不断进…
阅读更多...
C# 探险之旅：第十一节 - 循环(foreach)：一场“遍历”奇幻岛的大冒险！

C# 探险之旅：第十一节 - 循环(foreach)：一场“遍历”奇幻岛的大冒险！

嘿&#xff0c;勇敢的探险家们&#xff01;欢迎来到C#奇幻岛的第十一站——“遍历”奇幻岛&#xff01;今天&#xff0c;我们要乘坐一艘叫做foreach的魔法船&#xff0c;去遍历&#xff08;也就是一个一个看过来&#xff09;岛上那些神秘的宝藏箱&#xff01;准备好了吗&#x…
阅读更多...
LearnOpenGL学习（高级OpenGL -＞ 高级GLSL，几何着色器，实例化）

LearnOpenGL学习（高级OpenGL -＞ 高级GLSL，几何着色器，实例化）

高级GLSL 内建变量 顶点着色器 gl_PointSoze : float 输出变量&#xff0c;用于控制渲染 GL_POINTS 型图元时&#xff0c;点的大小。可用于粒子系统。将其设置为 gl_Position.z 时&#xff0c;可以使点的距离越远&#xff0c;大小越大。创建出类似近视眼看远处灯光的效果 gl…
阅读更多...
java之集合（详细-Map,Set,List）

java之集合（详细-Map,Set,List）

1集合体系概述 1.1集合的概念 集合是一种容器&#xff0c;用来装数据的&#xff0c;类似于数组&#xff0c;但集合的大小可变&#xff0c;开发中也非常常用。 1.2集合分类 集合分为单列集合和多列集合 Collection代表单列集合&#xff0c;每个元素&#xff08;数据&#xff…
阅读更多...
手机租赁系统开发指南一站式服务流程解析

手机租赁系统开发指南一站式服务流程解析

内容概要 手机租赁系统的开发是一个复杂但有趣的过程&#xff0c;像搭建乐高一样&#xff0c;只要找到合适的模块&#xff0c;就能打造出一个宾至如归的租赁平台。在这部分&#xff0c;我们将对开发流程的整体结构进行简要概述&#xff0c;并指出每个环节的重要性。 首先&…
阅读更多...
CS5563国产DP转HDMI芯片支持10k@60Hz视频转换IC

CS5563国产DP转HDMI芯片支持10k@60Hz视频转换IC

CS5563 4Lane DP to HDMI2.1 10k60Hz适用各种TYPEC/DP转HDMI8K60HZ方案 。深圳市安格瑞科技代理的ASL芯片系列DP转HDMI视频转换方案提供了CS5263、CS5563三个型号供选择。这些芯片在性能和功能上各有特点&#xff1a; CS5263专为高性能打造&#xff0c;支持DP到HDMI2.0的4k60H…
阅读更多...
JS进阶DAY5|本地存储

JS进阶DAY5|本地存储

嗨&#xff5e;&#x1f44b; 欢迎来到JavaScript本地存储的世界。在这里&#xff0c;我们可以像烘焙师一样&#xff0c;将数据烘焙成小饼干&#xff08;cookies&#xff09;&#xff0c;或者将它们保存在冰箱&#xff08;localStorage&#xff09;里&#xff0c;以便下次访问时…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023