miki艾比利个人博客

愿居于一城,与卿所见美好......

推荐文章

9种设计模式在Spring中的运用,一定要非常熟练!

    1.简单工厂(非23种设计模式中的一种)

    • 实现方式:BeanFactory。 Spring中的BeanFactory就是简单工厂模式的体现,根据传入一个唯一的标识来获得Bean对象,但是否是在传入参数后创建还是传入参数前创建这个要根据具体情况来定。
    • 实质:由一个工厂类根据传入的参数,动态决定应该创建哪一个产品类。
    • 实现原理:
      • bean容器的启动阶段:
        • 读取bean的xml配置文件,将bean元素分别转换成一个BeanDefinition对象。
        • 然后通过BeanDefinitionRegistry将这些bean注册到beanFactory中,保存在它的一个ConcurrentHashMap中。
        • 将BeanDefinition注册到了beanFactory之后,在这里Spring为我们提供了一个扩展的切口,允许我们通过实现接口BeanFactoryPostProcessor 在此处来插入我们定义的代码。典型的例子就是:PropertyPlaceholderConfigurer,我们一般在配置数据库的dataSource时使用到的占位符的值,就是它注入进去的。
      • 容器中bean的实例化阶段:
        实例化阶段主要是通过反射或者CGLIB对bean进行实例化,在这个阶段Spring又给我们暴露了很多的扩展点:
        • 各种的Aware接口,比如 BeanFactoryAware,对于实现了这些Aware接口的bean,在实例化bean时Spring会帮我们注入对应的BeanFactory的实例。
        • BeanPostProcessor接口,实现了BeanPostProcessor接口的bean,在实例化bean时Spring会帮我们调用接口中的方法。
        • InitializingBean接口,实现了InitializingBean接口的bean,在实例化bean时Spring会帮我们调用接口中的方法。
        • DisposableBean接口,实现了BeanPostProcessor接口的bean,在该bean死亡时Spring会帮我们调用接口中的方法。
    • 设计意义:
      • 松耦合。可以将原来硬编码的依赖,通过Spring这个beanFactory这个工长来注入依赖,也就是说原来只有依赖方和被依赖方,现在我们引入了第三方——spring这个beanFactory,由它来解决bean之间的依赖问题,达到了松耦合的效果.
      • bean的额外处理。通过Spring接口的暴露,在实例化bean的阶段我们可以进行一些额外的处理,这些额外的处理只需要让bean实现对应的接口即可,那么spring就会在bean的生命周期调用我们实现的接口来处理该bean。[非常重要]

    2.工厂方法

    • 实现方式:FactoryBean接口。
    • 实现原理:
      实现了FactoryBean接口的bean是一类叫做factory的bean。其特点是,spring会在使用getBean()调用获得该bean时,会自动调用该bean的getObject()方法,所以返回的不是factory这个bean,而是这个bean.getOjbect()方法的返回值。
    • 例子:
      • 典型的例子有spring与mybatis的结合。
      • 代码示例

      • 说明:
        我们看上面该bean,因为实现了FactoryBean接口,所以返回的不是 SqlSessionFactoryBean 的实例,而是她的 SqlSessionFactoryBean.getObject() 的返回值。

    3.单例模式

    • Spring依赖注入Bean实例默认是单例的。
    • Spring的依赖注入(包括lazy-init方式)都是发生在AbstractBeanFactory的getBean里。getBean的doGetBean方法调用getSingleton进行bean的创建。
    • 分析getSingleton()方法

      public Object getSingleton(String beanName){
          //参数true设置标识允许早期依赖
          return getSingleton(beanName,true);
      }
      protected Object getSingleton(String beanName, boolean allowEarlyReference) {
          //检查缓存中是否存在实例
          Object singletonObject = this.singletonObjects.get(beanName);
          if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
              //如果为空,则锁定全局变量并进行处理。
              synchronized (this.singletonObjects) {
                  //如果此bean正在加载,则不处理
                  singletonObject = this.earlySingletonObjects.get(beanName);
                  if (singletonObject == null && allowEarlyReference) {  
                      //当某些方法需要提前初始化的时候则会调用addSingleFactory 方法将对应的ObjectFactory初始化策略存储在singletonFactories
                      ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                      if (singletonFactory != null) {
                          //调用预先设定的getObject方法
                          singletonObject = singletonFactory.getObject();
                          //记录在缓存中,earlysingletonObjects和singletonFactories互斥
                          this.earlySingletonObjects.put(beanName, singletonObject);
                          this.singletonFactories.remove(beanName);
                      }
                  }
              }
          }
          return (singletonObject != NULL_OBJECT ? singletonObject : null);
      }
      
      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • getSingleton()过程图
        ps:spring依赖注入时,使用了 双重判断加锁 的单例模式
        这里写图片描述
      • 总结
      • 单例模式定义:保证一个类仅有一个实例,并提供一个访问它的全局访问点。
      • spring对单例的实现:spring中的单例模式完成了后半句话,即提供了全局的访问点BeanFactory。但没有从构造器级别去控制单例,这是因为spring管理的是任意的java对象。

    4. 适配器模式

    • 实现方式:SpringMVC中的适配器HandlerAdatper。
    • 实现原理:HandlerAdatper根据Handler规则执行不同的Handler。
    • 实现过程:
      DispatcherServlet根据HandlerMapping返回的handler,向HandlerAdatper发起请求,处理Handler。HandlerAdapter根据规则找到对应的Handler并让其执行,执行完毕后Handler会向HandlerAdapter返回一个ModelAndView,最后由HandlerAdapter向DispatchServelet返回一个ModelAndView。
    • 实现意义:
      HandlerAdatper使得Handler的扩展变得容易,只需要增加一个新的Handler和一个对应的HandlerAdapter即可。因此Spring定义了一个适配接口,使得每一种Controller有一种对应的适配器实现类,让适配器代替controller执行相应的方法。这样在扩展Controller时,只需要增加一个适配器类就完成了SpringMVC的扩展了。

    5.装饰器模式

    • 实现方式:
      Spring中用到的包装器模式在类名上有两种表现:一种是类名中含有Wrapper,另一种是类名中含有Decorator。
    • 实质:
      • 动态地给一个对象添加一些额外的职责。
      • 就增加功能来说,Decorator模式相比生成子类更为灵活。

    6.代理模式

    • 实现方式: AOP底层,就是动态代理模式的实现。
      • 动态代理:在内存中构建的,不需要手动编写代理类
      • 静态代理:需要手工编写代理类,代理类引用被代理对象。
    • 实现原理:
      切面在应用运行的时刻被织入。一般情况下,在织入切面时,AOP容器会为目标对象创建动态的创建一个代理对象。SpringAOP就是以这种方式织入切面的。
      织入:把切面应用到目标对象并创建新的代理对象的过程。

    7.观察者模式

    • 实现方式:spring的事件驱动模型使用的是 观察者模式 ,Spring中Observer模式常用的地方是listener的实现。
    • 具体实现:
      事件机制的实现需要三个部分,事件源,事件,事件监听器

      • ApplicationEvent抽象类[事件]

        • 继承自jdk的EventObject,所有的事件都需要继承ApplicationEvent,并且通过构造器参数source得到事件源.
        • 该类的实现类ApplicationContextEvent表示ApplicaitonContext的容器事件.
        • 代码:

          public abstract class ApplicationEvent extends EventObject {
              private static final long serialVersionUID = 7099057708183571937L;
              private final long timestamp;
              public ApplicationEvent(Object source) {
              super(source);
              this.timestamp = System.currentTimeMillis();
              }
              public final long getTimestamp() {
                  return this.timestamp;
              }
          }
          
          • 1
          • 2
          • 3
          • 4
          • 5
          • 6
          • 7
          • 8
          • 9
          • 10
          • 11
      • ApplicationListener接口[事件监听器]

        • 继承自jdk的EventListener,所有的监听器都要实现这个接口。
        • 这个接口只有一个onApplicationEvent()方法,该方法接受一个ApplicationEvent或其子类对象作为参数,在方法体中,可以通过不同对Event类的判断来进行相应的处理。
        • 当事件触发时所有的监听器都会收到消息。
        • 代码:

              public interface ApplicationListener<E extends ApplicationEvent> extends                EventListener {
                           void onApplicationEvent(E event);
          } 
          
          • 1
          • 2
          • 3
      • ApplicationContext接口[事件源]

        • ApplicationContext是spring中的全局容器,翻译过来是”应用上下文”。
        • 实现了ApplicationEventPublisher接口。
        • 职责:负责读取bean的配置文档,管理bean的加载,维护bean之间的依赖关系,可以说是负责bean的整个生命周期,再通俗一点就是我们平时所说的IOC容器。
        • 代码:

          public interface ApplicationEventPublisher {
                  void publishEvent(ApplicationEvent event);
          }   
          
          public void publishEvent(ApplicationEvent event) {
              Assert.notNull(event, "Event must not be null");
              if (logger.isTraceEnabled()) {
                   logger.trace("Publishing event in " + getDisplayName() + ": " + event);
              }
              getApplicationEventMulticaster().multicastEvent(event);
              if (this.parent != null) {
              this.parent.publishEvent(event);
              }
          }
          
          • 1
          • 2
          • 3
          • 4
          • 5
          • 6
          • 7
          • 8
          • 9
          • 10
          • 11
          • 12
          • 13
          • 14
      • ApplicationEventMulticaster抽象类[事件源中publishEvent方法需要调用其方法getApplicationEventMulticaster]

        • 属于事件广播器,它的作用是把Applicationcontext发布的Event广播给所有的监听器.
        • 代码:

          public abstract class AbstractApplicationContext extends DefaultResourceLoader
              implements ConfigurableApplicationContext, DisposableBean {  
              private ApplicationEventMulticaster applicationEventMulticaster;  
              protected void registerListeners() {  
              // Register statically specified listeners first.  
              for (ApplicationListener<?> listener : getApplicationListeners()) {  
              getApplicationEventMulticaster().addApplicationListener(listener);  
              }  
              // Do not initialize FactoryBeans here: We need to leave all regular beans  
              // uninitialized to let post-processors apply to them!  
              String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);  
              for (String lisName : listenerBeanNames) {  
              getApplicationEventMulticaster().addApplicationListenerBean(lisName);  
              }  
            }  
          }
          
          • 1
          • 2
          • 3
          • 4
          • 5
          • 6
          • 7
          • 8
          • 9
          • 10
          • 11
          • 12
          • 13
          • 14
          • 15
          • 16

    8.策略模式

    • 实现方式:Spring框架的资源访问Resource接口 。该接口提供了更强的资源访问能力,Spring 框架本身大量使用了 Resource 接口来访问底层资源。
    • Resource 接口介绍
      • source 接口是具体资源访问策略的抽象,也是所有资源访问类所实现的接口。
      • Resource 接口主要提供了如下几个方法:
        • getInputStream():定位并打开资源,返回资源对应的输入流。每次调用都返回新的输入流。调用者必须负责关闭输入流。
        • exists():返回 Resource 所指向的资源是否存在。
        • isOpen():返回资源文件是否打开,如果资源文件不能多次读取,每次读取结束应该显式关闭,以防止资源泄漏。
        • getDescription():返回资源的描述信息,通常用于资源处理出错时输出该信息,通常是全限定文件名或实际 URL。
        • getFile:返回资源对应的 File 对象。
        • getURL:返回资源对应的 URL 对象。
          最后两个方法通常无须使用,仅在通过简单方式访问无法实现时,Resource 提供传统的资源访问的功能。
      • Resource 接口本身没有提供访问任何底层资源的实现逻辑,针对不同的底层资源,Spring 将会提供不同的 Resource 实现类,不同的实现类负责不同的资源访问逻辑。
      • Spring 为 Resource 接口提供了如下实现类:
        • UrlResource:访问网络资源的实现类。
        • ClassPathResource:访问类加载路径里资源的实现类。
        • FileSystemResource:访问文件系统里资源的实现类。
        • ServletContextResource:访问相对于 ServletContext 路径里的资源的实现类.
        • InputStreamResource:访问输入流资源的实现类。
        • ByteArrayResource:访问字节数组资源的实现类。
          这些 Resource 实现类,针对不同的的底层资源,提供了相应的资源访问逻辑,并提供便捷的包装,以利于客户端程序的资源访问。

    9.模版方法模式

    • 经典模板方法定义:
      • 父类定义了骨架(调用哪些方法及顺序),某些特定方法由子类实现
      • 最大的好处:代码复用,减少重复代码。除了子类要实现的特定方法,其他方法及方法调用顺序都在父类中预先写好了。
      • 所以父类模板方法中有两类方法:
        • 共同的方法:所有子类都会用到的代码
        • 不同的方法:子类要覆盖的方法,分为两种:
          • 抽象方法:父类中的是抽象方法,子类必须覆盖
          • 钩子方法:父类中是一个空方法,子类继承了默认也是空的
            注:为什么叫钩子,子类可以通过这个钩子(方法),控制父类,因为这个钩子实际是父类的方法(空方法)!
    • Spring模板方法模式实质:
      是模板方法模式和回调模式的结合,是Template Method不需要继承的另一种实现方式。Spring几乎所有的外接扩展都采用这种模式。
    • 具体实现:
      JDBC的抽象和对Hibernate的集成,都采用了一种理念或者处理方式,那就是模板方法模式与相应的Callback接口相结合。
    • 采用模板方法模式是为了以一种统一而集中的方式来处理资源的获取和释放,以JdbcTempalte为例:

      public abstract class JdbcTemplate {  
           public final Object execute(String sql){  
              Connection con=null;  
              Statement stmt=null;  
              try{  
                  con=getConnection();  
                  stmt=con.createStatement();  
                  Object retValue=executeWithStatement(stmt,sql);  
                  return retValue;  
              }catch(SQLException e){  
                   ...  
              }finally{  
                  closeStatement(stmt);  
                  releaseConnection(con);  
              }  
          }   
          protected abstract Object executeWithStatement(Statement   stmt, String sql);  
      }  
      
      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
    • 引入回调原因:

      • JdbcTemplate是抽象类,不能够独立使用,我们每次进行数据访问的时候都要给出一个相应的子类实现,这样肯定不方便,所以就引入了回调 。
      • 回调代码

        public interface StatementCallback{  
            Object doWithStatement(Statement stmt);  
        }   
        
        • 1
        • 2
        • 3
      • 利用回调方法重写JdbcTemplate方法

        public class JdbcTemplate {  
            public final Object execute(StatementCallback callback){  
                Connection con=null;  
                Statement stmt=null;  
                try{  
                    con=getConnection();  
                    stmt=con.createStatement();  
                    Object retValue=callback.doWithStatement(stmt);  
                    return retValue;  
                }catch(SQLException e){  
                    ...  
                }finally{  
                    closeStatement(stmt);  
                    releaseConnection(con);  
                }  
            }  
        
            ...//其它方法定义  
        }   
        
        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        • 10
        • 11
        • 12
        • 13
        • 14
        • 15
        • 16
        • 17
        • 18
        • 19
      • Jdbc使用方法如下:

        JdbcTemplate jdbcTemplate=...;  
            final String sql=...;  
            StatementCallback callback=new StatementCallback(){  
            public Object=doWithStatement(Statement stmt){  
                return ...;  
            }  
        }    
        jdbcTemplate.execute(callback);  
        
        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
    • 为什么JdbcTemplate没有使用继承?
      因为这个类的方法太多,但是我们还是想用到JdbcTemplate已有的稳定的、公用的数据库连接,那么我们怎么办呢?我们可以把变化的东西抽出来作为一个参数传入JdbcTemplate的方法中。但是变化的东西是一段代码,而且这段代码会用到JdbcTemplate中的变量。怎么办?那我们就用回调对象吧。在这个回调对象中定义一个操纵JdbcTemplate中变量的方法,我们去实现这个方法,就把变化的东西集中到这里了。然后我们再传入这个回调对象到JdbcTemplate,从而完成了调用。

      参考:
      https://www.cnblogs.com/digdeep/p/4518571.html
      https://www.cnblogs.com/tongkey/p/7919401.html
      https://www.cnblogs.com/fingerboy/p/6393644.html
      https://blog.csdn.net/ovoo_8/article/details/51189401
      https://blog.csdn.net/z69183787/article/details/65628166

      《spring源码深度分析》

    阅读全文>>

作者:miki艾比利分类:【javaEE浏览(515评论(0

2020-12-08 10:30:46

Springcloud配置启动一工程多实例

    Springcloud配置启动一工程多实例

    前言

    最近在学习微服务,要学习微服务的负载均衡,涉及到一个服务要启动多个实例,这个时候又不想重复的创建工程,网上查了一下都是关于idea设置单一工程多实例使用的,对于这个不能忍啊,于是我就琢磨了一下使用myeclipse怎样启动多实例,教程如下:

     

    1. 创建springcloud工程,并启动

    1.设置好相关application的名称,和端口号,启动方式如下:

    1. 利用spring tool工具Boot Dashboard启动:

    右键(ReDebugger

    这样就完成了一个实例的启动方式,接下来启动第二个,第三个哟:

    2.创建第二个实例并启动

     

    1.如图:就创建出第三个实例了,这个时候接下来只需要更改一下端口即可:

     

    2.选中创建的实例,点击Open Config

    3.进入如下配置:

    4.更改端口并启动

    利用工具启动项目:

    右键(ReDebugger,以debugger模式启动:

    如下图:启动成功!!一个启动了三个实例。

    阅读全文>>

作者:miki艾比利分类:【springcloud浏览(553评论(0

2020-04-15 11:49:47

记录一次硬盘崩盘事故带来的灾难

    2019.12.19  miki

    2018年6月购置的神舟战神Z7-kp7gc笔记本,原价7600多买的,后来想着这个牌子的摸具比较难拆,就让店家帮忙把原装的126的固态升级为一个256的固态系统盘,注意,此时已经掉入了一个坑,由于加大固态盘,店家肯定会收取你好几百的升级费用,但是,虽然收了你的钱,但是不一定为你办事情,它为你升级的某个不知名的sata接口的achive协议的杂牌固态盘,虽然是256G,但是价钱同你的原装126的固态盘价位差不多,原装的126的固态盘则是三星的PCI-E接口的MVMe协议的,速度相对sata接口的要快上好几倍。

    坑1:

     

    PCIe和SATA的区别如下:

    1、接口类型不同:

    SATA(串行ATA)是SSD使用的一种连接接口,用于与系统进行数据通信。它创建于2003年,这意味着它有很多时间将自己巩固为当今最广泛使用的连接类型之一。

    PCIe(Peripheral Component Interconnect Express)可以视为与主板更直接的数据连接。它通常用于显卡等设备,这些设备也需要极快的数据连接。

    2、速率不同:

    SATA 3.0是最流行的SSD形式,其理论传输速度为6 Gb / s(750 MB / s)。但是由于在编码传输数据时出现了一些物理偏差,它实际上具有4.8 Gb / s(600 MB / s)的实际传输速度。

    PCIe 3.0的有效传输速度为每通道985 MB / s,由于PCIe设备可支持1x,4x,8x或16x通道,因此您可以将潜在的传输速度提高到15.76 GB / s。

    3、接口协议不同:

    接口有AHCI协议与NVMe协议,AHCI较旧,专为HDD和SATA而设计,这意味着使用AHCI的PCIe SSD可能无法发挥其最大潜力。NVMe专为与PCIe配合使用而设计,因此性能更佳。

    坑2:

    机械硬盘崩盘,刚买来的时候就是个小小白,虽然现在也还是个小白,但是刚买过来的时候,机械盘读取的特别慢,我i以为是常态,就没在意,就这样浑浑噩噩的用了一年半,以至于后面的崩盘。最最可惜的是,丢失的数据无价,这几年总结,积累的东西全没了,对此我心疼了好久,好久。所以,大家一定要记得资料定时备份,时刻注意硬盘的状态,防止最后一场空。

    坑3:

    数据恢复,硬盘崩了,找数据恢复一定要谨慎,不要随随便便找一家不知名的数据恢复门店,对方极有可能会将你的硬盘资料加密,或者造成二次伤害,以此为胁迫,漫天要价,让你无法去其他的专业机构去恢复,我这边恢复数据就找了一家公司,叫什么雷超科技有限公司,能力是真烂,让我自己买介质,(就是自己买原装硬盘型号的二手的,磁头一定要好,硬盘坏道一定要少),然后给我恢复了半个月,到头来,数据重要的还是丢失了一半,剩下一部分即使恢复出来了,文件也是损坏的,无法使用。最后跟我要了1000块钱,真是心疼。最后只能根据文件名自己慢慢恢复资料。

    总结

    硬盘保养一定要仔细。

    硬盘是电脑中较容易损坏的配件,但其中有相当一部分的原因是用户操作不当所致。其实,只要在日常使用中注意一些小技巧,便可以减少硬盘出故障的可能性,从而延长其正常的使用寿命。

    1.读写忌断电
    现时硬盘的转速大都是7200转,在进行读写时,整个盘片处于高速旋转状态中,如果忽然切断电源,将使得磁头与盘片猛烈磨擦,从而导致硬盘出现坏道甚至损坏。所以在关机时,一定要注意机箱面板上的硬盘指示灯是否没有闪烁,即硬盘已经完成读写操作之后才可以按照正常的程序关闭电脑。硬盘指示灯闪烁时,一定不可切断电源。

    2.防止受震动
    硬盘是十分精密的存储设备,进行读写操作时,磁头在盘片表面的浮动高度只有几微米;即使在不工作的时候,磁头与盘片也是接触的。硬盘在工作时,一旦发生较大的震动,就容易造成磁头与资料区相撞击,导致盘片资料区损坏或刮伤磁盘,丢失硬盘内所储存的文件数据。因此,在工作时或关机后主轴电机尚未停顿之前,千万不要搬动电脑或移动硬盘,以免磁头与盘片产生撞击而擦伤盘片表面的磁层。此外,在硬盘的安装、拆卸过程中也要加倍小心,防止过分摇晃或与机箱铁板剧烈碰撞。

    3.远离磁场
    磁场是损毁硬盘数据的隐形杀手,因此要尽可能地使硬盘不靠近强磁场,如音箱、手机、电台等,以免硬盘里所记录的资料因磁化而受到破坏。机有信号时会产生强烈磁场,可能磁化附近的硬盘

    4.减少频繁操作
    如果长时间运行一个程序(如大型软件或玩游戏),这时就要注意了,这样磁头会长时间频繁读写同一个硬盘位置(即程序所在的扇区),而使硬盘产生坏道。
    另外,如果长时间使用一个操作系统,也会使系统文件所在的硬盘扇区(不可移动)处于长期读取状态,从而加快该扇区的损坏速度。当然,最好是安装有两个或以上的操作系统交替使用,以避免对硬盘某个扇区做长期的读写操作。

    5.恰当的使用时间
    在一天中,最好不要让硬盘的工作时间超过10个小时,而且不要连续工作超过8个小时,应该在使用一段时间之后就关闭电脑,让硬盘有足够的休息时间。

    6.定期整理碎片
    硬盘工作时会频繁地进行读写操作,同时程序的增加、删除也会产生大量的不连续的磁盘空间与磁盘碎片。当不连续磁盘空间与磁盘碎片数量不断增多时,就会影响到硬盘的读取效能。如果数据的增删操作较为频繁或经常更换软件,则应该每隔一定的时间(如一个月)就运行Windows系统自带的磁盘碎片整理工具,进行磁盘碎片和不连续空间的重组工作,将硬盘的性能发挥至最佳。

    7.增加内存与良好供电
    如果经常使用一些内存需求很大的软件(如图像处理、模型设计等软件),就应该增加内存,来减少大量的文件交换时在硬盘上进行的读写操作,从而延长硬盘的使用寿命。
    另外,一定要使用性能稳定的电源,如果电源的供电不纯或功率不足,很容易就会造成资料丢失甚至硬盘损坏。

    阅读全文>>

作者:miki艾比利分类:【日记浏览(455评论(0

2019-12-19 19:46:54

用Kettle在数据集成中进行分区

    让我们假设,我们用简单的数据集进行了一次转换,该数据集具有印度城市明智的州人口数。我们需要获取总人口数。我们使用“ 内存按步骤分组” 构建一个简单的转换文件,并根据State对源数据进行分组以获得总人口数。

    KTR找到明智的人口计数国家

    现在,假设你有少量的源数据,而不是源中的数百万条记录。因此,逐步进行内存分组将花费你巨大的成本。我们不是简单地通过,而是利用多核计算机的功能。

    Pentaho将为你提供一个定义步骤中数据副本数的选项。在Pentaho中按步骤定义内存组的多行是使用多核计算机的一种方法。因此,请按以下步骤对“内存组”进行以下操作:

    >>  右键单击 “内存分组依据
     ” >>选择“更改份数以开始
     ” >>将值设置为 3或大于1的任何数字

    将份数输入到3

    但是,一旦执行了上面的转换,我们就会看到结果有很大的不同,这并不是预期的。这是因为源步骤是按循环方式将数据逐步发送到“内存组”的3个副本。这些内存组中的每一个都以自己的方式逐步处理数据,最后发送输出。这是PDI中的并行性,但是在这种情况下,我们没有得到正确的输出。

    因此,我们在这里要做的就是对数据进行分区。这里的想法是将类似种类的数据发送到每个分区,然后通过分组而不是根据上述数据进行分组。它像3 Memory Step by Step,每个分区都有分区数据,例如分区1中的西孟加拉邦,分区2中的喀拉拉邦,等等。

    在PDI中创建分区

    创建分区要遵循的步骤:

    >>转到转换的
    设计”选项卡>>在“分区模式”选项卡中,创建一个“新模式
     ” >>输入“分区名称”。它可以是任何可读的名称。
    >>输入分区ID或所需的分区数。
    到目前为止,对分区没有命名约束。 
    只需给出分区1,分区2等。

    完成上述步骤后。现在继续进行转换并执行以下操作:

    >>右键单击“内存组”,一步步
     >>选择“分区”。
    >>选择“分区”方法。选择除法余数>>选择分区架构。
    这是上面在“设计”选项卡中创建的所有分区架构的列表。
    >>接下来,你需要选择要分区的字段。
    选择一个合适的。

    最后,你将看到类似以下的内容:

    带有分区架构和数据的KTR

    执行后,返回的结果是正是我们需要的:

    最终分区输出

    阅读全文>>

作者:miki艾比利分类:【ETL浏览(1142评论(0

2019-11-14 09:38:16

【转载】kettle集群原理分析

    本文转自:http://blog.csdn.net/dqswuyundong/article/details/5952009

    Kettle集群

    Kettle是一款开源的ETL工具,以其高效和可扩展性而闻名于业内。其高效的一个重要原因就是其多线程和集群功能。

    Kettle的多线程采用的是一种流水线并发的机制,我们在另外的文章中专门有介绍。这里主要介绍的是kettle的集群。

    集群允许转换以及转换中的步骤在多个服务器上并发执行。在使用kettle集群时,首先需要定义的是Cluster schema。所谓的Cluster schema就是一系列的子服务器的集合。在一个集群中,它包含一个主服务器(Master)和多个从属服务器服务器(slave)。如下图所示。

    子服务器(Slave servers)允许你在远程服务器上执行转换。建立一个子服务器需要你在远程服务器上建立一个叫做“Carte”的 web 服务器,该服务器可以从Spoon(远程或者集群执行)或者转换任务中接受输入。

    在以后的描述中,如果我们提到的是子服务器,则包括集群中的主服务器和从属服务器;否则我们会以主服务器和从属服务器来进行特别指定。

    设计

    要让转换是以集群方式执行,首先需要在Spoon中进行图形化的设计工作。定义一个以集群方式运行的转换,主要包括定义cluster schema和定义转换两个步骤。

    定义cluster schema

    创建子服务器

    服务tab 选项

    选项

    描述

    服务器名称

    子服务器的名称

    主机名称或IP地址

    用作子服务器的机器的地址

    端口号

    与远程服务通信的端口号

    用户名

    获取远程服务器的用户名

    密码

    获取远程服务器的密码

    是主服务器吗

    在转换以集群形式执行时,该子服务器将作为主服务器

    注意: 在集群环境下执行转化时,你必须有一个子服务器作为主服务器(master server)而其余所有的子服务器都作为从属服务器(slave)

    Proxy tab options

    选项

    描述

    代理服务器主机名

    设置你要通过代理进行连接的主机名

    代理服务器端口

    设置与代理进行连接时所需的端口号

       

    Ignore proxy for hosts: regexp|separated

    指定哪些服务器不需要通过代理来进行连接。该选项支持你使用正则表达式来制定多个服务器,多个服务器之间以' | ' 字符来进行分割

    创建cluster schema

    选项描述

    选项

    描述

    Schema 名称

    集群schema的名称

    端口号

    这里定义的端口号是指从哪一个端口号开始分配给子服务器。每一个在子服务器中执行的步骤都要消耗一个端口号。

    注意: 确保没有别的网络协议会使用你定义的范围之类的端口,否则会引起问题

    Sockets缓存大小

    TCP内部缓存的大小

    Sockets刷新间隔(rows)

    当TCP的内部缓存通过网络完全发送出去并且被清空时处理的行数

    Sockets数据是否压缩

    如果该选项被选中,则所有的数据都会使用Gzip压缩算法进行压缩以减轻网络传输量

    Dynamic Cluster

    动态集群指的是在运行的时候才能获知从属服务器的信息。这种情形适用于主机可以自动增加或者去除的情形,例如云计算。

    主服务器的设置不变,但是它可以接受从属服务器的注册。一旦接受了某个从属服务器的注册,则每隔30秒去监视该从属服务器是否还处于有效状态

    子服务器

    这里是一个要在集群中使用的服务器列表。这个列表中包含一个主服务器和任意数目的从属服务器。

    在dynamic Cluster的情况下,只需要选择主服务器即可

    定义转换

    定义完了cluster schema后,下一步就是定义在集群环境下执行的转换。我们这里展现的只是一个最简单的例子,完全是为了演示而用。现实情况中的集群有可能非常复杂。

    首先你像平时一样创建转换,以hop连接连个两个步骤。然后你指定第二个步骤将在集群下执行

    然后选择需要使用的集群。转换如图一样显示在GUI中。

    注意 Cx4显示这个步骤将在集群中运行,而这个集群中有4个从属服务器。假设我们将计算结果再次存入到数据表中

    这个转换虽然定义了集群,但是我们同样可以让它在单机环境下执行,而且可以得到相同的结果。这意味着你可以使用普通的本地模式来测试它。

    执行转换

    要想以集群方式来运行转换或者作业,首先需要启动在Cluster  schema中定义的主服务器和从属服务器,然后再运行转换或者作业。

    启动子服务器

    子服务器其实是一个嵌入式的名为Carte的小web server。要进行集群转换,首先需要启动cluster schema中的子服务器

    脚本启动

    kettle提供了carte.bat和carte.sh(linux)批处理脚本来启动子服务器,这种启动方式分为两种

    使用主机号和端口号

    Carte 127.0.0.1 8080

    Carte 192.168.1.221 8081

    使用配置文件

    Carte  /foo/bar/carte-config.xml

    Carte http://www.example.com/carte-config.xml

    如果cluster schema中定义了Dynamic cluster选项,则必须使用配置文件来进行启动,当这个子服务器启动时,它需要向配置文件中“masters”中列出的主服务器列表中汇报其运行状态(通过调用主服务器的registerSlave服务),已达到动态地设置子服务器的目的。配置文件格式

    <slave_config>
       <masters>
       <slaveserver>
         <name>master1</name>
         <hostname>localhost</hostname>
         <port>8080</port>
         <username>cluster</username>
         <password>cluster</password>
         <master>Y</master>
       </slaveserver>
      </masters>
      <report_to_masters>Y</report_to_masters>
    <slaveserver>
      <name>slave4-8084</name>
      <hostname>localhost</hostname>
      <port>8084</port>
      <username>cluster</username>
      <password>cluster</password>
      <master>N</master>
    </slaveserver>
    </slave_config>

    这个配置文件主要包括以下几个节点

    Ø       masters: 这里列出来的服务器是当前子服务器需要向其汇报状态的主服务器。如果当前这个子服务器是主服务器,则它将连接其它的主服务器来获得这个集群中的所有子服务器。

    Ø       report_to_masters : 如果为Y,则表示需要向定义的主服务器发送消息以表明该从属服务器存在

    Ø       slaveserver : 这里定义的就是当前carte实例运行时需要的子服务器的配置情况

    这里定义的username和password在向主服务器调用Register服务时连接主服务器时提供的安全设置。在 <slaveserver>部分,你可以使用<network_interface> 参数,这个参数的优先级高于<hostname>参数 ,如果你的机器中安装有多个网卡,这个设置可以起作用。

    程序启动

    Kettle提供了org.pentaho.di.www.Carte类,你可以通过该类提供的函数来启动或者停止子服务器。

    Ø         启动子服务器

    SlaveServerConfig config = new SlaveServerConfig(hostname, port, false);

    Carte. runCarte(config);

    Ø         停止子服务器

    carte.getWebServer().stopServer();

    子服务器内幕

    我们前面提到过子服务器实际上就是一个web server,该web server是基于Jetty这个嵌入式的开源servlet容器。

    这个web server主要是提供转换运行的环境,另外一个重要的功能通过提供servlet来在客户端、主服务器和从属服务器之间进行通讯和控制。主服务器和从属服务器之间是通过httpClient来进行通讯的,通讯时传递的数据是xml格式。通过提供的servlet,可以实现启动、停止、暂停转换或者作业、获得转换或者作业的状态、注册子服务器、获得子服务器的列表等等

    Kettle主要提供了以下的几种基于servlet的服务

    Ø         GetRootServlet:获得Carte的根目录

    Ø         GetStatusServlet:获得在服务器上运行的所有的转换和作业的状态

    Ø         GetTransStatusServlet:获得在服务器上运行的某个指定的转换的每个步骤的运行状态。

    Ø         PrepareExecutionTransServlet:让服务器上的某个指定的转换做好运行的准备。

    Ø         StartTransServlet:执行服务器上的某个指定的转换

    Ø         PauseTransServlet:暂停或者重新运行某一个转换

    Ø         StopTransServlet:停止正在运行的转换

    Ø         CleanupTransServlet:清理运行转换时的环境

    Ø         AddTransServlet:向子服务器中增加某个转换。如果服务器中有正在运行或者准备运行的相同名字的转换,则抛出异常。

    Ø         AllocateServerSocketServlet:分配一个新的socket端口号。这个端口号是基于你在定义cluster schema中设置的端口号,依次加1

    Ø         StartJobServlet:执行服务器上某个指定的作业

    Ø         StopJobServlet:停止正在运行的作业

    Ø         GetJobStatusServlet:获得某个指定作业的状态

    Ø         AddJobServlet:向当前的子服务器中添加某个作业。

    Ø         RegisterSlaveServlet:注册某个服务器的信息。服务器信息包括子服务器是否活动、最新活动的时间、最新不活动的时间。这个在dynamic cluster中需要用到,由从属服务器向主服务器汇报当前状态。

    Ø         GetSlavesServlet:获得集群中子服务器的信息

    Ø         AddExportServlet:以zip文件的形式向caret服务器传递作业或者转换信息,并将信息加入到服务器中。

    运行转换

    在spoon中运行

    在kettle的集成设计环境spoon中,你可以选择转换中的“运行”菜单项,或者按F9快捷键,弹出以下的窗口

    这里有三个选项来决定转换是以什么方式来执行

    Ø       本地执行: 转换或者作业将在你现在使用的JVM中运行。

    Ø       远程执行: 允许你指定一个想运行转换的远程服务器。这需要你在远程服务器上安装Pentaho Data Integration(Kettle)并且运行Carte子服务器。

    Ø       集群方式执行: 允许你在集群环境下执行作业或者转换

     

    当你选择“集群方式执行”选项是,你可以选择以下的选项

    Ø       提交转换: 分解转换并且将转换提交到不同的主服务器和从属服务器。

    Ø       准备执行: 它将在主服务器和从属服务器上执行转换的初始化阶段。

    Ø       开始执行: 它将在主服务器和从属服务器中执行实际的转换任务。

    Ø       显示转换: 显示将要在集群上执行的生成的转换(可以参看下面的分析).

    编程运行

    你也可以通过使用Kettle提供的API通过编程来以集群的方式运行转换。

    TransMeta transMeta = new TransMeta("cluster.ktr");

    //设置执行模式

    TransExecutionConfiguration config = new TransExecutionConfiguration();

    config.setExecutingClustered(true);

    config.setExecutingLocally(false);

    config.setExecutingRemotely(false);

    config.setClusterPosting(true);

    config.setClusterPreparing(true);

    config.setClusterStarting(true);

    config.setLogLevel(LogWriter.LOG_LEVEL_BASIC);

    TransSplitter transSplitter = Trans.executeClustered(transMeta, config);

    long nrErrors = Trans.monitorClusteredTransformation("cluster  test", transSplitter, null, 1);

    需要注意的是这段代码可以在一个独立的JVM中执行,而不必要在主服务器中执行。

    运行内幕

    当以集群方式来运行转换时,Kettle主要执行以下几个步骤来执行分布式的处理

    Ø 分解转换

    在定义转换的时候,如果在某个步骤中定义使用集群,那么这个步骤其实是在从属服务器(slave server)上执行的,例如我们在前面定义转换的modify javascript value步骤中,我们定义了使用集群,那么这个步骤将在从属服务器中执行;而Cx4表示这个步骤是在4个从属服务器上执行。如果步骤中没有定义集群,则表示该步骤是在主服务器(master server)上执行。如果前一步骤在主服务器上执行,而后一步骤需要在从属服务器上执行,或者相反,则这时需要分别在前一步骤和后一步骤之间建立一个remoteStep步骤,前面的remoteStep建立socketWriter进程,它负责从上一步骤中取出数据然后通过socket传输到对应的子服务器的remoteStep中。而后一步骤所在的子服务器的remoteStep步骤则建立一个socketReader,负责从socket中获取数据,并将数据将数据传输到后一步骤中,以供后一步骤来进行后续处理。

    所以在以集群方式执行转换时,首要的任务是将转换分解成可以在各个子服务器上执行的转换。

    我们还是以上面建立的转换来进行分析描述:

    上图是在主服务器上建立的转换

    And 4 slaves transformations:

    上图是在4个从属服务器上建立的转换,我们可以注意到这四个从属服务器上的转换是一样的,除了端口号不一样。另外我们还注意到在前述Cluster Schema 定义中我们指定了端口号为4000,则为每一个建立的socket连接就是端口号4000开始,依次加1。另外,还可以看到数据是通过使用socket  Writer和socket Reader的remoteStep步骤通过TCP/IP的socket来传递数据的。

    Ø         提交转换

    对于第一步骤生成的子转换,将调用每个子服务器提供的AddTransServlet服务将转换的信息增加到每个子服务器中(包括主服务器和从属服务器)。

    Ø         准备转换

    调用每个子服务器的PrepareExecutionTransServlet服务来准备转换

    Ø         启动转换

    调用每个子服务器的StartExecutionTransServlet服务来启动转换。

    Ø         监控转换

    在各服务器的转换都启动后,调用Trans.monitorClusteredTransformation来监控各个服务器的运行状态(使用各子服务器提供的GetTransStatusServlet服务来获得每个子服务器的状态)。

    例子

    目的

    做一个转换(表输入---à排序--à表输出)

    然后在两台pc机器上实验。把集群放到排序插件上。

    配置两台子服务器

    创建子服务器

    在主对象下的转换下的子服务器右键单击新建。

    右键单击子服务器新建

    填写相关的配置,用户名和密码为cluster,如果要修改得修改kettle默认路径下的pwd下的kettle.pwd文件里的用户名密码。

    这个是从属服务器。

    配置schemas

    新建schemas

    在选择子服务器中选择这两个服务器。

    开启两台机器的carte服务

    在10.2.4.81机器和10.2.4.188机器的控制台开启carte服务。

    C:/pdi-open-3.1.0-826是保存kettle的文件夹

    188机器也和他一样。

    在转换中添加集群

    右击字段选择选择集群。

    点击确定。

    出现cx1代表成功。

    然后运行,就OK了。

    ---------------------------------以下内容是我自己添加的----------------------------------------

    更多资料:

    http://forums.pentaho.com/showthread.php?60500-clustering-in-Kettle
    http://forums.pentaho.com/archive/index.php/t-54398.html

    阅读全文>>

作者:miki艾比利分类:【ETL浏览(622评论(0

2019-10-30 10:51:20

【转载】myeclipse和idea阿里代码质量检测插件安装及使用

    本文参考 阿里巴巴代码规范插件安装说明

    一、插件安装

    1. 环境: JDK1.8,Eclipse4+。

    本文使用的JDK版本为:jdk1.8.0_152;Eclipse版本是: Oxygen.3 (4.7.3)

    2. 安装

    Help -> Install New Software...

    输入Update Site地址:https://p3c.alibaba.com/plugin/eclipse/update 回车,

     

    然后勾选Ali-CodeAnalysis,再一直点Next ...按提示走下去就好。
    选择接受证书点击finish完成操作。

     

     

    如下图界面提示选择install anyway


    然后就是提示重启了,点击restart now,安装完毕。

     


    出现如下图所示图标则,安装成功。

     

    至此插件安装完毕。


    注意:有同学反映插件扫描会触发很多 "JPA Java Change Event Handler (Waiting)" 的任务,这个是Eclipse的一个bug

    因为插件在扫描的时候会对文件进行标记,所以触发了JPA的任务。卸载JPA插件,

    或者尝试升级到最新版的Eclipse。附:JPA project Change Event Handler问题解决

    二、插件使用

    目前插件实现了开发手册中的53条规则,大部分基于PMD实现,其中有4条规则基于Eclipse实现,支持4条规则的QuickFix功能。

    * 所有的覆写方法,必须加@Override注解,

    * if/for/while/switch/do等保留字与左右括号之间都必须加空格,

    * long或者Long初始赋值时,必须使用大写的L,不能是小写的l

    * Objectequals方法容易抛空指针异常,应使用常量或确定有值的对象来调用equals

    目前不支持代码实时检测,需要手动触发。

    代码扫描

    可以通过右键菜单、Toolbar按钮两种方式手动触发代码检测。

     

    触发扫描

    在当前编辑的文件中点击右键,可以在弹出的菜单中触发对该文件的检测。

     

    在左侧的Project目录树种点击右键,可以触发对整个工程或者选择的某个目录、文件进行检测。

     

    也可以通过Toolbar中的按钮来触发检测,目前Toolbar的按钮触发的检测范围与您IDE当时的焦点有关,如当前编辑的文件或者是Project目录树选中的项,是不是感觉与右键菜单的检测范围类似呢。

    扫描结果

    简洁的结果面板,按规则等级分类,等级->规则->文件->违规项。同时还提供一个查看规则详情的界面。

    清除结果标记更方便,支持上面提到的4条规则QuickFix。

    查看所有规则

     

     

    image

    国际化

     

    虽然是抄的,但是有用就好

    阅读全文>>

作者:miki艾比利分类:【编程浏览(749评论(0

2019-10-29 09:18:02

【转载】ExecutorService的正确关闭方法

    ExecutorService的正确关闭方法

    转自:https://blog.csdn.net/xueyepiaoling/article/details/61200270

    虽然使用ExecutorService可以让线程处理变的很简单,可是有没有人觉得在结束线程运行时候只调用shutdown方法就可以了?实际上,只调用shutdown方法的是不够的。我们用学校的老师和学生的关系来说明这个问题。

    shutdown只是起到通知的作用

    我们来假设如下场景:
    学校里在课上老师出了一些问题安排全班同学进行解答并对学生说“开问题解答完毕后请举手示意!”
    如果有学生解答完毕后会举手对老师说“老师我做完了!”,如果大家都解题完毕后上课结束。

    上面的场景对应于ExecutorService里的方法的话是下面的样子。

    • 老师: ExecutorService
    • 学生: ExecutorService里的线程
    • 问题: 通过参数传递给ExecutorService.execute的任务(Runnable)
    • 授课: main线程
    • 学校: Java进程
    • “问题解答完毕后请举手示意!”是shutdown方法。
    • “老师我做完了!”是各个任务(Runnable)的运行结束。

    所有的任务(Runnable)都结束了的话main线程(授课)也结束了。

    在这里,我们假设试卷中有难度较大的问题,当然学生解答较难的问题也会比较花时间。在上面的场景中老师除了shutdown方法之外什么也做不了,只能呆呆得等着学生们说,“老师我做完了!”之后才可以有下一步动作。这都是因为shutdown方法只是用来通知的方法。

    这时如果即使授课时间结束(main线程结束),学校也不能放学(Java进程结束),因为学生们还在解题中呢。这个时候如果你是老师你会怎么做?

    一般的情况肯定是经过一定的时间在授课快要结束的时候,如果还有人没有解答出来的话,或者公布给大家解题方法,或者作为课后习题让学生回去继续思考,然后结束上课对不对!

    定好下课时间后等待结束

    如果经过了一定的时间任务(Runnable)还不结束的时候我们可以通过中止任务(Runnable)的执行,以防止一直等待任务的结束。awaitTermination方法正是可以实现这个中止作用的角色。

    具体的使用方法是,在shutdown方法调用后,接着调用awaitTermination方法。这时只需要等待awaitTermination方法里第一个参数指定的时间。

    如果在指定的时间内所有的任务都结束的时候,返回true,反之返回false。返回false意味着课程结束的时候还有题目没有解答出来的学生。

    通过shutdownNow方法,我们可以作为老师向同学发出“没有解答出来的同学明天给出解答”的命令后结束授课。

    shutdownNow方法的作用是向所有执行中的线程发出interrupted以中止线程的运行。这时,各个线程会抛出InterruptedException异常(前提是
    线程中运行了sleep等会抛出异常的方法)

    所以正确的中止线程的方法如下:

    public static void main(String[] args) {  
       
        ExecutorService pool = Executors.newFixedThreadPool(5);  
        final long waitTime = 8 * 1000;  
        final long awaitTime = 5 * 1000;  
       
        Runnable task1 = new Runnable(){  
            public void run(){  
                try {  
                    System.out.println("task1 start");  
                    Thread.sleep(waitTime);  
                    System.out.println("task1 end");  
                } catch (InterruptedException e) {  
                    System.out.println("task1 interrupted: " + e);  
                }  
            }  
        };  
       
        Runnable task2 = new Runnable(){  
            public void run(){  
                try {  
                    System.out.println("task2 start");  
                    Thread.sleep(1000);  
                    System.out.println("task2 end");  
                } catch (InterruptedException e) {  
                    System.out.println("task2 interrupted: " + e);  
                }  
            }  
        };  
        // 让学生解答某个很难的问题  
        pool.execute(task1);  
       
        // 让学生解答很多问题  
        for(int i=0; i<1000; ++i){  
            pool.execute(task2);  
        }  
       
        try {  
            // 向学生传达“问题解答完毕后请举手示意!”  
            pool.shutdown();  
       
            // 向学生传达“XX分之内解答不完的问题全部带回去作为课后作业!”后老师等待学生答题  
            // (所有的任务都结束的时候,返回TRUE)  
            if(!pool.awaitTermination(awaitTime, TimeUnit.MILLISECONDS)){  
                // 超时的时候向线程池中所有的线程发出中断(interrupted)。  
                pool.shutdownNow();  
            }  
        } catch (InterruptedException e) {  
            // awaitTermination方法被中断的时候也中止线程池中全部的线程的执行。  
            System.out.println("awaitTermination interrupted: " + e);  
            pool.shutdownNow();  
        }  
       
        System.out.println("end");  
    }  
    

    可以看出上面程序中waitTime的值比awaitTime大的情况下,发生Timeout然后执行中的线程会中止执行而结束。

    反过来如果缩小waitTime的值,增大awaitTime的值的的话,各个线程就会不被中止的正常运行至结束。

    在这里,如果我们把awaitTime和shutdownNow方法全部屏蔽掉的只留下shutdown方法的话会怎样呢? 会变成表示main方法结束的「end」显示出来之后,会打印出很多的task2的start和end。这就是虽然课程结束了,但是学校仍然不能放学的不正常状态。最恶劣的情况会导致JAVA进程一直残留在OS中。

    所以我们一定不要忘记使用awaitTermination和shutdownNow。

    shutdown也是很重要的

    看了上面的描述后可能有些人会认为,只需要执行awaitTermination和shutdownNow就可以正常结束线程池中的线程了。其实不然。
    shutdown方法还有「大家只解答我要求的问题,其它的不用多做」的意思在里面。

    shutdown方法调用后,就不能再继续使用ExecutorService来追加新的任务了,如果继续调用execute方法执行新的任务的话,就会抛出RejectedExecutionException异常。(submit方法也会抛出上述异常)

    而且,awaitTermination方法也不是在它被调用的时间点上简单得等待任务结束而是在awaitTermination方法调用后,持续监视各个任务的状态以或者是否线程已经运行结束。所以不调用shutdown方法执行调用awaitTermination的话由于追加出来的任务可能会导致任务状态监视出现偏差而发生预料之外的awaitTermination的Timeout异常。

    所以正确的调用顺序是:

    shutdown方法
    awaitTermination方法
    shutdownNow方法(发生异常或者是Timeout的时候)
    

    实际开发的系统可能会有不能强制线程中止执行的场景出现,所以虽然推荐使用上面说的调用顺序但也并不是绝对一成不变的。

    阅读全文>>

作者:miki艾比利分类:【javaEE浏览(503评论(0

2019-10-25 19:33:30

解决getConnection或者java.sql.rs.next() 时,线程hang住,导致代码卡顿问题

    1. 问题复现

    当你兴高采烈的写完一堆获取数据库连接的代码准备测试时,由于服务器性能,或者网络问题,导致线程阻塞,页面卡死。大多数数据库可能会具备连接超时的设置,你可以设置一下连接超时,自动退出即可。但是,有的数据库就是那么尿性,又或者是本身提供的jdbc驱动不支持连接超时设置,这个时候就很头疼了,每次页面查询数据或者点击测试连接的时候,让前台写一堆ajax超时设置吗,好了,废话不多说,此处教你一个方法,使用java中的ExecutorService来实现任务的中止。

    ExecutorService简介:

    查看java的api可知,

    继承于Executor,提供了管理终止的方法和可以生成Future,用来跟踪一个或多个异步任务进度的方法。

    可以关闭Service,之后会拒绝执行新的任务。提供了两种终止方法,shutdown()会终止任务,但是shutdown()之前提交的任务会继续执行,而shutdownNow()会终止掉没启动的任务并且终止正在运行的任务。终止的时候如果没有提交的任务,没有等待的任务,没有正在执行的任务时,应该释放executor资源。

    总的来说,实现ExecutorService,就有终止任务,和生成Future跟踪任务的能力。

    3.代码

    下面上代码:

    public static void main(String[] args) {
    		
    		boolean hasNext = false;
    		
    		Runnable runnable = new Runnable() {
                public void run() {
                    try {
                       Thread.sleep(5000);
                       System.out.println("乐乐");
                    } catch (Throwable e) {
                        
                    }
                }
            };
    //      Thread thread = new Thread(runnable);
    //      thread.start();
            
            System.out.println("tomcat初始化..");
            System.out.println("开始时间:"+System.currentTimeMillis());
            
            //首先构造Executor接口,下面的例子是创建一个单线程的执行者,你也可以根据需要创建基于线程池的执行者
            ExecutorService executor = Executors.newSingleThreadExecutor();
            
            //将rs.next()或者getcConnection方法委托给Callable接口去调用,通过Future接口获取返回结果
    		FutureTask future = new FutureTask(new Callable() {
    			public Boolean call() throws IOException {
    				try {
    					//模拟超时
    					Thread.sleep(5000);
    				} catch (InterruptedException e) {
    					e.printStackTrace();return false;
    				}
    				System.out.println("获取连接成功..");
    				return true;
    			}
    		});
    		
    		try {
    			executor.execute(future);
    			hasNext = future.get(2, TimeUnit.SECONDS);
    		} catch (InterruptedException | ExecutionException | TimeoutException e) {
    			e.printStackTrace();
    			System.out.println("超时啦...");
    			//捕获异常后,关闭当前任务!!!重要  2019.10.24  miki
    			executor.shutdown();
    		}       
            if(hasNext) {
            	//System.out.println("到达时间:"+System.currentTimeMillis());
            	System.out.println("到达时间:"+System.currentTimeMillis());
            }      
            
    	}

    执行结果如下:

    注意如下:

    shutdown()

    不能添加新任务,否则抛异常。但是已存在的任务会继续执行完成。(所以才会打印出来获取链接成功

    shutdownNow()

    不接收新任务,不处理等待任务,尝试中断已存在线程(通过Thread.interrupt(),这个方法作用有限,你的任务里没有抛出InterruptException的话,就中断不了了)

    Future submit(Callable task);

    Future submit(Runnable task, T result);

    谢谢观看,记得掉个赞哦

     

    阅读全文>>

作者:miki艾比利分类:【javaEE浏览(452评论(0

2019-10-24 21:19:07

【转载】Java:new一个对象的过程中发生了什么?

    作者:沉默哥

    cnblogs.com/JackPn/p/9386182.html

    java在new一个对象的时候,会先查看对象所属的类有没有被加载到内存,如果没有的话,就会先通过类的全限定名来加载。加载并初始化类完成后,再进行对象的创建工作。

    我们先假设是第一次使用该类,这样的话new一个对象就可以分为两个过程:加载并初始化类和创建对象。

    一、类加载过程(第一次使用该类)

    java是使用双亲委派模型来进行类的加载的,所以在描述类加载过程前,我们先看一下它的工作过程:

    双亲委托模型的工作过程是:如果一个类加载器(ClassLoader)收到了类加载的请求,它首先不会自己去尝试加载这个类,而是把这个请求委托给父类加载器去完成,每一个层次的类加载器都是如此,因此所有的加载请求最终都应该传送到顶层的启动类加载器中,只有当父类加载器反馈自己无法完成这个加载请求(它的搜索范围中没有找到所需要加载的类)时,子加载器才会尝试自己去加载。

    使用双亲委托机制的好处是:能够有效确保一个类的全局唯一性,当程序中出现多个限定名相同的类时,类加载器在执行加载时,始终只会加载其中的某一个类。

    1、加载

    由类加载器负责根据一个类的全限定名来读取此类的二进制字节流到JVM内部,并存储在运行时内存区的方法区,然后将其转换为一个与目标类型对应的java.lang.Class对象实例

    2、验证

    格式验证:验证是否符合class文件规范

    语义验证:检查一个被标记为final的类型是否包含子类;检查一个类中的final方法是否被子类进行重写;确保父类和子类之间没有不兼容的一些方法声明(比如方法签名相同,但方法的返回值不同)

    操作验证:在操作数栈中的数据必须进行正确的操作,对常量池中的各种符号引用执行验证(通常在解析阶段执行,检查是否可以通过符号引用中描述的全限定名定位到指定类型上,以及类成员信息的访问修饰符是否允许访问等)

    3、准备

    为类中的所有静态变量分配内存空间,并为其设置一个初始值(由于还没有产生对象,实例变量不在此操作范围内)

    被final修饰的static变量(常量),会直接赋值;

    4、解析

    将常量池中的符号引用转为直接引用(得到类或者字段、方法在内存中的指针或者偏移量,以便直接调用该方法),这个可以在初始化之后再执行。
    解析需要静态绑定的内容。 // 所有不会被重写的方法和域都会被静态绑定

    以上2、3、4三个阶段又合称为链接阶段,链接阶段要做的是将加载到JVM中的二进制字节流的类数据信息合并到JVM的运行时状态中。

    5、初始化(先父后子)

    • 4.1 为静态变量赋值

    • 4.2 执行static代码块

    注意:static代码块只有jvm能够调用


    如果是多线程需要同时初始化一个类,仅仅只能允许其中一个线程对其执行初始化操作,其余线程必须等待,只有在活动线程执行完对类的初始化操作之后,才会通知正在等待的其他线程。

    因为子类存在对父类的依赖,所以类的加载顺序是先加载父类后加载子类,初始化也一样。不过,父类初始化时,子类静态变量的值也有有的,是默认值。

    最终,方法区会存储当前类类信息,包括类的静态变量、类初始化代码(定义静态变量时的赋值语句 和 静态初始化代码块)、实例变量定义、实例初始化代码(定义实例变量时的赋值语句实例代码块和构造方法)和实例方法,还有父类的类信息引用。

    二、创建对象

    1、在堆区分配对象需要的内存

    分配的内存包括本类和父类的所有实例变量,但不包括任何静态变量

    2、对所有实例变量赋默认值

    将方法区内对实例变量的定义拷贝一份到堆区,然后赋默认值

    3、执行实例初始化代码

    初始化顺序是先初始化父类再初始化子类,初始化时先执行实例代码块然后是构造方法

    4、如果有类似于Child c = new Child()形式的c引用的话,在栈区定义Child类型引用变量c,然后将堆区对象的地址赋值给它

    需要注意的是,每个子类对象持有父类对象的引用,可在内部通过super关键字来调用父类对象,但在外部不可访问

    补充:

    通过实例引用调用实例方法的时候,先从方法区中对象的实际类型信息找,找不到的话再去父类类型信息中找。

    如果继承的层次比较深,要调用的方法位于比较上层的父类,则调用的效率是比较低的,因为每次调用都要经过很多次查找。这时候大多系统会采用一种称为虚方法表的方法来优化调用的效率。

    所谓虚方法表,就是在类加载的时候,为每个类创建一个表,这个表包括该类的对象所有动态绑定的方法及其地址,包括父类的方法,但一个方法只有一条记录,子类重写了父类方法后只会保留子类的。当通过对象动态绑定方法的时候,只需要查找这个表就可以了,而不需要挨个查找每个父类。

    本文系转载文章,来源注明出处https://mp.weixin.qq.com/s?__biz=MzU3MjY3NTA4Mw==&mid=2247484670&idx=1&sn=0aa6c48864938e67ec240f172881b96d&chksm=fccc019acbbb888c419beb4366a98a94a30be829b11b51e1e00fbd24deaaefbccc27ce4c8b48&mpshare=1&scene=23&srcid=&sharer_sharetime=1571197826923&sharer_shareid=740d3594a7d56bac2db24d531aeafff1#rd

    阅读全文>>

作者:miki艾比利分类:【jvm浏览(353评论(0

2019-10-16 15:36:15