MySQL 主从复制（Master-Slave Replication）是一种数据复制技术，用于在多个数据库服务器之间的数据同步。在主从复制架构中，一个服务器被设置为主服务器（Master），充当数据源，其他服务器被设置为从服务器（Slave），用来复制主服务器的数据。

1.主从复制优点

主从复制的主要优点有以下几个：

1. 高可用性
   ：通过将主数据库的数据复制到一个或多个从数据库，可以在
   主数据库故障时快速切换到从数据库
   ，以实现系统的高可用性和容错能力，从而保证系统的持续可用性。
2. 提高整体性能和吞吐量
   ：通过将读请求分散到多个从服务器上进行处理，从而减轻了主服务器的负载压力，提高数据库系统的整体性能和吞吐量。主服务器主要负责写操作，而从服务器主要负责读操作，从而分担了主服务器的压力。
3. 数据备份和恢复
   ：通过主从同步，可以将主服务器上的数据异步复制到从服务器上，从而实现数据备份和灾难恢复的需求。在应对意外数据丢失、灾难恢复或误操作时，可以使用从服务器作为数据的备份源来进行数据恢复。

2.如何实现主从复制？

① 配置并重启主服务器

在主服务器的配置文件（my.cnf）中添加以下参数：

[mysqld] server-id = 1 # 设置服务器 ID，每个主服务器和从服务器都必须有唯一的 ID

log_bin = /var/log/mysql/mysql-bin.log # 开启二进制日志，记录数据修改操作

以上配置完成之后，重启 MySQL 服务器，因为重启了 MySQL 服务才能让配置生效。

② 创建用于主从复制的用户

登录到主服务器上，执行以下命令：

CREATE USER 'repl'@'%' IDENTIFIED BY 'password';    -- 替换为实际的用户名和密码
GRANT REPLICATION SLAVE ON *.* TO 'repl'@'%';

③ 查看主服务器状态

在 MySQL 主服务器中，执行以下命令，记录下 File 和 Position 的值，后续用于配置从服务器：

SHOW MASTER STATUS;

④ 配置并重启从服务器

在从服务器的配置文件（my.cnf）中添加以下参数：

[mysqld]

server-id = 2 # 设置服务器 ID，每个主服务器和从服务器都必须有唯一的 ID

重启从服务器，让以上配置生效。

⑤ 在从服务器上设置主服务器信息

登录到从服务器的 MySQL 中，执行以下命令（将 MASTER_HOST、MASTER_USER、MASTER_PASSWORD、MASTER_LOG_FILE 和 MASTER_LOG_POS 替换为对应的值）：

CHANGE MASTER TO MASTER_HOST='master_ip', MASTER_USER='repl', 
MASTER_PASSWORD='password', MASTER_LOG_FILE='binlog_file', 
MASTER_LOG_POS=log_file_position;

⑥ 启动从服务器的复制进程

执行以下命令启动从服务器的复制进程：

START SLAVE;

⑦ 检查从服务器的复制状态

执行以下命令，确保 Slave_IO_Running 和 Slave_SQL_Running 的值都为 "YES"：

SHOW SLAVE STATUS \G;

3.主从复制原理

MySQL 数据库的主从复制主要是基于 Binary Log（二进制文件，简称 bin log）实现的，它的实现流程如下：

它的主要执行流程如下：

1. 主数据库接收到一个写操作（如 INSERT、UPDATE、DELETE）时，会将这个操作记录到二进制日志（Binary Log）中，将数据修改的操作按顺序记录下来。
2. 从数据库 IO 线程会自动连接主服务，从二进制中读取同步数据，记录到中继日志（Relay Log）中。
3. 从数据库的 SQL 线程会定期从中继日志中获取同步数据，写入到从数据库中。

4.Bin Log 日志格式

Binary Log 二级制日志，它总共有以下三种格式（不同的日志格式决定了不同的主从同步效果）：

1. STATEMENT 格式（语句模式，出现在 MySQL 5.1 之前）
   ：在这种格式下，binlog 记录的是执行的 SQL 语句的文本。
   
   1. 优点：日志文件通常较小，复制效率较高。
   2. 缺点：在某些情况下，由于数据库环境的差异（如表结构、字符集等），在从服务器上重放这些 SQL 语句可能会导致不一致的结果。例如，获取当前时间的函数或存储过程等，可能会导致数据不一致。
2. ROW 格式（行模式，诞生于 MySQL 5.1）
   ：在这种格式下，binlog 记录的是每一行数据更改的具体内容。
   
   1. 优点：能够精确地记录数据的变化，避免了 STATEMENT 格式中的环境依赖问题，提供了更强的一致性保证。
   2. 缺点：日志文件可能会比 STATEMENT 格式大，因为记录了每一行的详细变化。此外，ROW 格式的日志在进行大量数据更新时可能会导致更高的 I/O 开销。
3. MIXED 格式（混合模式）
   ：在这种格式下，binlog 可以根据具体的 SQL 语句和操作自动选择使用 STATEMENT 或 ROW 格式。
   
   1. 优点：结合了 STATEMENT 和 ROW 格式的优点，能够在保证一致性的同时尽可能地优化日志大小和复制性能。
   2. 缺点：由于混合使用了两种格式，可能需要更复杂的管理和监控。在某些特定情况下，MIXED 格式可能无法达到最优的性能或一致性。

5.主从复制模式

MySQL 中主要有以下两种主从复制的模式，分别是异步复制和半同步复制。

1. 异步复制
   ：MySQL 主从复制中最常见和默认的模式。在异步复制模式中，主服务器将数据修改操作记录到二进制日志（Binary Log）中，并将日志传输给从服务器。从服务器接收到二进制日志后，会异步地应用这些日志进行数据复制。
   
   1. 优点：它的优点是及时响应给使用者，主服务器不会受到从服务器的影响而等待确认，可以提高主服务器的性能。
   2. 缺点：由于是异步复制，可能存在数据传输的延迟，且从服务器上的复制过程是不可靠的。如果主服务器故障，尚未应用到从服务器的数据可能会丢失。
2. 半同步复制
   ：半同步复制是 MySQL 主从复制中的一种增强模式。在半同步复制模式中，主服务器将数据修改操作记录到二进制日志，并等待至少一个从服务器确认已接收到并应用了这些日志后才继续执行后续操作。
   
   1. 优点：可以提供更高的数据一致性和可靠性，确保至少一个从服务器与主服务器保持同步。如果主服务器故障，已经确认接收并应用到从服务器的数据不会丢失。
   2. 缺点：由于半同步复制需要等待从服务器的确认，因此相对于异步复制，会增加一定的延迟，可能会影响主服务器的性能。

如果对数据一致性和可靠性要求较高，可以考虑使用半同步复制；如果对延迟和主服务器性能要求较高，可以继续使用异步复制，根据实际需求调整复制模式。

小结

MySQL 主从复制用于多个数据库服务器之间的数据同步，它可以提供高可用性、提高数据库整体性能和吞吐量，以及可以进行数据备份和数据库恢复。MySQL 主从复制是通过 bin log 实现的，主服务写入操作会同时添加到 bin log 中，而从数据库定期拉取主数据库的 bin log，然后将拉取的数据存放到自己的 relay log 中，之后再由单独 SQL 线程将数据写入到从数据库中，此时 MySQL 的主从同步就完成了。

本文已收录到我的面试小站
www.javacn.site
，其中包含的内容有：Redis、JVM、并发、并发、MySQL、Spring、Spring MVC、Spring Boot、Spring Cloud、MyBatis、设计模式、消息队列等模块。

什么是反射

在说反射概念之前，我们先说另外2个概念：
编译期
和
运行期
。

编译期：

• 编译期是源代码从文本形式转换为字节码的过程，这发生在Java代码被JVM执行之前。
• 在编译期，编译器对源代码进行语法检查、类型检查、变量名解析等操作，确保代码符合Java的语法规则，并将其编译成字节码（.class文件）。
• 编译期间的操作基于静态类型信息。编译器只能使用它在编译时了解的信息，而不能知晓运行时的具体情况。

运行期：

• 运行期是指编译后的代码在Java虚拟机（JVM）上执行的过程。
• 在运行期，JVM执行编译后的字节码，并进行各种运行时操作，如内存分配、垃圾回收等。

反射机制
主要发生在
运行期
。反射允许程序在运行时动态访问和操作类、对象、方法、属性等。

使用反射，程序可以获取类的信息（如类名、方法、字段等），并可以创建对象、调用方法、修改字段值，这些都是在运行时发生的。

补充：在学习
JVM内存结构
时，我们知道在类信息是存放在
方法区
的。

反射的优缺点

优点：

在运行时获得类的各种内容，进行反编译，对于Java这种先编译再运行的语言，能够让我们很方便的创建灵活的代码，这些代码可以在运行时装配，无需在组件之间进行源代码的链接，更加容易实现面向对象。

缺点：

（1）反射会消耗一定的系统资源，因此，如果不需要动态地创建一个对象，那么就不需要用反射；

（2）反射调用方法时可以忽略权限检查，因此可能会破坏封装性而导致安全问题。

反射的入口：Class类

类 Class 的实例代表在运行中的 Java 应用程序中的类和接口。枚举是一种类，注解是一种接口。每个数组也属于一个类，这个类以 Class 对象的形式反映出来，这个 Class 对象被所有具有相同元素类型和维数的数组共享。Java 的基本类型（boolean、byte、char、short、int、long、float 和 double）以及关键字 void 也表示为 Class 对象。

三种方式获取Class对象

• 通过实例对象获取Class对象

• 通过类名.class获取Class对象

• 通过Class.forName(String className)获取Class对象

@SpringBootTest
class DemoReflectionApplicationTests {

    @Test
    void contextLoads() throws ClassNotFoundException {
        User user = new User();
        Class<? extends User> u1 = user.getClass();
        System.out.println(u1.getName());
        System.out.println(u1.hashCode());

        Class<User> u2 = User.class;
        System.out.println(u2.hashCode());

        Class<?> u3 = Class.forName("com.example.reflection.pojo.User");
        System.out.println(u3.hashCode());
    }

}

com.example.reflection.pojo.User
1970707120
1970707120
1970707120

在运行期间，一个类只有一个Class对象产生。

获取到Class对象，我们能拿到哪些信息？

获取名称信息

// 返回Java内部使用的真正的名称
public String getName();
// 返回的名称不带包信息
public String getSimpleName();
// 返回的名称更加友好
public String getCanonicalName();
// 返回包信息
public String getPackage();

@Test
void contextLoad2() throws ClassNotFoundException {
    Class<?> u = Class.forName("com.example.reflection.pojo.User");
    System.out.println(u.getName());
    System.out.println(u.getSimpleName());
    System.out.println(u.getCanonicalName());
    System.out.println(u.getPackage());

    Class<String> s = String.class;
    System.out.println(s.getName());
    System.out.println(s.getSimpleName());
    System.out.println(s.getCanonicalName());
    System.out.println(s.getPackage());
}

结果：

com.example.reflection.pojo.User
User
com.example.reflection.pojo.User
package com.example.reflection.pojo
java.lang.String
String
java.lang.String
package java.lang, Java Platform API Specification, version 1.8

获取字段信息

Class获取字段信息的方法：

// 返回所有的public字段，包括其父类的，如果没有字段，返回空数组
public Field[] getFields()
// 返回本类声明的所有字段，包括非public的，但不包括父类的
public Field[] getDeclaredFields()
// 返回本类或父类中指定名称的public字段，找不到抛出异常NoSuchFieldException
public Field getField(String name)
// 返回本类中声明的指定名称的字段，找不到抛出异常NoSuchFieldException
public Field getDeclaredField(String name)

获取到Field以后，进一步获取字段信息：

// 获取字段的名称
public String getName()
// 判断当前程序是否有该字段的访问权限
public boolean isAccessible()
// flag设为true表示忽略Java的访问检查机制，以允许读写非public的字段
public void setAccessible(boolean flag)
// 获取指定对象obj中该字段的值
public Object get(Object obj)
// 将指定对象obj中该字段的值设为value
public void set(Object obj, Object value)

// 返回字段的修饰符
public int getModifiers()
//返回字段的类型
public Class<? > getType()
//查询字段的注解信息，下一章介绍注解
public <T extends Annotation> T getAnnotation(Class<T> annotationClass)
public Annotation[] getDeclaredAnnotations()

获取方法信息

类中定义的
静态方法
和
实例方法
都算在内，用类Method表示。

//返回所有的public方法，包括其父类的，如果没有方法，返回空数组
public Method[] getMethods()
//返回本类声明的所有方法，包括非public的，但不包括父类的
public Method[] getDeclaredMethods()
//返回本类或父类中指定名称和参数类型的public方法，
//找不到抛出异常NoSuchMethodException
public Method getMethod(String name, Class<? >... parameterTypes)
//返回本类中声明的指定名称和参数类型的方法，找不到抛出异常NoSuchMethodException
public Method getDeclaredMethod(String name, Class<? >... parameterTypes)

获取到Method后，进一步获取方法的详细信息：

//获取方法的名称
public String getName()
//flag设为true表示忽略Java的访问检查机制，以允许调用非public的方法
public void setAccessible(boolean flag)
//在指定对象obj上调用Method代表的方法，传递的参数列表为args
public Object invoke(Object obj, Object... args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException

创建对象和构造方法

Class直接创建对象，调用无参构造器。

public T newInstance()

Class获取构造器:

//获取所有的public构造方法，返回值可能为长度为0的空数组
public Constructor<? >[] getConstructors()
//获取所有的构造方法，包括非public的
public Constructor<? >[] getDeclaredConstructors()
//获取指定参数类型的public构造方法，没找到抛出异常NoSuchMethodException
public Constructor<T> getConstructor(Class<? >... parameterTypes)
//获取指定参数类型的构造方法，包括非public的，没找到抛出异常NoSuchMethodException
public Constructor<T> getDeclaredConstructor(Class<? >... parameterTypes)

获取到构造器用构造器创建对象：

public T newInstance(Object ... initargs)

类型检查和转换

类型检查：

/**
* Params:
* obj – the object to check
* Returns:
* true if obj is an instance of this class
*/
public native boolean isInstance(Object obj);

类型转换：

// 将一个对象转换为由此 Class 对象所代表的类或接口。
public T cast(Object obj) 

获取Class的类型信息

Class代表的类型既可以是普通的类，也可以是内部类，还可以是基本类型、数组等，对于一个给定的Class对象，它到底是什么类型呢？可以通过以下方法进行检查：

public native boolean isArray()  //是否是数组
public native boolean isPrimitive()  //是否是基本类型
public native boolean isInterface()  //是否是接口
public boolean isEnum()  //是否是枚举
public boolean isAnnotation()  //是否是注解
public boolean isAnonymousClass()  //是否是匿名内部类
public boolean isMemberClass()  //是否是成员类，成员类定义在方法外，不是匿名类
public boolean isLocalClass()  //是否是本地类，本地类定义在方法内，不是匿名类

获取类的声明信息

//获取修饰符，返回值可通过Modifier类进行解读
public native int getModifiers()
//获取父类，如果为Object，父类为null
public native Class<? super T> getSuperclass()
//对于类，为自己声明实现的所有接口，对于接口，为直接扩展的接口，不包括通过父类继承的
public native Class<? >[] getInterfaces();
//自己声明的注解
public Annotation[] getDeclaredAnnotations()
//所有的注解，包括继承得到的
public Annotation[] getAnnotations()
//获取或检查指定类型的注解，包括继承得到的
public <A extends Annotation> A getAnnotation(Class<A> annotationClass)
public boolean isAnnotationPresent(Class<? extends Annotation> annotationClass)

对于反射这一块内容的话，其实理解起来并不是很难，但确实是很重要，所以非常建议把代码全部敲一遍。

对于编程学习来说，Coding百遍，其义自见。

仍然是不变的硬道理。

以上就是关于反射的所有内容，感谢阅读！

联系我：
https://haibin9527.gitee.io/about_me/

前言

每当提起低代码，很多人都会下意识的出现过激反应，吐槽低代码都是**，唯恐避之不及。可能大部分人觉得低代码就是替代手写代码，对于程序员来说这是不可接受的。其实低代码表述的含义非常宽泛，我相信很多人可能都在低代码平台中受益过，而且确实可以提升效率。像原型工具（
Figma
）、建站平台（
Webflow
、
Framer
）、BI 报表（
Power BI
、
Looker Studio
）、3D 模型搭建（
Spline
、
Womp
）、动画编辑器（
Rive
）等等，这些都是非常有名的一些在线工具。

言归正传，本文并不是为了介绍低代码平台，也不想评价低代码的好坏，只是想聊一聊低代码平台中 GUI 的设计思路和实现方式。

Acrodata GUI 是一款适用于低代码平台的轻量级 GUI 库，现已开源。

GitHub:
https://github.com/acrodata/gui
Playground:
https://acrodata.github.io/gui/playground

什么是 GUI

GUI 翻译为图形用户界面，是指采用图形方式显示的计算机操作用户界面。在前端编程中，我们一般很少使用 GUI 这样的描述，所以很多人会错误地认为 GUI = UI library。

那么到底什么是 GUI 呢？为了便于理解，我们可以参照前端项目中比较有名的 GUI 项目
dat.gui
。做过 3D 可视化或者熟悉 ThreeJS 的朋友一定非常熟悉这个库。dat.gui 的主要用途就是将配置项转换成图形化控件，方便调试参数。

除了
dat.gui
之外，还有其它几款 GUI 项目也做得不错，
tweakpane
、
lil-gui
、
leva
。

低代码平台中的配置栏

对于使用过低代码平台或者开发过类似产品的朋友来说，低代码平台的布局已经司空见惯，在布局的右侧通常都是配置栏。当然，我们使用的很多软件也是如此。随便贴几张主流工具的截图。

首先说一点，并不是每一款低代码产品都需要 GUI 生成配置，比如第一张截图 Webflow，它的所有组件的配置项都是一样的（全部是 CSS 的可视化配置），这种情况直接写一个公共组件可能更简单。

但是像第三张截图 Looker Studio 这样的产品，每一种图表组件的配置都不一样，同时还允许用户自定义组件，那么这类产品就非常需要一套灵活易用的 GUI 库了。

在 Acrodata GUI 的文档站首页，我用 GUI 创建了一个稍微复杂的
CSS 渐变生成器
，它和低代码平台中的配置栏非常类型，欢迎把玩尝试。

在音视频领域，把已经发布的混音歌曲或者音频文件逆向分离一直是世界性的课题。音波混合的物理特性导致在没有原始工程文件的情况下，将其还原和分离是一件很有难度的事情。

言及背景音人声分离技术，就不能不提Spleeter，它是一种用于音频源分离（音乐分离）的开源深度学习算法，由Deezer研究团队开发。使用的是一个性能取向的音源分离算法，并且为用户提供了已经预训练好的模型，能够开箱即用，这也是Spleeter泛用性高的原因之一，关于Spleeter，请移步：
人工智能AI库Spleeter免费人声和背景音乐分离实践(Python3.10)
，这里不再赘述。

MVSEP-MDX23背景音人声分离技术由Demucs研发，Demucs来自Facebook Research团队，它的发源晚于Spleeter，早于MDX-Net，并且经历过4个大版本的迭代，每一代的模型结构都被大改。Demucs的生成质量从v3开始大幅质变，一度领先行业平均水平，v4是现在最强的开源乐器分离单模型，v1和v2的网络模型被用作MDX-net其中的一部分。

本次我们基于MVSEP-MDX23来对音频的背景音和人声进行分离。

本地分离人声和背景音

如果本地离线运行MVSEP-MDX23，首先克隆代码：

git clone https://github.com/jarredou/MVSEP-MDX23-Colab_v2.git

随后进入项目并安装依赖：

cd MVSEP-MDX23-Colab_v2  
pip3 install -r requirements.txt

随后直接进推理即可：

python3 inference.py --input_audio test.wav --output_folder ./results/

这里将test.wav进行人声分离，分离后的文件在results文件夹生成。

注意推理过程中会将分离模型下载到项目的models目录，极其巨大。

同时推理过程相当缓慢。

这里可以添加--single_onnx参数来提高推理速度，但音质上有一定的损失。

如果本地设备具备12G以上的显存，也可以添加--large_gpu参数来提高推理的速度。

如果本地没有N卡或者显存实在捉襟见肘，也可以通过--cpu参数来使用cpu进行推理，但是并不推荐这样做，因为本来就慢，用cpu就更慢了。

令人暖心的是，官方还利用Pyqt写了一个小的gui界面来提高操作友好度：

__author__ = 'Roman Solovyev (ZFTurbo), IPPM RAS'  
  
if __name__ == '__main__':  
    import os  
  
    gpu_use = "0"  
    print('GPU use: {}'.format(gpu_use))  
    os.environ["CUDA_VISIBLE_DEVICES"] = "{}".format(gpu_use)  
  
import time  
import os  
import numpy as np  
from PyQt5.QtCore import *  
from PyQt5 import QtCore  
from PyQt5.QtWidgets import *  
import sys  
from inference import predict_with_model  
  
  
root = dict()  
  
  
class Worker(QObject):  
    finished = pyqtSignal()  
    progress = pyqtSignal(int)  
  
    def __init__(self, options):  
        super().__init__()  
        self.options = options  
  
    def run(self):  
        global root  
        # Here we pass the update_progress (uncalled!)  
        self.options['update_percent_func'] = self.update_progress  
        predict_with_model(self.options)  
        root['button_start'].setDisabled(False)  
        root['button_finish'].setDisabled(True)  
        root['start_proc'] = False  
        self.finished.emit()  
  
    def update_progress(self, percent):  
        self.progress.emit(percent)  
  
  
class Ui_Dialog(object):  
    def setupUi(self, Dialog):  
        global root  
  
        Dialog.setObjectName("Settings")  
        Dialog.resize(370, 180)  
  
        self.checkbox_cpu = QCheckBox("Use CPU instead of GPU?", Dialog)  
        self.checkbox_cpu.move(30, 10)  
        self.checkbox_cpu.resize(320, 40)  
        if root['cpu']:  
            self.checkbox_cpu.setChecked(True)  
  
        self.checkbox_single_onnx = QCheckBox("Use single ONNX?", Dialog)  
        self.checkbox_single_onnx.move(30, 40)  
        self.checkbox_single_onnx.resize(320, 40)  
        if root['single_onnx']:  
            self.checkbox_single_onnx.setChecked(True)  
  
        self.pushButton_save = QPushButton(Dialog)  
        self.pushButton_save.setObjectName("pushButton_save")  
        self.pushButton_save.move(30, 120)  
        self.pushButton_save.resize(150, 35)  
  
        self.pushButton_cancel = QPushButton(Dialog)  
        self.pushButton_cancel.setObjectName("pushButton_cancel")  
        self.pushButton_cancel.move(190, 120)  
        self.pushButton_cancel.resize(150, 35)  
  
        self.retranslateUi(Dialog)  
        QtCore.QMetaObject.connectSlotsByName(Dialog)  
        self.Dialog = Dialog  
  
        # connect the two functions  
        self.pushButton_save.clicked.connect(self.return_save)  
        self.pushButton_cancel.clicked.connect(self.return_cancel)  
  
    def retranslateUi(self, Dialog):  
        _translate = QtCore.QCoreApplication.translate  
        Dialog.setWindowTitle(_translate("Settings", "Settings"))  
        self.pushButton_cancel.setText(_translate("Settings", "Cancel"))  
        self.pushButton_save.setText(_translate("Settings", "Save settings"))  
  
    def return_save(self):  
        global root  
        # print("save")  
        root['cpu'] = self.checkbox_cpu.isChecked()  
        root['single_onnx'] = self.checkbox_single_onnx.isChecked()  
        self.Dialog.close()  
  
    def return_cancel(self):  
        global root  
        # print("cancel")  
        self.Dialog.close()  
  
  
class MyWidget(QWidget):  
    def __init__(self):  
        super().__init__()  
        self.initUI()  
  
    def initUI(self):  
        self.resize(560, 360)  
        self.move(300, 300)  
        self.setWindowTitle('MVSEP music separation model')  
        self.setAcceptDrops(True)  
  
    def dragEnterEvent(self, event):  
        if event.mimeData().hasUrls():  
            event.accept()  
        else:  
            event.ignore()  
  
    def dropEvent(self, event):  
        global root  
        files = [u.toLocalFile() for u in event.mimeData().urls()]  
        txt = ''  
        root['input_files'] = []  
        for f in files:  
            root['input_files'].append(f)  
            txt += f + '\n'  
        root['input_files_list_text_area'].insertPlainText(txt)  
        root['progress_bar'].setValue(0)  
  
    def execute_long_task(self):  
        global root  
  
        if len(root['input_files']) == 0 and 1:  
            QMessageBox.about(root['w'], "Error", "No input files specified!")  
            return  
  
        root['progress_bar'].show()  
        root['button_start'].setDisabled(True)  
        root['button_finish'].setDisabled(False)  
        root['start_proc'] = True  
  
        options = {  
            'input_audio': root['input_files'],  
            'output_folder': root['output_folder'],  
            'cpu': root['cpu'],  
            'single_onnx': root['single_onnx'],  
            'overlap_large': 0.6,  
            'overlap_small': 0.5,  
        }  
  
        self.update_progress(0)  
        self.thread = QThread()  
        self.worker = Worker(options)  
        self.worker.moveToThread(self.thread)  
  
        self.thread.started.connect(self.worker.run)  
        self.worker.finished.connect(self.thread.quit)  
        self.worker.finished.connect(self.worker.deleteLater)  
        self.thread.finished.connect(self.thread.deleteLater)  
        self.worker.progress.connect(self.update_progress)  
  
        self.thread.start()  
  
    def stop_separation(self):  
        global root  
        self.thread.terminate()  
        root['button_start'].setDisabled(False)  
        root['button_finish'].setDisabled(True)  
        root['start_proc'] = False  
        root['progress_bar'].hide()  
  
    def update_progress(self, progress):  
        global root  
        root['progress_bar'].setValue(progress)  
  
    def open_settings(self):  
        global root  
        dialog = QDialog()  
        dialog.ui = Ui_Dialog()  
        dialog.ui.setupUi(dialog)  
        dialog.exec_()  
  
  
def dialog_select_input_files():  
    global root  
    files, _ = QFileDialog.getOpenFileNames(  
        None,  
        "QFileDialog.getOpenFileNames()",  
        "",  
        "All Files (*);;Audio Files (*.wav, *.mp3, *.flac)",  
    )  
    if files:  
        txt = ''  
        root['input_files'] = []  
        for f in files:  
            root['input_files'].append(f)  
            txt += f + '\n'  
        root['input_files_list_text_area'].insertPlainText(txt)  
        root['progress_bar'].setValue(0)  
    return files  
  
  
def dialog_select_output_folder():  
    global root  
    foldername = QFileDialog.getExistingDirectory(  
        None,  
        "Select Directory"  
    )  
    root['output_folder'] = foldername + '/'  
    root['output_folder_line_edit'].setText(root['output_folder'])  
    return foldername  
  
  
def create_dialog():  
    global root  
    app = QApplication(sys.argv)  
  
    w = MyWidget()  
  
    root['input_files'] = []  
    root['output_folder'] = os.path.dirname(os.path.abspath(__file__)) + '/results/'  
    root['cpu'] = False  
    root['single_onnx'] = False  
  
    button_select_input_files = QPushButton(w)  
    button_select_input_files.setText("Input audio files")  
    button_select_input_files.clicked.connect(dialog_select_input_files)  
    button_select_input_files.setFixedHeight(35)  
    button_select_input_files.setFixedWidth(150)  
    button_select_input_files.move(30, 20)  
  
    input_files_list_text_area = QTextEdit(w)  
    input_files_list_text_area.setReadOnly(True)  
    input_files_list_text_area.setLineWrapMode(QTextEdit.NoWrap)  
    font = input_files_list_text_area.font()  
    font.setFamily("Courier")  
    font.setPointSize(10)  
    input_files_list_text_area.move(30, 60)  
    input_files_list_text_area.resize(500, 100)  
  
    button_select_output_folder = QPushButton(w)  
    button_select_output_folder.setText("Output folder")  
    button_select_output_folder.setFixedHeight(35)  
    button_select_output_folder.setFixedWidth(150)  
    button_select_output_folder.clicked.connect(dialog_select_output_folder)  
    button_select_output_folder.move(30, 180)  
  
    output_folder_line_edit = QLineEdit(w)  
    output_folder_line_edit.setReadOnly(True)  
    font = output_folder_line_edit.font()  
    font.setFamily("Courier")  
    font.setPointSize(10)  
    output_folder_line_edit.move(30, 220)  
    output_folder_line_edit.setFixedWidth(500)  
    output_folder_line_edit.setText(root['output_folder'])  
  
    progress_bar = QProgressBar(w)  
    # progress_bar.move(30, 310)  
    progress_bar.setValue(0)  
    progress_bar.setGeometry(30, 310, 500, 35)  
    progress_bar.setAlignment(QtCore.Qt.AlignCenter)  
    progress_bar.hide()  
    root['progress_bar'] = progress_bar  
  
    button_start = QPushButton('Start separation', w)  
    button_start.clicked.connect(w.execute_long_task)  
    button_start.setFixedHeight(35)  
    button_start.setFixedWidth(150)  
    button_start.move(30, 270)  
  
    button_finish = QPushButton('Stop separation', w)  
    button_finish.clicked.connect(w.stop_separation)  
    button_finish.setFixedHeight(35)  
    button_finish.setFixedWidth(150)  
    button_finish.move(200, 270)  
    button_finish.setDisabled(True)  
  
    button_settings = QPushButton('⚙', w)  
    button_settings.clicked.connect(w.open_settings)  
    button_settings.setFixedHeight(35)  
    button_settings.setFixedWidth(35)  
    button_settings.move(495, 270)  
    button_settings.setDisabled(False)  
  
    mvsep_link = QLabel(w)  
    mvsep_link.setOpenExternalLinks(True)  
    font = mvsep_link.font()  
    font.setFamily("Courier")  
    font.setPointSize(10)  
    mvsep_link.move(415, 30)  
    mvsep_link.setText('Powered by <a href="https://mvsep.com">MVSep.com</a>')  
  
    root['w'] = w  
    root['input_files_list_text_area'] = input_files_list_text_area  
    root['output_folder_line_edit'] = output_folder_line_edit  
    root['button_start'] = button_start  
    root['button_finish'] = button_finish  
    root['button_settings'] = button_settings  
  
    # w.showMaximized()  
    w.show()  
    sys.exit(app.exec_())  
  
  
if __name__ == '__main__':  
    create_dialog()

效果如下：

界面虽然朴素，但相当实用，Spleeter可没给我们提供这个待遇。

Colab云端分离人声和背景音

托Google的福，我们也可以在Colab云端使用MVSEP-MDX23：

https://colab.research.google.com/github/jarredou/MVSEP-MDX23-Colab_v2/blob/v2.3/MVSep-MDX23-Colab.ipynb#scrollTo=uWX5WOqjU0QC

首先安装MVSEP-MDX23：

#@markdown #Installation  
#@markdown *Run this cell to install MVSep-MDX23*  
print('Installing... This will take 1 minute...')  
%cd /content  
from google.colab import drive  
drive.mount('/content/drive')  
!git clone https://github.com/jarredou/MVSEP-MDX23-Colab_v2.git &> /dev/null  
%cd /content/MVSEP-MDX23-Colab_v2  
!pip install -r requirements.txt &> /dev/null  
# onnxruntime-gpu nightly fix for cuda12.2  
!python -m pip install ort-nightly-gpu --index-url=https://aiinfra.pkgs.visualstudio.com/PublicPackages/_packaging/ort-cuda-12-nightly/pypi/simple/  
print('Installation done !')

随后编写推理代码：

#@markdown #Separation  
from pathlib import Path  
import glob  
  
%cd /content/MVSEP-MDX23-Colab_v2  
  
  
input = '/content/drive/MyDrive' #@param {type:"string"}  
output_folder = '/content/drive/MyDrive/output' #@param {type:"string"}  
#@markdown ---  
#@markdown *Bigshifts=1 to disable that feature*  
  
BigShifts = 7 #@param {type:"slider", min:1, max:41, step:1}  
#@markdown ---  
overlap_InstVoc = 1 #@param {type:"slider", min:1, max:40, step:1}  
overlap_VitLarge = 1 #@param {type:"slider", min:1, max:40, step:1}  
#@markdown ---  
weight_InstVoc = 8 #@param {type:"slider", min:0, max:10, step:1}  
weight_VitLarge = 5 #@param {type:"slider", min:0, max:10, step:1}  
#@markdown ---  
use_VOCFT = False #@param {type:"boolean"}  
overlap_VOCFT = 0.1 #@param {type:"slider", min:0, max:0.95, step:0.05}  
weight_VOCFT = 2 #@param {type:"slider", min:0, max:10, step:1}  
#@markdown ---  
vocals_instru_only = True #@param {type:"boolean"}  
overlap_demucs = 0.6 #@param {type:"slider", min:0, max:0.95, step:0.05}  
#@markdown ---  
output_format = 'PCM_16' #@param ["PCM_16", "FLOAT"]  
if vocals_instru_only:  
    vocals_only = '--vocals_only true'  
else:  
    vocals_only = ''  
  
  
if use_VOCFT:  
    use_VOCFT = '--use_VOCFT true'  
else:  
    use_VOCFT = ''  
  
if Path(input).is_file():  
  file_path = input  
  Path(output_folder).mkdir(parents=True, exist_ok=True)  
  !python inference.py \  
        --large_gpu \  
        --weight_InstVoc {weight_InstVoc} \  
        --weight_VOCFT {weight_VOCFT} \  
        --weight_VitLarge {weight_VitLarge} \  
        --input_audio "{file_path}" \  
        --overlap_demucs {overlap_demucs} \  
        --overlap_VOCFT {overlap_VOCFT} \  
        --overlap_InstVoc {overlap_InstVoc} \  
        --overlap_VitLarge {overlap_VitLarge} \  
        --output_format {output_format} \  
        --BigShifts {BigShifts} \  
        --output_folder "{output_folder}" \  
        {vocals_only} \  
        {use_VOCFT}  
  
else:  
  file_paths = sorted([f'"{glob.escape(path)}"' for path in glob.glob(input + "/*")])[:]  
  input_audio_args = ' '.join(file_paths)  
  Path(output_folder).mkdir(parents=True, exist_ok=True)  
  !python inference.py \  
          --large_gpu \  
          --weight_InstVoc {weight_InstVoc} \  
          --weight_VOCFT {weight_VOCFT} \  
          --weight_VitLarge {weight_VitLarge} \  
          --input_audio {input_audio_args} \  
          --overlap_demucs {overlap_demucs} \  
          --overlap_VOCFT {overlap_VOCFT} \  
          --overlap_InstVoc {int(overlap_InstVoc)} \  
          --overlap_VitLarge {int(overlap_VitLarge)} \  
          --output_format {output_format} \  
          --BigShifts {BigShifts} \  
          --output_folder "{output_folder}" \  
          {vocals_only} \  
          {use_VOCFT}

这里默认使用google云盘的目录，也可以修改为当前服务器的目录地址。

结语

MVSEP-MDX23 和 Spleeter 都是音频人声背景音分离软件，作为用户，我们到底应该怎么选择？

MVSEP-MDX23 基于 Demucs4 和 MDX 神经网络架构，可以将音乐分离成“bass”、“drums”、“vocals”和“other”四个部分。MVSEP-MDX23 在 2023 年的音乐分离挑战中获得了第三名，并且在 MultiSong 数据集上的质量比较中表现出色。它提供了 Python 命令行工具和 GUI 界面，支持 CPU 和 GPU 加速，可以在本地运行。

Spleeter 是由 Deezer 开发的开源音频分离库，它使用深度学习模型将音频分离成不同的音轨，如人声、伴奏等。Spleeter 提供了预训练的模型，可以在命令行或作为 Python 库使用。它的优势在于易用性和灵活性，可以根据需要分离不同数量的音轨。

总的来说，MVSEP-MDX23 在音频分离的性能和精度上表现出色，尤其适合需要高质量音频分离的专业用户。而 Spleeter 则更适合普通用户和开发者，因为它易于使用，并且具有更多的定制选项。

年末了，再来总结一下吧，希望本人明年的年终总结文还能在博客园发。

这次总结的主题是本人出的java书。这几年本人出了不少书，其中有python、redis和Java方面的。

姑且不说其它，java方面，本人出了spring boot，spring cloud（第一代），spring cloud alibaba（第二代）和基于spring boot+vue.js的全栈开发案例书。自我吹嘘一下，这些书好歹能自成体系，能帮助初学者系统入门。

按时间顺序，本人先是出了这本，《Spring Cloud实战》，清华出版社。当年spring cloud微服务框架还是第一代，服务治理还是用eureka组件，网关还是zuul组件，安全方面还是hystrix组件，所以这本书包含的技术现在应该可能是用不到了。

但是这本书对我的帮助倒是比较大的，一方面是稿酬相对较多，至今本人还能收到这本书的稿酬，另一方面，本人两次跳槽，面试中这本书都帮到了我，特别有一次，我面试的team叫cloud team，这本书正好对景。

后来，本人在一家互联网公司里积累了不少架构方面的经验，体会到一个java资深开发要升级到架构，首先是得会用分布式组件，毕竟如果只会用spring boot体系内的api，对程序员的帮助总是有限的。

所以本人之后出了本《Spring Boot+Vue.js+分布式组件全栈开发训练营》，也是清华出版社，其中讲spring boot的ioc和aop等技术之外，还讲了在spring boot系统里如何整合型地使用dubbo，redis，mycat以及消息中间件。

从读者的反应来看，不少读者通过读这本书，有效地掌握了分布式组件的初步技能，为提升架构技能打下了很好的基础。而且，这本书，还被不少学校选做了教材，所以这本书前后累计下来，估计也卖了不少。

写好这本书以后，由于本人在工作中进一步掌握了架构和容器方面的技能，而且当时spring cloud微服务也升级到了第二版，也就是Alibaba版，所以本人就顺带出了这本书，《Spring Cloud Alibaba与Kubernetes微服务容器化实践》。

这本书除了讲nacos服务治理组件，sentinel安全治理组件，ribbon负载均衡组件，gateway网关组件等第二代微服务组件的用法外，还包含了两大特色，第一是讲述了用docker+k8s等devops技术，打包部署spring boot+nacos等组件项目等技巧，第二讲述了用jenkins实现自动化部署的步骤。

这本书的前半段讲nacos等组件用法的内容，确实能面向初学者，但其中的集群，docker，k8s等内容，更能帮助一些只具备增删改查技能的java程序员进一步提升。

而且在写这本书的时候，本人自认为在框架和集群方面有了更深的认识，所以应该能用举重若轻的方式，向大家讲清楚相关技能。

在写好这本书以后，本人想写一本能适用于零项目经验求职者的面试书，讲得再直接一些，这些求职者（比如培训班学员或转行的人）只跑通过spring boot学习项目，零真实项目经验，但需要在面试中通过包装简历和准备各种说辞，向面试官证明自己有2，3年经验。

但是后来一想，可能这些人更大的问题是不知道学习项目该如何获取，毕竟虽然网上学习项目很多，但要根据视频或说明文字跑通一个项目真不容易，毕竟真有不少学习项目照说明是跑不通的。而且跑通学习项目的要义是，通过说明其中必要技术的用法，从而证明自己做过真实项目，而不是一味地堆砌复杂技术，更不是一味去收集各种业务类型的学习项目。

有鉴于此，本人干脆在搭建了一个spring boot+vue.js企业级管理系统的前提下，出了这本书，《Spring Boot+Vue.js企业级管理系统实战》。

这本书是围绕一个可运行的项目，讲述了前后端技术的用法，这个项目的后端其实有两个版本，一个是spring boot，另一个是spring cloud alibaba。所以一方面，不少计算机在校生能用这本书的项目做课程设计或毕业设计，同时能用这本书里的文字内容充实自己的毕业论文，另一方面，一些零项目经验但想入行java的人，可以在跑通这个学习项目的前提下，准备基于商业项目经验的面试。

至此，本人设想的Java方面系列书就还剩最后一块拼图，即面试书。当下Java方面的面试资料太多，书也不少，但一般仅限于讲解面试题，但当下面试官在确认技术时，会结合项目实践来问。

比如会问，你们项目怎么写日志，怎么做测试，怎么做部署，（数据库或事务等方面）你解决过哪些技术方面的问题，如果求职者没做过商业项目，这块大概率回答不好。更有甚者，不少零项目经验的求职者，哪怕想包装项目，但不知道真实项目长什么样，会用到哪些组件或技术，或者只是熟悉日志等技术等api用法，无法结合项目实践证明自己用过，所以当下大多数零真实项目的求职者不是卡在面试题背不好，而是卡在无法证明项目经验。

在上述书的铺垫下，本人当下正在写的这本面试书会包含如下的要点。

1 告诉求职者真实项目长什么样，这还不算，告诉求职如何在面试中证明自己做过真实项目。

2 零项目经验的求职者固然需要跑通学习项目，并从中掌握写日志连数据库等技术，但如果就用这套说辞去说，那大概率会让面试官听出这是学习项目。也就是说，如何把学习项目的技术转化成商业项目的经验，这是个大问题，但本书会讲这点。

3 就单单说java面试题，大而全地全部背，不如结合底层代码结合项目说，本书还会从虚拟机调优，集合，设计模式等方面，告诉求职者如何在自己掌握有限知识的基础上，通过引导，让面试官感觉你很行。

4 这点是最重要的，就告诉求职者，如何结合项目和细节api，告诉面试官，自己在项目里用过事务，redis，dubbo或微服务组件等高级技能，这还不算，还能通过项目场景和排查过程，向面试官证明自己排查和解决过事务，redis，dubbo或微服务等方面的线上问题。这块技能应该能帮到不少java资深开发成功面成架构师的岗位。

这本书应该是24年4，5月写好，24年的6，7月出版，敬请大家期待，说句不该说的话，真本书应该会被不少面试官痛恨，因为看了这本书以后，一些零项目经验的求职者，或者包装项目的求职者，真可能大大提升面试成的可能。或者是，这本面试书完稿后，本人再写一本书，专门讲靠吹过面试的java求职者，入职后该如何快速上手项目，从而能高效地过试用期。

本来还想再罗列些今年干的活以及展望什么的，后来发现又没有挣到太多的钱，不说也罢，来年只是希望，彼此身体健康。最后对IT行业以及程序员挣钱的一些感受吧。

1 在行情没像18年19年彻底变好前，慎重跳槽，但不是说不能跳槽。比如当下在小公司，工作也算稳定，别为了涨几千块就跳，当下跳槽其实更看公司，比如小公司跳槽进国企外企或知名公司，这种机会别放弃。

2 不少人在唱衰Java乃至IT行业，固然当下这个行业比较卷，但相比其他行业，IT行业好歹还提供了足量的薪资还算高的岗位，所以相比其他行业，IT还值得入。但这句话不是鼓励一些24,25岁的已经从事其他行业的人转行IT，当下这种转行不是说不行，但难很多。

3 当下找工作，更看重项目实践经验，如果单靠背面试题，当下找IT工作越来越难，这也是本人期待上文提到的面试书能畅销的原因。

4 在本职工作做好前，别过多做自媒体。什么叫本职工作最好？在当下项目组能发挥出顶梁柱的作用。而且本职工作做好以后，更应该通过挑战更高级别职位来提升薪资，而不是自媒体。这里说个本人知道的数据吧。比如公众号，大概5000个粉丝，一般得无收益干个半年，这样的粉丝量，一天大概有2000个点击，大概日入顶多10元，这样一个月才300。每天直播2,3个小时，大部分主播的收益也就几百，这样满打满算一个月才5000。所以论投入时间，挣钱效益最高还要算上班。

5 不少小公司的程序员，除了业务以外，可能还真只是掌握的增删改查，这批程序员挑战大公司的技巧是，通过网上找关于redis或kafka或其它值钱技能的线上问题解决方案，然后嵌入到自己的业务里，以此作为自己解决问题的说辞，然后去面试，这样大概率能在面试中证明各种值钱技术的项目实践经验。

6 别轻易听一些言论的蛊惑，去投钱或辞职创业，再量化些，每个月薪资不足3万，同时兼职收益不足1万，别考虑创业。前者是用来衡量工作能力，后者是用来量化外面的渠道和自己谈事情的本事。哪怕要创业，可以先从挣小钱做起，比如开个知识星球或通过各种自媒体试做一下，这样试错成本不会太高。

7 之后程序员这行，对学历要求会越来越高，大概3,4年前大专学历还可能进大厂，当下至少得本科。所以一些低学历但年轻的程序员，或者可以升个学历吧，当下本科学历还行，当然最好的更是硕士。

8 程序员出书真的管用，倒不是说能挣到钱，但出书确实不难，而且出了书以后，在面试中对程序员的帮助会超出大家的想象。

9 IT行业的恢复速度其实可能真不慢。对比下08年的行情吧，当年受美国次贷危机的影响，IT行情也不好，当年一个是“财源滚滚”是和裁员滚滚是谐音，所以程序员都很忌讳，另一个是叫双失，即失业失恋。不过大概到09年的年底，就开始逐渐恢复了，不少互联网公司，其实就是兴起于那个时候，而不少人说的互联网红利，也是起始于那个时间点。

10 程序员一定得注意身体。比如当下本人在外企，尚且不敢去体检，不敢看体检报告单，更何况是一些996或高压力的公司。虽然不少程序员工作起来身不由己，但还是请各位注意身体。

最后也希望大家在来年身体健康，万事如意。