计数器 订阅
计数是一种最简单基本的运算。计数器就是实现这种运算的逻辑电路,计数器在数字系统中主要是对脉冲的个数进行计数,以实现测量、计数和控制的功能,同时兼有分频功能,计数器是由基本的计数单元和一些控制门所组成,计数单元则由一系列具有存储信息功能的各类触发器构成,这些触发器有RS触发器、T触发器、D触发器及JK触发器等。计数器在数字系统中应用广泛,如在电子计算机的控制器中对指令地址进行计数,以便顺序取出下一条指令,在运算器中作乘法、除法运算时记下加法、减法次数,又如在数字仪器中对脉冲的计数等等。计数器可以用来显示产品的工作状态,一般来说主要是用来表示产品已经完成了多少份的折页配页工作。它主要的指标在于计数器的位数,常见的有3位和4位的。很显然,3位数的计数器最大可以显示到999,4位数的最大可以显示到9999。 展开全文
计数是一种最简单基本的运算。计数器就是实现这种运算的逻辑电路,计数器在数字系统中主要是对脉冲的个数进行计数,以实现测量、计数和控制的功能,同时兼有分频功能,计数器是由基本的计数单元和一些控制门所组成,计数单元则由一系列具有存储信息功能的各类触发器构成,这些触发器有RS触发器、T触发器、D触发器及JK触发器等。计数器在数字系统中应用广泛,如在电子计算机的控制器中对指令地址进行计数,以便顺序取出下一条指令,在运算器中作乘法、除法运算时记下加法、减法次数,又如在数字仪器中对脉冲的计数等等。计数器可以用来显示产品的工作状态,一般来说主要是用来表示产品已经完成了多少份的折页配页工作。它主要的指标在于计数器的位数,常见的有3位和4位的。很显然,3位数的计数器最大可以显示到999,4位数的最大可以显示到9999。
信息
指    标
计数器的位数
组    成
基本的计数单元和一些控制门
分    类
同步计数器和异步计数器
释    义
运算的逻辑电路
中文名
计数器
功    能
测量、计数和控制
计数器基本信息
狭义的计数器是指一些常用计时器,例如体育比赛中测试时间的计时器等,但本词条所要介绍的并不是这种计时器,要介绍的是应用更为广泛的时序逻辑电路中的计数器。
收起全文
精华内容
下载资源
问答
  • 计数器

    千次阅读 2020-05-05 18:10:56
    同步计数器 】 同步二进制计数器 同步二进制加法计数器 原理 4位二进制同步加法计数器 方程 状态转换表 ( 利用第16个计数脉冲到达时C端电位的下降沿可作为向高位计数器电路进位的输出信号 ) ...

    • 计数器的容量(计数器的模):时序中实际的状态个数。=2n
    • n位二进制计数器中能计到的最大数=2n-1

    【 1. 同步计数器 】

    ① 同步二进制计数器

    同步二进制加法计数器

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

    4位二进制同步加法计数器
    在这里插入图片描述

    方程
    在这里插入图片描述

    状态转换表
    ( 利用第16个计数脉冲到达时C端电位的下降沿可作为向高位计数器电路进位的输出信号 )
    在这里插入图片描述在这里插入图片描述

    状态转换图
    每输入16个脉冲,触发器状态循环一次,并且输出端C产生一个进位信号,故为16进制计数器
    在这里插入图片描述

    时序图
    从时序图中可以看出,若计数输入脉冲的频率为f0,则Q0、Q1、Q2、Q3输出端脉冲的频率将依次为12f 0 \frac{1}{2}f~0~14f 0 \frac{1}{4}f~0~18f 0 \frac{1}{8}f~0~116f 0 \frac{1}{16}f~0~
    分频功能。
    在这里插入图片描述

    74161 十六进制四位二进制加法计数器

    具有加法计数、同步预置数、异步置0、保持功能。

    在这里插入图片描述

    LD’ 预置数控制端
    D0 ~ D3 数据输入端
    C 进位输出端
    RD’ 异步置零(复位)端
    EP、ET 工作状态控制端

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

    74163

    具有同步清零、同步并行预置数、计数、保持功能。

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

    同步二进制减法计数器

    原理
    在这里插入图片描述

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

    同步二进制加/减计数器

    单时钟方式 74191

    74LS191功能:异步置数、保持、加/减计数
    在这里插入图片描述

    单时钟定义
    由加/减控制电平的高低来决定加计数还是减计数
    在这里插入图片描述

    逻辑图
    采用T触发器
    在这里插入图片描述

    方程
    在这里插入图片描述

    功能表
    在这里插入图片描述

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

    双时钟方式 74193

    74LS193功能:异步置零、异步置数、保持、加/减计数
    在这里插入图片描述

    逻辑图
    采用 T’ 触发器( 即T触发器的T=1)
    在这里插入图片描述

    方程
    在这里插入图片描述

    功能表
    在这里插入图片描述

    ② 同步十进制计数器

    同步十进制加法计数器

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

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

    驱动方程
    在这里插入图片描述
    状态方程
    在这里插入图片描述

    状态转换表
    在这里插入图片描述

    状态转换图(可自启动)
    在这里插入图片描述

    74160

    在这里插入图片描述

    74162

    在这里插入图片描述

    同步十进制减法计数器

    原理
    在这里插入图片描述

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

    驱动方程
    在这里插入图片描述
    状态方程
    在这里插入图片描述

    状态转换表
    在这里插入图片描述

    状态转换图
    在这里插入图片描述

    同步十进制加减计数器

    单时钟类型:74LS190、74LS168、CC4510
    双时钟类型:74LS192、CC40192

    【 2. 异步计数器 】

    ① 异步二进制计数器

    异步二进制加法计数器

    在这里插入图片描述

    异步二进制减法计数器

    在这里插入图片描述

    ② 异步十进制计数器

    异步十进制加法计数器

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

    【 3. N进制计数器→M进制计数器 】

    在这里插入图片描述

    ① N>M

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

    异步置零
    如图6.3.30(a)虚线
    从S0计数到SM时立即又异步 (时间极短) 被置成S0,故SM状态不稳定(稳定状态循环中不包括这个状态)。在这里插入图片描述在这里插入图片描述
    同步置零
    如图6.3.30(a)实线
    从S0计数到SM-1时同步(等到下个时钟) 被置成S0(稳定状态循环中包括这个状态)。在这里插入图片描述

    异步置数
    如图6.3.30(b)虚线
    从S0计数到Si+1时异步(时间极短) 被置成Sj(其中快进了N-M个状态),再计数到S0。故Si+1状态不稳定(稳定状态循环中不包括这个状态)。
    .
    同步置数
    如图6.3.30(b)实线
    从S0计数到Si时同步(等到下个时钟) 被置成Sj(其中快进了N-M个状态),再计数到S0。Si状态不稳定(稳定状态循环中包括这个状态)
    在这里插入图片描述在这里插入图片描述

    异步置零

    在这里插入图片描述

    同步置零

    在这里插入图片描述

    同步置数

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

    ② N<M

    在这里插入图片描述

    M=N1xN2

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

    在这里插入图片描述

    M<NxN

    在这里插入图片描述

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

    【 4. 移位寄存器型计数器 】

    ① 环形计数器

    在这里插入图片描述

    ② 扭环形计数器

    在这里插入图片描述

    【 5. 计数器应用 】

    ① 顺序节拍脉冲发生器

    74LS138译码器的 S1、S2、S3可视为总开关,当三者同时有效时,方可正常工作,否则其8个输出端均为1。
    在这里插入图片描述

    ② 序列脉冲发生器

    74LS152为8选1数据选择器在这里插入图片描述在这里插入图片描述

    展开全文
  • 计数器计数器计数器计数器计数器计数器计数器计数器计数器计数器计数器计数器计数器计数器计数器计数器计数器计数器计数器计数器计数器计数器计数器计数器
  • 日期计数器日期日期计数器计数器日期计数器日期计数器日期计数器
  • 可编程定时器/计数器8254的简单使用,在屏幕上输出当前计数值,然后输出两个频率不同的方波信号。

    一、实验目的

    掌握8254的基本工作原理和编程方法,用示波器观察不同方式下的波形。(说明:没有示波器,所以用LED灯的闪烁来观察)

    二、实验原理和内容

    在这里插入图片描述

    三、编程提示

    在这里插入图片描述

    四、电路接线图

    实验1:
    在这里插入图片描述
    实验2:
    在这里插入图片描述

    五、程序设计流程图

    实验1:
    在这里插入图片描述
    实验2:
    在这里插入图片描述

    六、一些说明

    1. 实验1中,每次读取后简单判断一下是不是跟上次一样,因为可能本次读取时计数器还没有减1。
    2. 实验2中,由于要输出两个不同的频率方波,并且要使LED灯来得及闪烁,所以需要用到三个计数器。

    七、程序源代码

    实验1:

    stack segment stack
        db 200 dup(0)
    stack ends
    
    data segment
          ZERO equ 280h
          ONE equ 281h
          CTRL equ 283h
    data ends
    
    code segment
          assume cs:code,ds:data,ss:stack
    
          newline MACRO   ;回车换行
            push ax
            push dx
            mov ah,02h
            mov dl,0ah
            int 21h
            mov ah,02h
            mov dl,0dh
            int 21h
            pop dx
            pop ax
          ENDM
    
          dispchar MACRO x    ;输出单个字符并换行
            push dx
            push ax
            newline
            mov ah,02h
            mov dl,x
            int 21h
            pop ax
            pop dx
          ENDM
    
          put_data MACRO x, y  ;x为端口,y为数据
            push ax
            push dx
            mov al, y
            mov dx, x
            out dx, al
            pop dx
            pop ax
          ENDM
    
       main:mov ax,data
            mov ds,ax
            mov ax, stack
            mov ss, ax
            put_data CTRL, 00010000b  ;计数器0工作在方式0下,只读写低8位,二进制计数码
            put_data ZERO, 0fh   ;写入计数器初值15,开始计数
      again:mov dx, ZERO
            in al, dx   ;读取通道0数据
            and al, 0fh;  读取低四位
            mov dl, al
            cmp bl, dl
            jz again   ;本次读出的数值与上次一样,说明还没有手动输入脉冲,继续读取,直到本次读取 的数据与上次不一样
            mov bl, dl  ;本次与上次不一样
            cmp dl, 9  ;判断是否小于9
            ja disp_
            add dl, 30h
            dispchar dl   ;显示0-9的一个数
            jmp again
      disp_:add dl, 37h
            dispchar dl    ;显示A-F中的一个数
            jmp again
            mov ah,4ch
            int 21h
    code ends
         end main
    

    实验2:

    stack segment stack
        db 200 dup(0)
    stack ends
    
    data segment
          ZERO equ 280h
          ONE equ 281h
          TWO equ 282h
          CTRL equ 283h
          
    data ends
    
    code segment
          assume cs:code,ds:data,ss:stack
          
          put_data MACRO x, y  ;x为端口 y为数据
            push ax
            push dx
            mov al, y
            mov dx, x
            out dx, al
            pop dx
            pop ax
          ENDM
    
    ;分析:连接时钟频率为1MHz,周期为1us,要求输出的1Hz的信号周期为1,分频系数为1e6,but8254最大计数为65536
    ;又因为1e6 = 1000 * 1000,所以通道0和通道1分别把信号1000分频即可
    
       main:mov ax,data
            mov ds,ax
            mov ax, stack
            mov ss, ax
            put_data CTRL, 00110111b  ;计数器0工作在方式3,读写16,BCD计数码
            put_data ZERO, 00   ;写入计数器初值1000
            put_data ZERO, 10h  ;先写低8位再写高80001 0000 0000 0000
            put_data CTRL, 01110110b  ;计数器1工作在方式3,读写16,二进制数码
            put_data ONE, 0e8h
            put_data ONE, 03h   ;写入计数器初值1000,开始计数,out0端为高电平,接LED灯,LED灯亮
            put_data CTRL 10110111b    ;计数器2工作在方式3下,读写16位,BCD计数码
            put_data TWO 02      ;写入计数初值2,输出两个端口,out1端口输出频率是out2端口2倍
            put_data TWO 00h
            mov ah, 4ch
            int 21h
    code ends
         end main
    
    展开全文
  • CSS 计数器

    2020-12-13 20:51:06
    CSS 计数器 CSS 计数器通过一个变量来设置,根据规则递增变量。 使用计数器自动编号 CSS 计数器根据规则来递增变量。 CSS 计数器使用到以下几个属性: counter-reset – 创建或者重置计数器 counter-increment – ...
  • 基于fpga,使用vhdl语言编写的6进制计数器。输入时钟为1hz
  • 约翰逊计数器

    2018-04-09 16:27:23
    约翰逊计数器 FPGA 约翰逊计数器 FPGA 约翰逊计数器 FPGA
  • 功能强大的鼠标键盘计数器,可以统计所有键盘及鼠标的点击次数。
  • 计数器
  • verilog计数器

    2020-04-15 22:05:31
    256位计数器,题目:设计一个 8位计数器,包含清零信号 clear,复位信号 rst,预加载值 preload。 解答: 本次设置的 preload=32。理论上最大计数值为 256。模块名称为 counter。
  • 计数器是一种重要的时序逻辑电路,广泛应用于各类数字系统中。介绍以集成计数器74LS161和74LS160为基础,用归零法设计N进制计数器的原理与步骤。用此方法设计了3种36进制计数器,并用Multisim10软件进行仿真。计算机...
  • counter计数器

    万次阅读 2019-12-02 18:16:46
    一、为什么要做计数器: 在唯品会的工作的时候,为了更好的推动系统向智慧供应链发展,理性分析供应商和商助对产品的使用频率,于是,开发了一款轻量级计数器,供各团队使用。 二、难点: 1、数据量大 2、各团队...

    一、为什么要做计数器:

    在唯品会的工作的时候,为了更好的推动系统向智慧供应链发展,理性分析供应商和商助对产品的使用频率,追溯服务历史调用情况,于是,开发了一款轻量级计数器,供各团队使用。

    二、难点:

    1、调用量大

    2、各团队需要保证极端情况下,计数器服务不可用时,不影响各团队业务正常运行

    3、需要使用简单

    4、个别需要统一业务日志

    5、不能有额外的定时器一直轮询

    三、优势:

    1、简单   @LogCounter  对应的类或者方法上 即可开启计数器功能

    2、可配置    日志记录可选择开启和关闭、可选择记录到本地、可选择记录到远程服务器

    3、统一日志  开启日志功能后,即可对方法的入参和出参进行记录

    4、采用了线程池隔离

    5、设计了漏斗策略

    四、代码:

          https://gitee.com/sunrisexq/counter

          

    package com.javaxiaobang.counter.aspect.log;
    
    import java.lang.annotation.Documented;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    /**
     * 功    能:日志注解标签
     * 作    者:java潇邦
     * 时    间:2018-05-19
     */
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    @Documented
    public @interface LogCounter {
    
        String counterName() default "";//计数器名称
    
        boolean useLogFile() default true;//true时记录log日志
    
        boolean useRemote() default true;//true时记录counter
    
        boolean useLocal() default false;//true时开启本地counter
    
    }
    
    package com.javaxiaobang.counter.aspect.log;
    
    import com.alibaba.fastjson.JSON;
    import com.javaxiaobang.counter.exception.CounterException;
    import org.apache.commons.lang3.StringUtils;
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.Signature;
    import org.aspectj.lang.annotation.AfterReturning;
    import org.aspectj.lang.annotation.AfterThrowing;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
    import org.aspectj.lang.reflect.MethodSignature;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.core.annotation.Order;
    import org.springframework.stereotype.Component;
    
    import java.lang.reflect.Method;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    /**
     * 功    能:日志AOP
     * 作    者:java潇邦
     * 时    间:2018-05-19
     */
    @Order
    @Aspect
    @Component("commonLogCounterAop")
    public class LogCounterAop {
    
        private final Logger logger = LoggerFactory.getLogger(this.getClass());
    
        private static ExecutorService pool = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
    
        @Autowired
        private LogCounterLocalBusiness logCounterLocalBusiness;
        @Autowired
        private LogCounterRemoteBusiness logCounterRemoteBusiness;
    
        //切入点
        @Pointcut("@annotation(com.javaxiaobang.counter.aspect.log.LogCounter)")
        public void anyMethod() {
        }
    
        //方法执行之前
        @Before("anyMethod()")
        public void before(final JoinPoint joinPoint) {
            try {
                Signature signature = joinPoint.getSignature();
                MethodSignature methodSignature = (MethodSignature) signature;
                Method method = methodSignature.getMethod();
                if (method != null && method.isAnnotationPresent(LogCounter.class)) {
                    String methodName = method.getName();
                    final LogCounter aspect = method.getAnnotation(LogCounter.class);
                    if (aspect.useLogFile()) {
                        logger.info("{}{}方法的参数值:{}", aspect.counterName(), methodName, JSON.toJSONString(joinPoint.getArgs()));
                    }
                    final String counterName = StringUtils.isBlank(aspect.counterName()) ? methodName : aspect.counterName();
                    if (aspect.useLocal()) {
                        pool.submit(new Runnable() {
                            @Override
                            public void run() {
                                logCounterLocalBusiness.execute(counterName);
                            }
                        });
                    }
                    if (aspect.useRemote()) {
                        pool.submit(new Runnable() {
                            @Override
                            public void run() {
                                logCounterRemoteBusiness.execute(counterName);
                            }
                        });
                    }
                }
            } catch (Exception e) {
                logger.debug("before切面异常:", e);
            }
        }
    
        //方法执行之后
        @AfterReturning(pointcut = "anyMethod()", returning = "retVal")
        public void after(JoinPoint joinPoint, Object retVal) {
            try {
                Signature signature = joinPoint.getSignature();
                MethodSignature methodSignature = (MethodSignature) signature;
                Method method = methodSignature.getMethod();
                if (method != null) {
                    String methodName = method.getName();
                    LogCounter aspect = method.getAnnotation(LogCounter.class);
                    if (aspect != null && aspect.useLogFile()) {
                        logger.info("{}{}方法的返回值:{}", aspect.counterName(), methodName, JSON.toJSONString(retVal));
                    }
                }
            } catch (Exception e) {
                logger.debug("after切面异常:", e);
            }
        }
    
        //方法执行之后异常日志
        @AfterThrowing(pointcut = "anyMethod()", throwing = "e")
        public void afterThrowing(JoinPoint joinPoint, Throwable e) throws CounterException {
            //不需要再记录ServiceException,因为在service异常切面中已经记录过
            if (e instanceof CounterException) {
                throw (CounterException) e;
            } else {
                Signature signature = joinPoint.getSignature();
                MethodSignature methodSignature = (MethodSignature) signature;
                Method method = methodSignature.getMethod();
                if (method != null) {
                    String methodName = method.getName();
                    LogCounter aspect = method.getAnnotation(LogCounter.class);
                    logger.warn("{}{}方法异常:", aspect.counterName(), methodName, e);
                    throw new CounterException();
                }
            }
        }
    
    
    }
    
    package com.javaxiaobang.counter.aspect.log;
    
    import com.javaxiaobang.counter.util.LogCounterUtil;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.stereotype.Component;
    
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.atomic.AtomicLong;
    import java.util.concurrent.locks.ReentrantLock;
    
    /**
     * 功    能:远程计数器-调用远程服务保存数据
     * 作    者:java潇邦
     * 时    间:2018-05-19
     */
    @Component("logCounterRemoteBusiness")
    public class LogCounterRemoteBusiness {
    
        private final Logger logger = LoggerFactory.getLogger(this.getClass());
    
        private static ReentrantLock lock = new ReentrantLock();
    
        private static String domain = LogCounterUtil.getDomain();
    
        private static long tryLockTime = 2;//尝试2秒获取锁的时间
    
        private static long refreshTime = 30000L;//30秒刷新一次
    
        private static ConcurrentHashMap<String, AtomicLong> countMap = new ConcurrentHashMap<String, AtomicLong>(32);//并发计数
    
        private static ConcurrentHashMap<String, Long> timeMap = new ConcurrentHashMap<String, Long>(32);//并发计时
    
        private static long detailRefreshTime = 10 * 60 * 1000L;//默认10分钟刷新数据
    
        private static ConcurrentHashMap<String, AtomicLong> detailCountMap = new ConcurrentHashMap<String, AtomicLong>(32);//并发计数
    
        private static ConcurrentHashMap<String, Long> detailTimeMap = new ConcurrentHashMap<String, Long>(32);//并发计时
    
    //    private CounterServiceHelper.CounterServiceClient client = new CounterServiceHelper.CounterServiceClient();//唯品会counter服务-对应两张表
    
        /**
         * 计数器逻辑处理
         */
        public void execute(String counterName) {
            commonMethod("total", counterName, refreshTime, countMap, timeMap);//计数器头表
            commonMethod("detail", counterName, detailRefreshTime, detailCountMap, detailTimeMap);//计数器明细表
        }
    
        private void commonMethod(String type, String counterName, long refreshTime, ConcurrentHashMap<String, AtomicLong> countMap, ConcurrentHashMap<String, Long> timeMap) {
            try {
                String key = counterName + domain;//唯一key
                AtomicLong atomicLong = countMap.get(key);
                if (null == atomicLong) {//原子计数器
                    synchronized (lock) {//并发控制
                        atomicLong = countMap.get(key);
                        if (null == atomicLong) {
                            countMap.put(key, new AtomicLong(1));
                            timeMap.put(key, System.currentTimeMillis());
                            return;
                        }
                    }
                }
                atomicLong.incrementAndGet();//原子计数器加1
    
                boolean flag = (System.currentTimeMillis() - timeMap.get(key) > refreshTime) && (atomicLong.get() > 0);//超过N秒 并且 次数大于0
                if (flag) {//满足条件的漏斗
                    if (lock.tryLock(tryLockTime, TimeUnit.SECONDS)) {
                        try {
                            flag = (System.currentTimeMillis() - timeMap.get(key) > refreshTime) && (atomicLong.get() > 0);//避免错误更新
                            if (flag) {
                                long counter = countMap.get(key).get();
                                timeMap.put(key, System.currentTimeMillis());//重新计时
                                atomicLong.set(0);
                                countMap.put(key, atomicLong);//重新计数
                                if ("detail".equals(type)) {
                                    incrementDetailCounter(counterName, domain, counter, refreshTime);
                                } else {
                                    incrementCounter(counterName, domain, counter);
                                }
                            }
                        } finally {
                            lock.unlock();
                        }
                    } else {
                        logger.warn("2秒内没有获取到锁则放弃,下次再调用远程保存数据的服务:{}", key);
                    }
                }
            } catch (Exception e) {
                logger.debug("remote计数器异常:", e);
            }
        }
    
        /**
         * 保存到counter_info头表
         */
        public void incrementCounter(String counterName, String domain, long counter) {
            //调用远程方法
    //        try {
    //            CounterInfo counterInfo = new CounterInfo();
    //            counterInfo.setCounterName(counterName);
    //            counterInfo.setDomain(domain);
    //            counterInfo.setCounter(counter);
    //            client.incrementCounter(counterInfo);
    //        } catch (Exception e) {
    //            logger.debug("incrementCounter:", e);
    //        }
        }
    
        /**
         * 保存到counter_detail明细表
         */
        public void incrementDetailCounter(String counterName, String domain, long counter, long interval) {
            //调用远程方法
    //        try {
    //            CounterInfo counterInfo = new CounterInfo();
    //            counterInfo.setCounterName(counterName);
    //            counterInfo.setDomain(domain);
    //            counterInfo.setCounter(counter);
    //            counterInfo.setInterval(interval);
    //            client.incrementDetailCounter(counterInfo);
    //        } catch (Exception e) {
    //            logger.debug("incrementDetailCounter:", e);
    //        }
        }
    
        public static long getRefreshTime() {
            return refreshTime;
        }
    
        public static void setRefreshTime(long refreshTime) {
            LogCounterRemoteBusiness.refreshTime = refreshTime;
        }
    
        public static long getDetailRefreshTime() {
            return detailRefreshTime;
        }
    
        public static void setDetailRefreshTime(long detailRefreshTime) {
            LogCounterRemoteBusiness.detailRefreshTime = detailRefreshTime;
        }
    
        public static void setDomain(String domain) {
            LogCounterRemoteBusiness.domain = domain;
        }
    
        public static String getDomain() {
            return domain;
        }
    
    
    }
    
    package com.javaxiaobang.counter.aspect.log;
    
    import com.javaxiaobang.counter.aspect.delay.LogCounterDelayInterface;
    import com.javaxiaobang.counter.util.LogCounterUtil;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.atomic.AtomicLong;
    import java.util.concurrent.locks.ReentrantLock;
    
    /**
     * 功    能:本地计数器-实现LogCounterDelayInterface接口-保存到本地数据库
     * 作    者:java潇邦
     * 时    间:2018-05-19
     */
    @Component("logCounterLocalBusiness")
    public class LogCounterLocalBusiness {
    
        private final Logger logger = LoggerFactory.getLogger(this.getClass());
    
        private static ReentrantLock lock = new ReentrantLock();
    
        private static String domain = LogCounterUtil.getDomain();
    
        private static long tryLockTime = 2;//尝试2秒获取锁的时间
    
        private static long refreshTime = 30000L;//30秒刷新一次
    
        private static ConcurrentHashMap<String, AtomicLong> countMap = new ConcurrentHashMap<String, AtomicLong>(32);//并发计数
    
        private static ConcurrentHashMap<String, Long> timeMap = new ConcurrentHashMap<String, Long>(32);//并发计时
    
        private static long detailRefreshTime = 10 * 60 * 1000L;//默认10分钟刷新数据
    
        private static ConcurrentHashMap<String, AtomicLong> detailCountMap = new ConcurrentHashMap<String, AtomicLong>(32);//并发计数
    
        private static ConcurrentHashMap<String, Long> detailTimeMap = new ConcurrentHashMap<String, Long>(32);//并发计时
    
        //懒加载
        @Autowired(required = false)
        private LogCounterDelayInterface logCounterDelayInterface;
    
        /**
         * 计数器逻辑处理
         */
        public void execute(String counterName) {
            commonMethod("total", counterName, refreshTime, countMap, timeMap);
            commonMethod("detail", counterName, detailRefreshTime, detailCountMap, detailTimeMap);
        }
    
        private void commonMethod(String type, String counterName, long refreshTime, ConcurrentHashMap<String, AtomicLong> countMap, ConcurrentHashMap<String, Long> timeMap) {
            try {
                String key = counterName + domain;//唯一key
                AtomicLong atomicLong = countMap.get(key);
                if (null == atomicLong) {//原子计数器
                    synchronized (lock) {//并发控制
                        atomicLong = countMap.get(key);
                        if (null == atomicLong) {
                            countMap.put(key, new AtomicLong(1));
                            timeMap.put(key, System.currentTimeMillis());
                            return;
                        }
                    }
                }
                atomicLong.incrementAndGet();//原子计数器加1
    
                boolean flag = (System.currentTimeMillis() - timeMap.get(key) > refreshTime) && (atomicLong.get() > 0);//超过N秒 并且 次数大于0
                if (flag) {//满足条件的漏斗
                    if (lock.tryLock(tryLockTime, TimeUnit.SECONDS)) {
                        try {
                            flag = (System.currentTimeMillis() - timeMap.get(key) > refreshTime) && (atomicLong.get() > 0);//避免错误更新
                            if (flag) {
                                long counter = countMap.get(key).get();
                                timeMap.put(key, System.currentTimeMillis());//重新计时
                                atomicLong.set(0);
                                countMap.put(key, atomicLong);//重新计数
                                if ("detail".equals(type)) {
                                    logCounterDelayInterface.incrementDetailCounter(counterName, domain, counter, refreshTime);
                                } else {
                                    logCounterDelayInterface.incrementCounter(counterName, domain, counter);
                                }
                            }
                        } finally {
                            lock.unlock();
                        }
                    } else {
                        logger.warn("2秒内没有获取到锁则放弃,下次再调用保存数据的服务:{}", key);
                    }
                }
            } catch (Exception e) {
                logger.info("local计数器异常:", e);
            }
        }
    
        public static void setDomain(String domain) {
            LogCounterLocalBusiness.domain = domain;
        }
    
        public static String getDomain() {
            return domain;
        }
    
        public static long getRefreshTime() {
            return refreshTime;
        }
    
        public static void setRefreshTime(long refreshTime) {
            LogCounterLocalBusiness.refreshTime = refreshTime;
        }
    
        public static long getDetailRefreshTime() {
            return detailRefreshTime;
        }
    
        public static void setDetailRefreshTime(long detailRefreshTime) {
            LogCounterLocalBusiness.detailRefreshTime = detailRefreshTime;
        }
    }
    

     

    展开全文
  • 计数器源码

    2018-06-28 11:38:06
    加法计数器 是随着计数脉冲的不断输入而递增计数的; 减法计数器是随着计数脉冲的不断输入而递 减计数的;可增可减的称可逆计数器
  • 绍了计数器CD40192在这里被接成加计数器的使用方法
  • 主播礼物计数器是一款用于主播礼物计算和比赛计数的辅助工具。这款主播礼物计数器,使用方便,适用于各种媒体主播平台,提供两队数据的增减,同时可以用快捷键进行操作,简单
  • 下面描述的是一个模60计数器,该计数器通过将模10计数器和模6计数器级联的方式构成,每当模10计数器计数到1001时,模6计数器就会计数加1,直至计数到60时,即模6计数器到达0101、模10计数器到达1001时,计数状态又...
  • 二进制计数器 n位的2进制计数器,可以表示2^n个状态 相邻的两组数据会出现两位或两位以上不一样 环形计数器(右移) n位的环形计数器,可以表示n个状态 举例:4位的独热码环形计数器的数据表示(0001 >>...

    二进制计数器

    n位的2进制计数器,可以表示2^n个状态

    相邻的两组数据会出现两位或两位以上不一样

     

    环形计数器(右移)

    n位的环形计数器,可以表示n个状态

    举例:4位的独热码环形计数器的数据表示(0001 >> 0010 >> 0100 >> 1000 >> 0001  ……)

    相邻的两组数据会有两位不一样

     

    Johnson计数器(右移)

    n位的Johnson计数器,可以表示2n个状态

    举例:4位的Johnson计数器的数据表示(1000 >> 1100 >> 1110 >> 1111 >> 0111 >> 0011 >> 0001 >> 0000 >> 1000 ……)

    相邻的两组数据只有一位不一样(我想这正是Johnson计数器存在的意义吧,有点像格雷码),是可靠计数器

    最右位是0,则左移入1;最右位是1,则左移入0

     

     

     

     

    展开全文
  • 新型计数器 新型计数器 51控制 简单经典!!!!
  • 水泥计数器、面粉厂计数器、装车机自动计数器;中盈环球自动计数器
  • 库伯勒 HC77系列计数器-脉冲计数器rar,库伯勒 HC77系列计数器-脉冲计数器
  • JSP计数器 JSP计数器 JSP计数器
  • eda 计数器

    2015-05-15 09:01:29
    eda 9999计数器 用于工厂产品技术,采用160 技术
  • 利用Redis实现高并发计数器

    万次阅读 热门讨论 2018-03-02 22:58:57
    业务需求中经常有需要用到计数器的场景:譬如一个手机号一天限制发送5条短信、一个接口一分钟限制多少请求、一个接口一天限制调用多少次等等。使用Redis的Incr自增命令可以轻松实现以上需求。以一个接口一天限制调用...
  • LR计数器说明.docLR计数器说明.docLR计数器说明.docLR计数器说明.doc

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 437,842
精华内容 175,136
关键字:

计数器