多线程与高并发--------线程

一、线程的基础概念

一、基础概念

1.1 进程与线程

什么是进程？

进程是指运行中的程序。 比如我们使用钉钉，浏览器，需要启动这个程序，操作系统会给这个程序分配一定的资源（占用内存资源）。

什么线程？

线程是CPU调度的基本单位，每个线程执行的都是某一个进程的代码的某个片段。

举个栗子：房子与人

比如现在有一个100平的房子，这个方式可以看做是一个进程

房子里有人，人就可以看做成一个线程。

人在房子中做一个事情，比如吃饭，学习，睡觉。这个就好像线程在执行某个功能的代码。

所谓进程就是线程的容器，需要线程利用进程中的一些资源，处理一个代码、指令。最终实现进程锁预期的结果。

进程和线程的区别：

  • 根本不同：进程是操作系统分配的资源，而线程是CPU调度的基本单位。
  • 资源方面：同一个进程下的线程共享进程中的一些资源。线程同时拥有自身的独立存储空间。进程之间的资源通常是独立的。
  • 数量不同：进程一般指的就是一个进程。而线程是依附于某个进程的，而且一个进程中至少会有一个或多个线程。
  • 开销不同：毕竟进程和线程不是一个级别的内容，线程的创建和终止的时间是比较短的。而且线程之间的切换比进程之间的切换速度要快很多。而且进程之间的通讯很麻烦，一般要借助内核才可以实现，而线程之间通讯，相当方面。

1.2 多线程

什么是多线程？

多线程是指：单个进程中同时运行多个线程。

多线程的不低是为了提高CPU的利用率。

可以通过避免一些网络IO或者磁盘IO等需要等待的操作，让CPU去调度其他线程。

这样可以大幅度的提升程序的效率，提高用户的体验。

比如Tomcat可以做并行处理，提升处理的效率，而不是一个一个排队。

比如要处理一个网络等待的操作，开启一个线程去处理需要网络等待的任务，让当前业务线程可以继续往下执行逻辑，效率是可以得到大幅度提升的。

多线程的局限

  • 如果线程数量特别多，CPU在切换线程上下文时，会额外造成很大的消耗。
  • 任务的拆分需要依赖业务场景，有一些异构化的任务，很难对任务拆分，还有很多业务并不是多线程处理更好。
  • 线程安全问题：虽然多线程带来了一定的性能提升，但是再做一些操作时，多线程如果操作临界资源，可能会发生一些数据不一致的安全问题，甚至涉及到锁操作时，会造成死锁问题。

1.3 串行、并行、并发

什么是串行：

串行就是一个一个排队，第一个做完，第二个才能上。

什么是并行：

并行就是同时处理。（一起上！！！）

什么是并发：

这里的并发并不是三高中的高并发问题，这里是多线程中的并发概念（CPU调度线程的概念）。CPU在极短的时间内，反复切换执行不同的线程，看似好像是并行，但是只是CPU高速的切换。

并行囊括并发。

并行就是多核CPU同时调度多个线程，是真正的多个线程同时执行。

单核CPU无法实现并行效果，单核CPU是并发。

1.4 同步异步、阻塞非阻塞

同步与异步：执行某个功能后，被调用者是否会主动反馈信息

阻塞和非阻塞：执行某个功能后，调用者是否需要一直等待结果的反馈。

两个概念看似相似，但是侧重点是完全不一样的。

同步阻塞：比如用锅烧水，水开后，不会主动通知你。烧水开始执行后，需要一直等待水烧开。

同步非阻塞：比如用锅烧水，水开后，不会主动通知你。烧水开始执行后，不需要一直等待水烧开，可以去执行其他功能，但是需要时不时的查看水开了没。

异步阻塞：比如用水壶烧水，水开后，会主动通知你水烧开了。烧水开始执行后，需要一直等待水烧开。

异步非阻塞：比如用水壶烧水，水开后，会主动通知你水烧开了。烧水开始执行后，不需要一直等待水烧开，可以去执行其他功能。

异步非阻塞这个效果是最好的，平时开发时，提升效率最好的方式就是采用异步非阻塞的方式处理一些多线程的任务。

二、线程的创建

线程的创建分为三种方式：

2.1 继承Thread类 重写run方法

启动线程是调用start方法，这样会创建一个新的线程，并执行线程的任务。

如果直接调用run方法，这样会让当前线程执行run方法中的业务逻辑。

public class MiTest {public static void main(String[] args) {MyJob t1 = new MyJob();t1.start();for (int i = 0; i < 100; i++) {System.out.println("main:" + i);}}}
class MyJob extends Thread{@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.println("MyJob:" + i);}}
}

2.2 实现Runnable接口 重写run方法

public class MiTest {public static void main(String[] args) {MyRunnable myRunnable = new MyRunnable();Thread t1 = new Thread(myRunnable);t1.start();for (int i = 0; i < 1000; i++) {System.out.println("main:" + i);}}}class MyRunnable implements Runnable{@Overridepublic void run() {for (int i = 0; i < 1000; i++) {System.out.println("MyRunnable:" + i);}}
}

最常用的方式：

  • 匿名内部类方式：
    Thread t1 = new Thread(new Runnable() {@Overridepublic void run() {for (int i = 0; i < 1000; i++) {System.out.println("匿名内部类:" + i);}}
});
  • lambda方式：
    Thread t2 = new Thread(() -> {for (int i = 0; i < 100; i++) {System.out.println("lambda:" + i);}
});

2.3 实现Callable 重写call方法，配合FutureTask

Callable一般用于有返回结果的非阻塞的执行方法

同步非阻塞。

public class MiTest {public static void main(String[] args) throws ExecutionException, InterruptedException {//1. 创建MyCallableMyCallable myCallable = new MyCallable();//2. 创建FutureTask，传入CallableFutureTask futureTask = new FutureTask(myCallable);//3. 创建Thread线程Thread t1 = new Thread(futureTask);//4. 启动线程t1.start();//5. 做一些操作//6. 要结果Object count = futureTask.get();System.out.println("总和为：" + count);}
}class MyCallable implements Callable{@Overridepublic Object call() throws Exception {int count = 0;for (int i = 0; i < 100; i++) {count += i;}return count;}
}

2.4 基于线程池构建线程

追其底层，其实只有一种，实现Runnble

二、线程的使用

2.1 线程的状态

Java中给线程准备的6种状态

在这里插入图片描述

NEW：Thread对象被创建出来了，但是还没有执行start方法。

RUNNABLE：Thread对象调用了start方法，就为RUNNABLE状态（CPU调度/没有调度）

BLOCKED：synchronized没有拿到同步锁，被阻塞的情况

WAITING：调用wait方法就会处于WAITING状态，需要被手动唤醒

Object.wait with no timeout
Thread.join with no timeout
LockSupport.park

TIME_WAITING：调用sleep方法或者join方法，会被自动唤醒，无需手动唤醒

Thread.sleep
Object.wait with timeout
Thread.join with timeout
LockSupport.parkNanos
LockSupport.parkUntil

BLOCKED、WAITING、TIME_WAITING：都可以理解为是阻塞、等待状态，因为处在这三种状态下，CPU不会调度当前线程

TERMINATED：run方法执行完毕，线程生命周期到头了

在Java代码中验证一下效果

NEW：

public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(() -> {});System.out.println(t1.getState());
}

RUNNABLE：

public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(() -> {while(true){}});t1.start();Thread.sleep(500);System.out.println(t1.getState());
}

BLOCKED：

public static void main(String[] args) throws InterruptedException {Object obj = new Object();Thread t1 = new Thread(() -> {// t1线程拿不到锁资源，导致变为BLOCKED状态synchronized (obj){}});// main线程拿到obj的锁资源synchronized (obj) {t1.start();Thread.sleep(500);System.out.println(t1.getState());}
}

WAITING：

public static void main(String[] args) throws InterruptedException {Object obj = new Object();Thread t1 = new Thread(() -> {synchronized (obj){try {obj.wait();} catch (InterruptedException e) {e.printStackTrace();}}});t1.start();Thread.sleep(500);System.out.println(t1.getState());
}

TIMED_WAITING：

public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(() -> {try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}});t1.start();Thread.sleep(500);System.out.println(t1.getState());
}

TERMINATED：

public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(() -> {try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}});t1.start();Thread.sleep(1000);System.out.println(t1.getState());
}

2.2 线程的常用方法

2.2.1 获取当前线程

Thread的静态方法获取当前线程对象

public static void main(String[] args) throws ExecutionException, InterruptedException {// 获取当前线程的方法Thread main = Thread.currentThread();System.out.println(main);// "Thread[" + getName() + "," + getPriority() + "," +  group.getName() + "]";// Thread[main,5,main]
}
2.2.2 线程的名字

在构建Thread对象完毕后，一定要设置一个有意义的名称，方面后期排查错误

public static void main(String[] args) throws ExecutionException, InterruptedException {Thread t1 = new Thread(() -> {System.out.println(Thread.currentThread().getName());});t1.setName("模块-功能-计数器");t1.start();
}
2.2.3 线程的优先级

其实就是CPU调度线程的优先级、

java中给线程设置的优先级别有10个级别，从1~10任取一个整数。

如果超出这个范围，会排除参数异常的错误

public static void main(String[] args) throws ExecutionException, InterruptedException {Thread t1 = new Thread(() -> {for (int i = 0; i < 1000; i++) {System.out.println("t1:" + i);}});Thread t2 = new Thread(() -> {for (int i = 0; i < 1000; i++) {System.out.println("t2:" + i);}});t1.setPriority(1);t2.setPriority(10);t2.start();t1.start();
}
2.2.4 线程的让步

可以通过Thread的静态方法yield，让当前线程从运行状态转变为就绪状态。

public static void main(String[] args) throws ExecutionException, InterruptedException {Thread t1 = new Thread(() -> {for (int i = 0; i < 100; i++) {if(i == 50){Thread.yield();}System.out.println("t1:" + i);}});Thread t2 = new Thread(() -> {for (int i = 0; i < 100; i++) {System.out.println("t2:" + i);}});t2.start();t1.start();
}
2.2.5 线程的休眠

Thread的静态方法，让线程从运行状态转变为等待状态

sleep有两个方法重载：

  • 第一个就是native修饰的，让线程转为等待状态的效果
  • 第二个是可以传入毫秒和一个纳秒的方法（如果纳秒值大于等于0.5毫秒，就给休眠的毫秒值+1。如果传入的毫秒值是0，纳秒值不为0，就休眠1毫秒）

sleep会抛出一个InterruptedException

public static void main(String[] args) throws InterruptedException {System.out.println(System.currentTimeMillis());Thread.sleep(1000);System.out.println(System.currentTimeMillis());
}
2.2.6 线程的强占

Thread的非静态方法join方法

需要在某一个线程下去调用这个方法

如果在main线程中调用了t1.join()，那么main线程会进入到等待状态，需要等待t1线程全部执行完毕，在恢复到就绪状态等待CPU调度。

如果在main线程中调用了t1.join(2000)，那么main线程会进入到等待状态，需要等待t1执行2s后，在恢复到就绪状态等待CPU调度。如果在等待期间，t1已经结束了，那么main线程自动变为就绪状态等待CPU调度。

public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(() -> {for (int i = 0; i < 10; i++) {System.out.println("t1:" + i);try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}});t1.start();for (int i = 0; i < 10; i++) {System.out.println("main:" + i);try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}if (i == 1){try {t1.join(2000);} catch (InterruptedException e) {e.printStackTrace();}}}
}
2.2.7 守护线程

默认情况下，线程都是非守护线程

JVM会在程序中没有非守护线程时，结束掉当前JVM

主线程默认是非守护线程，如果主线程执行结束，需要查看当前JVM内是否还有非守护线程，如果没有JVM直接停止

public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(() -> {for (int i = 0; i < 10; i++) {System.out.println("t1:" + i);try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}});t1.setDaemon(true);t1.start();
}
2.2.8 线程的等待和唤醒

可以让获取synchronized锁资源的线程通过wait方法进去到锁的等待池，并且会释放锁资源

可以让获取synchronized锁资源的线程，通过notify或者notifyAll方法，将等待池中的线程唤醒，添加到锁池中

notify随机的唤醒等待池中的一个线程到锁池

notifyAll将等待池中的全部线程都唤醒，并且添加到锁池

在调用wait方法和notify以及norifyAll方法时，必须在synchronized修饰的代码块或者方法内部才可以，因为要操作基于某个对象的锁的信息维护。

public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(() -> {sync();},"t1");Thread t2 = new Thread(() -> {sync();},"t2");t1.start();t2.start();Thread.sleep(12000);synchronized (MiTest.class) {MiTest.class.notifyAll();}
}public static synchronized void sync()  {try {for (int i = 0; i < 10; i++) {if(i == 5) {MiTest.class.wait();}Thread.sleep(1000);System.out.println(Thread.currentThread().getName());}} catch (InterruptedException e) {e.printStackTrace();}
}

2.3 线程的结束方式

线程结束方式很多，最常用就是让线程的run方法结束，无论是return结束，还是抛出异常结束，都可以

2.3.1 stop方法（不用）

强制让线程结束，无论你在干嘛，不推荐使用当然当然方式，但是，他确实可以把线程干掉

public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(() -> {try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}});t1.start();Thread.sleep(500);t1.stop();System.out.println(t1.getState());
}
2.3.2 使用共享变量（很少会用）

这种方式用的也不多，有的线程可能会通过死循环来保证一直运行。

咱们可以通过修改共享变量在破坏死循环，让线程退出循环，结束run方法

static volatile boolean flag = true;public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(() -> {while(flag){// 处理任务}System.out.println("任务结束");});t1.start();Thread.sleep(500);flag = false;
}
2.3.3 interrupt方式

共享变量方式

public static void main(String[] args) throws InterruptedException {// 线程默认情况下，    interrupt标记位：falseSystem.out.println(Thread.currentThread().isInterrupted());// 执行interrupt之后，再次查看打断信息Thread.currentThread().interrupt();// interrupt标记位：tureSystem.out.println(Thread.currentThread().isInterrupted());// 返回当前线程，并归位为false interrupt标记位：tureSystem.out.println(Thread.interrupted());// 已经归位了System.out.println(Thread.interrupted());// =====================================================Thread t1 = new Thread(() -> {while(!Thread.currentThread().isInterrupted()){// 处理业务}System.out.println("t1结束");});t1.start();Thread.sleep(500);t1.interrupt();
}

通过打断WAITING或者TIMED_WAITING状态的线程，从而抛出异常自行处理

这种停止线程方式是最常用的一种，在框架和JUC中也是最常见的

public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(() -> {while(true){// 获取任务// 拿到任务，执行任务// 没有任务了，让线程休眠try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();System.out.println("基于打断形式结束当前线程");return;}}});t1.start();Thread.sleep(500);t1.interrupt();
}

wait和sleep的区别？

  • sleep属于Thread类中的static方法、wait属于Object类的方法
  • sleep属于TIMED_WAITING，自动被唤醒、wait属于WAITING，需要手动唤醒。
  • sleep方法在持有锁时，执行，不会释放锁资源、wait在执行后，会释放锁资源。
  • sleep可以在持有锁或者不持有锁时，执行。 wait方法必须在只有锁时才可以执行。

wait方法会将持有锁的线程从owner扔到WaitSet集合中，这个操作是在修改ObjectMonitor对象，如果没有持有synchronized锁的话，是无法操作ObjectMonitor对象的。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://xiahunao.cn/news/1380552.html

如若内容造成侵权/违法违规/事实不符，请联系瞎胡闹网进行投诉反馈，一经查实，立即删除！

相关文章

MMORPG大型游戏设计与开发（服务器 游戏场景 地图和区域）

MMORPG大型游戏设计与开发（服务器 游戏场景 地图和区域）

地图的数据以及区域的信息是场景的重要组成部分&#xff0c;这些数据同时存在客户端和服务器&#xff0c;而且都是由编辑器生成的。那么保存的文件数据结构是怎样的&#xff1f;一张3D的场景地图又是怎样处理这些数据的&#xff1f;同时告诉大家这里同样只是讲的理论与设计&…
阅读更多...
对话CMU计算机新院长：看好AI交叉创新出成果，建议新生先泛后专

对话CMU计算机新院长：看好AI交叉创新出成果，建议新生先泛后专

2019-11-21 13:25:16 唐木 发自 天龙寺 量子位 报道 | 公众号 QbitAI 谁是全球最好的大学&#xff1f;谁有全球最好的计算机学院&#xff1f; 如果你问李开复、陆奇、沈向洋、洪小文等功成名就的计算机大牛&#xff0c;多半都会得到同一个答案&#xff1a; Carnegie Mellon …
阅读更多...
[转]天龙八部服务器端-共享内存的设计

[转]天龙八部服务器端-共享内存的设计

一、服务器构架 一个天龙八部游戏区&#xff0c;主要服务器部署情况如下图所示: 实际部署可能有所不同。区角色数据库可以安装到Machine4&#xff0c;那么一个区有5台物理机器。LoginServer和WorldServer、CharacterDB、BillingServer有连接。WorldServer和各个GameServer有连接…
阅读更多...
天龙八部服务器端---共享内存的设计

天龙八部服务器端---共享内存的设计

2019独角兽企业重金招聘Python工程师标准>>> 原文地址&#xff1a;http://zhktiger.blog.sohu.com/163971755.html&#xff0c;非常感谢作者的分享。 一、服务器构架 一个天龙八部游戏区&#xff0c;主要服务器部署情况如下图所示: 实际部署可能有所不同。区角色…
阅读更多...
天龙八部服务器端共享内存的设计

天龙八部服务器端共享内存的设计

原文&#xff1a;http://zhktiger.blog.sohu.com/163971760.html 一、服务器构架 一个天龙八部游戏区&#xff0c;主要服务器部署情况如下图所示: 实际部署可能有所不同。区角色数据库可以安装到Machine4&#xff0c;那么一个区有5台物理机器。LoginServer和WorldServer、Chara…
阅读更多...
初识鸿蒙跨平台开发框架ArkUI-X

初识鸿蒙跨平台开发框架ArkUI-X

HarmonyOS是一款面向万物互联时代的、全新的分布式操作系统。在传统的单设备系统能力基础上&#xff0c;HarmonyOS提出了基于同一套系统能力、适配多种终端形态的分布式理念&#xff0c;能够支持手机、平板、智能穿戴、智慧屏、车机等多种终端设备&#xff0c;提供全场景&#…
阅读更多...
虚拟DOM（Virtual DOM）和真实DOM（Real DOM）区别

虚拟DOM（Virtual DOM）和真实DOM（Real DOM）区别

虚拟DOM&#xff08;Virtual DOM&#xff09; 虚拟DOM是以Javascript的形式存在来描述DOM&#xff0c;创建虚拟DOM的目的就是将虚拟DOM更好的渲染到页面UI中&#xff0c;它与真实的DOM是一一对应的不可以直接更新HTML元素更新&#xff0c;更新JSX操作DOM方便&#xff0c;消耗少…
阅读更多...
【技术科普】VR、AR、MR的区别

【技术科普】VR、AR、MR的区别

VR、AR、MR定义&#xff1a; 什么是虚拟现实&#xff1f; 虚拟现实(Virtual Reality&#xff0c;简称VR&#xff0c;又译作灵境、幻真)是近年来出现的高新技术&#xff0c;也称灵境技术或人工环境。虚拟现实是利用电脑模拟产生一个三维空间的虚拟世界&#xff0c;提供使用者关…
阅读更多...
OSVR接入HMD设备

OSVR接入HMD设备

推荐一本书<<金字塔原理>>&#xff0c;本文按照书中说提的“是什么&#xff0c;为什么&#xff0c;怎么做”&#xff0c;来说明如何把HMD设备接入到OSVR上。 为什么要做OSVR插件 对于我们来说&#xff0c;后续要制作的产品是头盔&#xff0c;对于头盔设备通过插件…
阅读更多...
迈德威视SDK

迈德威视SDK

引入 代码 public class MVCamera : InterfaceCamera{#region 属性字段PictureBox pb_ShowImage;//图像框tSdkCameraDevInfo[] tCameraDevInfoList;CameraSdkStatus status;public static CameraHandle[] m_hCamera; // 句柄CAMERA_SNAP_PROC m_CaptureCallback;In…
阅读更多...
MVVM 架构,ViewModel和LiveData(一)

MVVM 架构,ViewModel和LiveData(一)

MVVM 架构,ViewModel和LiveData(一) 标签&#xff08;空格分隔&#xff09;&#xff1a; 翻译计划 Android开发 原文链接 MVVM architecture, ViewModel and LiveData (Part 1) 正文 在Google I/O之间,Google推出了包含LiveData和ViewModel的组件架构,这有助于开发者们使用…
阅读更多...
DRMM model

DRMM model

Paper 的引用&#xff1a; Guo J, Fan Y, Ai Q, et al. A deep relevance matching model for ad-hoc retrieval[C]//Proceedings of the 25th ACM International on Conference on Information and Knowledge Management. ACM, 2016: 55-64. Retrieval or Matching 论文中说到…
阅读更多...
JVM(JAVA虚拟机)、DVM(Dalvik虚拟机)和ART虚拟机

JVM(JAVA虚拟机)、DVM(Dalvik虚拟机)和ART虚拟机

一、什么是DVM&#xff0c;和JVM有什么不同&#xff1f; JVM是Java Virtual Machine&#xff0c;而DVM就是Dalvik Virtual Machine&#xff0c;是安卓中使用的虚拟机&#xff0c;所有安卓程序都运行在安卓系统进程里&#xff0c;每个进程对应着一个Dalvik虚拟机实例。他们都提…
阅读更多...
关于Hdmi2.1，FRL，DSC，VRR，ALLM你需要知道这些

关于Hdmi2.1，FRL，DSC，VRR，ALLM你需要知道这些

文章目录 TMDSFRLDSCVRRALLM相关设备Nvidia显卡电视游戏机显示器 注意的坑 最近在研究Hdmi相关内容&#xff08;看游戏设备hhh&#xff09;&#xff0c;网上很多信息都是零零碎碎的&#xff0c;结合自己的一些研究简单记录一下。 Hdmi&#xff0c;High Definition Multimedia I…
阅读更多...
HDMI 2.1 VRR功能详解

HDMI 2.1 VRR功能详解

7.6可变刷新率和快速更新 可变刷新率&#xff08;VRR&#xff09;允许图片在源完成准备后立即通过链路发送。在链路支持的最大字符速率大于给定视频定时所需的速率的情况下&#xff0c;Fast VActive&#xff08;FVA&#xff09;减少了传输图片所需的时间。这些特性提供了性能、…
阅读更多...
VVC帧间预测（八）DMVR

VVC帧间预测（八）DMVR

解码端运动向量修正(Decoder side motion vector refinement ,DMVR)是为了提高merge模式下双向预测MV的准确性而提出的技术。双向预测是在list0和list1中分别找一个运动向量MV0和MV1&#xff0c;然后将MV0和MV1所指向的预测块进行加权得到最终的预测块。而DMVR不是直接使用MV0和…
阅读更多...
ARVR技术 | AR, VR, MR和XR?想搞清楚不?

ARVR技术 | AR, VR, MR和XR?想搞清楚不?

AR, VR, MR&#xff0c;现在还有XR ?这些缩写是什么?它们代表什么? 让我们快速梳理一下技术术语。 首先&#xff0c;虽然你可能熟悉其中的一些术语&#xff0c;如AR和VR, 但MR和XR对许多人来说仍然是新鲜的术语。 目前的共识是&#xff0c;所有这些互补形式的现实都落在一…
阅读更多...
MDD(模型驱动开发)

MDD(模型驱动开发)

前言导读 当下企业软件应用开发面临着需求复杂多变、新的需求和系统不断增长&#xff0c;软件系统变得越来越复杂&#xff0c;普通的软件开发方式难以快速满足用户需求。为了解决这些问题&#xff0c;就出现了很多新的方法&#xff0c;其中最突出的一个就是模型驱动开发 MDD &a…
阅读更多...
RSCMVR

RSCMVR

也是之前发了 ~~ 又带来马教授的~~ 神器稀疏卷积性能和稳健性超越ResNet 标题就是简写可好? 尽管深度神经网络在图像分类方面具有很强的经验性能&#xff08;empirical performance&#xff09;&#xff0c;但这类模型往往被视为「黑盒」&#xff0c;最为人诟病的就是「难以解…
阅读更多...
EMD和VMD

EMD和VMD

作者&#xff1a;桂。 时间&#xff1a;2017-03-06 20:57:22 链接&#xff1a;http://www.cnblogs.com/xingshansi/p/6511916.html 前言 本文为Hilbert变换一篇的内容补充&#xff0c;主要内容为&#xff1a; 1&#xff09;EMD原理介绍 2&#xff09;代码分析 3&#xff09…
阅读更多...
最新文章

Copyright @ 2022~2023