How to schedule the thread's priority?

本文讨论了UI线程与工作线程在应用程序中的重要性,强调了使用线程对于构建响应迅速的GUI至关重要。文章介绍了如何通过合理设置工作线程的优先级、数量及适时挂起等手段来提高用户体验,并提供了Swing组件的最佳实践,如利用invokeLater与invokeAndWait方法将任务转移至事件分发线程。

1 UI application

  The user is boss of the application, so the UI thread has highest priority. workerthread has lower priority.

·  Keep the priorityof worker threads low.

·  Keep the numberof worker threads small.

·  Consider suspending worker threads duringCPU-intensive operations like scrolling.

Key Points

  • Using threads is essential for building responsive GUIs. Blocking user activity to wait for long tasks to complete leads to poor perceived performance.
  • The user is the boss. Always let your users know what's going on and give them regular status updates when waiting for long tasks to complete.
  • Once realized, Swing components should only be touched by code executing inside the AWT event-dispatch thread.
  • Use invokeLater and invokeAndWait to move work to the event dispatching thread.
  • Use timers for repeated operations. You can use either the javax.swing.Timer or java.util.Timer. The utility Timer class gives you more control, but you have to move work to the event- dispatch thread yourself. You can use the SwingTimerTask utility described in this chapter to move work to the event-dispatch thread.
  • Use SwingWorker to execute time-consuming tasks on new threads and update the GUI on the event-dispatch thread.
  • Interrupt worker threads when the user is driving the system.

 

2 Real time server application:


<!-- go/cmark --> <!--* freshness: {owner: 'sprang' reviewed: '2021-04-12'} *--> # Paced Sending The paced sender, often referred to as just the "pacer", is a part of the WebRTC RTP stack used primarily to smooth the flow of packets sent onto the network. ## Background Consider a video stream at 5Mbps and 30fps. This would in an ideal world result in each frame being ~21kB large and packetized into 18 RTP packets. While the average bitrate over say a one second sliding window would be a correct 5Mbps, on a shorter time scale it can be seen as a burst of 167Mbps every 33ms, each followed by a 32ms silent period. Further, it is quite common that video encoders overshoot the target frame size in case of sudden movement especially dealing with screensharing. Frames being 10x or even 100x larger than the ideal size is an all too real scenario. These packet bursts can cause several issues, such as congesting networks and causing buffer bloat or even packet loss. Most sessions have more than one media stream, e.g. a video and an audio track. If you put a frame on the wire in one go, and those packets take 100ms to reach the other side - that means you have now blocked any audio packets from reaching the remote end in time as well. The paced sender solves this by having a buffer in which media is queued, and then using a _leaky bucket_ algorithm to pace them onto the network. The buffer contains separate fifo streams for all media tracks so that e.g. audio can be prioritized over video - and equal prio streams can be sent in a round-robin fashion to avoid any one stream blocking others. Since the pacer is in control of the bitrate sent on the wire, it is also used to generate padding in cases where a minimum send rate is required - and to generate packet trains if bitrate probing is used. ## Life of a Packet The typical path for media packets when using the paced sender looks something like this: 1. `RTPSenderVideo` or `RTPSenderAudio` packetizes media into RTP packets. 2. The packets are sent to the [RTPSender] class for transmission. 3. The pacer is called via [RtpPacketSender] interface to enqueue the packet batch. 4. The packets are put into a queue within the pacer awaiting opportune moments to send them. 5. At a calculated time, the pacer calls the `PacingController::PacketSender()` callback method, normally implemented by the [PacketRouter] class. 6. The router forwards the packet to the correct RTP module based on the packet's SSRC, and in which the `RTPSenderEgress` class makes final time stamping, potentially records it for retransmissions etc. 7. The packet is sent to the low-level `Transport` interface, after which it is now out of scope. Asynchronously to this, the estimated available send bandwidth is determined - and the target send rate is set on the `RtpPacketPacer` via the `void SetPacingRates(DataRate pacing_rate, DataRate padding_rate)` method. ## Packet Prioritization The pacer prioritized packets based on two criteria: * Packet type, with most to least prioritized: 1. Audio 2. Retransmissions 3. Video and FEC 4. Padding * Enqueue order The enqueue order is enforced on a per stream (SSRC) basis. Given equal priority, the [RoundRobinPacketQueue] alternates between media streams to ensure no stream needlessly blocks others. ## Implementations The main class to use is called [TaskQueuePacedSender]. It uses a task queue to manage thread safety and schedule delayed tasks, but delegates most of the actual work to the `PacingController` class. This way, it's possible to develop a custom pacer with different scheduling mechanism - but ratain the same pacing logic. ## The Packet Router An adjacent component called [PacketRouter] is used to route packets coming out of the pacer and into the correct RTP module. It has the following functions: * The `SendPacket` method looks up an RTP module with an SSRC corresponding to the packet for further routing to the network. * If send-side bandwidth estimation is used, it populates the transport-wide sequence number extension. * Generate padding. Modules supporting payload-based padding are prioritized, with the last module to have sent media always being the first choice. * Returns any generated FEC after having sent media. * Forwards REMB and/or TransportFeedback messages to suitable RTP modules. At present the FEC is generated on a per SSRC basis, so is always returned from an RTP module after sending media. Hopefully one day we will support covering multiple streams with a single FlexFEC stream - and the packet router is the likely place for that FEC generator to live. It may even be used for FEC padding as an alternative to RTX. ## The API The section outlines the classes and methods relevant to a few different use cases of the pacer. ### Packet sending For sending packets, use `RtpPacketSender::EnqueuePackets(std::vector<std::unique_ptr<RtpPacketToSend>> packets)` The pacer takes a `PacingController::PacketSender` as constructor argument, this callback is used when it's time to actually send packets. ### Send rates To control the send rate, use `void SetPacingRates(DataRate pacing_rate, DataRate padding_rate)` If the packet queue becomes empty and the send rate drops below `padding_rate`, the pacer will request padding packets from the `PacketRouter`. In order to completely suspend/resume sending data (e.g. due to network availability), use the `Pause()` and `Resume()` methods. The specified pacing rate may be overriden in some cases, e.g. due to extreme encoder overshoot. Use `void SetQueueTimeLimit(TimeDelta limit)` to specify the longest time you want packets to spend waiting in the pacer queue (pausing excluded). The actual send rate may then be increased past the pacing_rate to try to make the _average_ queue time less than that requested limit. The rationale for this is that if the send queue is say longer than three seconds, it's better to risk packet loss and then try to recover using a key-frame rather than cause severe delays. ### Bandwidth estimation If the bandwidth estimator supports bandwidth probing, it may request a cluster of packets to be sent at a specified rate in order to gauge if this causes increased delay/loss on the network. Use the `void CreateProbeCluster(...)` method - packets sent via this `PacketRouter` will be marked with the corresponding cluster_id in the attached `PacedPacketInfo` struct. If congestion window pushback is used, the state can be updated using `SetCongestionWindow()` and `UpdateOutstandingData()`. A few more methods control how we pace: * `SetAccountForAudioPackets()` determines if audio packets count into bandwidth consumed. * `SetIncludeOverhead()` determines if the entire RTP packet size counts into bandwidth used (otherwise just media payload). * `SetTransportOverhead()` sets an additional data size consumed per packet, representing e.g. UDP/IP headers. ### Stats Several methods are used to gather statistics in pacer state: * `OldestPacketWaitTime()` time since the oldest packet in the queue was added. * `QueueSizeData()` total bytes currently in the queue. * `FirstSentPacketTime()` absolute time the first packet was sent. * `ExpectedQueueTime()` total bytes in the queue divided by the send rate. [RTPSender]: https://source.chromium.org/chromium/chromium/src/+/main:third_party/webrtc/modules/rtp_rtcp/source/rtp_sender.h;drc=77ee8542dd35d5143b5788ddf47fb7cdb96eb08e [RtpPacketSender]: https://source.chromium.org/chromium/chromium/src/+/main:third_party/webrtc/api/rtp_packet_sender.h;drc=ea55b0872f14faab23a4e5dbcb6956369c8ed5dc [RtpPacketPacer]: https://source.chromium.org/chromium/chromium/src/+/main:third_party/webrtc/modules/pacing/rtp_packet_pacer.h;drc=e7bc3a347760023dd4840cf6ebdd1e6c8592f4d7 [PacketRouter]: https://source.chromium.org/chromium/chromium/src/+/main:third_party/webrtc/modules/pacing/packet_router.h;drc=3d2210876e31d0bb5c7de88b27fd02ceb1f4e03e [TaskQueuePacedSender]: https://source.chromium.org/chromium/chromium/src/+/main:third_party/webrtc/modules/pacing/task_queue_paced_sender.h;drc=5051693ada61bc7b78855c6fb3fa87a0394fa813 [RoundRobinPacketQueue]: https://source.chromium.org/chromium/chromium/src/+/main:third_party/webrtc/modules/pacing/round_robin_packet_queue.h;drc=b571ff48f8fe07678da5a854cd6c3f5dde02855f 翻译
最新发布
12-03
### IAR工具链整合到FreeRTOS中的方法 将IAR工具链整合或重构到FreeRTOS中,涉及多个关键步骤和配置选项。以下是详细说明: #### 1. 环境配置 在开始之前,需要确保安装了IAR Embedded Workbench,并正确配置目标硬件支持包(HSP)。此外,还需要下载并安装适合目标处理器架构的FreeRTOS版本[^1]。 #### 2. 工程创建与设置 使用IAR Embedded Workbench创建一个新的工程文件,选择对应的目标设备。在工程设置中,指定编译器选项以匹配FreeRTOS的需求。例如,启用优化选项以减少代码大小和提高性能[^2]。 #### 3. 配置FreeRTOS内核 根据目标硬件调整`FreeRTOSConfig.h`文件中的宏定义,包括但不限于任务堆栈大小、时钟滴答频率等参数。这些设置直接影响系统的运行效率和资源消耗[^3]。 ```c #define configTICK_RATE_HZ ( ( TickType_t ) 1000 ) #define configMAX_PRIORITIES ( 5U ) #define configMINIMAL_STACK_SIZE ( ( unsigned short ) 128 ) ``` #### 4. 中断优先级管理 对于基于ARM Cortex-M系列的微控制器,必须正确配置中断优先级以避免抢占问题。通过修改`portmacro.h`中的相关定义来实现这一点[^4]。 ```c #define configLIBRARY_LOWEST_INTERRUPT_PRIORITY 15 #define configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY 5 ``` #### 5. 测试与验证 完成上述步骤后,构建并加载项目到目标板上进行测试。可以使用IAR提供的调试工具监控任务切换、内存使用等情况,确保系统稳定运行[^5]。 #### 6. 代码示例:初始化FreeRTOS 以下是一个简单的FreeRTOS初始化示例,展示如何创建任务并启动调度程序。 ```c #include "FreeRTOS.h" #include "task.h" void vTaskFunction(void *pvParameters) { // Task implementation here } int main(void) { xTaskCreate(vTaskFunction, "TaskName", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL); vTaskStartScheduler(); return 0; } ```
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值