精华内容
下载资源
问答
  • vue 表单验证由异步变更为同步
    千次阅读
    2020-07-08 17:22:00

    写前端项目时vue表单验证突然变成异步了,导致如果获取校验函数的返回值,应该是升级iview组件导致的,这里记录一下改为同步的一种写法

    实现功能:表单中进行规则设置,当触发提交或者流程中的下一页时触发这些规则校验

    表单

    <Form ref="businessInfo" :model="businessInfo" :rules="businessInfoRule" :label-width="120">
        <Row>
                                <Col span="8">
                                    <Col span="22">
                                        <FormItem label="业务信息:" prop="objectInfo">
                                            <!-- {{sendData.busnissMsg}} -->
                                            <Input v-model="businessInfo.objectInfo" placeholder="具体使用集群的业务名称"></Input>
                                        </FormItem>
                                    </Col>
                                </Col>
                                <Col span="8">
                                    <Col span="22">
                                        <FormItem label="OP:" prop="op">
                                            <Input v-model="businessInfo.op" placeholder="产品线OP"></Input>
                                        </FormItem>
                                    </Col>
                                </Col>
                                <Col span="8">
                                    <Col span="22">
                                        <FormItem label="项目邮件组:" prop="mailGroup">
                                            <Input v-model="businessInfo.mailGroup" placeholder="邮箱地址"></Input>
                                        </FormItem>
                                    </Col>
                                </Col>
        </Row>  
    </Form>
    

    规则在data中设置

    • 子key的名字和上述表单子项的prop设置的名字要一样
    businessInfoRule:{
                    op:[
                        {required:true,message: '请填写业务op',trigger: 'change'}
                    ],
                    mailGroup:[
                        {required:true,type:'email',message: '请正确填写邮箱信息',trigger: 'change'},
                    ],
                    note:[
                        {required:true,message: '请填写业务用途',trigger: 'change'},
                        {max:30,message: '请限制在30个字范围内',trigger: 'change'}
                    ],
                    objectInfo:[
                        {required:true,message: '请填写业务信息',trigger: 'change'},
                    ]
                },
    

    规则校验的函数以及调用函数

    • Promise是内置的函数
    • this.checkForm().then(res=> 这里的res是checkForm函数返回的结果集
      
    • 通过Promis和this.checkForm().then(res=>这种调用方法实现同步调用,即当checkForm执行完毕后才会进入下一逻辑
    checkForm(){
                return new Promise((resolve, reject) => {
                    this.$refs['businessInfo'].validate((valid) => {
                        console.log('inner')
                        console.log(valid)
                        if (valid) {
                            resolve(true)
                        } else {
                            this.$Message.error('请检查业务及归属信息');
                            checkResult = false
                            resolve(false)
                        }
                    })
                })
    },
    changeCrrentPage(){
        this.checkForm().then(res=>{
                            if (res){
                                console.log(res)
                                this.defaultPage = page;
                                this.$refs.flowApply.changePage(page)
                            }
                        })
        break  
    }
    

    错误的写法

    • 以前均是采用此中方法进行校验,但是升级了iview组件之后此方法不在生效,在调用checkForm函数时其变为了异步方式,即if(this.checkForm()) 这里的返回时undefined
    checkForm(){
                return new Promise((resolve, reject) => {
                    this.$refs['businessInfo'].validate((valid) => {
                        console.log('inner')
                        console.log(valid)
                        if (valid) {
                            return(true)
                        } else {
                            this.$Message.error('请检查业务及归属信息');
                            return false
                        }
                    })
                })
    },
    changeCrrentPage(){
        if (this.checkForm()) {
                            this.defaultPage = page;
                            this.$refs.flowApply.changePage(page)
                        }
        break  
    }
    
    更多相关内容
  • 验证AHB2APB同步

    千次阅读 2021-08-03 23:59:07
    文章目录项目SPEC相关协议测试点分解设计测试用例 项目SPEC 相关协议 中文协议可以看:AHB5...= AHB clock 的频率,频率范围 3 AHB的不同BURST类型数据的读写访问 BURST类型和数据位宽的各种排列组合,包括: 8


    👉关于AHB2APB的设计请看:AHB2APB设计
    👉关于AHB2APB的设计的代码请看:AHB2APB同步桥的设计代码


    1.项目SPEC

    根据ARM官方提供的SPEC,如下:
    在这里插入图片描述
    在这里插入图片描述

    2.相关协议

    中文协议可以看:AHB5协议APB4协议
    ARM英文原版协议:ARM官方文档网址

    3.测试点分解

    ❔分解角度:SPEC文档、AHB协议、APB协议

    序号测试项目预期结果
    1APB协议(APB2 APB3 APB4)中的信号
    2APB clock频率 <= AHB clock 的频率,频率范围
    3AHB的不同BURST类型数据的读写访问BURST类型和数据位宽的各种排列组合,包括: 8种BURST类型,3种不同的数据位宽
    4配置参数检查1.不同位宽的地址,0x0000 ~ 0xFFFF每个地址都做读写操作;2.配置REGISTER_WDATA参数;3.配置REGISTER_RDATA参数
    5PCLKEN对HCLK的分频
    6reset信号在传输过程中发生reset,模块功能能否恢复正常
    7检查APBACTIVE信号检查APBACTIVE信号的行为是否正确
    8HTRANS测busy类型
    9AHB端口信号检查检查HPORT、HREADYOUT、HRESP的功能
    10多个AHB transfer连续传输检查连续的BURST的访问:1.包括读写;2.不同burst;3.有无IDLE
    11APB端口信号检查检查APBACTIVE、PSTRB、PREADY和PSLVERR的功能

    👊注意:测试点是从多个不同的角度去看的,所有有的可能会重叠,这个都没有什么关系。

    4.设计测试用例

    1️⃣考虑AHB端,设计sequence:

    • AHB single Write32(从最简单的开始)

    • AHB single Read32

    • AHB Burst 检查

      • burst 随机
      • size随机
      • 数据、地址随机,但是必须要覆盖到边界值
      • 读写随机
      • HPROT随机
    • 将上面的各种sequence进行组合,测试连续间断或不间断的AHB传输

    2️⃣考虑APB端,设计sequence:

    • pready始终为1
    • pready为0,发生有效的位置随机、持续几个周期(1~16)随机
    • pslverr始终为0
    • pslverr有效,有效的位置随机

    3️⃣考虑AHB 、APB时钟频率,设计sequence:

    • 频率相同
    • 频率比为2:1 、4:1、8:1、16:1

    4️⃣组合以上的各种sequence,设计virtual sequence:

    • AHB的各种sequence与APB各种sequence运行在不同的AHB、APB时钟频率比下

    5.实现难点及处理方法

    5.1 在APB的 slave 中:

    🎏 driver发送数据和monitor采样的时候,需要判断当前的 reset 信号是否有效​

    • 当driver在发送数据时,有可能在这个过程中发生复位。所以在发送数据前要判断复位信号是否有效,或者用fork …join_none也行。
    • monitor中采样肯定是forever的。在每次采样前,都判断一下reset信号是不是有效,如果有效的话,那本次就不采样。

    🎏 monitor中transaction的例化处理​ ❓

    • 因为在monitor中声明了一个transaction句柄,如果再采样前就例化了这个transaction,假如这个样采好了,但是没有component及时来拿。下一个时钟沿到来的时候,monitor又采样了,这就把之前的数据给覆盖了。
    • 所以为了避免数据包被覆盖,每次monitor采样时,就重新例化一个新的transaction对象。

    🎏对于协议中 pslverr 信号的处理​ ❓

    • 可以把pslverr做到transaction中,通过sequence来随机。
    • 也可以把pslverr放到config中,如果要修改pslverr,在发送sequence之前,对apb vip 的config重新配置(可以内置一个reconfig()函数)。
    • driver在每次发包的时候,先要等到pready拉高,然后再判断pslverr是否为低。若pslverr为低,则进行后续对总线的读写操作。

    🎏 怎么样去反馈在传输时,多个周期的pready信号的拉低

    • 把pready拉低的周期数(pready_num)做到transaction中,通过sequence随机化pready拉低的周期数。

    5.2 在AHB的master中:

    🎏 AHB的transaction怎么定义

    • 可以将一个burst 划分为一个transaction。用3个动态数组或者队列将 address、data、htrans分别保存,直到将数组或队列中的数据发送完。

    • 在transaction类定义时,就需要给address、data、htrans做赋初值和约束。

    🎏 AHB是流水线的传输,怎么发包

    AHB在连续传输时,存在地址周期和数据周期交叠的情况。如果使用transaction按一个burst的形式发,可以通过声明两个transaction类的句柄(addr_pkg 和data_pkg)来轮转,解决data_phase和addr_phase 交叠的问题。

    • 首先,在时钟上升沿先判断data_pkg是不是空包,如果是null,再判断addr_pkg是不是null,如果是,那就通过try_next_item( ) 获取一个新的burst transaction。

    • 当获取到这个addr_pkg时,就把这个data_phase发到总线上(只发送一个address),并且将addr_pkg句柄赋值给data_pkg,也就是addr_pkg 和data_pkg指向同一个transaction对象。此时这一拍时钟沿结束,等待下一拍。

    • 当下一拍时钟沿到来时,首先判断data_pkg就不为null了,会将data_pkg中的data数据发送到总线上(只发送一个data)。然后
      如果此时data_pkg 和addr_pkg 句柄指向的transaction内还有没发完的data和address,就会继续再往总线上发一个address ,然后又会等到下一拍,将address对应的data发到总线上。

    • 由此不断地先发address 再发data循环,直到将transaction中保存address 和data的队列或数组发空为止,结束这个burst,把data_pkg 和addr_pkg 句柄指向null 。再获取一个新的transaction。

    🎏 monitor怎么采样

    到底是按一个burst去采,还是按一个single transaction去采样呢?试想一下,monitor采样的数据最终要交给scoreboard ,scoreboard需要比较 apb_monitor和 ahb_monitor 发送过来的数据,而apb_monitor 它发送过来的数据都是一个single transaction。如果我们将ahb_monitor的数据打包成一个burst发过去,monitor内要有打包数据的逻辑,同时发送到scoreboard中,还需要将包拆解成single transaction。所以ahb_monitor可以直接按一个single transaction去采样。


    【代码编写中…】

    展开全文
  • 提出了一种适用同步整流模式开关电源的过零检测电路。该电路通过将同步整流管的漏端电压信号转化成电流信号,并将该电流与偏置电流进行比较,从而确定同步整流管续流过程中电流是否为零。由于使用与整流管同类型的...
  • Java中synchronized同步锁用法及作用范围

    万次阅读 多人点赞 2018-01-18 13:33:52
    Java 中的 synchronized 关键字可以在多线程环境下用来作为线程安全的同步锁。本文主要对 synchronized 的作用,以及其有效范围进行讨论。 Java中的对象锁和类锁:java的对象锁和类锁在锁的概念上基本上和内置锁是...

    Java 中的 synchronized 关键字可以在多线程环境下用来作为线程安全的同步锁。本文主要对 synchronized 的作用,以及其有效范围进行讨论。
    Java中的对象锁和类锁:java的对象锁和类锁在锁的概念上基本上和内置锁是一致的,但是,两个锁实际是有很大的区别的,对象锁是用于对象实例方法,或者一个对象实例上的,类锁是用于类的静态方法或者一个类的class对象上的。我们知道,类的对象实例可以有很多个,但是每个类只有一个class对象,所以不同对象实例的对象锁是互不干扰的,但是每个类只有一个类锁。但是有一点必须注意的是,其实类锁只是一个概念上的东西,并不是真实存在的,它只是用来帮助我们理解锁定实例方法和静态方法的区别的。

    synchronized 关键字主要有以下几种用法:
    - 非静态方法的同步;
    - 静态方法的同步;
    - 代码块。

    下面分对象锁和类锁来分别说明 synchronized 用法:

    对象锁

    非静态方法使用 synchronized 修饰的写法,修饰实例方法时,锁定的是当前对象:

        public synchronized void test(){
            // TODO
        }

    代码块使用 synchronized 修饰的写法,使用代码块,如果传入的参数是 this,那么锁定的也是当前的对象:

        public void test(){
            synchronized (this) {
                // TODO
            }
        }

    下面通过例子来说明对象锁:
    定义一个类,方法如下,将 count 自减,从 5 到 0:

    public class TestSynchronized {
    
        public synchronized void minus() {
            int count = 5;
            for (int i = 0; i < 5; i++) {
                count--;
                System.out.println(Thread.currentThread().getName() + " - " + count);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                }
            }
        }
    
    }

    测试调用方法如下:

    public class Run {
    
        public static void main(String[] args) {
    
            final TestSynchronized test = new TestSynchronized();
    
            Thread thread1 = new Thread(new Runnable() {
    
                @Override
                public void run() {
                    test.minus();
                }
            });
    
            Thread thread2 = new Thread(new Runnable() {
    
                @Override
                public void run() {
                    test.minus();
                }
            });
    
            thread1.start();
            thread2.start();
    
        }
    
    }

    两个线程 thread1 和 thread2,同时访问对象的方法,由于该方法是 synchronized 关键字修饰的,那么这两个线程都需要获得该对象锁,一个获得后另一个线程必须等待。所以我们可以猜测运行结果应该是,一个线程执行完毕后,另一个线程才开始执行,运行例子,输出打印结果如下:

    Thread-0 - 4
    Thread-0 - 3
    Thread-0 - 2
    Thread-0 - 1
    Thread-0 - 0
    Thread-1 - 4
    Thread-1 - 3
    Thread-1 - 2
    Thread-1 - 1
    Thread-1 - 0

    (另:thread1 和 thread2 谁先执行并不一定)
    本例对于对象锁进行了基础的解释。但是对象锁的范围是怎样的,对象的某个同步方法被一个线程访问后,其他线程能不能访问该对象的其他同步方法,以及是否可以访问对象的其他非同步方法呢,下面对两种进行验证:

    对两个同步方法两个线程的验证:
    修改类如下,加入 minus2() 方法,和 minus() 方法一样:

    package com.test.run;
    
    public class TestSynchronized {
    
        public synchronized void minus() {
            int count = 5;
            for (int i = 0; i < 5; i++) {
                count--;
                System.out.println(Thread.currentThread().getName() + " - " + count);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                }
            }
        }
    
        public synchronized void minus2() {
            int count = 5;
            for (int i = 0; i < 5; i++) {
                count--;
                System.out.println(Thread.currentThread().getName() + " - " + count);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                }
            }
        }
    
    }

    测试调用如下,两个线程访问不同的方法:

    public class Run {
    
        public static void main(String[] args) {
    
            final TestSynchronized test = new TestSynchronized();
    
            Thread thread1 = new Thread(new Runnable() {
    
                @Override
                public void run() {
                    test.minus();
                }
            });
    
            Thread thread2 = new Thread(new Runnable() {
    
                @Override
                public void run() {
                    test.minus2();
                }
            });
    
            thread1.start();
            thread2.start();
        }
    
    }

    输出结果如下:

    Thread-0 - 4
    Thread-0 - 3
    Thread-0 - 2
    Thread-0 - 1
    Thread-0 - 0
    Thread-1 - 4
    Thread-1 - 3
    Thread-1 - 2
    Thread-1 - 1
    Thread-1 - 0

    可以看到,某个线程得到了对象锁之后,该对象的其他同步方法是锁定的,其他线程是无法访问的。
    下面看是否能访问非同步方法:
    修改类代码如下,将 minus2() 的 synchronized 修饰去掉,代码如下:

    public class TestSynchronized {
    
        public synchronized void minus() {
            int count = 5;
            for (int i = 0; i < 5; i++) {
                count--;
                System.out.println(Thread.currentThread().getName() + " - " + count);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                }
            }
        }
    
        public void minus2() {
            int count = 5;
            for (int i = 0; i < 5; i++) {
                count--;
                System.out.println(Thread.currentThread().getName() + " - " + count);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                }
            }
        }
    
    }

    测试调用的类不变,如下:

    public class Run2 {
    
        public static void main(String[] args) {
    
            final TestSynchronized test = new TestSynchronized();
    
            Thread thread1 = new Thread(new Runnable() {
    
                @Override
                public void run() {
                    test.minus();
                }
            });
    
            Thread thread2 = new Thread(new Runnable() {
    
                @Override
                public void run() {
                    test.minus2();
                }
            });
    
            thread1.start();
            thread2.start();
    
        }
    
    }

    执行结果如下:

    Thread-1 - 4
    Thread-0 - 4
    Thread-1 - 3
    Thread-0 - 3
    Thread-1 - 2
    Thread-0 - 2
    Thread-1 - 1
    Thread-0 - 1
    Thread-1 - 0
    Thread-0 - 0

    可以看到,结果是交替的,说明线程是交替执行的,说明如果某个线程得到了对象锁,但是另一个线程还是可以访问没有进行同步的方法或者代码。进行了同步的方法(加锁方法)和没有进行同步的方法(普通方法)是互不影响的,一个线程进入了同步方法,得到了对象锁,其他线程还是可以访问那些没有同步的方法(普通方法)。当获取到与对象关联的内置锁时,并不能阻止其他线程访问该对象,当某个线程获得对象的锁之后,只能阻止其他线程获得同一个锁。

    类锁

    类锁需要 synchronized 来修饰静态 static 方法,写法如下:

        public static synchronized void test(){
            // TODO
        }

    或者使用代码块,需引用当前的类:

        public static void test(){
            synchronized (TestSynchronized.class) {
                // TODO
            }
        }

    举例说明类锁的作用:

    public class TestSynchronized {
    
        public static synchronized void minus() {
            int count = 5;
            for (int i = 0; i < 5; i++) {
                count--;
                System.out.println(Thread.currentThread().getName() + " - " + count);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                }
            }
        }
    
    }

    测试调用类如下:

    public class Run {
    
        public static void main(String[] args) {
    
            Thread thread1 = new Thread(new Runnable() {
    
                @Override
                public void run() {
                    TestSynchronized.minus();
                }
            });
    
            Thread thread2 = new Thread(new Runnable() {
    
                @Override
                public void run() {
                    TestSynchronized.minus();
                }
            });
    
            thread1.start();
            thread2.start();
    
        }
    
    }

    输出结果如下:

    Thread-0 - 4
    Thread-0 - 3
    Thread-0 - 2
    Thread-0 - 1
    Thread-0 - 0
    Thread-1 - 4
    Thread-1 - 3
    Thread-1 - 2
    Thread-1 - 1
    Thread-1 - 0

    可以看到,类锁和对象锁其实是一样的,由于静态方法是类所有对象共用的,所以进行同步后,该静态方法的锁也是所有对象唯一的。每次只能有一个线程来访问对象的该非静态同步方法。
    类锁的作用和对象锁类似,但是作用范围是否和对象锁一致呢,下面看对象锁和类锁是否等同:
    修改类,两个同步方法,其中一个是静态的:

    public class TestSynchronized {
    
        public static synchronized void minus() {
            int count = 5;
            for (int i = 0; i < 5; i++) {
                count--;
                System.out.println(Thread.currentThread().getName() + " - " + count);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                }
            }
        }
    
        public synchronized void minus2() {
            int count = 5;
            for (int i = 0; i < 5; i++) {
                count--;
                System.out.println(Thread.currentThread().getName() + " - " + count);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                }
            }
        }
    
    }

    测试调用类如下,静态方法直接用类调用,实例方法由对象来调用:

    public class Run {
    
        public static void main(String[] args) {
    
            final TestSynchronized test = new TestSynchronized();
    
            Thread thread1 = new Thread(new Runnable() {
    
                @Override
                public void run() {
                    TestSynchronized.minus();
                }
            });
    
            Thread thread2 = new Thread(new Runnable() {
    
                @Override
                public void run() {
                    test.minus2();
                }
            });
    
            thread1.start();
            thread2.start();
    
        }
    
    }

    运行结果:

    Thread-1 - 4
    Thread-0 - 4
    Thread-0 - 3
    Thread-1 - 3
    Thread-0 - 2
    Thread-1 - 2
    Thread-0 - 1
    Thread-1 - 1
    Thread-1 - 0
    Thread-0 - 0

    可以看到两个线程是交替进行的,也就是说类锁和对象锁是不一样的锁,是互相独立的。

    展开全文
  • 使用引起门输出值变化的条件的时序验证的...在许多情况下,同步时序电路的时序验证可以导致对组合逻辑电路的验证,这些电路形成外部输出值并决定存储器元件的输入值。 在对这些组合逻辑电路的验证中,我们验证它们没
  •  使用NIPXI、NIVideoMASTER、NILabVIEW和NITestStand管理软件,开发一个验证数字视频信号参数的自动化系统,验证范围从信道延迟测量和颜色验证,到同步脉冲定时、噪声谱和非线性测量。  “使用基于NITestStand...
  • Java中synchronized同步锁四种用法及作用范围

    万次阅读 多人点赞 2018-12-17 17:20:13
    Java中synchronized同步锁用法及作用范围 - 在梅边的专栏 - CSDN博客 https://blog.csdn.net/yx0628/article/details/79086511   Java中synchronized同步锁用法及作用范围       Java 中的 synchronized ...

     

    Java中synchronized同步锁用法及作用范围 - 在梅边的专栏 - CSDN博客
    https://blog.csdn.net/yx0628/article/details/79086511

     

    Java中synchronized同步锁用法及作用范围

     

     

     

    Java 中的 synchronized 关键字可以在多线程环境下用来作为线程安全的同步锁。本文主要对 synchronized 的作用,以及其有效范围进行讨论。 
    Java中的对象锁和类锁:java的对象锁和类锁在锁的概念上基本上和内置锁是一致的,但是,两个锁实际是有很大的区别的,对象锁是用于对象实例方法,或者一个对象实例上的,类锁是用于类的静态方法或者一个类的class对象上的。我们知道,类的对象实例可以有很多个,但是每个类只有一个class对象,所以不同对象实例的对象锁是互不干扰的,但是每个类只有一个类锁。但是有一点必须注意的是,其实类锁只是一个概念上的东西,并不是真实存在的,它只是用来帮助我们理解锁定实例方法和静态方法的区别的。

    synchronized 关键字主要有以下几种用法: 
    - 非静态方法的同步; 
    - 静态方法的同步; 
    - 代码块。

    下面分对象锁和类锁来分别说明 synchronized 用法:

    对象锁

    非静态方法使用 synchronized 修饰的写法,修饰实例方法时,锁定的是当前对象:

        public synchronized void test(){
            // TODO
        }

    代码块使用 synchronized 修饰的写法,使用代码块,如果传入的参数是 this,那么锁定的也是当前的对象:

        public void test(){
            synchronized (this) {
                // TODO
            }
        }
    • 1
    • 2
    • 3
    • 4
    • 5

    下面通过例子来说明对象锁: 
    定义一个类,方法如下,将 count 自减,从 5 到 0:

    public class TestSynchronized {
    
        public synchronized void minus() {
            int count = 5;
            for (int i = 0; i < 5; i++) {
                count--;
                System.out.println(Thread.currentThread().getName() + " - " + count);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                }
            }
        }
    
    }

    测试调用方法如下:

    public class Run {
    
        public static void main(String[] args) {
    
            final TestSynchronized test = new TestSynchronized();
    
            Thread thread1 = new Thread(new Runnable() {
    
                @Override
                public void run() {
                    test.minus();
                }
            });
    
            Thread thread2 = new Thread(new Runnable() {
    
                @Override
                public void run() {
                    test.minus();
                }
            });
    
            thread1.start();
            thread2.start();
    
        }
    
    }

    两个线程 thread1 和 thread2,同时访问对象的方法,由于该方法是 synchronized 关键字修饰的,那么这两个线程都需要获得该对象锁,一个获得后另一个线程必须等待。所以我们可以猜测运行结果应该是,一个线程执行完毕后,另一个线程才开始执行,运行例子,输出打印结果如下:

    Thread-0 - 4
    Thread-0 - 3
    Thread-0 - 2
    Thread-0 - 1
    Thread-0 - 0
    Thread-1 - 4
    Thread-1 - 3
    Thread-1 - 2
    Thread-1 - 1
    Thread-1 - 0

    (另:thread1 和 thread2 谁先执行并不一定) 
    本例对于对象锁进行了基础的解释。但是对象锁的范围是怎样的,对象的某个同步方法被一个线程访问后,其他线程能不能访问该对象的其他同步方法,以及是否可以访问对象的其他非同步方法呢,下面对两种进行验证:

    对两个同步方法两个线程的验证: 
    修改类如下,加入 minus2() 方法,和 minus() 方法一样:

    package com.test.run;
    
    public class TestSynchronized {
    
        public synchronized void minus() {
            int count = 5;
            for (int i = 0; i < 5; i++) {
                count--;
                System.out.println(Thread.currentThread().getName() + " - " + count);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                }
            }
        }
    
        public synchronized void minus2() {
            int count = 5;
            for (int i = 0; i < 5; i++) {
                count--;
                System.out.println(Thread.currentThread().getName() + " - " + count);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                }
            }
        }
    
    }

    测试调用如下,两个线程访问不同的方法:

    public class Run {
    
        public static void main(String[] args) {
    
            final TestSynchronized test = new TestSynchronized();
    
            Thread thread1 = new Thread(new Runnable() {
    
                @Override
                public void run() {
                    test.minus();
                }
            });
    
            Thread thread2 = new Thread(new Runnable() {
    
                @Override
                public void run() {
                    test.minus2();
                }
            });
    
            thread1.start();
            thread2.start();
        }
    
    }

    输出结果如下:

    Thread-0 - 4
    Thread-0 - 3
    Thread-0 - 2
    Thread-0 - 1
    Thread-0 - 0
    Thread-1 - 4
    Thread-1 - 3
    Thread-1 - 2
    Thread-1 - 1
    Thread-1 - 0

    可以看到,某个线程得到了对象锁之后,该对象的其他同步方法是锁定的,其他线程是无法访问的。 
    下面看是否能访问非同步方法: 
    修改类代码如下,将 minus2() 的 synchronized 修饰去掉,代码如下:

    public class TestSynchronized {
    
        public synchronized void minus() {
            int count = 5;
            for (int i = 0; i < 5; i++) {
                count--;
                System.out.println(Thread.currentThread().getName() + " - " + count);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                }
            }
        }
    
        public void minus2() {
            int count = 5;
            for (int i = 0; i < 5; i++) {
                count--;
                System.out.println(Thread.currentThread().getName() + " - " + count);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                }
            }
        }
    
    }

    测试调用的类不变,如下:

    public class Run2 {
    
        public static void main(String[] args) {
    
            final TestSynchronized test = new TestSynchronized();
    
            Thread thread1 = new Thread(new Runnable() {
    
                @Override
                public void run() {
                    test.minus();
                }
            });
    
            Thread thread2 = new Thread(new Runnable() {
    
                @Override
                public void run() {
                    test.minus2();
                }
            });
    
            thread1.start();
            thread2.start();
    
        }
    
    }

     

    • 执行结果如下:
    Thread-1 - 4
    Thread-0 - 4
    Thread-1 - 3
    Thread-0 - 3
    Thread-1 - 2
    Thread-0 - 2
    Thread-1 - 1
    Thread-0 - 1
    Thread-1 - 0
    Thread-0 - 0

    可以看到,结果是交替的,说明线程是交替执行的,说明如果某个线程得到了对象锁,但是另一个线程还是可以访问没有进行同步的方法或者代码。进行了同步的方法(加锁方法)和没有进行同步的方法(普通方法)是互不影响的,一个线程进入了同步方法,得到了对象锁,其他线程还是可以访问那些没有同步的方法(普通方法)。当获取到与对象关联的内置锁时,并不能阻止其他线程访问该对象,当某个线程获得对象的锁之后,只能阻止其他线程获得同一个锁。

    类锁

    类锁需要 synchronized 来修饰静态 static 方法,写法如下:

        public static synchronized void test(){
            // TODO
        }

    或者使用代码块,需引用当前的类:

        public static void test(){
            synchronized (TestSynchronized.class) {
                // TODO
            }
        }

    举例说明类锁的作用:

    public class TestSynchronized {
    
        public static synchronized void minus() {
            int count = 5;
            for (int i = 0; i < 5; i++) {
                count--;
                System.out.println(Thread.currentThread().getName() + " - " + count);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                }
            }
        }
    
    }

     

    • 测试调用类如下:
    public class Run {
    
        public static void main(String[] args) {
    
            Thread thread1 = new Thread(new Runnable() {
    
                @Override
                public void run() {
                    TestSynchronized.minus();
                }
            });
    
            Thread thread2 = new Thread(new Runnable() {
    
                @Override
                public void run() {
                    TestSynchronized.minus();
                }
            });
    
            thread1.start();
            thread2.start();
    
        }
    
    }

     

    输出结果如下:

    Thread-0 - 4
    Thread-0 - 3
    Thread-0 - 2
    Thread-0 - 1
    Thread-0 - 0
    Thread-1 - 4
    Thread-1 - 3
    Thread-1 - 2
    Thread-1 - 1
    Thread-1 - 0

    可以看到,类锁和对象锁其实是一样的,由于静态方法是类所有对象共用的,所以进行同步后,该静态方法的锁也是所有对象唯一的。每次只能有一个线程来访问对象的该非静态同步方法。 
    类锁的作用和对象锁类似,但是作用范围是否和对象锁一致呢,下面看对象锁和类锁是否等同: 
    修改类,两个同步方法,其中一个是静态的:

    public class TestSynchronized {
    
        public static synchronized void minus() {
            int count = 5;
            for (int i = 0; i < 5; i++) {
                count--;
                System.out.println(Thread.currentThread().getName() + " - " + count);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                }
            }
        }
    
        public synchronized void minus2() {
            int count = 5;
            for (int i = 0; i < 5; i++) {
                count--;
                System.out.println(Thread.currentThread().getName() + " - " + count);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                }
            }
        }
    
    }

    测试调用类如下,静态方法直接用类调用,实例方法由对象来调用:

    public class Run {
    
        public static void main(String[] args) {
    
            final TestSynchronized test = new TestSynchronized();
    
            Thread thread1 = new Thread(new Runnable() {
    
                @Override
                public void run() {
                    TestSynchronized.minus();
                }
            });
    
            Thread thread2 = new Thread(new Runnable() {
    
                @Override
                public void run() {
                    test.minus2();
                }
            });
    
            thread1.start();
            thread2.start();
    
        }
    
    }

    运行结果:

    Thread-1 - 4
    Thread-0 - 4
    Thread-0 - 3
    Thread-1 - 3
    Thread-0 - 2
    Thread-1 - 2
    Thread-0 - 1
    Thread-1 - 1
    Thread-1 - 0
    Thread-0 - 0

    可以看到两个线程是交替进行的,也就是说类锁和对象锁是不一样的锁,是互相独立的。

     

     

     

     

     

     

     

    =================================================================

    =================================================================

    =================================================================

    =================================================================

     

     

     

     

     

     

    synchronized的四种用法 - 行走江湖的少侠哥 - CSDN博客
    https://blog.csdn.net/sinat_32588261/article/details/72880159

     

     

    synchronized的四种用法

     

    一 修饰方法

     

    Synchronized修饰一个方法很简单,就是在方法的前面加synchronized,synchronized修饰方法和修饰一个代码块类似,只是作用范围不一样,修饰代码块是大括号括起来的范围,而修饰方法范围是整个函数。

    例如:

    方法一

     

     
    1. public synchronized void method()

    2. {

    3. // todo

    4. }

    方法二

     

     
    1. public void method()

    2. {

    3. synchronized(this) {

    4. // todo

    5. }

    6. }

     

    写法一修饰的是一个方法,写法二修饰的是一个代码块,但写法一与写法二是等价的,都是锁定了整个方法时的内容。

    synchronized关键字不能继承。 
    虽然可以使用synchronized来定义方法,但synchronized并不属于方法定义的一部分,因此,synchronized关键字不能被继承。如果在父类中的某个方法使用了synchronized关键字,而在子类中覆盖了这个方法,在子类中的这个方法默认情况下并不是同步的,而必须显式地在子类的这个方法中加上synchronized关键字才可以。当然,还可以在子类方法中调用父类中相应的方法,这样虽然子类中的方法不是同步的,但子类调用了父类的同步方法,因此,子类的方法也就相当于同步了。这两种方式的例子代码如下: 
    在子类方法中加上synchronized关键字

     

     
    1. class Parent {

    2. public synchronized void method() { }

    3. }

    4. class Child extends Parent {

    5. public synchronized void method() { }

    6. }

     

     

    在子类方法中调用父类的同步方法

     

     
    1. class Parent {

    2. public synchronized void method() { }

    3. }

    4. class Child extends Parent {

    5. public void method() { super.method(); }

    6. }

     

    1. 在定义接口方法时不能使用synchronized关键字。
    2. 构造方法不能使用synchronized关键字,但可以使用synchronized代码块来进行同步。 

     

     

     

     

    二 修饰一个代码块

    1)一个线程访问一个对象中的synchronized(this)同步代码块时,其他试图访问该对象的线程将被阻塞

    注意下面两个程序的区别

     

     
    1. class SyncThread implements Runnable {

    2. private static int count;

    3.  
    4. public SyncThread() {

    5. count = 0;

    6. }

    7.  
    8. public void run() {

    9. synchronized(this) {

    10. for (int i = 0; i < 5; i++) {

    11. try {

    12. System.out.println(Thread.currentThread().getName() + ":" + (count++));

    13. Thread.sleep(100);

    14. } catch (InterruptedException e) {

    15. e.printStackTrace();

    16. }

    17. }

    18. }

    19. }

    20.  
    21. public int getCount() {

    22. return count;

    23. }

    24. }

    25.  
    26. public class Demo00 {

    27. public static void main(String args[]){

    28. //test01

    29. // SyncThread s1 = new SyncThread();

    30. // SyncThread s2 = new SyncThread();

    31. // Thread t1 = new Thread(s1);

    32. // Thread t2 = new Thread(s2);

    33. //test02

    34. SyncThread s = new SyncThread();

    35. Thread t1 = new Thread(s);

    36. Thread t2 = new Thread(s);

    37.  
    38. t1.start();

    39. t2.start();

    40. }

    41. }


    test01的运行结果

     

    test02的运行结果

     

    当两个并发线程(thread1和thread2)访问同一个对象(syncThread)中的synchronized代码块时,在同一时刻只能有一个线程得到执行,另一个线程受阻塞,必须等待当前线程执行完这个代码块以后才能执行该代码块。Thread1和thread2是互斥的,因为在执行synchronized代码块时会锁定当前的对象,只有执行完该代码块才能释放该对象锁,下一个线程才能执行并锁定该对象

    为什么上面的例子中thread1和thread2同时在执行。这是因为synchronized只锁定对象,每个对象只有一个锁(lock)与之相关联。

    2)当一个线程访问对象的一个synchronized(this)同步代码块时,另一个线程仍然可以访问该对象中的非synchronized(this)同步代码块。 

    例:

     

     
    1. class Counter implements Runnable{

    2. private int count;

    3.  
    4. public Counter() {

    5. count = 0;

    6. }

    7.  
    8. public void countAdd() {

    9. synchronized(this) {

    10. for (int i = 0; i < 5; i ++) {

    11. try {

    12. System.out.println(Thread.currentThread().getName() + ":" + (count++));

    13. Thread.sleep(100);

    14. } catch (InterruptedException e) {

    15. e.printStackTrace();

    16. }

    17. }

    18. }

    19. }

    20.  
    21. //非synchronized代码块,未对count进行读写操作,所以可以不用synchronized

    22. public void printCount() {

    23. for (int i = 0; i < 5; i ++) {

    24. try {

    25. System.out.println(Thread.currentThread().getName() + " count:" + count);

    26. Thread.sleep(100);

    27. } catch (InterruptedException e) {

    28. e.printStackTrace();

    29. }

    30. }

    31. }

    32.  
    33. public void run() {

    34. String threadName = Thread.currentThread().getName();

    35. if (threadName.equals("A")) {

    36. countAdd();

    37. } else if (threadName.equals("B")) {

    38. printCount();

    39. }

    40. }

    41. }

    42.  
    43. public class Demo00{

    44. public static void main(String args[]){

    45. Counter counter = new Counter();

    46. Thread thread1 = new Thread(counter, "A");

    47. Thread thread2 = new Thread(counter, "B");

    48. thread1.start();

    49. thread2.start();

    50. }

    51. }

     

     

    可以看见B线程的调用是非synchronized,并不影响A线程对synchronized部分的调用。从上面的结果中可以看出一个线程访问一个对象的synchronized代码块时,别的线程可以访问该对象的非synchronized代码块而不受阻塞。

    3)指定要给某个对象加锁

     

     
    1. /**

    2. * 银行账户类

    3. */

    4. class Account {

    5. String name;

    6. float amount;

    7.  
    8. public Account(String name, float amount) {

    9. this.name = name;

    10. this.amount = amount;

    11. }

    12. //存钱

    13. public void deposit(float amt) {

    14. amount += amt;

    15. try {

    16. Thread.sleep(100);

    17. } catch (InterruptedException e) {

    18. e.printStackTrace();

    19. }

    20. }

    21. //取钱

    22. public void withdraw(float amt) {

    23. amount -= amt;

    24. try {

    25. Thread.sleep(100);

    26. } catch (InterruptedException e) {

    27. e.printStackTrace();

    28. }

    29. }

    30.  
    31. public float getBalance() {

    32. return amount;

    33. }

    34. }

    35.  
    36. /**

    37. * 账户操作类

    38. */

    39. class AccountOperator implements Runnable{

    40. private Account account;

    41. public AccountOperator(Account account) {

    42. this.account = account;

    43. }

    44.  
    45. public void run() {

    46. synchronized (account) {

    47. account.deposit(500);

    48. account.withdraw(500);

    49. System.out.println(Thread.currentThread().getName() + ":" + account.getBalance());

    50. }

    51. }

    52. }

    53.  
    54. public class Demo00{

    55.  
    56. //public static final Object signal = new Object(); // 线程间通信变量

    57. //将account改为Demo00.signal也能实现线程同步

    58. public static void main(String args[]){

    59. Account account = new Account("zhang san", 10000.0f);

    60. AccountOperator accountOperator = new AccountOperator(account);

    61.  
    62. final int THREAD_NUM = 5;

    63. Thread threads[] = new Thread[THREAD_NUM];

    64. for (int i = 0; i < THREAD_NUM; i ++) {

    65. threads[i] = new Thread(accountOperator, "Thread" + i);

    66. threads[i].start();

    67. }

    68. }

    69. }


    运行结果

     

    在AccountOperator 类中的run方法里,我们用synchronized 给account对象加了锁。这时,当一个线程访问account对象时,其他试图访问account对象的线程将会阻塞,直到该线程访问account对象结束。也就是说谁拿到那个锁谁就可以运行它所控制的那段代码。 
    当有一个明确的对象作为锁时,就可以用类似下面这样的方式写程序。

     

     
    1. public void method3(SomeObject obj)

    2. {

    3. //obj 锁定的对象

    4. synchronized(obj)

    5. {

    6. // todo

    7. }

    8. }


    当没有明确的对象作为锁,只是想让一段代码同步时,可以创建一个特殊的对象来充当锁:

     

     

     
    1. class Test implements Runnable

    2. {

    3. private byte[] lock = new byte[0]; // 特殊的instance变量

    4. public void method()

    5. {

    6. synchronized(lock) {

    7. // todo 同步代码块

    8. }

    9. }

    10.  
    11. public void run() {

    12.  
    13. }

    14. }

     

     

    本例中去掉注释中的signal可以看到同样的运行结果


    三 修饰一个静态的方法

    Synchronized也可修饰一个静态方法,用法如下:

     

     
    1. public synchronized static void method() {

    2. // todo

    3. }


    静态方法是属于类的而不属于对象的。同样的,synchronized修饰的静态方法锁定的是这个类的所有对象。

     

     

     
    1. /**

    2. * 同步线程

    3. */

    4. class SyncThread implements Runnable {

    5. private static int count;

    6.  
    7. public SyncThread() {

    8. count = 0;

    9. }

    10.  
    11. public synchronized static void method() {

    12. for (int i = 0; i < 5; i ++) {

    13. try {

    14. System.out.println(Thread.currentThread().getName() + ":" + (count++));

    15. Thread.sleep(100);

    16. } catch (InterruptedException e) {

    17. e.printStackTrace();

    18. }

    19. }

    20. }

    21.  
    22. public synchronized void run() {

    23. method();

    24. }

    25. }

    26.  
    27. public class Demo00{

    28.  
    29. public static void main(String args[]){

    30. SyncThread syncThread1 = new SyncThread();

    31. SyncThread syncThread2 = new SyncThread();

    32. Thread thread1 = new Thread(syncThread1, "SyncThread1");

    33. Thread thread2 = new Thread(syncThread2, "SyncThread2");

    34. thread1.start();

    35. thread2.start();

    36. }

    37. }


     

    syncThread1和syncThread2是SyncThread的两个对象,但在thread1和thread2并发执行时却保持了线程同步。这是因为run中调用了静态方法method,而静态方法是属于类的,所以syncThread1和syncThread2相当于用了同一把锁。

     

    四  修饰一个类

    Synchronized还可作用于一个类,用法如下:

     

     
    1. class ClassName {

    2. public void method() {

    3. synchronized(ClassName.class) {

    4. // todo

    5. }

    6. }

    7. }

     

     
    1. /**

    2. * 同步线程

    3. */

    4. class SyncThread implements Runnable {

    5. private static int count;

    6.  
    7. public SyncThread() {

    8. count = 0;

    9. }

    10.  
    11. public static void method() {

    12. synchronized(SyncThread.class) {

    13. for (int i = 0; i < 5; i ++) {

    14. try {

    15. System.out.println(Thread.currentThread().getName() + ":" + (count++));

    16. Thread.sleep(100);

    17. } catch (InterruptedException e) {

    18. e.printStackTrace();

    19. }

    20. }

    21. }

    22. }

    23.  
    24. public synchronized void run() {

    25. method();

    26. }

    27. }

     

     

    本例的的给class加锁和上例的给静态方法加锁是一样的,所有对象公用一把锁

     

    总结

    A. 无论synchronized关键字加在方法上还是对象上,如果它作用的对象是非静态的,则它取得的锁是对象;如果synchronized作用的对象是一个静态方法或一个类,则它取得的锁是对类,该类所有的对象同一把锁。 
    B. 每个对象只有一个锁(lock)与之相关联,谁拿到这个锁谁就可以运行它所控制的那段代码。 
    C. 实现同步是要很大的系统开销作为代价的,甚至可能造成死锁,所以尽量避免无谓的同步控制。

     

    展开全文
  • Maxim推出业界第一款可提供全运营级时钟同步的IC DS3104,适用于新型同步以太网(SyncE)线卡以及SONET/SDH/SyncE混合线卡。这一新型线卡时钟IC采用Maxim经过验证的基于DSP的数字PLL (DPLL)技术(首先用于高度集成的DS...
  •  使用NIPXI、NIVideoMASTER、NILabVIEW和NITestStand管理软件,开发一个验证数字视频信号参数的自动化系统,验证范围从信道延迟测量和颜色验证,到同步脉冲定时、噪声谱和非线性测量。  “使用基于NITestStand...
  • 话题:数据库同步为什么不建议使用dblink方式回答:其实 dblink同步的情况非常常见。但是在Oracle的一些版本(如11.2.0.3)中有一个特别大的隐患。可能会导致scn增长过快,无法同步,并且该症状会通过dblink传染到与之...
  • 常见的两级触发器同步 多bit信号采用简单的两级触发器同步 CDC中复杂的同步设计 亚稳态总会有概率的存在 单bit信号的CDC同步设计 慢时钟域到快时钟域的同步情况 快时钟域到慢时钟域的同步情况 多bit信号的CDC同步...
  • 同步

    千次阅读 2019-05-07 11:49:29
    同步技术是早期RTS游戏常用的一种同步技术,本篇文章要给大家介绍的是RTX游戏中帧同步实现,帧同步是一种前后端数据同步的方式,一般应用于对实时性要求很高的网络游戏,想要了解更多帧同步的知识,继续往下看。
  • 为了增大对16-APSK信号的鉴相范围,提高环路捕获带宽,提出了在环路捕获阶段使用精简星座鉴相、在捕获完成后使用混合NDA/DD鉴相的载波同步结构。这种结构在实现了环路捕获带宽增加的同时,仍然保持了混合NDA/DD法...
  • 但是,穿过材料的最大X射线穿透路径增加,这意味着CT系统应与高能X射线源和宽动态范围检测器搭配使用以完成CT扫描。 在这项研究中,我们提出并测试了一种基于线性排列和同步旋转多转盘的新颖高效的CT扫描方法,而不...
  • 音视频开发---音视频同步算法

    千次阅读 多人点赞 2019-07-31 19:29:08
    本文是对音视频同步算法的总结,以阅读ffplay.c源码为基础,结合各位博主的分析,逐渐深入理解同步算法原理, 并根据自身理解, 编写一套简易的视频播放器,用于验证音视频同步算法。 ffplay简介 ffplay是FFmpeg...
  • 同步是什么 所谓帧同步(lockstep),其实是同步操作,确保两个客户端逻辑一致,然后服务器接收每个客户端操作(cmd), 然后再下发下去,相同的逻辑,相同的操作,便会播放(DoAction)相同的结果。 如何...
  • UE4网络同步详解(一)——理解同步规则

    万次阅读 多人点赞 2017-10-15 21:41:40
    这篇文章主要以问题的形式,针对UE同步的各个方面的内容,做一个详细而充分的讨论。对于新手理解UE的同步机制非常有帮助,对于有一定的基础而没有深入的UE程序也或许有一些启发。如果想深入了解同步的实现原理,可以...
  • 游戏开发入门(九)游戏同步技术

    千次阅读 2018-02-05 22:21:52
    视频链接:游戏开发入门(九)游戏同步技术(3节课 时常:约1小时07分钟) 第三个视频后9分钟没有声音,不过核心内容都已涉及到 笔记与总结(请先学习视频内容): 1.网络同步的概念与意义 概念:任何一款...
  • 在已有的广义同步定义基础上,提出了一种新的概念―-非恒同混沌系统的全状态广义同步(FSGS),给 出了实现全状态广义同步的统一的控制器形式,该控制器适用范围大,结构相对简单,并且是自适应的.以Chua电 路、L orenz系统...
  • 以太坊主动数据同步简析

    千次阅读 2022-03-23 14:34:19
    以太坊数据同步是一个复杂的流程,需要节点、数据主体、以太坊P2P通信协议、执行器通力合作才能完成。数据主体如何确定需要同步的数据呢?不同数据又是否需要分类同步呢?
  • unity 实现帧同步

    万次阅读 多人点赞 2019-02-09 17:14:18
    哪些游戏需要使用同步 如何实现一个可行的帧同步框架 帧同步原理 帧同步算法 基础核心算法 渲染更新机制 定点数 关于dotween的正确使用 随机数 服务器同步校验 逻辑和渲染如何进行分离 逻辑代码版本控制策略...
  • ntpdate linux时间同步命令

    千次阅读 2021-01-17 03:23:49
    ntpdate linux时间同步命令名称ntpdate – 通过NTP 设置日期和时间概要ntpdate [ -Bbdpqsuv ] [ -a key# ] [ -e authdelay ] [ -k keyfile ][ -o version ] [ -p samples ] [ -t timeout ] server[ … ]说明ntpdate ...
  • 适用于相机照片,保存的照片和屏幕截图,甚至可以自定义,因此用户可以选择要同步的文件夹和不同步的文件夹。 Dropbox has a similar feature with automatic camera uploads. Dropbox具有自动上传相机的类似功能...
  • 摘要:讨论面向5G的同步支撑网在网络架构、同步精度、安全性、可靠性、监测性等方面的需求,介绍一种基于光纤的高精度时间同步网的实现方案,并给出经过现网1300km、19个节点传递的时间同步测试结果。利用该方案既...
  • 本发明涉及数据库管理领域,尤其涉及一种异地实时同步SQL数据的方法。背景技术:随着时代的发展,数据传输呈全球化趋势,而目前在数据库管理领域,异地调用数据显得非常慢。技术实现要素:鉴于目前存在的上述不足,...
  • Unity基础学习六,网络同步

    千次阅读 2022-02-14 18:41:26
    3.如何使用网络同步使用网络同步的不同方案比较。 3.1状态同步 将其他玩家的状态行为同步的方式(请求其他玩家的状态并显示在NPC上),一般情况下AI逻辑,技能逻辑,战斗计算都由服务器运算,将运算的结果同步给...
  • 同步电机模型的MATLAB仿真模型

    千次阅读 2020-09-28 21:10:39
    文末下载完整资料                     摘要   采用电力电子变频装置实现电压频率协调控制,改变了同步电机历来的恒速运行不能调速的面貌,使它和异步电机一样成为调速...再使用MATLAB中用于仿真
  • 恒定风场中假定不同的风速及风区长度,通过比较SWAN模型与SMB方法等经验风浪公式的计算结果,得出SWAN模型风浪模拟的适用范围.针对大风速下计算波高偏大的情况,通过分析参考波速引起的输入风速变小及拖曳力系数...
  • 同步方式依次对这个问题进行解决,已验证各类同步方式的使用注意事项。 3.同步代码块 同步代码块加锁的范围是 代码块{} 内的代码,同步对象根据加锁对象的不同而不同。 3.1.加锁对象是 本地变量 的同步...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 115,523
精华内容 46,209
关键字:

同步验证的适用范围