计数器 订阅
计数是一种最简单基本的运算。计数器就是实现这种运算的逻辑电路,计数器在数字系统中主要是对脉冲的个数进行计数,以实现测量、计数和控制的功能,同时兼有分频功能,计数器是由基本的计数单元和一些控制门所组成,计数单元则由一系列具有存储信息功能的各类触发器构成,这些触发器有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数据选择器在这里插入图片描述在这里插入图片描述

    展开全文
  • *CPU时序: 振荡周期:为单片机提供定时信号的振荡源周期(如晶振周期或外加周期)。...工作原理是随机器内部的时钟或者外部脉冲信号对寄存器数据加1,当计数器加到全1时,再加1便会置0溢出,使相应终端...

    *CPU时序:
    振荡周期:为单片机提供定时信号的振荡源周期(如晶振周期或外加周期)。
    状态周期:为两个振荡周期。用S表示(又称S周期或时钟周期)。
    机器周期:为六个状态周期。
    指令周期:完成一条指令所需要的全部时间,以机器周期为单位。
    在51单片机中有两组定时计数器,与CPU相互独立。
    工作原理是随机器内部的时钟或者外部脉冲信号对寄存器数据加1,当计数器加到全1时,再加1便会置0溢出,使相应终端位置1。(使用时,由溢出计时器的值减去计数初值才是加1计数器的计数值,ps:需输入的便是计数初值)。
    *
    相关结构图在文章结尾,请结合查看。

    定时计数器由高八位THx和低八位TLx两个寄存器组成。
    还有TMOD工作方式寄存器。
    TCON控制寄存器,控制T0、T1的启动停止及设置溢出标志。

    TMOD寄存器
    {
    *该寄存器用于控制定时计数器的工作方式。
    前四位为T1方式,后四位为T0方式。(图一)
    GATE是门控位:
    GATE=0时,只需软件将TCON中的TR0/1为高电平,便可启动定时计数器。
    GATE=1时,上述条件满足切同时外部中断引脚INT0/1为高电平,才可启动定时计数器。
    C/T:
    C/T=0为定时模式,C/T=1为计数模式。
    M1和M0:
    工作方式设置位,具体见图二。
    主要使用方式1;方式2一般用于串口通信(精确性)。
    *}
    TCON寄存器(图一)
    该寄存器高四位与控制定时计数器相关。(低四位控制外部中断)

    *TF0/1:
    T1/0溢出请求标志位,溢出置1,发送中断请求,CPU后自动清0,也可软件清0。
    T1/0工作时,CPU可随时查询TF1/0状态(所以T1/0可用作查询测试的标志)。

    TR1/0:
    T1/0运行控制位,置1时,T1/0开始工作;置0时,停止工作。
    *
    定时计数器工作方式
    以工作方式1为例(图三)
    若GATE=0/1,经过(1处)翻转为1/0,再经过或门:为1时,便不受外部中断控制,进入与门,此时便由TR1/0控制;为0时,外部中断控制此处为1或0,再进入下一步,此时便由外部中断和TR1/0控制。
    T1/0启动后,随振荡周期+1,低八位满便向高八位+1,满后溢出置1,TF1/0发送中断请求。
    【计数个数与计数初值关系:X=2(16次方)-N】

    定时器使用
    初始化:
    对TMOD赋值,确定T0/1工作方式。
    计算初值,并写入。
    中断方式,开启EA总中断,开放定时器中断。
    使TR0/1置位,启动定时或计数。
    以下为定时器T0使用方法

    void Timer0Init()
    {
    TMOD =TMOD | 0x01  //或运算           
    TR0 = 1;         //开始计时
    ET0 = 1;             //打开定时器0中断
    EA = 1;               //打开总中断
    TH0 = 0xfc;
    TL0 = 0xfc;        //设置初值,计算方法见文后
    }
    void main()
    {
       Timer0Init();
       //neirong
    }
    void Time0 () interrupt  1
    {
         //neirong
    }
    

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

    在这里插入图片描述

    展开全文
  • 51单片机计数器

    千次阅读 2018-12-20 19:08:52
    T0计数器计数,方式2工作,对p3.4输入单脉冲计数 ORG 0000H AJMP MAIN ORG 000BH AJMP TIME0 ORG 0100H MAIN: MOV IE,#00H MOV TMOD , #06H MOV TH0,#00H MOV TL0,#00H SETB TR0 TIME0: MOV P1,TL0 SJMP TIME0 END ...

    T0计数器计数,方式2工作,对p3.4输入单脉冲计数
    在这里插入图片描述

    ORG 0000H
    AJMP MAIN
    ORG 000BH
    AJMP TIME0

    ORG 0100H
    MAIN:
    MOV IE,#00H
    MOV TMOD , #06H
    MOV TH0,#00H
    MOV TL0,#00H
    SETB TR0
    TIME0:
    MOV P1,TL0
    SJMP TIME0

    END

    展开全文
  • 欧姆龙总和计数器/时间计数器(DIN72×36) H7HPpdf,欧姆龙总和计数器/时间计数器(DIN72×36) H7HP:实现易读取、相当于IP66耐油型的耐水性、耐油性的DIN72×36大小的总和计数器/时间计数器。实现字符高度6位型15mm、8...
  • 对于同步计数器,由于时钟脉冲同时作用于各个触发器,克服了异步触发器所遇到的触发器逐级延迟问题,于是大大提高了计数器工作频率,各级触发器输出相差小,译码时能避免出现尖峰;但是如果同步计数器级数增加,就会...
  • 在安全通信中使用发送序列计数器机制不是由于它本身是安全方法,只有把发送序列计数器和鉴别模式或 组合模式结合起来才有意义,否则攻击者对计数器的任何修改都将难于觉察。  序列计数器的工作原理是每个APDU含有...
  • verilog计数器

    2020-04-15 22:05:31
    256位计数器,题目:设计一个 8位计数器,包含清零信号 clear,复位信号 rst,预加载值 preload。 解答: 本次设置的 preload=32。理论上最大计数值为 256。模块名称为 counter。
  • QT主播专用计数器是一款QT主播非常喜欢的计数器辅助工具,支持自定义皮肤/同礼物数量对战/不同礼物积分对战/辛运大转盘/翻牌时刻/猜拳/掷骰子等互动小游戏!颜值优质,功能强大!
  • 计数器在工业控制中有着广泛的应用。传统的数字计数器都是用中小规模数字集成电路构成的,不但电路复杂,成本高,功能修改也不易。用单片机制作的计数器可以克服传统数字电路计数器的局限,有着广阔的应用前景。 ...
  • TMOD-》定时器/计数器方式控制寄存器TCON-》定时器/计数器控制寄存器SMOD-》串行口波特率系数选择位SCON-》串行口控制寄存器SBUF -》串行口数据缓冲器TH0 -》定时器/计数器0(高字节)TL0 -》定时器/计数器0(低字节...
  • 在数字电路中,把记忆输人脉冲个数的操作称为计数,计数器就是实现计数操作的时序逻辑电路。计数 器应用非常广泛,除用于计数、分频外,还用于数字测量、运算和控制,从小型数字仪表到大型数字电子 计算机,几乎...
  • 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;
        }
    }
    

     

    展开全文
  • 主播礼物计数器是一款用于主播礼物计算和比赛计数的辅助工具。这款主播礼物计数器,使用方便,适用于各种媒体主播平台,提供两队数据的增减,同时可以用快捷键进行操作,简单
  • 摘要:计数器是数字系统中应用广泛的基本逻辑器件。本文主要介绍了以同步十进制计数器74LS160 为基础,应用反馈复零法实现的N 进制计数器的设计方法。并应用EWB 软件对所设计的电路进行仿真,仿真结果表明设计的...
  • PLC高速计数器,西门子PLCS7-200高速计数器指令用法,指令根据HSC特殊内存位的状态配置和控制高速计数 器。参数N指定高速计数器的号码。 高速计数器最多可配置为十二种不同的操作模式。 每台计数器在功能受支持的...
  • 由PHP粉丝网开发的夏日PHP图形计数器程序是一款简单的图片计数器,为了直观显示一个网站有多少用户浏览,需要在网页底部放一个图片计数器,也就是当前页面的访问量,访问量的数据是保存在 txt 文件里,可自动生成 ...
  • 1,增加文字计数器,可进行切换。 2,优化PHP计数器核心代码。   夏日PHP图形计数器程序由PHP粉丝网开发是一款简单的图片计数器,为了直观显示一个网站有多少用户浏览,需要在网页底部放一个图片计数器,也就是...
  • 计数器课程设计报告

    2019-03-30 00:17:35
    利用CD4062和红外对管的计数器,需要的下载。电路原理:由红外发射管产生红外线,红外接收管接收红外线。当光线被挡住会产生一个触发脉冲,送入计数器的CP端,使计数器计数加“1”。CD4026的使能端INH接地,芯片持续...
  • 摘要 以多种种典型的中规模集成 (MSI) 计数器芯片为例,采用反馈置零法 ( 复位法 )、反馈置数法 ( 置位法 ) 和级联法来构成任意进制计数器。最后总结出详细的设计步骤。  1 绪论  计数器是数字逻辑系统中...
  • 异步计数器又称行波计数器,它的下一位计数器的输出作上一位计数器的时钟信号,一级一级串行连接起来就构成了一个异步计数器。异步计数器与同步计数器不同之处就在于时钟脉冲的提供方式,但是,由于异步计数器采用...
  • PIC16F87X单片机内部配置了3个定时器/计数器,分别记为TMR0、TMR1、TMR2。这3个定时器/计数器模块不仅在电路结构上不相同,而且其在设计的初衷和使用上也各有不同。 · 定时器/计数器TMR0。 定时器/计数器TMR0...
  • 定时/计数器都有定时或对外部事件计数的功能。通常,定时/计数器归纳起来一般有3种类型:  硬件计数器 可在简单软件控制下计数,特点是成本低,使用方便,但是专用性强,使用不广泛。  软件定时/计数器 特点是...
  • Verilog HDL计数器设计(作业1)

    万次阅读 2016-11-20 22:24:19
    Verilog HDL计数器设计(作业1)目录:Verilog HDL计数器设计作业1 设计内容 信号定义 RTL设计图 Quartus RTL电路图 计数器波形仿真图 计数器代码 设计内容 信号定义 RTL设计图 Quartus RTL电路图 计数器波形仿真图 ...
  • Mulitisim计数器.ms14

    2020-09-02 20:01:02
    设计一个计数器,其功能要求如下: 1)计数以秒为单位步进 2)任意时刻,点按按键 1,计数器可置数为 n1 3)点按按键 2,计数器可开始计数,再次点按按键 2,计数器 停止计数,再次点按又开始计数,如此循环 4)...
  • 设计 4 位 BCD 十进制计数器 Design a 4-digit BCD decimal counter module bcd_4d_cnt( //4位十进制计数器 input clk, input reset_n, input en, //同步使能 input load, //同步装载 input [15:0] d, ...
  • 二进制计数器 n位的2进制计数器,可以表示2^n个状态 相邻的两组数据会出现两位或两位以上不一样 环形计数器(右移) n位的环形计数器,可以表示n个状态 举例:4位的独热码环形计数器的数据表示(0001 >>...
  • 所谓可逆计数器,就是根据计数控制信号的不同,在时钟脉冲作用下,计数器可以进行加1或者减1操作的一种计数器。可逆计数器有一个特殊的控制端,这就是DR端。\u5f53DIR='0'时,计数器进行加1操作,\u5f53DIR='1'时,...

空空如也

1 2 3 4 5 ... 20
收藏数 54,724
精华内容 21,889
关键字:

计数器