你还拿着培训班教给你的 Cookie 去面试？确定不要进来看一下 Cookie 到底是什么样子的？

发表于 2019-11-20 | 分类于 HTTP

说实话，之前面试都是直接去背诵的面试题，关于 Cookie 的一些内容，比如说，记录浏览器端的数据信息啦， Cookie 的生命周期啦，这些内容，也从来没有研究过 Cookie 到底是怎么工作的，今天我们就来了解一下 Cookie 到底是怎么工作的。

阅读全文 »

羞，Spring Bean 初始化/销毁竟然有这么多姿势

发表于 2019-11-17 | 分类于 Spring ，系列

一、前言

日常开发过程有时需要在应用启动之后加载某些资源，或者在应用关闭之前释放资源。Spring 框架提供相关功能，围绕 Spring Bean 生命周期，可以在 Bean 创建过程初始化资源，以及销毁 Bean 过程释放资源。Spring 提供多种不同的方式初始化/销毁 Bean，如果同时使用这几种方式，Spring 如何处理这几者之间的顺序？

有没有觉得标题很熟悉，没错标题模仿二哥「@沉默王二」文章羞，Java 字符串拼接竟然有这么多姿势。

二、姿势剖析

首先我们先来回顾一下 Spring 初始化/销毁 Bean 几种方式，分别为：

init-method/destroy-method
InitializingBean/DisposableBean
@PostConstruct/@PreDestroy
ContextStartedEvent/ContextClosedEvent

PS: 其实还有一种方式，就是继承 Spring Lifecycle 接口。不过这种方式比较繁琐，这里就不再分析。

2.1、init-method/destroy-method

这种方式在配置文件文件指定初始化/销毁方法。XML 配置如下

<bean id="demoService" class="com.dubbo.example.provider.DemoServiceImpl"  destroy-method="close"  init-method="initMethod"/>

或者也可以使用注解方式配置：

@Configurable
public class AppConfig {

    @Bean(initMethod = "init", destroyMethod = "destroy")
    public HelloService hello() {
        return new HelloService();
    }
}

还记得刚开始接触学习 Spring 框架，使用就是这种方式。

2.2、InitializingBean/DisposableBean

这种方式需要继承 Spring 接口 InitializingBean/DisposableBean，其中 InitializingBean 用于初始化动作，而 DisposableBean 用于销毁之前清理动作。使用方式如下：

@Service
public class HelloService implements InitializingBean, DisposableBean {
    
    @Override
    public void destroy() throws Exception {
        System.out.println("hello destroy...");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("hello init....");
    }
}

2.3、@PostConstruct/@PreDestroy

这种方式相对于上面两种方式来说，使用方式最简单，只需要在相应的方法上使用注解即可。使用方式如下：

@Service
public class HelloService {


    @PostConstruct
    public void init() {
        System.out.println("hello @PostConstruct");
    }

    @PreDestroy
    public void PreDestroy() {
        System.out.println("hello @PreDestroy");
    }
}

这里踩过一个坑，如果使用 JDK9 之后版本，@PostConstruct/@PreDestroy 需要使用 maven 单独引入 javax.annotation-api，否者注解不会生效。

2.4、ContextStartedEvent/ContextClosedEvent

这种方式使用 Spring 事件机制，日常业务开发比较少见，常用与框架集成中。Spring 启动之后将会发送 ContextStartedEvent 事件，而关闭之前将会发送 ContextClosedEvent 事件。我们需要继承 Spring ApplicationListener 才能监听以上两种事件。

@Service
public class HelloListener implements ApplicationListener {

    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        if(event instanceof ContextClosedEvent){
            System.out.println("hello ContextClosedEvent");
        }else if(event instanceof ContextStartedEvent){
            System.out.println("hello ContextStartedEvent");
        }

    }
}

也可以使用 @EventListener注解，使用方式如下：

public class HelloListenerV2 {
    
    @EventListener(value = {ContextClosedEvent.class, ContextStartedEvent.class})
    public void receiveEvents(ApplicationEvent event) {
        if (event instanceof ContextClosedEvent) {
            System.out.println("hello ContextClosedEvent");
        } else if (event instanceof ContextStartedEvent) {
            System.out.println("hello ContextStartedEvent");
        }
    }
}

PS:只有调用 ApplicationContext#start 才会发送 ContextStartedEvent。若不想这么麻烦，可以监听 ContextRefreshedEvent 事件代替。一旦 Spring 容器初始化完成，就会发送 ContextRefreshedEvent。

三、综合使用

回顾完上面几种方式，这里我们综合使用上面的四种方式，来看下 Spring 内部的处理顺序。在看结果之前，各位读者大人可以猜测下这几种方式的执行顺序。

public class HelloService implements InitializingBean, DisposableBean {


    @PostConstruct
    public void init() {
        System.out.println("hello @PostConstruct");
    }

    @PreDestroy
    public void PreDestroy() {
        System.out.println("hello @PreDestroy");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("bye DisposableBean...");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("hello InitializingBean....");
    }

    public void xmlinit(){
        System.out.println("hello xml-init...");
    }

    public void xmlDestory(){
        System.out.println("bye xmlDestory...");
    }

    @EventListener(value = {ContextClosedEvent.class, ContextStartedEvent.class})
    public void receiveEvents(ApplicationEvent event) {
        if (event instanceof ContextClosedEvent) {
            System.out.println("bye ContextClosedEvent");
        } else if (event instanceof ContextStartedEvent) {
            System.out.println("hello ContextStartedEvent");
        }
    }

}

xml 配置方式如下：

    <context:annotation-config />
    <context:component-scan base-package="com.dubbo.example.demo"/>
    
    <bean class="com.dubbo.example.demo.HelloService" init-method="xmlinit" destroy-method="xmlDestory"/>

应用启动方法如下：

ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/dubbo-provider.xml");
context.start();
context.close();

程序输出结果如下所示：

最后采用图示说明总结以上结果：

四、源码解析

不知道各位读者有没有猜对这几种方式的执行顺序，下面我们就从源码角度解析 Spring 内部处理的顺序。

4.1、初始化过程

使用 ClassPathXmlApplicationContext 启动 Spring 容器，将会调用 refresh 方法初始化容器。初始化过程将会创建 Bean 。最后当一切准备完毕，将会发送 ContextRefreshedEvent。当容器初始化完毕，调用 context.start() 就发送 ContextStartedEvent 事件。

refresh 方法源码如下：

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
            //... 忽略无关代码

            // 初始化所有非延迟初始化的 Bean
            finishBeanFactoryInitialization(beanFactory);

            // 发送 ContextRefreshedEvent
            finishRefresh();

            //... 忽略无关代码
    }
}

一路跟踪 finishBeanFactoryInitialization 源码，直到 AbstractAutowireCapableBeanFactory#initializeBean，源码如下：

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        // 调用 BeanPostProcessor#postProcessBeforeInitialization 方法
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }

    try {
        // 初始化 Bean
        invokeInitMethods(beanName, wrappedBean, mbd);
    }
    catch (Throwable ex) {
        throw new BeanCreationException(
                (mbd != null ? mbd.getResourceDescription() : null),
                beanName, "Invocation of init method failed", ex);
    }
}

BeanPostProcessor 将会起着拦截器的作用，一旦 Bean 符合条件，将会执行一些处理。这里带有 @PostConstruct 注解的 Bean 都将会被 CommonAnnotationBeanPostProcessor 类拦截，内部将会触发 @PostConstruct 标注的方法。

接着执行 invokeInitMethods ，方法如下:

protected void invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd)
        throws Throwable {

    boolean isInitializingBean = (bean instanceof InitializingBean);
    if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
        // 省略无关代码
        // 如果是 Bean 继承 InitializingBean，将会执行  afterPropertiesSet 方法
        ((InitializingBean) bean).afterPropertiesSet();
    }

    if (mbd != null) {
        String initMethodName = mbd.getInitMethodName();
        if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
                !mbd.isExternallyManagedInitMethod(initMethodName)) {
            // 执行 XML 定义 init-method
            invokeCustomInitMethod(beanName, bean, mbd);
        }
    }
}

如果 Bean 继承 InitializingBean 接口，将会执行 afterPropertiesSet 方法，另外如果在 XML 中指定了 init-method ，也将会触发。

上面源码其实都是围绕着 Bean 创建的过程，当所有 Bean 创建完成之后，调用 context#start 将会发送 ContextStartedEvent 。这里源码比较简单，如下：

public void start() {
    getLifecycleProcessor().start();
    publishEvent(new ContextStartedEvent(this));
}

4.2、销毁过程

调用 ClassPathXmlApplicationContext#close 方法将会关闭容器，具体逻辑将会在 doClose 方法执行。

doClose 这个方法首先发送 ContextClosedEvent，然再后开始销毁 Bean。

灵魂拷问:如果我们颠倒上面两者顺序，结果会一样吗？

doClose 源码如下：

protected void doClose() {
    if (this.active.get() && this.closed.compareAndSet(false, true)) {
        // 省略无关代码

        try {
            // Publish shutdown event.
            publishEvent(new ContextClosedEvent(this));
        }
        catch (Throwable ex) {
            logger.warn("Exception thrown from ApplicationListener handling ContextClosedEvent", ex);
        }


        // 销毁 Bean
        destroyBeans();

        // 省略无关代码
    }
}

destroyBeans 最终将会执行 DisposableBeanAdapter#destroy，@PreDestroy、DisposableBean、destroy-method 三者定义的方法都将会在内部被执行。

首先执行 DestructionAwareBeanPostProcessor#postProcessBeforeDestruction，这里方法类似与上面 BeanPostProcessor。

@PreDestroy 注解将会被 CommonAnnotationBeanPostProcessor 拦截，这里类同时也继承了 DestructionAwareBeanPostProcessor。

最后如果 Bean 为 DisposableBean 的子类，将会执行 destroy 方法，如果在 xml 定义了 destroy-method 方法，该方法也会被执行。

public void destroy() {
    if (!CollectionUtils.isEmpty(this.beanPostProcessors)) {
        for (DestructionAwareBeanPostProcessor processor : this.beanPostProcessors) {
            processor.postProcessBeforeDestruction(this.bean, this.beanName);
        }
    }

    if (this.invokeDisposableBean) {
        // 省略无关代码
        // 如果 Bean 继承 DisposableBean，执行 destroy 方法
        ((DisposableBean) bean).destroy();
        
    }

    if (this.destroyMethod != null) {
        // 执行 xml 指定的  destroy-method 方法
        invokeCustomDestroyMethod(this.destroyMethod);
    }
    else if (this.destroyMethodName != null) {
        Method methodToCall = determineDestroyMethod();
        if (methodToCall != null) {
            invokeCustomDestroyMethod(methodToCall);
        }
    }
}

五、总结

init-method/destroy-method 这种方式需要使用 XML 配置文件或单独注解配置类，相对来说比较繁琐。而InitializingBean/DisposableBean 这种方式需要单独继承 Spring 的接口实现相关方法。@PostConstruct/@PreDestroy 这种注解方式使用方式简单，代码清晰，比较推荐使用这种方式。

另外 ContextStartedEvent/ContextClosedEvent 这种方式比较适合在一些集成框架使用，比如 Dubbo 2.6.X 优雅停机就是用改机制。

六、Spring 历史文章推荐

1、Spring 注解编程之注解属性别名与覆盖
 2、Spring 注解编程之 AnnotationMetadata
3、Spring 注解编程之模式注解
 4、缘起 Dubbo ，讲讲 Spring XML Schema 扩展机制

阅读全文 »

一文看懂 Redis 的内存回收策略和 Key 过期策略

发表于 2019-11-16 | 分类于 Redis

01、前言

Redis 作为当下最热门的 Key-Value 存储系统，在大大小小的系统中都扮演着重要的角色，不管是 session 存储还是热点数据的缓存，亦或是其他场景，我们都会使用到 Redis。在生产环境我们偶尔会遇到 Redis 服务器内存不够的情况，那对于这种情况 Redis 的内存是如何回收处理的呢？另外对于带有过期时间的 Key Redis 又是如何处理的呢？

阅读全文 »

Flink 基础学习(四)转换 Transformation

发表于 2019-11-12 | 分类于 Flink

前言

前面写了如何使用 Flink 读取常用的数据源，也简单介绍了如何进行自定义扩展数据源，本篇介绍它的下一步：数据转换 Transformation，其中数据处理用到的函数，叫做算子 Operator，下面是算子的官方介绍。

算子将一个或多个 DataStream 转换为新的 DataStream。程序可以将多种转换组合成复杂的数据流拓扑。

阅读全文 »

程序员，别再迷恋多线程工作了

发表于 2019-11-11 | 分类于 java

我刚刚尝试了一下，一边用 iPad 看“Java 极客技术”自制的 SpringBoot 视频（1.2X 倍速），一边在 iMac 上回复博客上读者的留言。过了一会，视频上讲了什么，我完全没有印象了；而回复的内容也写得乱七八糟。

阅读全文 »

灵魂拷问：Java 的 substring() 是如何工作的？

发表于 2019-11-11 | 分类于 life

在逛 programcreek 的时候，我发现了一些小而精悍的主题。比如说：Java 的 substring() 方法是如何工作的？像这类灵魂拷问的主题，非常值得深入地研究一下。

阅读全文 »

手把手教你实现热更新功能，带你了解 Arthas 热更新背后的原理

发表于 2019-11-10 | 分类于 Java

一、前言

一天下午正在摸鱼的时候，测试小姐姐走了过来求助，说是需要改动测试环境 mock 应用。但是这个应用一时半会又找不到源代码存在何处。但是测试小姐姐的活还是一定要帮，突然想起了 Arthas 可以热更新应用代码，按照网上的步骤，反编译应用代码，加上需要改动的逻辑，最后热更新成功。对此，测试小姐姐很满意，并表示下次会少提 Bug。

嘿嘿，以前一直对热更新背后原理很好奇，借着这个机会，研究一下热更新的原理。

阅读全文 »

带你涨姿势的认识一下Kafka-Producer

发表于 2019-11-08 | 分类于 Kafka

上一篇文章我们主要介绍了什么是 Kafka，Kafka 的基本概念是什么，Kafka 单机和集群版的搭建，以及对基本的配置文件进行了大致的介绍，还对 Kafka 的几个主要角色进行了描述，我们知道，不管是把 Kafka 用作消息队列、消息总线还是数据存储平台来使用，最终是绕不过消息这个词的，这也是 Kafka 最最核心的内容，Kafka 的消息从哪里来？到哪里去？都干什么了？别着急，一步一步来，先说说 Kafka 的消息从哪来。

阅读全文 »

CentOS7 下搭建 Harbor 仓库以及登录

发表于 2019-11-07 | 分类于 k8s

手把手教会你在 CentOS7 环境下搭建 Harbor 仓库，以及使用 Docker 以 HTTP 方式登录 Harbor 仓库。

阅读全文 »

关于 HTTP 代理，你还需要了解这些，不然面试你是过不去的！

发表于 2019-11-07 | 分类于 HTTP系列

上一篇文章我们完整的介绍了 HTTP 是如何使用 TCP 进行连接的，接下来的文章我们再来看看你在面试中经常会被问到的关于代理的问题。

阅读全文 »

灵魂拷问：为什么 Java 字符串是不可变的？

发表于 2019-11-06 | 分类于 java

在逛 programcreek 的时候，发现了一些精妙绝伦的主题。比如说：为什么 Java 字符串是不可变的？像这类灵魂拷问的主题，非常值得深思。

阅读全文 »

【集合系列】- 深入浅出的分析 Hashtable

发表于 2019-11-05 | 分类于数据结构

Hashtable 一个元老级的集合类，早在 JDK 1.0 就诞生了，今天小编想和大家一起来揭开它的面纱！

阅读全文 »

【集合系列】- 深入浅出的分析 Set集合

发表于 2019-11-05 | 分类于 Java

前几篇文章中，咱们聊到 List、Map 接口相关的实现类，今天咱们来聊聊集合中的 Set 接口！

阅读全文 »

【集合系列】- 深入浅出的分析 Properties

发表于 2019-11-05 | 分类于 Java

最近在看 java 集合源码的时候，发现原来我们经常使用的 Properties 类既然继承自 Hashtable！又涨见识了！

阅读全文 »

面试的时候问你HTTP是如何使用TCP连接的你还不知道怎么回答么？今天我就来告诉你！

发表于 2019-11-05 | 分类于 HTTP系列

之前我写了篇关于 HTTP 的文章，文章中讲述了 HTTP的特点，HTTP 的报文，HTTP 的请求方式等知识，接下来，深入了，我们就关于 HTTP 引发的面试题来进行入手，一起来看一下吧！

阅读全文 »

从 Java 的平台无关性引入的一系列面试题

发表于 2019-11-04 | 分类于面试

在 Java 面试中，有一条很常见的询问路线：从对 Java 的认识，到谈 Java 的平台无关性，到 Java 中的反射机制，再到类加载机制，继而深入到双亲委派机制等。本文将根据这条路线，给出一份可供参考的回答，如有错误万望指正。（推荐读者们在回答的时候结合自己的认识和项目经历作答）

阅读全文 »

java并发编程之线程基础

发表于 2019-11-04 | 分类于 java线程

01、简介

百丈高楼平地起，要想学好多线程，首先还是的了解一下线程的基础，这边文章将带着大家来了解一下线程的基础知识。

02、线程的创建方式

实现 Runnable 接口
继承 Thread 类
实现 Callable 接口通过 FutureTask 包装器来创建线程
通过线程池创建线程

下面将用线程池和 ``Callable 的方式来创建线程

public class CallableDemo implements Callable<String> {

    @Override
    public String call() throws Exception {
        int a=1;
        int b=2;
        System. out .println(a+b);
        return "执行结果:"+(a+b);
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建一个可重用固定线程数为1的线程池
        ExecutorService executorService = Executors.newFixedThreadPool (1);
        CallableDemo callableDemo=new CallableDemo();
        //执行线程,用future来接收线程的返回值
        Future<String> future = executorService.submit(callableDemo);
        //打印线程的返回值
        System. out .println(future.get());
        executorService.shutdown();
    }
}

执行结果

3
执行结果:3

03、线程的生命周期

NEW：初始状态，线程被构建，但是还没有调用 start 方法。
RUNNABLED：运行状态，JAVA 线程把操作系统中的就绪和运行两种状态统一称为“运行中”。调用线程的 start() 方法使线程进入就绪状态。
BLOCKED：阻塞状态，表示线程进入等待状态,也就是线程因为某种原因放弃了 CPU 使用权。比如访问 synchronized 关键字修饰的方法，没有获得对象锁。
Waiting ：等待状态，比如调用wait()方法。
TIME_WAITING：超时等待状态，超时以后自动返回。比如调用 sleep(long millis) 方法
TERMINATED：终止状态，表示当前线程执行完毕。

看下源码：

public enum State {
        
        NEW,

        RUNNABLE,
        
        BLOCKED,
         
        WAITING,
       
        TIMED_WAITING,
        
        TERMINATED;
}

04、线程的优先级

线程的最小优先级：1
线程的最大优先级：10
线程的默认优先级：5
通过调用 getPriority() 和 setPriority(int newPriority) 方法来获得和设置线程的优先级

看下源码：

	/**
     * The minimum priority that a thread can have.
     */
    public final static int MIN_PRIORITY = 1;

    /**
     * The default priority that is assigned to a thread.
     */
    public final static int NORM_PRIORITY = 5;

    /**
     * The maximum priority that a thread can have.
     */
    public final static int MAX_PRIORITY = 10;

看下代码：

public class ThreadA extends Thread {

    public static void main(String[] args) {
        ThreadA a = new ThreadA();
        System.out.println(a.getPriority());//5
        a.setPriority(8);
        System.out.println(a.getPriority());//8
    }
}

线程优先级特性：

继承性：比如A线程启动B线程，则B线程的优先级与A是一样的。
规则性：高优先级的线程总是大部分先执行完，但不代表高优先级线程全部先执行完。
随机性：优先级较高的线程不一定每一次都先执行完。

05、线程的停止

stop() 方法，这个方法已经标记为过时了，强制停止线程，相当于kill -9。
interrupt() 方法，优雅的停止线程。告诉线程可以停止了，至于线程什么时候停止，取决于线程自身。

看下停止线程的代码：

public class InterruptDemo {
    private static int i ;
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            //默认情况下isInterrupted 返回 false、通过 thread.interrupt 变成了 true
            while (!Thread.currentThread().isInterrupted()) {
                i++;
            }
            System.out.println("Num:" + i);
        }, "interruptDemo");
        thread.start();
        TimeUnit.SECONDS.sleep(1);
        thread.interrupt(); //不加这句,thread线程不会停止
    }
}

看上面这段代码，主线程main方法调用 thread线程的 interrupt() 方法，就是告诉 thread 线程，你可以停止了（其实是将 thread 线程的一个属性设置为了true），然后 thread 线程通过 isInterrupted() 方法获取这个属性来判断是否设置为了true。这里我再举一个例子来说明一下，

看代码：

public class ThreadDemo {
    private volatile static Boolean interrupt = false ;
    private static int i ;

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            while (!interrupt) {
                i++;
            }
            System.out.println("Num:" + i);
        }, "ThreadDemo");
        thread.start();
        TimeUnit.SECONDS.sleep(1);
        interrupt = true;
    }
}

是不是很相似，再简单总结一下：

当其他线程通过调用当前线程的 interrupt 方法，表示向当前线程打个招呼，告诉他可以中断线程的执行了，并不会立即中断线程，至于什么时候中断，取决于当前线程自己。

线程通过检查资深是否被中断来进行相应，可以通过 isInterrupted() 来判断是否被中断。

这种通过标识符来实现中断操作的方式能够使线程在终止时有机会去清理资源，而不是武断地将线程停止，因此这种终止线程的做法显得更加安全和优雅。

06、线程的复位

两种复位方式：

Thread.interrupted()
通过抛出 InterruptedException 的方式

然后了解一下什么是复位：

线程运行状态时 Thread.isInterrupted() 返回的线程状态是 false，然后调用 thread.interrupt() 中断线程 Thread.isInterrupted() 返回的线程状态是 true，最后调用 Thread.interrupted() 复位线程Thread.isInterrupted() 返回的线程状态是 false 或者抛出 InterruptedException 异常之前，线程会将状态设为 false。

下面来看下两种方式复位线程的代码，首先是 Thread.interrupted() 的方式复位代码：

public class InterruptDemo {

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            while (true) {
                //Thread.currentThread().isInterrupted()默认是false,当main方式执行thread.interrupt()时,状态改为true
                if (Thread.currentThread().isInterrupted()) {
                    System.out.println("before:" + Thread.currentThread().isInterrupted());//before:true
                    Thread.interrupted(); // 对线程进行复位，由 true 变成 false
                    System.out.println("after:" + Thread.currentThread().isInterrupted());//after:false
                }
            }
        }, "interruptDemo");
        thread.start();
        TimeUnit.SECONDS.sleep(1);
        thread.interrupt();
    }
}

抛出 InterruptedException 复位线程代码：

public class InterruptedExceptionDemo {

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    // break;
                }
            }
        }, "interruptDemo");
        thread.start();
        TimeUnit.SECONDS.sleep(1);
        thread.interrupt();
        System.out.println(thread.isInterrupted());
    }
}

结果：

false
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at java.lang.Thread.sleep(Thread.java:340)
	at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
	at com.cl.concurrentprogram.InterruptedExceptionDemo.lambda$main$0(InterruptedExceptionDemo.java:16)
	at java.lang.Thread.run(Thread.java:748)

需要注意的是，InterruptedException 异常的抛出并不意味着线程必须终止，而是提醒当前线程有中断的操作发生，至于接下来怎么处理取决于线程本身，比如

直接捕获异常不做任何处理
将异常往外抛出
停止当前线程，并打印异常信息

像我上面的例子,如果抛出 InterruptedException 异常,我就break跳出循环让 thread 线程终止。

为什么要复位：

Thread.interrupted()是属于当前线程的，是当前线程对外界中断信号的一个响应，表示自己已经得到了中断信号，但不会立刻中断自己，具体什么时候中断由自己决定，让外界知道在自身中断前，他的中断状态仍然是 false，这就是复位的原因。

阅读全文 »

最常见的12道计算机网络面试题

发表于 2019-11-03 | 分类于面试题

本篇总结了12道最常见的计算机网络面试题，并给出了一些自己的看法，若有不妥之处万望指正。

阅读全文 »

Dubbo 优雅停机演进之路

发表于 2019-10-30 | 分类于 Dubbo

一、前言

在『ShutdownHook- Java 优雅停机解决方案』一文中我们聊到了 Java 实现优雅停机原理。接下来我们就跟根据上面知识点，深入 Dubbo 内部，去了解一下 Dubbo 如何实现优雅停机。

阅读全文 »

Java 中令人匪夷所思的 Magic 之魔数

发表于 2019-10-24 | 分类于 java基础

01、故事背景

试想一下你现在有个业务场景需要你识别出各种类型的文件，然后进行不同的处理，这些文件不管是用户上传还是怎么来的，你都需要知道文件是什么类型，比如是一张 JPG 图片，还是一个 GIF 图片又或者是 PDF 等等其他类型的文件。这个时候你会想，这还不简单么，几行 Java 代码就搞定了。

阅读全文 »