转载请标明出处：

https://blog.csdn.net/forezp/article/details/76408139

本文出自方志朋的博客

个人博客纯净版：https://www.fangzhipeng.com/architecture/2017/08/10/idea-boot-instances.html
在我讲解的案例中，经常一个工程启动多个实例，分别占用不同的端口，有很多读者百思不得其解，在博客上留言，给我发邮件，加我微信询问。所以有必要在博客上记录下，方便读者。
step 1
在IDEA上点击Application右边的下三角

,弹出选项后，点击Edit Configuration

step 2
打开配置后，将默认的Single instance only(单实例)的钩去掉。

step 3
通过修改application文件的server.port的端口，启动。多个实例，需要多个端口，分别启动。
更多阅读
史上最简单的 SpringCloud 教程汇总
SpringBoot教程汇总
Java面试题系列汇总

    

        

        扫码关注公众号有惊喜
    
    

        （转载本站文章请注明作者和出处 方志朋的博客）
    

文章目录
不共享实例变量
共享实例变量
解决方案

不共享实例变量
测试代码
public class MyThreadNotShared extends Thread {

    private int count = 5;

    public MyThreadNotShared(String name){
        super();
        this.setName(name);
    }

    @Override
    public void run() {
        super.run();
        while (count > 0) {
            count--;
            System.out.println("Thread is " + this.currentThread().getName() + ", count is " + count);
        }
    }
}

public class TestInstanceNotShared {
    public static void main(String[] args) {
        Thread a = new MyThreadNotShared("A");
        Thread b = new MyThreadNotShared("B");
        Thread c = new MyThreadNotShared("C");

        a.start();
        b.start();
        c.start();
    }
}

# 输出：
Thread is A, count is 4
Thread is C, count is 4
Thread is B, count is 4
Thread is C, count is 3
Thread is A, count is 3
Thread is A, count is 2
Thread is C, count is 2
Thread is B, count is 3
Thread is C, count is 1
Thread is C, count is 0
Thread is A, count is 1
Thread is A, count is 0
Thread is B, count is 2
Thread is B, count is 1
Thread is B, count is 0

程序创建了3个线程，每个线程都有各自的count变量，不存在多个线程访问同一个实例变量问题。
共享实例变量
测试代码
public class MyThreadShared extends Thread {

    private int count = 5;

    @Override
    public void run() {
        super.run();
        count--;
        System.out.println("Thread is " + this.currentThread().getName() + ", count is " + count);
    }
}

public class TestInstanceShared {
    public static void main(String[] args) {
        MyThreadShared myThread = new MyThreadShared();

        Thread a = new Thread(myThread,"A");
        Thread b = new Thread(myThread,"B");
        Thread c = new Thread(myThread,"C");
        Thread d = new Thread(myThread,"D");
        Thread e = new Thread(myThread,"E");

        a.start();
        b.start();
        c.start();
        d.start();
        e.start();
    }
}

# 输出:
Thread is A, count is 3
Thread is E, count is 0
Thread is D, count is 1
Thread is B, count is 3
Thread is C, count is 2

A线程和B线程获取到的count都是3，出现了非现场安全问题。
对count的值处理分为3步（执行这些步骤的过程中会被其他线程所打断）：
1、获取count的值；
2、计算count-1；
3、计算结果对count赋值。
A线程和B线程得出相同值的过程如下：




线程/时间
1
2
3
4
5
6
7




A
5

4

4




B

5

4

4



1、在时间单位为1处，A线程取得count变量的值为5。
2、在时间单位为2处，B线程取得count变量的值为5。
3、在时间单位为3处，A线程执行count–计算，将计算后的值4存储到临时变量中。
4、在时间单位为4处，B线程执行count–计算，将计算后的值4也存储到临时变量中。
5、在时间单位为5处，A线程将临时变量中的值4赋值给count。
6、在时间单位为6处，B线程将临时变量中的值4也赋值给count。
7、最终结果就是A线程和B线程得到相同的计算结果4，非线程安全问题出现了。
解决方案
增加synchronized关键字

参考链接：https://www.cnblogs.com/jpfss/p/8144630.html
1、背景
MySQL数据库的集中化运维，可以通过在一台服务器上，部署运行多个MySQL服务进程，通过不同的socket监听不同的服务端口来提供各自的服务。各个实例之间是相互独立的，每个实例的datadir, port, socket, pid都是不同的。
2、多实例特点
2.1 有效利用服务器资源，当单个服务器资源有剩余时，可以充分利用剩余的资源提供更多的服务。

2.2 资源互相抢占问题，当某个服务实例服务并发很高时或者开启慢查询时，会消耗更多的内存、CPU、磁盘IO资源，导致服务器上的其他实例提供服务的质量下降。
3、环境
必须关闭selinux
[root@node2 local]# cat /etc/redhat-release 
CentOS Linux release 7.4.1708 (Core) 
[root@node2 local]# uname  -r
3.10.0-1160.11.1.el7.x86_64
[root@MySQL ~]# getenforce 
Disabled

4、部署 [ 4个实例 ]
4.1  下载 MySQL 5.7 二制包 [ 推荐官方下载 ]　此下载版本大于5.7.5
[root@node2  ~]# wget wget https://dev.mysql.com/get/Downloads/MySQL-5.7/mysql-5.7.18-linux-glibc2.5-x86_64.tar.gz

4.2 解压 MySQL 5.7 二进制包到指定目录
[root@node2  ~]# tar zxvf mysql-5.7.18-linux-glibc2.5-x86_64.tar.gz -C /usr/local/

4.3 创建 MySQL 软链接
[root@node2 ~]# mv /usr/local/mysql-5.7.18-linux-glibc2.5-x86_64 /usr/local/mysql

4.4 创建 MySQL 用户
[root@node2 ~]# useradd -r -s /sbin/nologin mysql

4.5 在 MySQL 二进制包目录中创建 mysql-files 目录 [MySQL 数据导入/导出数据专放目录]
[root@node2 ~]# mkdir -v /usr/local/mysql/mysql-files
mkdir: created directory `/usr/local/mysql/mysql-files'

4.6 创建多实例数据目录
[root@node2 local]# mkdir -vp /data/mysql/data{3306..3309}
mkdir: 已创建目录 "/data/mysql"
mkdir: 已创建目录 "/data/mysql/data3306"
mkdir: 已创建目录 "/data/mysql/data3307"
mkdir: 已创建目录 "/data/mysql/data3308"
mkdir: 已创建目录 "/data/mysql/data3309"

4.7 修改 MySQL 二进制包目录的所属用户与所属组
[root@node2 local]# chown mysql.mysql /usr/local/mysql/ -R
[root@node2 local]# chown mysql.mysql /data/mysql -R

4.8 配置 MySQL 配置文件 /etc/my.cnf
[mysqld_multi]
mysqld    = /usr/local/mysql/bin/mysqld 
mysqladmin = /usr/local/mysql/bin/mysqladmin
log        = /tmp/mysql_multi.log
 
[mysqld3306]
datadir = /data/mysql/data3306  # 设置数据目录　[多实例中一定要不同]
socket = /tmp/mysql-3306.sock  # 设置sock存放文件名　[多实例中一定要不同]
port = 3306    # 设置监听开放端口　[多实例中一定要不同]
user = mysql  # 设置运行用户
innodb_buffer_pool_size = 32M  # 设置innodb 缓存大小
sql_mode='STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION'

[mysqld3307]
datadir = /data/mysql/data3307
socket = /tmp/mysql-3307.sock
port = 3307
user = mysql
innodb_buffer_pool_size = 32M
sql_mode='STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION'

[mysqld3308]
datadir = /data/mysql/data3308
socket = /tmp/mysql-3308.sock
port = 3308
user = mysql
innodb_buffer_pool_size = 32M
sql_mode='STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION'

[mysqld3309]
datadir = /data/mysql/data3309
socket = /tmp/mysql-3309.sock
port = 3309
user = mysql
innodb_buffer_pool_size = 32M
sql_mode='STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION'

4.9 初始化各个实例 [ 初始化完成后会自带随机密码在输出日志中 ]
[root@node2 ~]# /usr/local/mysql/bin/mysqld --initialize --user=mysql --basedir=/usr/local/mysql --datadir=/data/mysql/data3306
[root@node2 ~]# /usr/local/mysql/bin/mysqld --initialize --user=mysql --basedir=/usr/local/mysql --datadir=/data/mysql/data3307
[root@node2 ~]# /usr/local/mysql/bin/mysqld --initialize --user=mysql --basedir=/usr/local/mysql --datadir=/data/mysql/data3308
[root@node2 ~]# /usr/local/mysql/bin/mysqld --initialize --user=mysql --basedir=/usr/local/mysql --datadir=/data/mysql/data3309


注意：初始化的时候会输出密码，记录下来：2020-12-25T06:39:00.288011Z 1 [Note] A temporary  password is generated for root@localhost: dfIx98z,3fj(

4.10 各实例开启 SSL 连接
[root@node2 ~]# /usr/local/mysql/bin/mysql_ssl_rsa_setup --user=mysql --basedir=/usr/local/mysql --datadir=/data/mysql/data3306
[root@node2 ~]# /usr/local/mysql/bin/mysql_ssl_rsa_setup --user=mysql --basedir=/usr/local/mysql --datadir=/data/mysql/data3307
[root@node2  ~]# /usr/local/mysql/bin/mysql_ssl_rsa_setup --user=mysql --basedir=/usr/local/mysql --datadir=/data/mysql/data3308
[root@node2  ~]# /usr/local/mysql/bin/mysql_ssl_rsa_setup --user=mysql --basedir=/usr/local/mysql --datadir=/data/mysql/data3309


复制多实例脚本到服务管理目录下 [ /etc/init.d/ ]

[root@node2 ~]# cp /usr/local/mysql/support-files/mysqld_multi.server /etc/init.d/mysqld_multi

4.11 添加脚本执行权限
[root@node2 ~]# chmod +x /etc/init.d/mysqld_multi 

4.12 添加进service服务管理和配置环境变量
[root@node2 ~]# chkconfig --add mysqld_multi
[root@node2 ~]# echo "export PATH=$PATH:/usr/local/mysql/bin" >>/etc/profile
[root@node2 ~]# source /etc/profile

4.13 启动多实例
[root@node2 local]#  /usr/local/mysql/bin/mysqld_multi start    #开启多实例
[root@node2 local]#  /usr/local/mysql/bin/mysqld_multi report   #查看全部实例状态
[root@node2 local]#  /usr/local/mysql/bin/mysqld_multi start 3306 #启动单个实例
[root@node2 local]#  /usr/local/mysql/bin/mysqld_multi stop  3306 #停止单个实例
[root@node2 local]#  /usr/local/mysql/bin/mysqld_multi report
Reporting MySQL servers
MySQL server from group: mysqld3306 is running
MySQL server from group: mysqld3307 is running
MySQL server from group: mysqld3308 is running
MySQL server from group: mysqld3309 is running

4.14 查看实例监听端口
[root@node2 local]#  netstat -lntp | grep mysqld
tcp6       0      0 :::3306                 :::*                    LISTEN      8898/mysqld         
tcp6       0      0 :::3307                 :::*                    LISTEN      8901/mysqld         
tcp6       0      0 :::3308                 :::*                    LISTEN      8904/mysqld         
tcp6       0      0 :::3309                 :::*                    LISTEN      8907/mysqld   

5. 连接测试
实例3306测试：
[root@node2 local]# mysql -uroot -p -S /tmp/mysql-3306.sock 
Enter password:  #输入4.9 初始化输出的密码
Server version: 5.7.18 MySQL Community Server (GPL)
..................
mysql> set password for root@'localhost'=password('123456'); 
mysql> flush privileges;
mysql> create database test  ; #可以看到该实例的data目录下多了一个test库

其他实例连接：
[root@node2 local]# mysql -uroot -p -S /tmp/mysql-3307.sock  
[root@node2 local]# mysql -uroot -p -S /tmp/mysql-3308.sock  
[root@node2 local]# mysql -uroot -p -S /tmp/mysql-3309.sock  

遇到的问题：

/usr/local/mysql/bin/mysqld_multi stop  3306  停止3306实例无效。

解决： 自己写一个脚本来实现启停功能

#先把密码存放到一个安全的文件里面
echo '123456' >  /etc/mysql.pass
chmod 600   /etc/mysql.pass
vim /etc/init.d/mysqld_manager  #以后就可以通过这个脚本来管理mysql了
#!/bin/bash
tag=$1
port=$2
mysqld_multi="/usr/local/mysql/bin/mysqld_multi"
sql="/usr/local/mysql/bin/mysql"
sqladmin="/usr/local/mysql/bin/mysqladmin"
if [ "$tag" == "start" ] && [ "$port" == '' ];then 
    $mysqld_multi start 
else   
    case "$tag" in
        'start' )
            $mysqld_multi start $port
            ;;
        'stop' )
            $sqladmin -uroot -p`cat /etc/mysql.pass` -S /tmp/mysql-$port.sock  shutdown
            ;;
        'report' )
            $mysqld_multi report $port
            ;;
        'restart' )
            $sqladmin -uroot -p`cat /etc/mysql.pass` -S /tmp/mysql-$port.sock  shutdown
            $mysqld_multi start $port
            ;;
        *)
            echo "Usage: $0 {start|stop|report|restart}" >&2
            ;;
    esac
fi    
#赋权
chmod 755  /etc/init.d/mysqld_manager 

在使用Spring时，Bean之间会有些依赖，比如一个Bean A实例化时需要用到Bean B,那么B应该在A之前实例化好。很多时候Spring智能地为我们做好了这些工作，但某些情况下可能不是，比如Springboot的@AutoConfigureAfter注解，手动的指定Bean的实例化顺序。了解Spring内Bean的解析，加载和实例化顺序机制有助于我们更好的使用Spring/Springboot，避免手动的去干预Bean的加载过程，搭建更优雅的框架。
Spring容器在实例化时会加载容器内所有非延迟加载的单例类型Bean，看如下源码：
public abstract class AbstractApplicationContext extends DefaultResourceLoader
		implements ConfigurableApplicationContext, DisposableBean {
	
	//刷新Spring容器，相当于初始化
	public void refresh() throws BeansException, IllegalStateException {
		......
		// Instantiate all remaining (non-lazy-init) singletons.
		finishBeanFactoryInitialization(beanFactory);
	}
}

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
		implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
		
	/** List of bean definition names, in registration order */
	private volatile List<String> beanDefinitionNames = new ArrayList<String>(256);

	public void preInstantiateSingletons() throws BeansException {
		List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
		for (String beanName : beanNames) {
			......
			getBean(beanName);  //实例化Bean
		}
	}

}

ApplicationContext内置一个BeanFactory对象，作为实际的Bean工厂，和Bean相关业务都交给BeanFactory去处理。

在BeanFactory实例化所有非延迟加载的单例Bean时，遍历beanDefinitionNames 集合，按顺序实例化指定名称的Bean。beanDefinitionNames 属性是Spring在加载Bean Class生成的BeanDefinition时，为这些Bean预先定义好的名称，看如下代码：
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
		implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
	
	public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException {
		......
		this.beanDefinitionNames.add(beanName);
	}
}

BeanFactory在加载一个BeanDefinition（也就是加载Bean Class）时，将相应的beanName存入beanDefinitionNames属性中，在加载完所有的BeanDefinition后，执行Bean实例化工作，此时会依据beanDefinitionNames的顺序来有序实例化Bean，也就是说Spring容器内Bean的加载和实例化是有顺序的，而且近似一致，当然仅是近似。
Spring在初始化容器时，会先解析和加载所有的Bean Class，如果符合要求则通过Class生成BeanDefinition，存入BeanFactory中，在加载完所有Bean Class后，开始有序的通过BeanDefinition实例化Bean。
我们先看加载Bean Class过程，零配置下Spring Bean的加载起始于ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry（BeanDefinitionRegistry）方法，我总结了下其加载解析Bean Class的流程：

配置类可以是Spring容器的起始配置类，也可以是通过@ComponentScan扫描得到的类，也可以是通过@Import引入的类。如果这个类上含有@Configuration，@Component，@ComponentScan，@Import，@ImportResource注解中的一个，或者内部含有@Bean标识的方法，那么这个类就是一个配置类，Spring就会按照一定流程去解析这个类上的信息。
在解析的第一步会校验当前类是否已经被解析过了，如果是，那么需要按照一定的规则处理（@ComponentScan得到的Bean能覆盖@Import得到的Bean，@Bean定义的优先级最高）。
如果未解析过，那么开始解析：
解析内部类，查看内部类是否应该被定义成一个Bean，如果是，递归解析。
解析@PropertySource，也就是解析被引入的Properties文件。
解析配置类上是否有@ComponentScan注解，如果有则执行扫描动作，通过扫描得到的Bean Class会被立即解析成BeanDefinition，添加进beanDefinitionNames属性中。之后查看扫描到的Bean Class是否是一个配置类（大部分情况是，因为标识@Component注解），如果是则递归解析这个Bean Class。
解析@Import引入的类，如果这个类是一个配置类，则递归解析。
解析@Bean标识的方法，此种形式定义的Bean Class不会被递归解析
解析父类上的@ComponentScan，@Import，@Bean，父类不会被再次实例化，因为其子类能够做父类的工作，不需要额外的Bean了。
在1，3，4，6中都有递归操作，也就是在解析一个Bean Class A时，发现其上能够获取到其他Bean Class B信息，此时会递归的解析Bean Class B，在解析完Bean Class B后再接着解析Bean Class A，可能在解析B时能够获取到C，那么也会先解析C再解析B，就这样不断的递归解析。
在第3步中，通过@ComponentScan扫描直接得到的Bean Class会被立即加载入beanDefinitionNames中，但@Import和@Bean形式定义的Bean Class则不会，也就是说正常情况下面@ComponentScan直接得到的Bean其实例化时机比其他两种形式的要早。
通过@Bean和@Import形式定义的Bean Class不会立即加载，他们会被放入一个ConfigurationClass类中，然后按照解析的顺序有序排列，就是图片上的 “将配置类有序排列”。一个ConfigurationClass代表一个配置类，这个类可能是被@ComponentScan扫描到的，则此类已经被加载过了；也可能是被@Import引入的，则此类还未被加载；此类中可能含有@Bean标识的方法。
Spring在解析完了所有Bean Class后，开始加载ConfigurationClass。如果这个ConfigurationClass是被Import的，也就是说在加载@ComponentScan时其未被加载，那么此时加载ConfigurationClass代表的Bean Class。然后加载ConfigurationClass内的@Bean方法。
顺序总结：@ComponentScan  > @Import  > @Bean
下面看实际的启动流程：

此图顺序验证小框架：Spring Bean解析，加载及实例化顺序验证小框架
Bean Class的结构图如上所示，A是配置类的入口，通过A能直接或间接的引入一个模块。
此时启动Spring容器，将A引入容器内。
如果A是通过@ComponentScan扫描到的，那么此时的加载顺序是：

A > D > F > B > E > G > C
如果A是通过@Import形式引入的，那么此时的加载顺讯是：

D > F > B > E > G > A > C
当然以上仅仅代表着加载Bean Class的顺序，实际实例化Bean的顺序和加载顺序大体相同，但还是会有一些差别。

Spring在通过getBean(beanName)形式实例化Bean时，会通过BeanDefinition去生成Bean对象。在这个过程中，如果BeanDefinition的DependsOn不为空，从字面理解就是依赖某个什么，其值一般是某个或多个beanName，也就是说依赖于其他Bean，此时Spring会将DependsOn指定的这些名称的Bean先实例化，也就是先调用getBean(dependsOn)方法。我们可以通过在Bean Class或者@Bean的方法上标识**@DependsOn**注解，来指定当前Bean实例化时需要触发哪些Bean的提前实例化。
当一个Bean A内部通过@Autowired或者@Resource注入Bean B，那么在实例化A时会触发B的提前实例化，此时会注册A>B的dependsOn依赖关系，实质和@DependsOn一样，这个是Spring自动为我们处理好的。
了解Spring Bean的解析，加载及实例化的顺序机制能够加深对Spring的理解，搭建更优雅简介的Spring框架。