精华内容
下载资源
问答
  • 同步状态

    2018-05-19 16:54:33
    同步状态 public enum State { /** 线程新建未开始 */ NEW, /** 在虚拟机运行但是可能在等待其他来自操作系统的资源 */ RUNNABLE, /** 一个线程在等待监视器锁的阻塞状态为了进入或者重入一个同步块...

    同步状态

    public enum State {
       /**
       线程新建未开始
        */
       NEW,
    
       /**
       在虚拟机运行但是可能在等待其他来自操作系统的资源
        */
       RUNNABLE,
    
       /**
        一个线程在等待监视器锁的阻塞状态为了进入或者重入一个同步块或者方法
        */
       BLOCKED,
    
       /**
       无限等待其他线程执行一个特定的动作比如notify
        *<tt>Object.wait()</tt>--<tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> 
         <tt>Thread.join()</tt>--terminate.
        */
       WAITING,
    
       /**
       在给定时间内等待其他线程
        */
       TIMED_WAITING,
    
       /**完成退出
        */
       TERMINATED;
    }
    展开全文
  • 最近一个数据库同步问题纠结很久,事情是:主从数据库同步状态正常,无异常错误日志。但是其中一个表中的数据始终无法同步。(表中数据一直无变化)。由于主库在线业务不能停,首先小编想问题有可能出现在权限问题,...

    最近一个数据库同步问题纠结很久,事情是:

    主从数据库同步状态正常,无异常错误日志。但是其中一个表中的数据始终无法同步。(表中数据一直无变化)。由于主库在线业务不能停,首先小编想问题有可能出现在权限问题,经过各种资料查找,发现和权限无任何关系;其次,尝试重新创建一个实例去同步对应主库,但丰满的理想,毫无悬念被骨干的现实狠狠的扎破。痛定思痛,决定用数据库软件连上去,修改主库中的表,看是否可以同步。蒙眼了,修改的数据竟然可以同步过去,但是程序写到还是不能同步过去。判定是程序问题,可无真枪实弹摆在面前,如何让人信服。最终,只能动用终结者武器,mysqllogbin去核对update数据。果不其然,有个update数据库表名大写了。查看主库,有个这参数lower_case_table_names,不区分数据库表名的大小写;

    展开全文
  • 查看ntp同步状态

    千次阅读 2020-06-26 17:24:19
    使用如下命令查看节点同步状态 [root@controller ~]# ntpq -p remote refid st t when poll reach delay offset jitter ============================================================================== 218...

    使用如下命令查看节点同步状态

     

    [root@controller ~]# ntpq -p
         remote           refid      st t when poll reach   delay   offset  jitter
    ==============================================================================
     218.189.210.3   118.143.17.82    2 u    7   64    1  101.974  -33.967   0.000
     209.58.185.100  .INIT.          16 u    -   64    0    0.000    0.000   0.000
     103-226-213-30- .INIT.          16 u    -   64    0    0.000    0.000   0.000

    以下是几个字段的含义:

     

    remote:即NTP主机的IP或主机名称。
    注意最左边的符号,如果由“+”则代表目前正在作用钟的上层NTP,
    如果是“*”则表示也有连上线,不过是作为次要联机的NTP主机。
    
    refid:参考的上一层NTP主机的地址
    
    st:即stratum阶层
    
    when:几秒前曾做过时间同步更新的操作
    
    poll:下次更新在几秒之后
    
    reach:已经向上层NTP服务器要求更新的次数
    
    delay:网络传输过程钟延迟的时间
    
    offset:时间补偿的结果
    
    jitter:Linux系统时间与BIOS硬件时间的差异时间

    查询你的ntp服务器同步信息

     

    [root@controller ~]# ntpdate -q  0.hk.pool.ntp.org
    server 203.95.213.129, stratum 2, offset -0.020632, delay 0.06477
    server 209.58.185.100, stratum 2, offset -0.011884, delay 0.06216
    server 218.189.210.4, stratum 0, offset 0.000000, delay 0.00000
    server 218.189.210.3, stratum 2, offset -0.036728, delay 0.11096
     6 Apr 12:51:43 ntpdate[10190]: adjust time server 209.58.185.100 offset -0.011884 sec



     

    展开全文
  • 1. 同步队列 队列同步器的实现依赖内部的同步队列来完成同步状态的管理。...当同步状态释放时,会把头节点中的线程唤醒,使其再次尝试获取同步状态。 Node静态内部类的源码 static final class Node { sta...

     

    1. 同步队列

    队列同步器的实现依赖内部的同步队列来完成同步状态的管理。它是一个FIFO的双向队列,当线程获取同步状态失败时,同步器会将当前线程和等待状态等信息包装成一个节点并将其加入同步队列,同时会阻塞当前线程。当同步状态释放时,会把头节点中的线程唤醒,使其再次尝试获取同步状态。

    Node静态内部类的源码

    static final class Node {
        
        static final Node SHARED = new Node(); //标识一个这个节点是否为shared类型 
    
        static final Node EXCLUSIVE = null;
    
        static final int CANCELLED =  1; //线程已被取消;
        static final int SIGNAL    = -1; //当前线程的后继线程需要被unpark(唤醒);
        static final int CONDITION = -2; //线程(处在Condition休眠状态)在等待Condition调用signal()方法被唤醒;
        static final int PROPAGATE = -3; //(共享锁)其它线程获取到“共享锁”
                                         //INITIAL = 0:初始化状态
        volatile int waitStatus;
    
        volatile Node prev; // 前驱节点
        volatile Node next; //后继节点
    
        volatile Thread thread; //获取状态状态的线程
    
        /**
         * 等待队列中的后继节点。如果当前节点是共享的,那么这个字段是一个shared常量,
         * 也就是说节点类型(独占或共享)和等待队列中个后继节点共用同一个字段
         */
        Node nextWaiter;
    
        /**
         * Returns true if node is waiting in shared mode.
         */
        final boolean isShared() {
            return nextWaiter == SHARED;
        }
        
        final Node predecessor() throws NullPointerException {
            Node p = prev;
            if (p == null)
                throw new NullPointerException();
            else
                return p;
        }
    
        Node() {    // Used to establish initial head or SHARED marker
        }
    
        Node(Thread thread, Node mode) {     // Used by addWaiter
            this.nextWaiter = mode;
            this.thread = thread;
        }
    
        Node(Thread thread, int waitStatus) { // Used by Condition
            this.waitStatus = waitStatus;
            this.thread = thread;
        }
    }

    同步器包含了两个节点类型的引用,一个指向头节点,而另一个指向尾节点。

    2. 独占式同步状态获取

    acquire(int arg)方法为AQS提供的模板方法,该方法为独占式获取同步状态,但是该方法对中断不敏感,也就是说由于线程获取同步状态失败加入到CLH同步队列中,后续对线程进行中断操作时,线程不会从同步队列中移除。代码如下:

    public final void acquire(int arg) {
            if (!tryAcquire(arg) &&
                acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
                selfInterrupt();
        }

    acquire()说明

    (01) 先是通过tryAcquire()尝试获取锁。获取成功的话,直接返回;尝试失败的话,再通过acquireQueued()获取锁。

    (02) 尝试失败的情况下,会先通过addWaiter()来将“当前线程”加入到"CLH队列"末尾;然后调用acquireQueued(),在CLH队列中排序等待获取锁,在此过程中,线程处于休眠状态。直到获取锁了才返回。 如果在休眠等待过程中被中断过,则调用selfInterrupt()来自己产生一个中断。

    /**
     * “当前线程”自己产生一个中断
     */
    private static void selfInterrupt() {
        Thread.currentThread().interrupt();
    }

    说明:selfInterrupt()的代码很简单,就是“当前线程”自己产生一个中断。但是,为什么需要这么做呢?
    这必须结合acquireQueued()进行分析。如果在acquireQueued()中,当前线程被中断过,则执行selfInterrupt();否则不会执行。

    在acquireQueued()中,即使是线程在阻塞状态被中断唤醒而获取到cpu执行权利;但是,如果该线程的前面还有其它等待锁的线程,根据公平性原则,该线程依然无法获取到锁。它会再次阻塞! 该线程再次阻塞,直到该线程被它的前面等待锁的线程锁唤醒;线程才会获取锁,然后“真正执行起来”!
    也就是说,在该线程“成功获取锁并真正执行起来”之前,它的中断会被忽略并且中断标记会被清除! 因为在parkAndCheckInterrupt()中,我们线程的中断状态时调用了Thread.interrupted()。该函数不同于Thread的isInterrupted()函数,isInterrupted()仅仅返回中断状态,而interrupted()在返回当前中断状态之后,还会清除中断状态。 正因为之前的中断状态被清除了,所以这里需要调用selfInterrupt()重新产生一个中断!

     

    2.1 addWaiter()方法

    private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        // 快速尝试在尾部添加
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);
        return node;
    }
    
    
    private Node enq(final Node node){
        for (;;) {
            Node t = tail;
            if (t == null) { // Must initialize
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            } 
        }
    }

    2.2 acquireQueued()方法

    final boolean acquireQueued(final Node node, int arg) { //这是一个自旋的过程
        boolean failed = true;
        try {
            boolean interrupted = false; //中断标志
            for (;;) {
                final Node p = node.predecessor(); //获取后继节点
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    (parkAndCheckInterrupt))
                interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }
    /**
     * 设置同步状态获取失败后的节点状态,并返回"当前线程是否应该阻塞",
     */
    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        // 前继节点的状态
        int ws = pred.waitStatus;
        // 如果前继节点是SIGNAL状态,则意味这当前线程需要被unpark唤醒。此时,返回true。
        if (ws == Node.SIGNAL)
            return true;
        // 如果前继节点是“取消”状态,则设置 “当前节点”的 “当前前继节点”  为  “‘原前继节点’的前继节点”。
        if (ws > 0) {
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            // 如果前继节点为“0”或者“共享锁”状态,则设置前继节点为SIGNAL状态。
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }
    /**
     * 阻塞当前线程,并且返回“线程被唤醒之后”的中断状态
     */
    private final boolean parkAndCheckInterrupt() {
        // 通过LockSupport的park()阻塞“当前线程”。
        LockSupport.park(this);
        // 返回线程的中断状态。
        return Thread.interrupted();
    }

    3. 独占式同步状态释放

    public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }
    private void unparkSuccessor(Node node) {
      
        int ws = node.waitStatus;
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);
    
        Node s = node.next;
        if (s == null || s.waitStatus > 0) {
            s = null;
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        if (s != null)
            LockSupport.unpark(s.thread); //唤醒node的后继节点
    }

     

     

     

     

     

     

     

     

     

     

    展开全文
  • 通过调用通过调用同步器的doAcquireNanos(int arg,long nanosTimeout)方法可以超时获取同步状态,即在指定的时间段内获取同步状态,如果获取到同步状态则返回true,否则,返回false。该方法提供了传统Java同步操作...
  • 如何查看Geth同步状态

    千次阅读 2019-08-25 13:37:54
    本文将介绍如何检查Geth的区块同步状态。 如果希望快速掌握区块链应用的开发,推荐汇智网的 区块链应用开发系列教程, 内容涵盖比特币、以太坊、eos、超级账本fabric和tendermint等多种区块链, 以及 java、go、...
  • MySQL主从同步状态

    千次阅读 2014-05-09 17:09:29
    MySQL主从同步状态 博客分类:  mysql MySQLSQLSQL ServerHTML  因为mysql的slave报错,导致slave落后master很远。找资料查看同步状态。  引用 mysql> show slave status\G  ***********...
  • 同步 状态同步

    千次阅读 2019-01-12 22:28:10
    游戏中常见的同步方案,有状态同步和帧同步,一般大型的MMOARPG都是采用的是状态同步,比如魔兽世界,状态同步采用C/S架构,所有的状态由服务器来控制,安全性比较高,但是流量比较大。帧同步采用的是囚徒模式,所有...
  • 通过调用同步器的acquire(int arg)方法可以获取同步状态,该方法对中断不敏感,也就是由于线程获取同步状态失败后进入同步队列中,后续对线程进行中断操作时,线程不会从同步队列中移出。该方法代码清单如下。 ...
  • Server_Cert: No Last_IO_Errno: 0 Last_IO_Error: Last_SQL_Errno: 0 Last_SQL_Error: 1 row in set (0.00 sec) 如果下面一个为NO,表明同步停止。 引用 If either of these is NO, like this, then replication is...
  • 从同步器的同步队列、独占式获取和释放同步状态、共享式获取和释放同步状态、超时获取同步状态等核心数据结构和模板方法,分析同步器的实现。 1. 同步队列 ...
  • CLH 同步队列是一个 FIFO 双向队列,AQS 依赖它来完成同步状态的管理: 当前线程如果获取同步状态失败时,AQS则会将当前线程已经等待状态等信息构造成一个节点(Node)并将其加入到CLH同步队列,同时会阻塞当前线程...
  • 状态机是许多数字系统的核心部件,是一类重要的时序逻辑电路。...由于状态机所有触发器的时钟由同一脉冲边沿触发,故也称之为同步状态机。  根据状态机的输出信号是否与电路的输入有关分为Mealy 型状态机和Moo...
  • Java并发框架——同步状态的管理

    千次阅读 2015-01-03 22:35:51
    整个AQS框架核心功能都是围绕着其32位整型属性state进行,一般可以说它表示锁的数量,对同步状态的控制可以实现不同的同步工具,例如闭锁、信号量、栅栏等等。为了保证可见性此变量被声明为volatile,保证每次的原子...
  • 本系列主要针对有限状态机进行分析和设计,其中主要包括两部分:时钟同步状态机的分析和时钟同步状态机的设计,预计会有五篇文章进行展开,其中介绍一篇,分析和设计分别有两篇,每一部分都会有相应的实例。...
  • nagios 监控 mysql 主从同步状态

    千次阅读 2015-12-22 13:57:31
    nagios 监控 mysql 主从同步状态 作为一名运维人员,对于 Mysql 的主从同步我们并不陌生。我们如何能得知主从库是否在实时的同步呢?每隔一分钟登录到数据库到数据库执行 show slave status\G 显然是不靠谱。...
  • 本系列主要针对有限状态机进行分析和设计,其中主要包括两部分:时钟同步状态机的分析和时钟同步状态机的设计,预计会有五篇文章进行展开,其中介绍一篇,分析和设计分别有两篇,每一部分都会有相应的实例。...
  • 本系列主要针对有限状态机进行分析和设计,其中主要包括两部分:时钟同步状态机的分析和时钟同步状态机的设计,预计会有五篇文章进行展开,其中介绍一篇,分析和设计分别有两篇,每一部分都会有相应的实例。...
  • 本系列主要针对有限状态机进行分析和设计,其中主要包括两部分:时钟同步状态机的分析和时钟同步状态机的设计,预计会有五篇文章进行展开,其中介绍一篇,分析和设计分别有两篇,每一部分都会有相应的实例。...
  • 共享式获取与独占式获取最主要的区别在于同一时刻能否有多个线程同时获取到同步状态。以文件的读写为例,若一个程序在对文件进行读操作,那么这一时刻对于该文件的写操作均被阻塞,而读操作能够同时进行。写操作要求...
  • 为什么会有这疑问,关键代码如下: 可以发现,p就是当前node节点对象的前驱节点,而只有当p是头节点时,判断才...因为只有头节点才是成功获取了同步状态的节点,而当头节点释放了同步状态后,头节点会唤醒它的后继节
  •  主从数据库同步状态正常,无异常错误日志。但是其中一个表中的数据始终无法同步。(表中数据一直无变化)。由于主库在线业务不能停,首先小编想问题有可能出现在权限问题,经过各种资料查找,发现和权限无任何关系...
  •  AQS提供的模板方法基本分为3类:独占式获取与释放同步状态,共享式获取与释放同步状态和查询同步队列中的等待线程情况。 一、独占式同步状态获取与释放 public final void acquire(int arg) { if (!tryAcquire...
  • nagios 实现Mysql 主从同步状态的监控

    千次阅读 2014-10-16 13:27:12
    nagios 实现Mysql 主从同步状态的监控
  • Synchronization state同步状态 同步状态 同步视图显示你的本地工作平台与服务器存储库中资源的同步状态。状态按图标显示,你也可以把状态显示配置为资源名称之后的文字。下表列出图标的描述。 指向左边的蓝色...
  • 摘要:针对数据同步状态查看方法,GaussDB(DWS)提供了丰富的系统函数、视图、工具等可以直观地对同步进度进行跟踪,尤其是为方便定位人员使用,gs_ctl工具已集合了大部分相关系统函数的调用,可做到在任何时间,从未...
  • show slave status判断主从同步状态

    万次阅读 2015-08-15 20:58:01
    show slave status\G 会显示主从同步状态 例如 mysql> show slave status\G *************************** 1. row ***************************  Slave_IO_State: Waiting for master to send event
  • 检测mysql数据库主从同步中,从库的同步状态,并且发出短信告警。功能比较简单,主要是记录学习过程。
  • AQS的设计模式采用的模板方法模式,子类通过继承的方式,实现它的抽象方法来管理同步状态,对于子类而言它并没有太多的活要做,AQS提供了大量的模板方法来实现同步,主要是分为三类:独占式获取和释放同步状态、共享...
  • 同步状态下,相当于定子产生磁场,转子切割磁场产生产生电流通过转子绕组传向电网。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 35,307
精华内容 14,122
关键字:

同步状态