Synchronized小记

最新推荐文章于 2019-07-07 22:53:00 发布
最新推荐文章于 2019-07-07 22:53:00 发布
阅读量241 收藏
点赞数
文章标签： 线程同步
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuguoxiang815116/article/details/77043357
版权

Synchronized小记

对Synchronized一直理解的比较恍惚，抽时间查阅了一下资料，并且经过例子验证，放在这里记录一下。

基本用法应该都知道。先上测试代码：

public class SynchronizedTest {

    private String lock = new String();

    public void syncClass() {
        synchronized (SynchronizedTest.class) {
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName()+ ": Sync class loop " + i);
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public void syncClassThis() {
        synchronized (SynchronizedTest.this) {
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName()+ ": Sync class.this loop " + i);
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public void syncThis() {
        synchronized (this) {
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName()+ ": Sync this loop " + i);
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public void syncGlobalVar() {
        synchronized (lock) {
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName()+ ": Sync gloable variable loop " + i);
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public void syncLocalVar() {
        String flag = new String();
        synchronized (flag) {
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName()+ ": Sync local variable loop " + i);
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public synchronized void syncMethod() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+ ": Sync method loop " + i);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static synchronized void syncStaticMethod() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+ ": Sync static method loop " + i);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

Main函数代码如下：

public static void main(String[] args) {
        final SynchronizedTest a = new SynchronizedTest();  

        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
//                a.syncClass();
//                a.syncClassThis();
//                a.syncThis();
//                a.syncGlobalVar();
//                a.syncLocalVar();
//                a.syncMethod();
//                a.syncStaticMethod();
            }

        });
        t1.setName("A");
        t1.start();

        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
//                a.syncClass();
//                a.syncClassThis();
//                a.syncThis();
//                a.syncGlobalVar();
//                a.syncLocalVar();
//                a.syncMethod();
//                a.syncStaticMethod();
            }

        });
        t2.setName("B");
        t2.start();
    }

Part A

A1. Synchronized(ClassName.class)和Synchronized(ClassName.class)

执行代码如下：

public static void main(String[] args) {
        final SynchronizedTest a = new SynchronizedTest();  

        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                a.syncClass();
            }

        });
        t1.setName("A");
        t1.start();

        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                a.syncClass();
            }

        });
        t2.setName("B");
        t2.start();
    }

执行结果如下：

A: Sync class loop 0
A: Sync class loop 1
A: Sync class loop 2
A: Sync class loop 3
A: Sync class loop 4
B: Sync class loop 0
B: Sync class loop 1
B: Sync class loop 2
B: Sync class loop 3
B: Sync class loop 4

分析：Synchronized(ClassName.class)将类的对象上锁。Class锁对类的所有对象实例起作用，多线程同步执行。

A2. Synchronized(ClassName.class)与Synchronized静态方法

执行代码如下：

public static void main(String[] args) {
        final SynchronizedTest a = new SynchronizedTest();  

        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                a.syncClass();
            }

        });
        t1.setName("A");
        t1.start();

        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                a.syncStaticMethod();
            }

        });
        t2.setName("B");
        t2.start();
    }

执行结果如下：

A: Sync class loop 0
A: Sync class loop 1
A: Sync class loop 2
A: Sync class loop 3
A: Sync class loop 4
B: Sync static method loop 0
B: Sync static method loop 1
B: Sync static method loop 2
B: Sync static method loop 3
B: Sync static method loop 4

分析：synchronized static方法与synchronized(ClassName.class)代码块的作用一样。线程同步执行。

A3. Synchronized(ClassName.class)与其他

这里其他指的是:

  • a.syncClassThis() : synchronized (SynchronizedTest.this)
  • a.syncThis() : synchronized (this)
  • a.syncGlobalVar() : synchronized (lock) 全局变量lock
  • a.syncLocalVar() : synchronized (flag) 本地变量flag
  • a.syncMethod() : synchronized 非静态方法

其中一种执行结果:

A: Sync class loop 0
B: Sync method loop 0
B: Sync method loop 1
A: Sync class loop 1
A: Sync class loop 2
B: Sync method loop 2
B: Sync method loop 3
A: Sync class loop 3
A: Sync class loop 4
B: Sync method loop 4

我理解Synchronized(ClassName.class)与Synchronized静态方法是一个级别,对类的所有对象起作用，其他为一个级别。这两类别同用的时候，线程异步执行。

Part B

synchronized (ClassName.this)等同synchronized (this)，在这里做一致处理。同步代码块，this是对用该方法的对象本身，而class是对该类本身。

B1. synchronized (this)与synchronized (this)

测试代码：

public static void main(String[] args) {

        final SynchronizedTest a = new SynchronizedTest();  

        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                a.syncThis();
            }

        });
        t1.setName("A");
        t1.start();

        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                a.syncThis();
            }

        });
        t2.setName("B");
        t2.start();
    }

测试结果：

A: Sync this loop 0
A: Sync this loop 1
A: Sync this loop 2
A: Sync this loop 3
A: Sync this loop 4
B: Sync this loop 0
B: Sync this loop 1
B: Sync this loop 2
B: Sync this loop 3
B: Sync this loop 4

分析：当一个线程访问类的某个synchronized (this)同步代码块时，其它线程对同一个类中其它的synchronized (this)同步代码块的访问将是堵塞，这说明synchronized (this)使用的对象监视器是一个。

B2. synchronized (this)与synchronized 非静态方法

测试代码：

public static void main(String[] args) {

        final SynchronizedTest a = new SynchronizedTest();  

        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                a.syncThis();
            }

        });
        t1.setName("A");
        t1.start();

        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                a.syncMethod();
            }

        });
        t2.setName("B");
        t2.start();
    }

测试结果：

A: Sync this loop 0
A: Sync this loop 1
A: Sync this loop 2
A: Sync this loop 3
A: Sync this loop 4
B: Sync method loop 0
B: Sync method loop 1
B: Sync method loop 2
B: Sync method loop 3
B: Sync method loop 4

分析：和B1一样，多个线程调用同一个对象中不同名称的synchronized同步非静态方法或者synchronized(this)同步代码块时，线程同步。

B3. synchronized (this)与synchronized 全局变量

测试代码：

public static void main(String[] args) {

        final SynchronizedTest a = new SynchronizedTest();  

        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                a.syncThis();
            }

        });
        t1.setName("A");
        t1.start();

        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                a.syncGlobalVar();
            }

        });
        t2.setName("B");
        t2.start();
    }

结果（之一）如下：

A: Sync this loop 0
B: Sync gloable variable loop 0
A: Sync this loop 1
B: Sync gloable variable loop 1
A: Sync this loop 2
B: Sync gloable variable loop 2
B: Sync gloable variable loop 3
A: Sync this loop 3
A: Sync this loop 4
B: Sync gloable variable loop 4

this为调用syncThis()方法的对象实例，而syncGlobalVar()方法同步的是全局变量lock，互不影响，线程异步执行。

B4. synchronized (this)与synchronized 局部变量

测试代码:

public static void main(String[] args) {

        final SynchronizedTest a = new SynchronizedTest();  

        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                a.syncThis();
            }

        });
        t1.setName("A");
        t1.start();

        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                a.syncLocalVar();
            }

        });
        t2.setName("B");
        t2.start();
    }

结果(之一)如下：

A: Sync this loop 0
B: Sync local variable loop 0
B: Sync local variable loop 1
A: Sync this loop 1
B: Sync local variable loop 2
A: Sync this loop 2
A: Sync this loop 3
B: Sync local variable loop 3
B: Sync local variable loop 4
A: Sync this loop 4

与B3一样，同步代码块分别锁定this实例和局部变量flag，互不干涉，线程异步。

B5. synchronized (this)与synchronized 静态方法

两个线程分别调用syncThis()方法和syncStaticMethod()方法。结果（之一）如下:

A: Sync this loop 0
B: Sync static method loop 0
A: Sync this loop 1
B: Sync static method loop 1
B: Sync static method loop 2
A: Sync this loop 2
A: Sync this loop 3
B: Sync static method loop 3
B: Sync static method loop 4
A: Sync this loop 4

分析：在A2中讲过，synchronized (ClassName.class)和synchronized 静态方法效果一样，属于同步类本身。互不影响，线程异步执行。

Part C

C1. Synchronized 全局变量和Synchronized 全局变量

测试代码：

public static void main(String[] args) {

        final SynchronizedTest a = new SynchronizedTest();  

        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                a.syncGlobalVar();
            }

        });
        t1.setName("A");
        t1.start();

        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                a.syncGlobalVar();
            }

        });
        t2.setName("B");
        t2.start();
    }

测试结果：

A: Sync gloable variable loop 0
A: Sync gloable variable loop 1
A: Sync gloable variable loop 2
A: Sync gloable variable loop 3
A: Sync gloable variable loop 4
B: Sync gloable variable loop 0
B: Sync gloable variable loop 1
B: Sync gloable variable loop 2
B: Sync gloable variable loop 3
B: Sync gloable variable loop 4

分析：多个线程持有对象监视器作为同一个对象的前提下，同一时间只有一个线程可以执行synchronized(任意自定义对象)同步代码快。

C2. Synchronized 全局变量和Synchronized 局部变量

测试代码：

public static void main(String[] args) {

        final SynchronizedTest a = new SynchronizedTest();  

        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                a.syncGlobalVar();
            }

        });
        t1.setName("A");
        t1.start();

        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                a.syncLocalVar();
            }

        });
        t2.setName("B");
        t2.start();
    }

测试结果（之一）：

A: Sync gloable variable loop 0
A: Sync gloable variable loop 1
B: Sync local variable loop 0
A: Sync gloable variable loop 2
A: Sync gloable variable loop 3
B: Sync local variable loop 1
A: Sync gloable variable loop 4
B: Sync local variable loop 2
B: Sync local variable loop 3
B: Sync local variable loop 4

两个线程同步的为不同变量，线程异步执行。

C3. Synchronized 全局变量和Synchronized 非静态方法

测试代码：

public static void main(String[] args) {

        final SynchronizedTest a = new SynchronizedTest();  

        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                a.syncGlobalVar();
            }

        });
        t1.setName("A");
        t1.start();

        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                a.syncMethod();
            }

        });
        t2.setName("B");
        t2.start();
    }

测试结果（之一）：

A: Sync gloable variable loop 0
B: Sync method loop 0
A: Sync gloable variable loop 1
B: Sync method loop 1
B: Sync method loop 2
A: Sync gloable variable loop 2
B: Sync method loop 3
A: Sync gloable variable loop 3
B: Sync method loop 4
A: Sync gloable variable loop 4

同步代码块对象为全局变量，另一方为调用同步非静态类方法的对象，互不干涉，线程异步执行。

Part D

D1. Synchronized 局部变量和Synchronized 局部变量

测试代码：

public static void main(String[] args) {

        final SynchronizedTest a = new SynchronizedTest();  

        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                a.syncLocalVar();
            }

        });
        t1.setName("A");
        t1.start();

        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                a.syncLocalVar();
            }

        });
        t2.setName("B");
        t2.start();
    }

测试结果（之一）：

A: Sync local variable loop 0
B: Sync local variable loop 0
B: Sync local variable loop 1
A: Sync local variable loop 1
A: Sync local variable loop 2
B: Sync local variable loop 2
A: Sync local variable loop 3
B: Sync local variable loop 3
B: Sync local variable loop 4
A: Sync local variable loop 4

这个结果显而易见，线程异步。事实上，Synchronized 局部变量与其他任何同步方法或者同步代码块执行的时候，因为上锁的“对象”不同，线程之间都是异步执行的。

总结

Synchronized可以同步代码块和同步方法，同一个实例在进行多线程调用的时候，线程之间的执行结果如下表：

执行结果synchronized (ClassName.class)synchronized 静态方法synchronized (ClassName.this)synchronized (this)synchronized 非静态方法synchronized (全局变量)synchronized (局部变量)
synchronized (ClassName.class)同步同步异步异步异步异步异步
synchronized
静态方法		同步同步异步异步异步异步异步
synchronized (ClassName.this)异步异步同步同步同步异步异步
synchronized (this)异步异步同步同步同步异步异步
synchronized
非静态方法		异步异步同步同步同步异步异步
synchronized
(全局变量)		异步异步异步异步异步同步异步
synchronized
(局部变量)		异步异步异步异步异步异步异步
Miracle_Sylvain
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
synchronized.md
02-24
关于synchronized的自学笔记
Java关于Synchronized关键字在不同位置使用的理解
技海拾贝
03-10 4152
Java中的Syncronized关键字可以用来修饰同步方法：像这样synchronized void f() {/*body*/}和同步语句块：像这样synchronized(object){/*body*/}。 其中修饰同步方法可以分为修饰static方法和实例方法。 其中修饰同步语句块还可以分为修饰instance变量，Object Reference对象引用，class 字面常量。
史上最全synchronized用法详解
路漫漫，水迢迢
05-11 3261
Java中synchronized关键字用于代码的同步执行，他可以修饰代码块、方法、this、Object.class，能够保证在多线程环境中只有线程执行。synchronized作用范围越小并发能力越强，下面我们就各种场景来详解举例说明。多个synchronized(this)代码块并发执行当一个线程访问类中的synchronized(this)的代码块时，该类中的其他synchronized(t
synchronized的几个注意事项
可可
06-28 1590
当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法? 1、一个线程在访问一个对象的同步方法时，另一个线程可以同时访问这个对象的非同步方法。 2、一个线程在访问一个对象的同步方法时，另一个线程不能同时访问这个同步方法。 3、一个线程在访问一个对象的同步方法时，另一个线程不能同时访问这个对象的另一个同步方法。 在java中每个类对应一把锁，每个
【JAVA】多线程之synchronized 同步数据 方法
bluegem218的专栏
07-20 373
本例，开启一个公告线程处理flag变量，再开启三个线程抢夺flag变量处理。结果可以看出，三个线程分别排队等待获取flag的获取权。 package test; public class Test1 { private String flag[] = {"true"}; // private String flag = "true; class NotifyThread ext
Synchronized关键字
coder_flag的博客
01-12 320
1.Synchronized的作用 能够保证在同一时刻最多只有一个线程执行该段代码，以达到保证并发安全的效果。 2.Synchronized的地位 1.Synchronized是Java的关键字，被Java语言原生支持 2.是最基本的互斥同步手段 3.是并发编程中的元老级角色，是并发编程的必学内容 3.Synchronized的两个用法 对象锁 包括方法锁（默认锁对象为this当前实例对象）和同...
java synchronized demo
04-19
在Java编程语言中，`synchronized`关键字是一个非常重要的概念，它用于实现线程同步，以确保多线程环境下的数据一致性与安全性。本示例"java synchronized demo"旨在探讨`synchronized`关键字的用法及其作用机制。...
手写synchronized
07-18
(此代码不能运行，因为很多c++中的机制在java中不能实现)此代码仅用于学习synchronized的过程，从看了synchronized的源码后，根据c++中synchronized进行java手写。以MySynchronized类的monitorEnter方法为加锁入口，...
Android synchronized 测试案例
07-16
在Android开发中，`synchronized`关键字是Java语言中用于实现线程同步的重要工具，它在多线程环境下确保了共享资源的安全访问。本测试案例深入探讨了`synchronized`的使用方法，包括同步单个对象、同步多个对象以及...
synchronized并发讲解源码.zip
03-16
在Java编程语言中，`synchronized`关键字是一个非常重要的并发控制机制，用于保证多线程环境下的数据一致性。本文将深入解析`synchronized`的工作原理、使用方式以及它在并发编程中的重要性。通过分析提供的源码，...
synchronized方式死锁
Cruise的博客
06-10 318
public Runnable run1 = new Runnable(){ 8． public void run() { 9． synchronized(this) { //设置关键字 synchronized，以当前类为锁 10． while(count &lt; 1000) { 11． try { 12． //打印是否执行该方法 13． System.out.println(Thread.c...
synchronized（偏向锁和轻量级锁）（TODO）
anlao4870的博客
07-07 869
synchronized 　　JDK1.6对synchronized进行了各种优化，性能已经和ReentrantLock差不多了。 　　Java中的每一个对象都可以作为锁。具体表现为以下3种形式。 对于普通同步方法，锁是当前实例对象。 对于静态同步方法，锁是当前类的Class对象。 对于同步方法块，锁是Synchonized括号里配置的对象。 　　JVM基于进入和退出...
泛微协同办公平台E-cology9.0版本后台维护手册(D)--流程引擎.docx
最新发布
09-03
泛微后端技术文档
A fast intra mode decision algorithm combining neighboring info
09-03
论文提出了一种用于H.264/AVC高配置文件的快速帧内模式决策算法，旨在降低编码复杂度。 算法基于当前块的内容以及邻块的空间连续性来选择最佳预测模式。 通过使用重建的邻域像素，不同的预测模式会导致不同的残差块，算法利用残差块的特征来辅助模式决策。 提出的算法使用绝对变换差之和（SATD）来衡量残差块，并使用最可能的模式来指示邻块预测模式的影响。 实验结果表明，与全搜索算法相比，所提出的算法在编码性能略有下降的情况下，有效降低了帧内预测的复杂度
《会员卡刷卡消费管理系统专业版》是一款集系统设置、会员管理、充值积分、会员消费、查询统计于一体的软-MbccmsP.zip
09-03
c 《会员卡刷卡消费管理系统专业版》是一款集系统设置、会员管理、充值积分、会员消费、查询统计于一体的软_MbccmsP.zip 《会员卡刷卡消费管理系统专业版》是一款集系统设置、会员管理、充值积分、会员消费、查询统计于一体的软_MbccmsP.zip 《会员卡刷卡消费管理系统专业版》是一款集系统设置、会员管理、充值积分、会员消费、查询统计于一体的软_MbccmsP.zip 《会员卡刷卡消费管理系统专业版》是一款集系统设置、会员管理、充值积分、会员消费、查询统计于一体的软_MbccmsP.zip 《会员卡刷卡消费管理系统专业版》是一款集系统设置、会员管理、充值积分、会员消费、查询统计于一体的软_MbccmsP.zip 《会员卡刷卡消费管理系统专业版》是一款集系统设置、会员管理、充值积分、会员消费、查询统计于一体的软_MbccmsP.zip 《会员卡刷卡消费管理系统专业版》是一款集系统设置、会员管理、充值积分、会员消费、查询统计于一体的软_MbccmsP.zip《会员卡刷卡消费管理系统专业版》是一款集系统设置、会员管理、充值积分、会员消费、查询统计于一体的软_MbccmsP.zip 《会
基于springboot学生选课系统设计与实现.docx
09-03
基于springboot学生选课系统设计与实现.docx
【天线阻抗】基于matlab耦合偶极子天线阻抗计算【含Matlab源码 7447期】.mp4
09-03
Matlab研究室上传的视频均有对应的完整代码，皆可运行，亲测可用，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描视频QQ名片； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作
【无线电】基于matlab认知无线电网络中协同频谱传感的优化【含Matlab源码 7449期】.mp4
09-03
Matlab研究室上传的视频均有对应的完整代码，皆可运行，亲测可用，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描视频QQ名片； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作
【误码率仿真】基于matlab 2x2MIMO-LDPC系统误码率仿真【含Matlab源码 7446期】.zip
09-03
CSDN海神之光上传的代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博客文章底部QQ名片； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 功率谱估计： 故障诊断分析： 雷达通信：雷达LFM、MIMO、成像、定位、干扰、检测、信号分析、脉冲压缩 滤波估计：SOC估计 目标定位：WSN定位、滤波跟踪、目标定位 生物电信号：肌电信号EMG、脑电信号EEG、心电信号ECG 通信系统：DOA估计、编码译码、变分模态分解、管道泄漏、滤波器、数字信号处理+传输+分析+去噪（CEEMDAN）、数字信号调制、误码率、信号估计、DTMF、信号检测识别融合、LEACH协议、信号检测、水声通信
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值