Java多线程ZJ........

KinectV2彩色骨骼叠加:CoordinateMapper坐标映射与实现 在体感交互与计算机视觉应用中,多传感器数据的对齐是基础难题。KinectV2作为经典深度传感设备,同时输出彩色图像、深度数据和人体骨骼关节,三套坐标系分别采用像素、毫米与米为单位。若要实现彩色画面上稳定叠加人体骨骼,必须通过CoordinateMapper完成相机空间到彩色像素空间的映射,并处理视场角差异与边界异常。通过对坐标映射原理的剖析与C# WPF工程实践,开发者可实现流畅的骨骼融合效果,广泛应用于动作捕捉、康复训练、人机交互等场景。本文系统讲解KinectV2骨骼叠加的关键技术细节与常见坑点,为体感 阅读详情

一、创建线程方式

1、通过继承 Thread 类,重写run()方法并调用start()启动线程
2、实现 Runnable 接口
3、函数表达式

二、线程池

在Java中,线程池是用来管理多个线程的集合,避免频繁创建和销毁线程所带来的性能开销。Java提供了 Executor 框架来方便地使用线程池。

2.1、创建方式

1、使用Executors 工具,创建 固定大小线程池 创建一个固定数量的线程,可以确保不会创建超过指定数量的线程,适用于处理负载稳定的任务。

import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  

public class FixedThreadPoolA {  
    public static void main(String[] args) {  
        ExecutorService executor = Executors.newFixedThreadPool(3); 
        for (int i = 0; i < 10; i++) {  
            final int taskNumber = i;  
            executor.submit(() -> {  
                System.out.println("任务:。。。 " + taskNumber + " 正在线程中运行 " + Thread.currentThread().getName());  
            });  
        }  
        
        executor.shutdown();
    }  
}

2、缓存线程池:可缓存线程池在需要时创建新线程,并在之前构建的线程可用时重用它们。此池适合处理负载变化较大的任务。

import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  

public class CachedThreadPoolB {  
    public static void main(String[] args) {  
        ExecutorService executor = Executors.newCachedThreadPool();
        
        for (int i = 0; i < 10; i++) {  
            final int taskNumber = i;  
            executor.submit(() -> {  
                 System.out.println("任务:。。。 " + taskNumber + " 正在线程中运行 " + Thread.currentThread().getName());  
            });  
        }  
        
        executor.shutdown(); 
    }  
}

3、单线程池:确保只有一个线程在执行任务。它常用于需要保证任务顺序的场景。

import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  

public class SingleThreadExecutorC {  
    public static void main(String[] args) {  
        ExecutorService executor = Executors.newSingleThreadExecutor();
        
        for (int i = 0; i < 10; i++) {  
            final int taskNumber = i;  
            executor.submit(() -> {  
                System.out.println("任务:。。。 " + taskNumber + " 正在线程中运行 " + Thread.currentThread().getName());   
            });  
        }  
        
        executor.shutdown(); 
    }  
}

4、定时线程池:可以在指定的延迟后运行任务,或周期性地运行任务。

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

public class ScheduledThreadPoolD {  
    public static void main(String[] args) {  
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(2); 
        
        executor.schedule(() -> System.out.println("2庙后运行"), 2, TimeUnit.SECONDS);   
        executor.scheduleAtFixedRate(() -> System.out.println("每1秒执行一次"), 0, 1, TimeUnit.SECONDS); // 定期执行     
        try {  
            Thread.sleep(5000);   
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
        executor.shutdown(); 
    }  
}

5、ThreadPoolExecutor 类(重要)
1、是一个更灵活的创建线程池的方式。通过直接实例化该类,您可以自定义线程池的参数,包括核心线程数、最大线程数、空闲线程存活时间、任务队列类型和线程工厂等。

import java.util.concurrent.Executors;  
import java.util.concurrent.ThreadPoolExecutor;  
import java.util.concurrent.TimeUnit;  

public class CustomThreadPoolExample {  
    public static void main(String[] args) {  
        ThreadPoolExecutor executor = new ThreadPoolExecutor(  
                2, // 核心线程数  
                5, // 最大线程数  
                60, // 空闲线程的存活时间  
                TimeUnit.SECONDS, // 空闲线程存活时间的单位  
                new ArrayBlockingQueue<>(10) // 阻塞队列  
        );  

        for (int i = 0; i < 20; i++) {  
            final int taskNumber = i;  
            executor.submit(() -> {  
                System.out.println("任务... " + taskNumber + " 正在线程中运行 " + Thread.currentThread().getName());  
            });  
        }  
        executor.shutdown();  
    }  
}

2.2、ThreadPoolExecutor

1、核心参数:

  1. corePoolSize:线程池中的常驻核心线程数
  2. maximumPoolSize:线程池中允许的最大线程数
  3. keepAliveTime:当线程池中的线程数量超过 corePoolSize 时,多余的空闲线程等待新任务的最大时间。
  4. unit:keepAliveTime 的时间单位。
  5. workQueue:任务队列,用于在任务通过 execute 方法提交时保存等待执行的任务。
  6. threadFactory:线程工厂,用于创建线程。
  7. handler:拒绝策略,用于处理任务队列已满的情况。

2、工作队列:

  1. SynchronousQueue:这种队列没有容量,任务只有在有空闲线程的情况下才能提交成功。这种队列通常被用于需要立即执行的任务,优先执行当前任务,如果当前没有空闲线程,那么会新建线程执行任务。
  2. LinkedBlockingQueue:这种队列是基于链表实现的,容量可选,可以无限大。如果容量为正数,那么就是一个固定大小的队列。如果容量为负数,那么队列大小就是无限大的。这种队列通常被用于需要大量等待时间的任务,如 IO 操作等,因为它可以缓存大量的任务。
  3. ArrayBlockingQueue:这种队列是基于数组实现的,容量固定,不能动态增加。这种队列通常被用于需要有界限的任务,如控制并发数量。
  4. PriorityBlockingQueue:这种队列是基于优先级排序的,可以实现优先级任务先执行。这种队列通常被用于需要将任务按照一定优先级进行排序执行的任务,比如在线程池中处理任务的优先级。

3、拒绝策略:

  1. CallerRunsPolicy:使用调用者线程执行该任务,如果提交任务的线程池已满,将会使用调用线程来执行当前任务。这种策略通常被用于对提交任务的队列长度进行控制,而不是对线程数进行控制。
  2. AbortPolicy:直接抛出拒绝执行异常,从而抛弃任务。(默认)
  3. DiscardPolicy:直接抛弃添加的任务,不抛出异常。
  4. DiscardOldestPolicy:抛弃队列头的元素,以便为新的任务提供空间。
    通常情况下,如果要保证所有任务一定被执行完毕,可以选择 CallerRunsPolicy。如果要保证线程池中的任务最多只有固定数目,可以选择 AbortPolicy或者 DiscardPolicy。如果要保证任务队列不会满,可以选择 DiscardOldestPolicy。

4、execute() 方法用于向线程池提交任务分为三个步骤

  1. 如果线程池中的线程数量小于 corePoolSize,尝试创建一个新的线程来执行任务。
  2. 如果任务可以成功放入任务队列中,需要再次检查线程池的状态,如果线程池已经关闭或者线程池中的线程数量为 0,则需要重新创建一个新的线程。
  3. 如果任务不能放入任务队列中,尝试创建一个新的线程来执行任务,如果创建失败,则拒绝该任务。ThreadPoolExecutor column:1342
public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        /*
         * Proceed in 3 steps:
         *
         * 1. If fewer than corePoolSize threads are running, try to
         * start a new thread with the given command as its first
         * task.  The call to addWorker atomically checks runState and
         * workerCount, and so prevents false alarms that would add
         * threads when it shouldn't, by returning false.
         *
         * 2. If a task can be successfully queued, then we still need
         * to double-check whether we should have added a thread
         * (because existing ones died since last checking) or that
         * the pool shut down since entry into this method. So we
         * recheck state and if necessary roll back the enqueuing if
         * stopped, or start a new thread if there are none.
         *
         * 3. If we cannot queue task, then we try to add a new
         * thread.  If it fails, we know we are shut down or saturated
         * and so reject the task.
         */
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        else if (!addWorker(command, false))
            reject(command);
    }

5、worker 线程是线程池的核心
  Worker 类实现了 Runnable 接口,并且继承了 AQS类,用于实现线程的同步和状态管理。runWorker() 方法用于执行任务分为以下:

  1. 获取 Worker 线程的第一个任务,如果第一个任务为空,则从任务队列中获取任务。
  2. 执行任务,如果任务执行过程中出现异常,则将异常抛出。
  3. 任务执行完成后,更新 Worker 线程的状态和统计信息。
  4. 如果 Worker 线程的状态为 TERMINATED,则移除该线程。
    final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            while (task != null || (task = getTask()) != null) {
                w.lock();
                // If pool is stopping, ensure thread is interrupted;
                // if not, ensure thread is not interrupted.  This
                // requires a recheck in second case to deal with
                // shutdownNow race while clearing interrupt
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        task.run();
                    } catch (RuntimeException x) {
                        thrown = x; throw x;
                    } catch (Error x) {
                        thrown = x; throw x;
                    } catch (Throwable x) {
                        thrown = x; throw new Error(x);
                    } finally {
                        afterExecute(task, thrown);
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

6、线程池中核心线程参数设置,零与非零区别

   1. 线程池中的核心参数指线程池中一直存在的线程数量,当有新任务提交到线程池时,线程池会优先使用核心线程来执行任务。如果核心线程数为零,则线程池中将没有一直存在的线程,所有的线程都是临时创建的,这样的话,线程池的创建和销毁就会比较大,会影响性能。
   2. 如果核心线程为非零,线程池中会一直存在一定数量的线程,可以频繁的创建和销毁线程,提高了性能。一般来说,核心线程数的设置应该根据应用程序的实际需要来决定,如果应用程序需要处理大量并发任务,可以适当增加核心线程数,提高并发能力。但是,如果核心线程数设置过大,会占用过多的系统资源,影响系统资源、稳定性和性能。因此,在设置核心线程数时需要根据实际情况进行权衡和调整。

7、什么需求下设置线程池的核心线程数为零

   1. 将线程池的核心线程数设置为零,意味着线程池不会创建任何线程,所有任务都会被放入任务队列中等待执行。这种情况下,只有当有任务提交时,线程池才会创建新的线程来处理任务,直到线程池中的线程数达到最大线程数。
将线程池的核心线程数设置为零,一般用于以下几种情况:
   ① 任务执行时间较短:如果任务执行时间很短,那么创建线程的开销可能会超过任务执行的时间,此时将线程池的核心线程数设置为 0,可以避免创建大量的线程,从而提高系统的性能和资源利用率。
   ② 资源受限:如果系统的资源受限,如 CPU、内存等资源较少,那么创建大量的线程可能会导致系统的负载过高,从而影响系统的稳定性和性能。此时将线程池的核心线程数设置为 0,可以避免创建大量的线程,从而减少对系统资源的占用。
注意:将线程池的核心线程数设置为 0,可能会导致任务在队列中等待的时间较长,从而影响任务的响应速度和处理效率。因此,在设置线程池的核心线程数时,需要根据实际情况进行权衡和调整,以达到最优的性能和资源利用率。

8、线程池什么业务条件下使用SynchronousQueue 做队列
  SynchronousQueue是一个无界队列,它不会存储任何元素,每个插入操作都必须等待相应的删除操作,否则插入操作将一直阻塞。这意味着在线程池中使用SynchronousQueue作为队列,任务只有在有空闲的线程时才会被执行,否则任务将一直等待,直到有线程可用。
   ① 任务处理时间短:由于SynchronousQueue没有容量,任务提交后需要立即被处理,如果任务处理时间过长,会导致任务在队列中等待,从而影响系统的性能。
   ② 任务提交速度与任务处理速度相近:由于 SynchronousQueue 没有容量,如果任务提交速度大于任务处理速度,就会导致任务被直接传递给另一个线程执行,而不是放到队列中等待执行,这样会导致系统的负载增加,可能会出现任务积压的情况
   ③ 系统负载较低:由于 SynchronousQueue 没有容量,如果系统负载较高,就会导致任务被直接传递给另一个线程执行,而不是放到队列中等待执行,这样会进一步增加系统的负载,可能会出现任务积压的情况。

9、线程池运行机制
   ① 创建线程池:初始化线程池,并设置线程池的核心线程数、最大线程数、线程空闲时间、工作队列等参数。
   ② 提交任务:当需要执行任务时,将任务提交到线程池中。
   ③ 线程调度:线程池中的线程会从工作队列中获取任务,并执行任务。如果工作队列为空,线程会根据设置的空闲时间进入等待状态。
   ④ 任务执行:线程会执行任务,并根据需要向工作队列中添加新任务。
   ⑤ 线程销毁:如果线程池中的线程闲置时间超过了设置的空闲时间,线程会被销毁

10、线程池运行流程三个阶段:提交任务、执行任务和关闭线程池
   ① 提交任务:将任务提交到线程池中,如果线程池中的线程数量小于核心线程数,那么会新建一个线程来执行任务,否则会将任务加入到等待队列中;如果等待队列已满,那么会新建一个线程来执行任务,否则根据设置的策略执行相应操作。
   ② 执行任务:线程从等待队列中获取任务并执行,如果线程执行完任务后处于空闲状态,那么根据设置的策略决定是否要销毁该线程。
   ③ 关闭线程池:调用 shutdown() 方法来关闭线程池,该方法不会立即关闭线程池,而是等待正在执行的任务和等待队列中的任务执行完毕后才会关闭线程池。

11、创建线程池方式优缺点
创建线程池的方式有两种:使用Executors工厂类创建和自定义线程池。
   11.1. 使用Executors工厂类创建线程池:
      优点:
      方便快捷:Executors提供了一些静态方法,可以快速创建不同类型的线程池,如newFixedThreadPool()、newCachedThreadPool()等。
      简化配置:通过使用预定义的线程池配置,可以简化线程池的创建和配置过程。
      缺点:
      容易导致资源耗尽:Executors的一些静态方法创建的线程池默认使用无界队列,当任务过多时,可能导致内存溢出。
      不可控制:Executors的一些静态方法创建的线程池的配置是固定的,无法对线程池进行灵活的调整和优化。
   11.2. 自定义线程池:
      优点:
      灵活可控:可以根据实际需求自定义线程池的配置,如核心线程数、最大线程数、任务队列类型等,以满足不同的业务需求。
      资源控制:可以通过自定义线程池来控制资源的使用,避免资源耗尽的问题。
      缺点:
      需要手动配置:相比于使用Executors工厂类,自定义线程池需要手动配置线程池的各项参数,需要更多的工作量和技术要求。
      容易出错:自定义线程池需要考虑线程安全、任务拒绝策略、线程池的状态管理等问题,容易出现错误。
   总结:使用Executors工厂类创建线程池是方便快捷的方式,但可能导致资源耗尽和无法灵活控制线程池。自定义线程池可以灵活控制和配置线程池,但需要手动配置和容易出错。选择创建线程池的方式应根据实际需求和具体情况来决定。

三、Fork/Join 框架

   1、Java 7 引入了 Fork/Join 框架,主要用于任务的分解和并行计算,尤其适合处理大规模计算任务。适合用于处理大规模计算或需要通过分治法解决的问题
   2、设计目标
  ①通过将一个大任务分解为多个小任务,来实现任务的并行执行。
  ②在多个 CPU 核心上高效地利用计算资源,从而提高程序性能。
  3、核心组件
  ①用于运行 Fork/Join 任务的线程池。它可以自动管理可用线程,并工作以实现最大并行度。
  ②表示将要在 ForkJoinPool 中执行的任务。ForkJoinTask 及其子类允许任务被分叉(fork)并最终合并(join)
   4、任务分割
  Fork(分叉): 将任务分成更小的子任务并并行执行。
  Join(合并): 在所有子任务完成后,合并结果。
   5、工作原理
   ①任务分解: 当一个任务被提交到 ForkJoinPool 时,该任务会被评估是否应当被进一步分解。如果任务足够小,则会被直接执行;如果任务较大,则会被分解为若干个子任务。
   ②任务执行: 被分解的子任务会被分叉到不同的线程中并行执行。每个小任务将在相应的工作线程中独立运行。
   ③结果合并: 当所有子任务完成后,主任务会等待所有结果并合并之。结果集通常会通过 join() 方法来获得。
   6、优点
   高性能: 利用多核处理器,提高应用性能。
   易于使用: 对于需要并行处理的算法,将任务分解为子任务非常直观。
   任务管理: Fork/Join 框架自动管理任务的分发、调度和执行。
   7、缺点
   适用场景有限: Fork/Join 框架更适合用于可分解的计算任务,对于不易分解的任务(如I/O处理),则不太适用。
   内存开销: 大量的小任务会消耗更多内存,并可能导致频繁的上下文切换。

四、Java8 CompletableFuture(了解)

   Java 8引入了 CompletableFuture 类,允许我们进行异步编程,以便在任务完成时获取结果,并支持非阻塞操作。

五、Java中的并发工具类

并发工具类:
1、CountDownLatch: 允许一个或多个线程等待其他线程执行完成。
2、CyclicBarrier: 使一组线程互相同步,直到所有线程都到达某一点。
3、Semaphore: 控制同时访问某特定资源的线程数量。
4、ReentrantLock: 一个比使用 synchronized 关键字更灵活的锁。

沙猫群优化算法(SCSO)详解:从沙漠生存智慧到全局优化引擎 本文详细介绍了沙猫群优化算法(SCSO),这是一种新型元启发式优化算法,灵感来源于沙猫在沙漠环境中的卓越狩猎行为。SCSO通过模拟沙猫的低频探测能力和精确攻击策略,将优化问题转化为搜索和捕获"猎物"的过程。算法核心包括探索阶段(全局搜索)和开发阶段(局部精细搜索),通过灵敏度范围模型和自适应控制参数实现两者的平衡。SCSO具有参数简单、收敛性能好等优点,适用于解决复杂全局优化问题。 阅读详情

相关推荐

新手必看:LiteRadio 2c SE遥控器从开箱到飞行的完整指南(附常见问题解答)

本文为新手提供LiteRadio 2c SE遥控器的完整使用指南,涵盖从开箱到首飞的20个关键步骤。详细介绍了遥控器的功能设置、与无人机的对频技巧以及首飞注意事项,帮助用户快速掌握飞行控制,避免常见错误。特别适合无人机初学者阅读。

weixin_29209801的博客 381

【Java/Python】多线程

多线程编程基础Java多线程创建线程继承Thread + 重写run(线程体)通过Runnable接口实现多线程静态代理设计模式通过Calllable接口实现多线程线程的状态和方法停止线程阻塞线程的同步和死锁问题单例设计模式死锁生产者消费者模式-信号灯法任务调度 Java多线程 本章内容来自尚学堂Java300集视频第二季多线程部分总结 程序、进程、线程 程序:指令集 静态概念 进程:操作系统调度程序 动态概念 线程:在进程内多条执行路径 一个进程中的线程共享相同的内存单元/内存地址空间->可以访

nicezheng_1995 819

鼎捷T100——二次开发:维护作业添加非实体字段

非实体字段添加

weixin_52342654的博客 1162

Java多线程

多线程 进程就是由一个或者多个线程构成的,是进程中的一个执行路径,共享一个内存空间,线程之间可以自由切换,并发执行. 一个进程最少有一个线程 ,线程是进程中一个最小的运行单位。 创建多线程 继承Thread类 实现Runnable类 实现Callable 继承Thread类方式创建多线程 package com.zlj.kaikeba.example0613.demo1; public class Demo1 { //Thread public static void main(Str

weixin_46043015的博客 155

基于浏览器插件的拼多多买家订单导出方法

基于浏览器插件的拼多多买家订单导出方法

2501_93542170的博客 1742

2021秋招IC验证面经-ARM中国/中科芯/飞腾/地平线/中兴

中科芯 (央企福利待遇好,但是百分百不解决户口,适合当地人进去躺平。) 现场面试,三个面试官,时间大约40min 首先介绍一下自己,介绍一下项目。所做项目用到了FIFO吗,深度是多少,位宽是多少,仲裁算法是什么? 验证环境中的reference model是自己写的还是本身就有的,仲裁怎么在参考模型中实现,参考模型怎么获取寄存器的值? 怎么配置RTL寄存器,通过平台的寄存器模型进行寄存器配置,寄存器模型里边的方法,写一个寄存器或读一个寄存器怎么实现? 寄存器如何实现前门访问和后门访问,后门访问时

weixin_48014653的博客 6323

多线程的理解

多线程的理解 什么是多线程? ​ 多线程的简单理解,即:同时处理多个事项,宏观方面可以理解为计算机在cpu的调度下,同时进行多项工作;类比可以看做,武侠高手左手画圆,右手画三角形,同时进行;但是,实际上微观理解,单核cpu同一时间只能处理一件事情,所以是将各个线程分为细小的时间片来交替进行,但是由于相对于人类感官速度极快,产生统一时间俩件事情同时进行了。打个比方,现在用一台单核cpu计算机,同时打开俩个视频,只看视频播放画面,其实是将视频切割为一个个细小的时间片交替cpu调度执行,同一时间点,只有一个在被c

qq_36098674的博客 3201

Android OTA 升级实战指南:从原理到实现

本文详细解析了Android OTA升级的原理与实现方法,包括AB升级与Recovery升级的机制对比、OTA升级包制作流程以及应用层升级功能的实现。通过实战案例和常见问题排查指南,帮助开发者掌握Android系统无线升级技术,提升设备维护效率。

weixin_42652674的博客 200

HelloWrold.zj

javaSE基础语言 学习目标 java入门 环境搭建 运行机制 *变量与数据类型 运算符 常用工具类 流程控制语句 *方法 java的语言发展 .机器语言 二进制代码表示的一种机器指令系统的集合 汇编语言 用助记符代替机器指令的操作码,用地址符号 或标号代替指令或操作数的地址,也成为符号语言。 高级语言 是一种指令集的体系,允许程序员使用接近日常英语的指令的编写程序。例如:c,c++,java,Python,Ruby 其他高级语言 Fortran,Cob

Peter_pans的博客 299

SAP-MM:SAP MM(物料管理)模块 的系统化学习计划

SAP MM模块的系统化学习计划

baidu_35680696的博客 1554

物联网通信中NB-IoT、Cat.1、LTE-M该如何选择?

首先我们要确定我们产品的关键需求,例如:我们的设备是否对数据传输速率有较高的要求,有较高要求我们就需要选择较高传输速率的Cat.1来开发我们的产品。同时关于产品性能方面,我们对功耗、延迟、可靠性也会有所要求,例如我们的产品为移动端产品,不方便布线以及安装电源,那我们就会采用电池供电的方式,所以在选择时可以优先考虑低功耗产品,最终结合其他需求选择出合适的协议。首先,我们需求的产品是不同的,我们需要根据产品需求或项目需求来进行选择,NB-IoT、Cat.1、Cat.M都有属于自己的优势。

a1809032425的博客 1217

[java]--多线程

进程和线程的区别:进程:在内存中进行的app;线程:进程的最小的执行单元,一个进程最小有一个或多个线程;简要理解:在内存和cpu中,cpu进入到内存提取代码的计算通道,叫做线程;多线程--提高内存的利用率;并发和并行:并发:同一时刻,一个执行任务在单个cpu上交替进行;并行:同一时刻,多个执行任务在多个cpu上进行;小trips:在单核cpu中,一个cpu在多个执行任务中高速切换--并发在多核cpu中,2核4线,若执行任务过多,同时并发和并行;调度。

2401_87366139的博客 817

FreeRTOS深入教程(任务创建的深入和任务调度机制分析)

本篇文章将带大家深入学习任务的创建和分析任务调度的机制。本篇文章深入的讲解了任务创建的内部实现和任务调度的源代码分析和实现,学习这篇文章有助于更深入的学习FreeRTOS的源码。

m0_49476241的博客 6396

java多线程下载器

本文主要介绍一个多线程下载器的实现方法,主要应用技术如下: Http请求; 线程池-ThreadExecutorPool; RandomAccessFile; CountDownLatch; 本文下载器的执行流程如下: 找到网上一个可供下载的链接; 发送http请求,获取下载文件信息; 设置http可分片下载,使用多线程分别对各个分片下载; 使用countDownLatch统计各个线程是否均已下载完毕; 合并各个分片成一个完整的下载文件,下载流程结束! 下载链接和主启动类 本文选取qq应用程序的下载

码来-陈平安的博客 1440

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

Java--多线程

//在学习多线程的过程中要知道每次的线程结果都可能不相同(和CPU的分配有关),要多运行几次找到规律 //关于多个线程操作一个对象和多个线程操作多个对象 –多线程操作一个对象就可以分享一个资源(多线程单个对象容易引发并发问题) 多线程操作多个对象() 1.线程的定义(每个类后面可以加引号,个人习惯不同) 继承Thread方法实现多线程 实现Runnable接口实

Youngzhou的博客 1万+

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

JAVA多线程详解(一)

JAVA多线程详解(一) 一. 线程简介 1. Process(进程)与 Thread(线程) 2. 本章核心概念 二. 线程实现(重点) 1. 线程创建 2. Thread类 3. 案例:下载图片 4. 实现Runnable接口 5. 小结: 6. 初识并发问题 7. 实现 Callable接口(了解即可) 8. Lamda表达式 9. 静态代理模式

Monuomeng的博客 237

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

2、多线程:多线程下载网络图片

学习过程观看视频:[狂神说Java] https://www.bilibili.com/video/BV1V4411p7EF?p=3 欢迎大家支持噢,很良心的老师了! java代码 package com.zjl; import org.apache.commons.io.FileUtils; import java.io.File; import java.io.IOException; import java.net.URL; /** * Created by zjl * 2020/11/16

Garry 246

24、多线程;线程池

学习过程观看视频:[狂神说Java] https://www.bilibili.com/video/BV1V4411p7EF?p=3 欢迎大家支持噢,很良心的老师了! java代码示例: package com.zjl; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; /** * Created by zjl * 2020/11/19 **/ public class Tes

Garry 136

java多线程模拟售票_Java:多线程模拟多站点售票过程

这是一个在并发状态下对共享资源的多线程访问。这些访问必须是互斥的进行,因为涉及到对资源的修改。假设现在销售火车票。目的地有3个,分别是北京,天津和上海。使用一个枚举类型表示。Destation.javapackagecom.zj.tickets;publicenumDestation {BEIJING,SHANGHAI,TIANJING}下面设计车票类,finalintoriginal表示车票基数...

weixin_30641597的博客 394

18、多线程:CopyOnWriteArrayList是线程安全的

学习过程观看视频:[狂神说Java] https://www.bilibili.com/video/BV1V4411p7EF?p=3 欢迎大家支持噢,很良心的老师了! java代码 package com.zjl; import java.util.concurrent.CopyOnWriteArrayList; /** * Created by zjl * 2020/11/18 **/ public class TestJUC { public static void main(Stri

Garry 420

6、多线程:实现Callable接口创建线程

学习过程观看视频:[狂神说Java] https://www.bilibili.com/video/BV1V4411p7EF?p=3 欢迎大家支持噢,很良心的老师了! 多线程下载网上图片资源Java代码 package com.zjl; import org.apache.commons.io.FileUtils; import java.io.File; import java.io.IOException; import java.net.URL; import java.util.concurren

Garry 179

5、多线程:龟兔赛跑

学习过程观看视频:[狂神说Java] https://www.bilibili.com/video/BV1V4411p7EF?p=3 欢迎大家支持噢,很良心的老师了! java代码 package com.zjl; /** * Created by zjl * 2020/11/16 **/ public class Race implements Runnable{ private static String winner; public void run() {

Garry 228

23、多线程:信号灯法

学习过程观看视频:[狂神说Java] https://www.bilibili.com/video/BV1V4411p7EF?p=3 欢迎大家支持噢,很良心的老师了! java代码 package com.zjl; /** * Created by zjl * 2020/11/19 **/ public class TestPC2 { public static void main(String[] args) { TV tv = new TV(); new

Garry 465

JAVA多线程上的单例模式

之前在上设计模式的时候老师讲了好几种单例模式,最终说每一个单例模式都有问题,原因在于if语句在多线程中同步,即将if语句放在synchronized外面和里面都会出现问题,最终的修改结果是来两个if语句,这样便很好得解决了多线程中条件判断的不同步而带来的问题:package com.zj; public class Instance { private static volatile Ins

mbshqqb的博客 391

20、多线程:Lock锁

学习过程观看视频:[狂神说Java] https://www.bilibili.com/video/BV1V4411p7EF?p=3 欢迎大家支持噢,很良心的老师了! 简介: 未加锁的代码存在并发问题 package com.zjl; /** * Created by zjl * 2020/11/18 **/ public class TestLock { public static void main(String[] args) { TestLock2 testLoc

Garry 127

22、多线程:管程法

学习过程观看视频:[狂神说Java] https://www.bilibili.com/video/BV1V4411p7EF?p=3 欢迎大家支持噢,很良心的老师了! package com.zjl; /** * Created by zjl * 2020/11/19 **/ public class TestPC { public static void main(String[] args) { SynContainer synContainer = new SynCo

Garry 322
上一篇: Mac 上搭建k8s
CoCo.......
博客等级 码龄7年 30粉丝 3原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值