精华内容
下载资源
问答
  • 基于PCIExpress的多核SoC片间异步桥设计与实现
  • apb/axi异步桥实现

    千次阅读 2020-03-20 17:49:28
    1.基本异步处理电路 1.1电平同步 1.2脉冲同步 现将脉冲变成电平,同步之后再恢复, 1.下面是脉冲展电平的做法 2.下面是电平恢复脉冲 1.3异步fifo 1.4demux同步 DEBUX通过一个同步到目标时钟域的信号...

    1.基本异步处理电路

    1.1电平同步

    1.2脉冲同步

    现将脉冲变成电平,同步之后再恢复,

    1.下面是脉冲展电平的做法

    2.下面是电平恢复脉冲

    1.3异步fifo

    1.4demux同步

    DEBUX通过一个同步到目标时钟域的信号作为目标时钟域多比特数据更新的使能信号

    2.Qualifier synchronization

    其实和demux很相像,先选择一个qualif的singal做同步,同步到ck2之后,用该信号做其他数据的选通信号。

    3.apb2apb的异步桥

    apb的信号中只有psel和pready会做sync,其他都不直接sync

    假设apb2apb的clk_1域为slave 端,需要同步到clk_2域master端

    psel_s/penalbe_s/pwrite_s/paddr_s/pwdata_s 需要同步到clk_2

    pready_m/prdata_m/pslverr_m需要同步到clk_1

    3.1 使用异步fifo的同步形式

    这种情况比较简单,但是资源占的较多

    3.2Qualifier synchronization 策略

    slave--->master过程如下:

    1.将psel_s&(~penable_s)这样一个pulse signal 经过脉冲同步到clk_2,为pulse_d

    2.用pulse_d拉高psel_m,用psel_m & penable_m & pready_m 拉低psel_m

    3.用pulse_d_ff1拉高penable_m,用psel_m & penable_m & pready_m 拉低penable_m

    4.pwrite_m/paddr_m/pwdata_m直接赋值

    以上地方直接赋值也可以用psel_m做个mux

    assign pwrite_m = psel_m & pwrite_s;

    assign paddr_m = psel_m & paddr_s;

    assign pwdata_m = psel_m & pwdata_s;

    master--->slave过程如下:

    1.将psel_m & penable_m & pready_m形成的pulse 信号同步到clk_1做pready_s

    2.用psel_m & penable_m & pready_m对prdata_m在clk_2域锁存,锁存的信号直接作为clk_1的prdata_s

    3.用psel_m & penable_m & pready_m对pslverr_m在clk_2域锁存,锁存的信号直接作为clk_1的pslverr_s(和prdata_s一样)

    4.其他AXI/AHB的桥在异步处理上类似于apb2apb的异步桥

    展开全文
  • aiosqlite为sqlite数据库提供了一个友好的异步接口。 它复制标准的sqlite3模块,但具有所有标准连接和游标方法的异步版本,以及用于自动关闭连接和游标的上下文管理器: async with aiosqlite.connect(...) as db...
  • 异步异步

    2018-03-06 16:47:12
    为了验证我对异步IO的理解,决定造一个异步文件IO的轮子。操作系统已经给出各种异步操作的API,如重叠IO, IOCP,kqueue,select,poll,epoll等机制,而且C++也有很多跨平台的异步IO库,如libevent,boost::asio等。...

    前言

    • 因为本科毕业设计中要做一个分布式文件系统,其中一个模块需要实现文件IO。为了验证我对异步IO的理解,决定造一个异步文件IO的轮子。操作系统已经给出各种异步操作的API,如重叠IO, IOCP,kqueue,select,poll,epoll等机制,而且C++也有很多跨平台的异步IO库,如libevent,boost::asio等。我参考已有的实现来完善这个小系统的功能。
    • 渣技术,渣代码,该日志也只是作为这个工程的记录,出现问题请各位指出。

    概述

    • 同步与异步:

      同步:假如我想对一个文件(socket也同理)进行处理,那么一般的流程就是:

      

    1 fstream file;
    2 file.open();
    3 file.read();
    4 //do something
    5 file.close();

      通常情况下,当这个线程运行到read()时会被阻塞,直到文件读取完成。

      异步:

      还是上面的代码,我在read()时通过操作系统或库提供的异步机制,告诉操作系统我想读一个文件,数据读完后执行某个功能;而当前线程在交代完操作系统该做什么工作之后,还可以做些别的事情(线程不必等待文件IO完成)。

    • 线程池

      为了避免IO阻塞线程导致程序无响应,完全可以为每一个文件操作创建一个线程,这样就可以同时处理多个文件了。但是创建线程,切换线程,销毁线程也是一笔资源开销,如果想重复使用已有的线程,就可以使用线程池。作为线程池,至少要提供创建线程和提交任务的功能,复杂一点可以智能控制线程池里的线程数量,还应该具有基本的负载均衡功能。这个文件系统中就会使用线程池。Windows API中的ThreadPool就很好用,但既然是造轮子,那么为了造轮子而造轮子也没什么关系,干脆就写个简单的线程池出来。

    • 使用的库

      这个模块只使用stl 和boost 两个库。

      stl主要涉及容器和fstream。boost涉及到智能指针shared_ptr,线程同步shared_mutex,lock_guard, boost::filesystem中的path和一些文件操作,线程操作创建退出等。

    •  智能指针

      自古以来内存管理都是C/C++中的重头戏,智能指针的功能就是分配出来的内存由库管理,如果某个智能指针指向的内存,通过其他的智能指针也能访问到(即有多个引用),那么该智能指针即时被销毁,指向的内存也不会销毁;只有这块内存没有引用,才会被库释放。

    • boost::filesystem

      这个库提供了一些跨平台文件操作的API,如文件夹遍历,查看属性,删除文件等。path类可以记录跨平台的路径。

    • 因为水平有限,这个模块基本不会出现跟模板有关的实现。(以后再说)

    实现

      AsyncStatus是异步IO中需要实现的功能。像读,写,放弃异步操作,错误处理等。

      ErrorCode会出现在回调函数中,表示之前异步读写的结果,如正在处理,出错,EOF等。

      FS_Handle_ST:这个结构体对应一个文件路径。在系统中每个handle都是唯一的,系统有一个map,通过handle可以找到它对应的路径。

      FS_AsyncHandle_ST:标识某个handle需要执行的任务,每个AsyncHandle都需要指定status即任务。一个handle可以有多个异步任务,但多个任务在系统中按照队列顺序执行。

    复制代码
     1     enum QueueOperation { PUSH_BACK, PUSH_FRONT };
     2     enum AsyncStatus { NONE, APPEND_WRITE, WRITE, READ, READ_ALL, ABORT, ERROR, EXIT };
     3     enum ErrorCode { DONE, PENDING, END_OF_FILE, OPEN_FAIL, BAD_STREAM, IO_FAIL, UNKNOWN_ERROR };        
     4 
     5     typedef uintmax_t FS_Handle;
     6     typedef uintmax_t FS_AsyncHandle;
     7 
     8     struct FS_AsyncHandle_ST {
     9         FS_Handle fileHandle = 0;
    10         FS_AsyncHandle asyncHandle = 0;
    11         AsyncStatus status = AsyncStatus::NONE;
    12     };
    13 
    14     struct FS_Handle_ST {
    15         FS_Handle handle = 0;
    16         boost::filesystem::path fullPath;
    17     };        
    复制代码

      回调函数:异步操作完成之后要做什么。使用的时候把功能在派生类里实现,重载虚函数run就可以了。

    复制代码
     1     class FileSystemIOCallback {
     2     public:
     3         void operator=(const FileSystemIOCallback & cb) {
     4             //..
     5         }
     6 
     7         FileSystemIOCallback(const FileSystemIOCallback & cb) {
     8             //..
     9         }
    10 
    11         FileSystemIOCallback() {
    12             //...
    13         }
    14 
    15         virtual ~FileSystemIOCallback() {
    16 
    17         }
    18 
    19         virtual void run(const FS_AsyncHandle_ST & ast, ErrorCode e, void * data, uintmax_t count) {
    20             //...
    21         }
    22     };
    复制代码
    •  功能概述

      fstream中有一个非常有趣的函数,readsome()方法,这个方法提出的目的是尽可能减少同步读取的阻塞时间。该方法会读取fstream内部缓冲区里的数据,读取的字节数取决于fstream内部缓冲区和作为参数传递给它的缓冲区的大小。举个例子,如果fstream缓冲区里只有10字节,我参数给出的缓冲区大小为100字节,不管这个文件后面还有没有数据,它只会去读10个字节。操作系统和函数库可能会使用由硬件引发的中断来读取数据,运行原理类似,但其具体实现未知,还要进一步了解。

      既然IO操作要阻塞线程很长一段时间,那么就把IO操作扔给线程或纤程,主线程只负责提交任务。

    展开全文
  • 针对双绕组异步发电机所带不可控整流直流侧电压的稳定问题,提出了一种在控制绕组侧补偿异步发电机所需无功励磁电流的新方法。该方法通过锁相环(PLL)检测出控制绕组中基波电压相位并超前90°作为实际应补偿的...
  • 目前,在船舶电站中,广泛应用的为同步电机发电系统,若采用异步电机发电系统整流得到直流电,与同步发电机相比,具有功率密度高,结构简单,机械强度高,制造成本低,维护方便等突出的优点。但感应电机作为发电机...
  • 异步助手 ( 异步帮助器 执照:麻省理工学院 用法 import time, random from async_helper import first_parallel_result def time_consuming_function(i): print("I consume a lot of time") time.sleep(random....
  • 同步复位、异步复位、异步复位同步释放、多时钟域复位电路和全局复位信号复位同步复位异步复位同步复位异步释放以两级寄存器异步复位为例说明存在的问题解决方法------异步复位同步释放参考博客复位电路设计全局...

    复位

    同步复位

    1 module test
    2 (
    3  input clk,
    4 input rst_n,
    5 input data_in,
    6 output reg out
    7  );
    8 always @ (posedge clk )
    9          if(!rst_n) out <= 1'b0;
    10          else out <= data_in;
    11 endmodule
    

    在这里插入图片描述
    优点:
    1.因为他只有在时钟有效电平到来时才有效,所以可以滤除高于时钟频率的毛刺。
    2.降低亚稳态出现的概率。(可以对rst信号先打一拍,然后在输入给rst_n,这样就可以降低亚稳态。)
    缺点:
    1.复位信号的有效时长必须大于时钟周期,才能真正被系统识别并完成复位任务。

    2.倘若采用同步复位的话,综合器就会在寄存器的数据输入端口插入组合逻辑,这样就会耗费较多的逻辑资源。

    异步复位

    1 module test
    2 (
    3  input clk,
    4  input rst_n,
    5  input data_in,
    6  output reg out
    7  );
    8  always @ (posedge clk or negedge rst_n)
    9          if(!rst_n) out <= 1'b0;
    10           else out <= data_in;
    11  endmodule 
    

    在这里插入图片描述
    优点
    大多数目标器件库的dff都有异步复位端口,因此采用异步复位可以节省资源。

    缺点:
    1.在复位信号释放(release)的时候容易出现问题。具体就是说:倘若复位释放时恰恰在时钟有效沿附近,就很容易使寄存器输出出现亚稳态,从而导致亚稳态。

    2.复位信号容易受到毛刺的影响。

    同步复位异步释放

    同步复位异步释放:既解决了同步复位的资源消耗问题,也解决了异步复位的亚稳态问题。其根本思想,也是将异步信号同步化。

    以两级寄存器异步复位为例说明存在的问题

    1 module test
    2 (
    3 input clk,
    4 input rst_n,
    5 input a,
    6 output reg c
    7  );
    8  
    9  reg b;
    10 always @ (posedge clk or negedge rst_n)
    11          if(!rst_n) b <= 1'b0;
    12          else b <= a;
    13         
    14 always @ (posedge clk or negedge rst_n)
    15          if(!rst_n) c <= 1'b0;
    16          else c <= b;       
    17 
    18 endmodule 
    

    在这里插入图片描述
    正常情况下,clk的上升沿c更新为b,b更新为a。一旦进入复位,b,c都清零;但是我们不能确定复位信号rst_n会在什么时候结束。如果结束于b_reg0和c_reg0的{launch edge –stup,launch edge+hold}时间只外,那么一切都会正常。但如果恰恰相反,会出现什么情况呢? rst_n的上升变化出现在了clk上升的建立保持时间上,此时clk检测到的rst_n的状态就会是一个亚稳态(是0是1不确定)。从代码里我们看到如果此时b_reg0和c_reg0认为rst_n为0,那么依然保持复位清零,而如果认为rst_n为1,那么就跳出复位。因为此时的rst_n的不确定性,就可能出现4种情况,即b_reg0和c_reg0都复位或者都跳出复位,再或者一个复位一个跳出复位。那么后者就会造成了系统工作不同步的问题,在这个简单的两级异步复位实例中这种危害表现的并不明显,但是我们试想一个大的工程项目里众多的寄存器出现如此情况又会是如何一番景象呢?
    在大工程项目里,如果采用异步复位,那么当亚稳态来临时候,所有寄存器都会随机复位或者跳出复位,导致系统进入未知的或者错误的工作状态。

    解决方法------异步复位同步释放

    第一种方式:
    在这里插入图片描述

    1 module test
     2 (
     3 input clk,
     4 input rst_n,
     5 input a,
     6 output reg c
     7  );
     8  
     9 reg b,rst_nr;
    10 always @ (posedge clk)
    11          rst_nr <= rst_n;  
    12             
    13 always @ (posedge clk or negedge rst_nr)
    14          if(!rst_nr) b <= 1'b0;
    15          else b <= a; 
    16             
    17 always @ (posedge clk or negedge rst_nr)
    18          if(!rst_nr) c <= 1'b0;
    19          else c <= b; 
    20             
    21 endmodule 
    

    将第一种方式的复位信号简化后则形成第二种方式。
    第二种方式:

    1 module test
     2 (
     3  input clk,
     4  input rst_n,
     5  output reg rst_out
     6  );
     7  
     8 always @ (posedge clk,negedge rst_n)
     9     if(!rst_n)
    10         rst_out<=1'b0;
    11      else
    12         rst_out<=1'b1;                        
    13  endmodule 
    
    

    在这里插入图片描述
    前两种方式都是属于异步复位同步释放,但是当出现一个毛刺信号时候,由于毛刺信号复位时间特别小,而信号变化需要一段时间,所以毛刺信号可能导致复位不彻底(即有些寄存器已经复位,有一些没有复位),系统出现错误的状态(即系统出现混乱),所以不可取。如果将该毛刺信号的复位延迟一个时钟周期,即系统检测到毛刺信号的下降沿后复位,等一个时钟后(即打一拍)再进行还原,可以有效避免这种情况出现。这就是我们所说的第三种方法。
    在这里插入图片描述

    第三种方式

    module rst 
    ( 
      input clk, 
      input rst_n, 
      output reg rst_out 
    ); 
    reg R1; 
        
    always @ (posedge clk,negedge rst_n)
         if(!rst_n)
             begin
                 R1 <= 1'b0;
                 rst_out <= 1'b0;
             end
         else
             begin
                 R1 <= 1'b1;
                 rst_out <= R1;
            end
    endmodule
    

    在这里插入图片描述
    异步复位,同步释放的好处是:
    1.不要求复位信号必须大于一个时钟周期;
    2.因为释放过程和时钟同步,所以有效降低了亚稳态出现的概率。
    3.消除毛刺信号的影响。

    参考博客

    https://www.cnblogs.com/qiweiwang/archive/2010/11/25/1887888.html

    复位电路设计

    全局复位(GSR)

    在很多FPGA中采用全局复位信号,即整个FPGA的所有触发器都使用同一个复位信号。所以GSR信号(全局复位信号)是一个高扇出的信号。

    对于多数FPGA,均有专用的全局异步复位/置位资源(GSR,GlobalSetReset)。使用GSR资源,异步复位到达所有寄存器的偏斜最小。

    多时钟域复位桥电路

    每个时钟域都要有自己的复位信号,而且复位信号要与该时钟域的时钟同步。如下图所示,复位信号在进入每个时钟域前都先进行异步复位同步释放操作,使得复位信号和该时钟域的时钟同步。
    在这里插入图片描述

    按键复位信号电路

    按键信号一般有抖动,所以在使用前需要消抖处理。
    这里有两种去抖动方案供大家参考:
    第一种:
    1.每隔20ms采集一次信号rst
    2.对rst信号打一拍,进行边沿检测。(这里需要对上升沿和下降沿都进行检测)
    如果检测到下降沿,则认为复位有效,系统进行复位。如果检测到上升沿,则认为复位释放。

    //===========================================================================
    // 采样按键值,20ms扫描一次,采样频率小于按键毛刺频率,相当于滤除掉了高频毛刺信号。
    //===========================================================================
    always @(posedge clk or negedge rst_n)     //检测时钟的上升沿和复位的下降沿
    begin
       if(!rst_n)                //复位信号低有效
          count <= 20'd0;        //计数器清0
       else
          begin
             if(count ==20'd999_999)   //20ms扫描一次按键,20ms计数(50M/50-1=999_999)
                begin
                   count <= 20'b0;     //计数器计到20ms,计数器清零
                   key_scan <= key_in; //采样按键输入电平
                end
             else
                count <= count + 20'b1; //计数器加1
         end
    end
    //===========================================================================
    // 按键信号锁存一个时钟节拍
    //===========================================================================
    reg [3:0] key_scan_r;
    always @(posedge clk)
        key_scan_r <= key_scan;       
        
    wire [3:0] flag_key = key_scan_r[3:0] & (~key_scan[3:0]);  //当检测到按键有下降沿变化时,代表该按键被按下,按键有效 
    
    

    第二种方法:
    1.先进行上升沿检测
    2.检测到上升沿后,开始计数20ms,采集20ms后的复位信号rst1
    3.如果rst1为高电平且上升沿有效,则认为复位释放。
    同理复位有效也是这样处理。
    在这里插入图片描述
    在这里插入图片描述

    常见的复位方式

    为什么大多数电路上的复位信号都是低电平有效?

    这是为了统一电路处理,使得上电复位过程和按键复位过程处理电路一致。一个板子在没有上电时候,各个管脚的信号可以认为是低电平的。并且电路上电和按键被按下时刻,数字电路的行为应该是一样的。而上电时刻,复位信号接一个高电平的模拟延时电路,从而保证时钟比复位信号早到(此时复位信号是低电平),如此芯片在工作开始前就复位了。

    我们习惯上通常使用的复位有三种方式:

    硬件开关:复位信号接一个拨码开关或按键,或者RC电路

    电源芯片:上电时候电源芯片产生,可以长时间维持,直到稳定。

    控制芯片:控制芯片产生复位脉冲。

    展开全文
  • 异步编程

    2020-03-24 22:21:32
    同步方法 程序运行的时候,在调用其他方法的时候,会等待被调用...在程序调用异步方法的时候,主程序不会等待方法执行完,而是主程序调用异步方法后直接继续运行,而异步方法会启动一个新线程来完成方法的计算。(异...

    同步方法

    程序运行的时候,在调用其他方法的时候,会等待被调用的方法按顺序执行完,才会继续执行。非常符合开发思维,有序执行(这个意思是干啥都是一起干(不管多少程序)等最慢的或者最长的完成之后才可以统一完成(铁哥们)(括号内自我理解如果不对就别当回事))
    异步方法

    在程序调用异步方法的时候,主程序不会等待方法执行完,而是主程序调用异步方法后直接继续运行,而异步方法会启动一个新线程来完成方法的计算。(异步相等于VIP干啥都是有特殊通道(括号内自我理解如果不对就别当回事))

    异步编程

    委托的异步调用

    1. 先根据比较耗时的功能方法声明对应的委托
    2. 给委托赋值,赋与这个耗时的功能函数
    3. 采用委托的BeginInvoke方法进行异步调用委托
      Invoke方法:类似于默认的方法调用,相当于直接使用()调用委托
      BeginInvoke方法:指采取异步调用委托
    4. 给BeginInvoke方法创建回调函数
      回调函数:回调函数是指,当前的正在执行的操作完成之后,立刻回调用的一个函数是回调函数
      BeginInvoke方法参数组成:
      1. 第一组参数:委托所指向的方法对应的参数
      2. AsyncCallback参数:与当前委托对应的回调函数
      3. object参数:假如回调函数需要参数则由object参数提供
        BeginInvoke方法返回值为IAsyncResult,而委托的回调函数必须有一个参数为IAsyncResult类型
    5. 通过EndInvoke获取对应委托的BeginInvoke的执行结果
    6. 因为BeginInvoke相当于重新创建的线程进行异步调用方法函数,所以回调函数也是异步的线程的执行的,那么异步线程和程序主线程相当于阳关道和独木桥,
      因此如果使用Winform或WPF中的控件要考虑清楚:UI中的控件等都是Winform或WPF主线程中创建的,而异步线程无法直接使用
      设置CheckForIllegalCrossThreadCalls =false,这个属性是用来设置Winform或者WPF中的主线程不在做控件的跨线程检测
    public partial class Form1 : Form
        {
            public Form1()
            {
                InitializeComponent();
            }
            private void button1_Click_1(object sender, EventArgs e)
            {
                int a = 0;
                //多线程编程
                //委托:ParameterizedThreadStart
                Thread objThread1 = new Thread(() =>
                 {
                     for (int i = 0; i < 10; i++)
                     {
                         a += i;
                         //当 一个控件的InvokeRequired属性值为真时,说明有一个创建它以外的线程想访问它,此时它将会在内部调用new MethodInvoker(LoadGlobalImage)来完成下面的步骤,
                         if (label1.InvokeRequired)
                         {
                             //Invoke方法:类似于默认的方法调用,相当于直接使用()调用委托
                             label1.Invoke(new Action<string>(s =>
                             {
                                 label1.Text = $"【{s}】";
                             }), a.ToString());
                         }
                         Thread.Sleep(500);
                     }
                 });
                objThread1.IsBackground = true;//设置为后台线程
                objThread1.Start();//启动任务,将其调度到当前任务调度程序执行。
            }
    
            private void button2_Click(object sender, EventArgs e)
            {
                int a = 0;
                Thread objThread02 = new Thread(() =>
                {
                    for (int i = 0; i < 100; i++)
                    {
                        a += i;
                        if (label2.InvokeRequired)
                        {
                            label2.Invoke(new Action<int>(s =>
                            {
                                label2.Text = $"【{s}】";
                            }), a);
                            Thread.Sleep(200);
                        }
                    }
                });
                objThread02.IsBackground = true;
                objThread02.Start();
            }
        }
    

    异步编程总结

    1. 异步编程是建立在委托基础上的一种编程方法
    2. 异步调用的每个方法都是独立的线程执行。因此。本质上就是一种多线程程序,也可以说是一种简化版本的多线程技术
    3. 比较适合在后台运行较为耗时的简单任务,并且任务要求相互独立,任务中不应该有代码直接访问可视化控件
    4. 如果后台任务要求必须按照特定顺序执行,或者必须访问公共资源,则异步编程不适合,而直接使用多线程技术

    多线程的异步

    public partial class Form1 : Form
        {
            public Form1()
            {
                InitializeComponent();
            }
            private void button1_Click_1(object sender, EventArgs e)
            {
                int a = 0;
                //多线程编程
                //委托:ParameterizedThreadStart
                Thread objThread1 = new Thread(() =>
                 {
                     for (int i = 0; i < 10; i++)
                     {
                         a += i;
                         //当 一个控件的InvokeRequired属性值为真时,说明有一个创建它以外的线程想访问它,此时它将会在内部调用new MethodInvoker(LoadGlobalImage)来完成下面的步骤,
                         if (label1.InvokeRequired)
                         {
                             //Invoke方法:类似于默认的方法调用,相当于直接使用()调用委托
                             label1.Invoke(new Action<string>(s =>
                             {
                                 label1.Text = $"【{s}】";
                             }), a.ToString());
                         }
                         Thread.Sleep(500);
                     }
                 });
                objThread1.IsBackground = true;//设置为后台线程
                objThread1.Start();//启动任务,将其调度到当前任务调度程序执行。
            }
    
            private void button2_Click(object sender, EventArgs e)
            {
                int a = 0;
                Thread objThread02 = new Thread(() =>
                {
                    for (int i = 0; i < 100; i++)
                    {
                        a += i;
                        if (label2.InvokeRequired)
                        {
                            label2.Invoke(new Action<int>(s =>
                            {
                                label2.Text = $"【{s}】";
                            }), a);
                            Thread.Sleep(200);
                        }
                    }
                });
                objThread02.IsBackground = true;
                objThread02.Start();
            }
        }
    

    后台线程

    指的是程序中的一些功能不需要和一般线程同时执行,或者这些功能对于UI界面中显示方面要求不高,可以设置为后台线程

    例如:VS工具中的,编译检测功能就是后台线程,当VS启动起来,除过前台线程给我们展示编辑菜单等界面,同时后台运行了检测程序
    句柄(Handle)

    句柄是一个标识符,用于代表操作系统中的各种资源,比如各种窗体、GDI绘图对象、进程和线程对象、文件等都用句柄

    句柄使用

    1. 即使进程退出,很多时候操作系统仍然保持进程句柄,操作系统句柄有限,使用用需要节省,比如打开文件后,使用完毕要及时关闭
    2. 句柄可以通过Process对象的Handle属性访问,比如进程退出的代码,时间等

    总结:拥有图形界面的程序都有一个主窗体,这个窗体也对应有一个句柄。当窗体关闭时进程也关闭。主窗体一般由主线程负责创建

    展开全文
  • 五花八门的日志框架 门面 slf4j common-log 实现 jul log4j logback 等 ...接器实现原理- 已上面jar包为例,接器重写了log4j,类名功能都一样,但是实现了slf接口。引入接器 排除实现 完美替代log4j的类。 ...
  • 谈谈异步编程

    2014-12-03 17:26:16
    目前需求中涉及到大量的异步操作,实际的页面越来越倾向于单页面应用。以后可以会使用backbone、angular、knockout等框架,但是关于异步编程的问题是首先需要面对的问题。随着node的兴起,异步编程成为一个非常热的...
  • 完整英文电子版 IEEE Std 802.1Qcr-2020 Local and Metropolitan Area Networks—Bridges and Bridged Networks Amendment 34:Asynchronous Traffic Shaping(本地和城域网--和桥接网络--修正案34:异步流量整形...
  • 异步编程 多线程编程 异步编程101 自上而下的C#异步编程介绍 从Redwood City到旧金山的渡轮看到的海上船只,2018年7月 在此博客文章中,我将自上而下地介绍C#中的异步编程。 这篇文章对C#的新手和对线程...
  • 在分析煤矿三相异步电机数学模型的基础上,设计了煤矿三相异步电机式驱动电路、IGBT驱动保护电路,并制作IGBT驱动板,进行试验测试。根据实验数据可知:所设计的电路能够按照控制信号规律驱动IGBT通断,具有结构简单、...
  • JS 异步编程

    2020-05-12 13:44:12
    教程简介 作者: TigerChain ...本文出自 TigerChain 简书 手把手教 Vue 系列 本节大纲 ...js 是一门单线程、非阻塞、异步、并发语言。...一、同步和异步 ...同步指的是任务是一个接一个的去完成...异步是一个相对概念,多线程.
  • JS异步编程

    千次阅读 2015-09-09 11:51:53
    谈谈异步编程  目前需求中涉及到大量的异步操作,实际的页面越来越倾向于单页面应用。以后可以会使用backbone、angular、knockout等框架,但是关于异步编程的问题是首先需要面对的问题。随着node的兴起,异步...
  • C#异步编程简介

    2021-02-01 22:43:37
    在 C# 5.0 中新增了两个关键字 await 和 async 来简化异步编程,实际上异步编程本身早在 .NET Framework 1.0 中就存在了,而在 .NET Framework 4.5 中,新增了一种基于任务的异步编程模式。大体来说,异步编程可以...
  • socket 同步异步

    2018-07-24 00:31:41
      MFC对SOCKET编程的支持其实是很充分的,然而其文档是语焉不详的。以至于大多数用VC编写的功能稍 复杂的网络程序,还是使用API的。故CAsyncSocket及CSocket事实上成为疑难,群众多敬而远之。...另外,异步非阻...
  • 现代的跨平台JavaScript,通过它,您可以在JavaScript和本机应用程序之间同步或异步调用彼此的功能。 DSBridge-Android: : 注意 DSBridge v3.0是一个里程碑版本。 与v2.0相比,我们进行了很多更改。 请注意,v...
  • 异步处理 委托异步 多线程异步

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,915
精华内容 10,766
关键字:

异步桥