Driver porting: the workqueue interface.

Linux下USB驱动开发完整指南 深入讲解Linux环境下USB驱动的开发流程,涵盖设备识别、驱动模块编写及usb通信机制,帮助开发者掌握usb通信的实际应用与调试技巧。 阅读详情

转自:http://lwn.net/Articles/23634/

Driver porting: the workqueue interface.

This article is part of the LWN Porting Drivers to 2.6 series.
The longstanding task queue interface was removed in 2.5.41; in its place is a new "workqueue" mechanism. Workqueues are very similar to task queues, but there are some important differences. Among other things, each workqueue has one or more dedicated worker threads (one per CPU, by default) associated with it. So all tasks running out of workqueues have a process context, and can thus sleep. Note that access to user space is not possible from code running out of a workqueue; there simply is no user space to access. Drivers can create their own work queues - with their own worker threads - but there is a default queue (for each processor) provided by the kernel that will work in most situations.

Workqueues are created with one of:

    struct workqueue_struct *create_workqueue(const char *name);
    struct workqueue_struct *create_singlethread_workqueue(const char *name);
A workqueue created with  create_workqueue() will have one worker thread for each CPU on the system;  create_singlethread_workqueue(), instead, creates a workqueue with a single worker process. The name of the queue is limited to ten characters; it is only used for generating the "command" for the kernel thread(s) (which can be seen in  ps or  top).

Tasks to be run out of a workqueue need to be packaged in a struct work_struct structure. This structure may be declared and initialized at compile time as follows:

    DECLARE_WORK(name, void (*function)(void *), void *data);
Here,  name is the name of the resulting  work_struct structure,  function is the function to call to execute the work, and  data is a pointer to pass to that function.

To set up a work_struct structure at run time, instead, use the following two macros:

    INIT_WORK(struct work_struct *work, 
              void (*function)(void *), void *data);
    PREPARE_WORK(struct work_struct *work, 
                 void (*function)(void *), void *data);
The difference between the two is that  INIT_WORK initializes the linked list pointers within the  work_struct structure, while  PREPARE_WORK changes only the function and data pointers. INIT_WORK must be used at least once before queueing the  work_struct structure, but should  not be used if the  work_struct might already be in a workqueue.

Actually queueing a job to be executed is simple:

    int queue_work(struct workqueue_struct *queue, 
                   struct work_struct *work);
    int queue_delayed_work(struct workqueue_struct *queue, 
	                   struct work_struct *work,
                           unsigned long delay);
The second form of the call ensures that a minimum delay (in jiffies) passes before the work is actually executed. The return value from both functions is nonzero if the  work_struct was actually added to  queue (otherwise, it may have already been there and will not be added a second time).

Entries in workqueues are executed at some undefined time in the future, when the associated worker thread is scheduled to run (and after the delay period, if any, has passed). If it is necessary to cancel a delayed task, you can do so with:

    int cancel_delayed_work(struct work_struct *work);
Note that this workqueue entry could actually be executing when  cancel_delayed_work() returns; all this function will do is keep it from starting after the call.

To ensure that none of your workqueue entries are running, call:

    void flush_workqueue(struct workqueue_struct *queue);
This would be a good thing to do, for example, in a device driver shutdown routine. Note that if the queue contains work with long delays this call could take a long time to complete. This function will  not (as of 2.5.68) wait for any work entries submitted after the call was first made; you should ensure that, for example, any outstanding work queue entries will not resubmit themselves. You should also cancel any delayed entries (with  cancel_delayed_work()) first if need be.

Work queues can be destroyed with:

    void destroy_workqueue(struct workqueue_struct *queue);
This operation will flush the queue, then delete it.

Finally, for tasks that do not justify their own workqueue, a "default" work queue (called "events") is defined. work_struct structures can be added to this queue with:

    int schedule_work(struct work_struct *work);
    int schedule_delayed_work(struct work_struct *work, unsigned long delay);
Most users of workqueues can probably use the predefined queue, but one should bear in mind that it is a shared resource. Long delays in the worker function will slow down other users of the queue, and should be avoided. There is a  flush_scheduled_work() function which will wait for everything on this queue to be executed. If your module uses the default queue, it should almost certainly call  flush_scheduled_work() before allowing itself to be unloaded.

One final note: schedule_work(), schedule_delayed_work() and flush_scheduled_work() are exported to any modules which wish to use them. The other functions (for working with separate workqueues) are exported to GPL-licensed modules only.


( Log in to post comments)

Driver porting: the workqueue interface.

Posted Jun 17, 2003 21:45 UTC (Tue) by btl (guest, #12097) [Link]

I'm trying to playing with workqueues... i've trouble on compiling
a little kernel module.

What include files do i need beside linux/workqueue.h?

I can't find where struct workqueue_struct is defined ;(

Driver porting: the workqueue interface.

Posted Dec 9, 2003 19:17 UTC (Tue) by bighead (guest, #17582) [Link]

Its work_struct, not workqueue_struct (if I get what you are asking).

Second you might need the usual, linux/init.h, linux/module.h etc header files. Take a look at http://www.xml.com/ldd/chapter/book/. The book is mainly 2.4 based. You can then see http://lwn.net/Articles/driver-porting/ for differences in 2.4 and 2.6.

Cheers!
Archit

Correction

Posted Apr 22, 2004 16:29 UTC (Thu) by proski (subscriber, #104) [Link]

Among other things, each workqueue has one or more dedicated worker threads (one per CPU) associated with it. So all tasks running out of workqueues have a process context, and can thus sleep.
This incorrectly implies that the task queue in 2.4 kernels is not run in the process context and cannot sleep. It's not true. The task queue is run in the context of the "keventd" process.

I believe the only significant difference is that the workqueue is processed in per-CPU threads whereas task queue is processed by a single kernel thread.

Correction

Posted Apr 22, 2004 16:41 UTC (Thu) by corbet (editor, #1) [Link]

Actually, 2.4 had several task queues, most of which did not run in process context. The scheduler queue, in later 2.4 kernels, runs out of keventd, but it is a single, shared thread. Workqueues have multiple, per-CPU threads which are dedicated to the queue. (When Rusty's patch goes in, single-thread workqueues will also be possible, though each queue will still have its own thread).

Workqueues also have nice features like a "flush" operation that can guarantee that your tasks are not running and will not run and a "delayed work" capability.

Driver porting: the workqueue interface.

Posted Aug 16, 2004 1:16 UTC (Mon) by baisa (guest, #24024) [Link]

How do I schedule work tasks (if indeed this is the object I should be using) to execute every timer tick? In the book, in chap 6 "Flow of Time" it lists at least 3 kernel task queues, one of which was a timer queue that dispatched its tasks each tick. But the entire "linux/tqueue.h" functionality was deleted in 2.6, and now I can't figure out how to dispatch some code every timer tick.

Thanks! Brad

Driver porting: the workqueue interface.

Posted Sep 15, 2004 7:05 UTC (Wed) by Albert (guest, #24733) [Link]

I ran into the same problem. We ran a stepper motor from the timer interrupt. In 2.6 I used the RTC instead. Here is some code for a minimal module that uses RTC to generate IRQ8 at 1024 Hz and also registers an interrupt handler for IRQ8 (via the RTC module).

/* 
* stepper.c - Stepper motor driver using RTC.
*/
#include <linux/module.h> /* Needed by all modules */
#include <linux/kernel.h> /* Needed for KERN_ALERT */
#include <linux/init.h> /* Needed for the macros */
#include <linux/ioctl.h>

#if defined(CONFIG_RTC) || defined(CONFIG_RTC_MODULE)

#include <linux/rtc.h>

#define DRIVER_AUTHOR "John Doe <some@one>"
#define DRIVER_DESC "Stepper motor driver using RTC"

static rtc_task_t rtc_task;
static atomic_t rtc_inc = ATOMIC_INIT(0);
static int stepper_freq = 1024; /* Frequency Hz */

static void stepper_interrupt(void *private_data)
{
int ticks;

atomic_inc(&rtc_inc);
ticks = atomic_read(&rtc_inc);

/* Add some code here to drive the stepper motor */
if (ticks % stepper_freq == 0) {
printk(KERN_WARNING "stepper_interrupt: %d\n", ticks);
}
}

static int __init stepper_init(void)
{
int err;
printk(KERN_ALERT "stepper_init: registering task\n");

rtc_task.func = stepper_interrupt;
err = rtc_register(&rtc_task);
if (err < 0)
return err;
rtc_control(&rtc_task, RTC_IRQP_SET, stepper_freq);
rtc_control(&rtc_task, RTC_PIE_ON, 0);
atomic_set(&rtc_inc, 0);
return 0;
}

static void __exit stepper_exit(void)
{
rtc_control(&rtc_task, RTC_PIE_OFF, 0);
rtc_unregister(&rtc_task);
printk(KERN_ALERT "stepper_exit: rtc_task unregistered\n");
}

module_init(stepper_init);
module_exit(stepper_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);

#endif /* CONFIG_RTC || CONFIG_RTC_MODULE */

Driver porting: the workqueue interface.

Posted Jan 20, 2005 6:17 UTC (Thu) by amit2030 (guest, #27378) [Link]

Hi,

I wanted to know whether the workqueue gets scheduled before a kernel thread (created by kthread_run()). I have a function that runs in the thread created by kthread_run(). If I use the workqueue interface, then will it be scheduled before other threads created by kthread_run().

Regards,

Driver porting: the workqueue interface.

Posted May 16, 2005 0:44 UTC (Mon) by Freiberg (guest, #29960) [Link]

Could you please tell me more about Work Queue synchronization?
Are they cumulative? If I scheduled the same work several times inside
one isr handler or different isr handlers will all of them run or not and in which sequence?

Thanks,
Vlad

Driver porting: the workqueue interface.

Posted Sep 3, 2008 21:43 UTC (Wed) by peetee3000 (guest, #53726) [Link]

Note that the workqueue interface has changed slightly in v2.6.20:

http://www.linuxhq.com/kernel/v2.6/20/include/linux/workq...

Ie, INIT_WORK now takes only 2 parameters.


BuildRoot配置RTL8822CE WIFI&BT模块(BT部分) 本文详细记录了在BuildRoot中配置RTL8822CE WiFi和蓝牙模块的过程。主要内容包括:1)通过修改rkwifibt.mk和Config.in文件解决模块配置问题;2)处理编译过程中遇到的路径和文件缺失问题;3)加载rtk_btusb.ko驱动时的固件加载失败问题及解决方法;4)使用hciconfig、hcitool等工具进行蓝牙调试的详细步骤,包括设备扫描、连接测试等。整个过程涉及内核配置、驱动加载、固件路径设置等多个技术环节,为类似WiFi/蓝牙模块的配置提供了详细参考。 阅读详情

相关推荐

MTK6765平台Flashlights驱动调试流程

本文以OCP81378闪光灯驱动移植为例,详细介绍了MTK平台驱动的移植与调试过程。主要内容包括:1. 驱动移植步骤:创建驱动文件、配置DTS设备树、定义闪光灯核心结构体;2. 驱动调试过程:排查I2C通信失败原因,最终发现需按MTK框架先注册platform驱动;3. 效果调试方法:通过ADB测试手电筒和闪光灯模式;4. 总结反思:绘制驱动架构框图、分析各层交互逻辑,特别关注了I2C电平兼容性、资源冲突等问题,并提供了硬件上拉电阻的检测方法。文章为MTK平台驱动开发提供了详细的实践参考。

aiaida的博客 253

工作队列 ( workqueue )

由来 在内核代码中,经常会遇到不能或不合适去马上调用某个处理过程,此时希望将该工作推送给某个内核线程执行,这样做的原因有很多,比如: 中断触发了某个过程的执行条件,而该过程执行时间较长或者会调用导致睡眠的函数,则该过程不应该在中断上下文中立即被调用。 类似于中断,一些紧急性的任务不希望执行比较耗时的非关键过程,则需要把该过程提交到低优先级线程执行。比如一个轮询的通信接收线程,它需要快速完成检测和接收数据,而对数据的解析则应该交由低优先级线程慢慢处理。 有时希望将一些工作集中起来以获取批处理的性能;或则合并

ScilogyHunter的博客 5949

AXI DMA控制器实战:从IP配置、Linux驱动到性能调优全解析

DMA(直接内存访问)是一种解放CPU、提升系统效率的关键技术,它允许外设硬件直接与内存交换数据。其核心原理在于通过专用控制器接管数据搬运任务,CPU仅需发起请求和接收中断通知。在基于ARM架构的SoC和FPGA系统中,AXI(高级可扩展接口)协议因其通道分离和突发传输特性,成为实现高性能DMA互连的行业标准。AXI DMA IP核(如Xilinx AXI DMA)的技术价值在于为内存与外设间建立了标准化的高速数据通路,广泛应用于视频流处理、高速数据采集等场景。本文聚焦于**AXI DMA控制器**的实战配

chuange6363的博客 392

linux 笔记--中断子系统之workqueue

linux workqueue,cmwq

Hober 2145

基于龙芯1C开源主板的嵌入式Linux开发与实战应用

嵌入式Linux系统是连接底层硬件与上层应用的核心软件平台,其工作原理在于通过Bootloader初始化硬件并引导Linux内核,内核再加载驱动、挂载根文件系统,最终启动用户空间服务。这一技术栈的价值在于为智能硬件提供了稳定、可定制且资源高效利用的操作环境,广泛应用于物联网网关、工业控制与消费电子等领域。本文聚焦于基于MIPS架构的龙芯1C开源主板,深入剖析其从Bootloader(PMON)引导、内核启动到交叉编译、系统定制的完整流程,并结合家庭无线网关与3D打印机控制器两个典型场景,演示了如何利用Bui

weixin_33824363的博客 425

【数据结构】汉诺塔问题(丰富图解)

经典汉诺塔问题,丰富图解,助你理解。

℉f的博客 4108

Linux系统-源码目录结构(一)

linux

qq_40067649的博客 422

Opencv学习-仿射变换与透视变换(几何变换)1

• 一、定义 变换是指对图像进行拉伸、收缩、扭曲和旋转等几何操作。对于平面区域有两种方式的几何转换:一种是基于23矩阵进行的变换,被称为仿射变换;一种是基于33矩阵进行的变换,被称为透视变换。也可被称为平面变换和空间变换。因为仿射变换需要找到3个映射点,三点确定一个平面。而透视变换需要确定四个映射点,四点确定一个三维空间。 • 二、Opencv中的函数定义 由于Opencv中都已封装好函数,变换的...

勉強 583

CANN driver 硬件驱动怎么在操作系统内核和昇腾NPU芯片之间架起一条零拷贝的数据高速公路

由于装饰器在模块被首次读取时由解释器来加载,所以它们的使用应受限于通用的包装器(wrapper)。如果装饰器与方法的类或所增强的函数签名绑定,那么应该将其重构为常规的可调用对象,以避免复杂性。在任何情况下,装饰器在处理 API 时,一个好的做法是将它们聚集在一个易于维护的模块中。常见的装饰器模式如下所示。• 参数检查。• 缓存。• 代理。• 上下文提供者。参数检查检查函数接受或返回的参数,在特定上下文中执行时可能有用。举个例子,如果一个。

2501_92093170的博客 184

用AI免费制作30分钟电影:完整工作流与实操解析

AI视频生成技术正大幅降低影视创作门槛,但真正制作一部完整电影并非一键生成,而是涉及剧本、分镜、画面、配音、剪辑的复杂流水线。理解其基本原理,是将文本转化为连续视觉叙事的关键。对于创作者而言,掌握角色一致性控制、素材批量管理、免费额度合理分配等技术价值,能有效避免生成结果崩坏与资源浪费。该能力可广泛应用于短视频创作、独立电影预演、教学演示等场景。本文以30分钟AI电影制作为例,拆解从工具选择到成片输出的全流程,重点分析免费方案下的时间与积分成本,以及最容易翻车的环节,并给出基于实践验证的排查与优化策略。

weixin_29056865的博客 334

基于STM32的Modbus TCP多主站数据监测

Modbus TCP通信协议在STM32上实现,STM32作为服务器采集内部传感器数据,并通过ADC进行转换,存入寄存器。两个PC机作为客户端访问服务器,服务器通过Socket通信实现监听连接,将数据发送给客户端。

hyp12347的博客 4296

Linux USB驱动阅读笔记(1)

本文是对相关 USB 驱动技术文章的补充与拓展。内容围绕 Linux USB 体系结构展开,深入补充了四个核心板块:USB 总线的设备查询与 Hub 传输机制;usb-skeleton 框架中的 DMA 机制与读写逻辑;USB 子系统核心的事件队列(usb_hub_wq)与主控初始化流程;以及 USB 鼠标驱动中 usb_mouse 与 input_dev 的结构体绑定和 URB 中断处理细节,旨在补全原文章的底层技术实现。

kdxiaojie的博客 527

GPD源码分析

gpd使用示例 先看下面一段代码,为标准gpd算法的使用方法,可以看到输入为点云,cloud_camera_; 输入:std::unique_ptr<gpd::util::Cloud> cloud_camera_ 输出: std::vector<std::unique_ptr<gpd::candidate::Hand>> grasps; // detect grasp poses gpd对象:std::unique_ptr<gpd::GraspDetect.

weixin_41003113的博客 2335

微服务全套

对于单表查询很好用自定义接口继承IService接口自定义实现类继承IService的实现类要传递baseMapper给ServiceImpl(IService的实现类)是因为调用Mapper方法时要知道要调用哪一个类的Mapper。

dllxhcjla的博客 468

Openlayers 教程 02 - 地图添加 WKT WKB GeoJson 格式的点线面数据

WebGIS 开发中,对于数据量不是很大的场景,可以直接从数据库读取数据,通过创建点线面要素(Feature),然后添加到矢量图层(vectorLayer)中,在地图上展示。添加点线面的方法可以封装一下,方便使用。...

非科班Java出身GISer的博客 3865

二极管钳位电路、限幅电路和检波电路Multisim电路仿真

本文系统介绍了二极管钳位、限幅和检波三种基础电路的工作原理及Multisim仿真验证。钳位电路通过电容-二极管配合实现波形整体平移,将波峰或波谷固定在指定电压;限幅电路利用二极管导通特性削除信号超出设定阈值的部分;检波电路则通过半波整流和电容滤波从调幅波中提取音频信号。三种电路均通过Multisim仿真验证了理论分析结果,展示了二极管在信号处理中的关键作用。这些基础电路广泛应用于信号调理、电平保护和通信解调等领域。

XU157303764的博客 1133

Linux SPI设备树驱动开发全解析:从硬件描述到用户空间接口

SPI(串行外设接口)作为一种高速同步串行总线,是嵌入式系统中连接Flash、传感器、显示屏等外设的核心通信协议。其工作原理基于主从架构和全双工同步传输,通过时钟、数据线和片选信号实现高效数据交换。在Linux内核中,SPI子系统采用标准的“总线-设备-驱动”模型进行抽象,设备树(Device Tree)则作为硬件描述语言,将外设的片选、时钟频率、工作模式等配置信息从内核代码中剥离,实现了硬件描述与驱动逻辑的解耦,极大提升了内核的可移植性和可维护性。这一技术方案对于驱动开发至关重要,尤其在瑞芯微RK3568

weixin_34176694的博客 295

复现:Mamba-UNet:降水临近预报的创新解决方案

Mamba-UNet通过其创新的双分支Mamba融合模块、多尺度时空注意力模块和动态分位数加权损失函数,在降水临近预报领域取得了显著的性能提升。它不仅在多种降水场景下表现出色,尤其在预测强降水事件方面展现出了强大的能力。这一创新模型为降水临近预报提供了一种新的解决方案,有望在未来的研究和应用中发挥更大的作用,为应对气候变化带来的挑战提供有力支持。随着技术的不断发展和优化,我们期待Mamba-UNet在更广泛的气象预报任务中发挥更大的价值,为各行各业提供更精准、更可靠的降水预报服务。

hanfeng5268的博客 916

Linux USB Hub驱动深度解析:从内核源码到设备枚举与调试实战

USB(通用串行总线)是现代计算机连接外设的核心技术,其核心在于一套精密的设备管理与通信协议。在Linux系统中,USB子系统通过分层驱动模型实现设备的即插即用,其中USB Hub驱动扮演着至关重要的“交通枢纽”角色。它不仅是硬件端口扩展的软件抽象,更是负责设备连接检测、电源管理、端口状态监控以及发起完整设备枚举流程的协调器。理解Hub驱动的工作原理,对于开发稳定的USB外设、调试复杂的设备兼容性问题以及优化系统电源管理具有极高的工程价值。本文聚焦于Linux内核中关键的`hub.c`模块,深入剖析其如何通

germmy-神一样的开发 375

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

Linux GPIO子系统深度解析:从设备树到驱动开发与libgpiod实践

GPIO(通用输入输出)是嵌入式系统与物理世界交互的基础接口,其核心原理是通过软件控制硬件引脚的电平状态,实现数字信号的输入与输出。在Linux系统中,GPIO子系统作为内核框架,将不同芯片厂商的硬件操作抽象为统一API,为驱动和应用开发者提供了标准化的访问方式,其技术价值在于实现了硬件操作的抽象化、安全性与可移植性。该技术广泛应用于LED控制、按键检测、传感器读取等嵌入式场景。本文聚焦于Linux环境下GPIO的现代操作方法,深入探讨了设备树(Device Tree)中的资源定义、GPIO描述符(gpio

weixin_33908217的博客 291

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

Linux下开发驱动,必须要满足框架吗?

不一定要“照抄某个固定模板”,但。否则驱动即使能编译,也很难被内核正确识别、加载、管理、卸载和和用户态交互。

weixin_41230430的博客 350

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

嵌入式显示与触摸驱动开发实战:从MIPI DSI接口到Linux输入子系统

在嵌入式系统与智能硬件开发中,显示与触摸交互是人机界面(HMI)的核心。其技术基础通常涉及高速串行显示接口与标准通信协议。MIPI DSI(Display Serial Interface)作为移动和嵌入式领域主流的显示接口标准,以其高带宽、低引脚数的优势,负责传输图像数据与初始化指令。而触摸功能则多通过I2C或SPI等标准接口与主控通信,并依赖Linux输入子系统进行事件上报。理解这些接口的底层原理,是进行驱动适配、时序调试与性能优化的前提。本文以一块集成了7英寸显示屏与电容触摸功能的典型模组(如“7-D

aibi9196的博客 440

嵌入式Linux内核集成RTL8309M交换芯片VLAN驱动实战

VLAN(虚拟局域网)是网络隔离的核心技术,通过在数据链路层划分独立的广播域,实现不同业务流量的逻辑隔离。其原理基于IEEE 802.1Q协议,在以太网帧头插入VLAN标签,交换机根据标签进行端口转发控制。这项技术的核心价值在于提升网络安全性、优化带宽利用并简化网络管理,广泛应用于企业网络、数据中心和工业控制等场景。在嵌入式领域,为实现定制化网络隔离,常需将非主线交换芯片驱动集成至Linux内核。本文以RTL8309M这款经典九口交换芯片为例,详细解析了如何将其VLAN驱动从源码编译为内核内置组件,涵盖了驱

weixin_34408717的博客 434

Android开发者必学:从file_operations入门Linux驱动开发

在操作系统与硬件交互的底层,Linux内核通过驱动扮演着软件与硬件间的“翻译官”角色。其核心原理基于“一切皆文件”的Unix哲学,用户空间通过标准文件操作函数与设备交互,而驱动则通过file_operations结构体实现这些操作的具体逻辑。掌握驱动开发技术,对于深入理解系统调用链路、排查硬件兼容性问题及进行深度性能优化具有重要价值。尤其在Android开发场景中,这有助于厘清从Framework、HAL到内核驱动的完整数据流向。本文将以file_operations和内核模块为切入点,结合并发控制与内存管

weixin_30455023的博客 302

面试问题总结

文章目录1.abstract和interface异同2.构造方法3.final关键字作用4.重写和重载的区别4.1重载4.2重写5.this关键字6.封装的作用,实现封装的步骤7.封装中的getter和setter方法分别作用7.1setter方法7.2getter方法8.Mybatis-plus与Spring Data JPA9.装箱和拆箱9.1装箱9.2拆箱10.ArrayList底层原理11.反射12.Filter13.$与#的区别14.js中的DOM对象与jQuery中的DOM区别15.四大元注解1

肥猫不是猫 1112

庖丁解 vmCore · 第六篇 · 众生之相:进程与线程的生死现场

解牛者,刀游骨缝,非割肉也。 读进程者,眼见状态,非枚举字段也。

深耕底层运维,沉淀实战干货,分享技术经验。 486
上一篇: Linux中的工作队列
下一篇: uboot中背光的启动参数传递
YasinLeeX
博客等级 码龄19年 380粉丝 310原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

YasinLeeX

再来一杯西湖龙井。

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值