发表于 | 分类于
字数统计: 348 | 阅读时长 ≈ 1

一. 登录自己的github，创建一个仓库。

         注意： 如果你希望你的站点能通过 <你的 GitHub 用户名>.github.io 域名访问，你的 repository 应该直接命名为 <你的 GitHub 用户名>.github.io。

二. 安装 （这里我是用管理员身份打开的cmd命令窗口进行的）

         注意： 如果你希望你的站点能通过 <你的 GitHub 用户名>.github.io 域名访问，你的 repository 应该直接命名为 <你的 GitHub 用户名>.github.io。

cnpm install --save hexo-deployer-git

三. 修改_config.yml文件

         还是去你自己创建的文件夹中找到_config.yml文件，在文件的最后，加入 如下内容

deploy:
  type: git
  repo: 第一步创建的仓库地址
  branch: master

例如

deploy:
  type: git
  repo: https://github.com/TomorrowLi/TomorrowLi.github.io
  branch: master

         这里注意，type , repo， branch 后面都有一个空格。

四. 推送到github上

将你创建的文件夹推送到github上，首先你肯定得进入到你的文件夹下，如我的是bolg，输入以下命令即可。

hexo g

hexo d

耐心等待即可。完成后可以到刚刚创建的仓库。

接下来你就可以通过你的仓库名字直接访问你的个人博客网站。不需要通过localhost:4000访问了。

如：https://tomorrowli.github.io/

至此，你就拥有一个自己的博客网站了。快来试试吧。

发表于 | 分类于
字数统计: 302 | 阅读时长 ≈ 1

         java.util.concurrent.Exchanger可以用来进行数据交换，或者被称为“数据交换器”。两个线程可以使用Exchanger交换数据。Exchanger（交换者）是一个用于线程间写作的工具类。Exchanger用于进行线程间的数据交换。它提供一个同步点，在这个同步点两个线程可以交换彼此的数据。这两个线程通过exchange()交换数据，如果第一个线程先执行exchange方法，它会一直等待第二个线程也执行exchange()，当连个线程都到达同步点时，这两个线程就可以交换数据，将本线程生产出来的数据传递给对方。

package com.semaphore;

import java.util.concurrent.Exchanger;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExchangerTest {

    private static final Exchanger<String> exgr = new Exchanger<String>();

    private static ExecutorService threadPool = Executors.newFixedThreadPool(2);

    public static void main(String[] args) {

        threadPool.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    String A = "银行流水A";// A录入银行流水数据
                    System.out.println("本来是" + A + "变成了" + exgr.exchange(A));
                } catch (InterruptedException e) {
                }
            }
        });

        threadPool.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    String B = "银行流水B";// B录入银行流水数据
                    System.out.println("本来是" + B + "变成了" + exgr.exchange(B));
                } catch (InterruptedException e) {
                }
            }
        });

        threadPool.shutdown();

    }
}

发表于 | 分类于
字数统计: 732 | 阅读时长 ≈ 3

1、通过join()方法指定顺序

     当然，thread的join方法实现多线程顺序执行有两种方式，一种是在子线程内部调用join()方法，另一种是直接在主线程调用join()方法；写法上是主线程上调用join()更直观，谁先执行谁后执行一目了然。子线程内部调用的话，相对的要注意调用的顺序。

1.子线程内部调用join()

public class ThreadJoinDemo {
    public static void main(String[] args) throws InterruptedException {
        final Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("打开冰箱！");
            }
        });

        final Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    thread1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("拿出一瓶牛奶！");
            }
        });

        final Thread thread3 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    thread2.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("关上冰箱！");
            }
        });

        //下面三行代码顺序可随意调整，程序运行结果不受影响，因为我们在子线程中通过“join()方法”已经指定了运行顺序（还有一个原因就是之前说的多线程的生命周期中有就绪状态，需要等待cpu调度，start并不意味着运行状态）。
        thread3.start();
        thread2.start();
        thread1.start();
    }
}
阅读全文 »

发表于 | 分类于
字数统计: 1,287 | 阅读时长 ≈ 7

  1. ReadFileThread

      public class ReadFileThread extends Thread {

 private ReaderFileListener processPoiDataListeners;
 private String filePath;
 private long start;
 private long end;

 public ReadFileThread(ReaderFileListener processPoiDataListeners,long start,long end,String file) {
     this.setName(this.getName()+"-ReadFileThread");
     System.out.println(this.getName());
     this.start = start;
     this.end = end;
     this.filePath = file;
     this.processPoiDataListeners = processPoiDataListeners;
 }

 @Override
 public void run() {
     ReadFile readFile = new ReadFile();
     readFile.setReaderListener(processPoiDataListeners);
     readFile.setEncode(processPoiDataListeners.getEncode());
 //  readFile.addObserver();
     try {
         readFile.readFileByLine(filePath, start, end + 1);
     } catch (Exception e) {
         e.printStackTrace();
     }
 }

    }

阅读全文 »

发表于 | 分类于
字数统计: 1,537 | 阅读时长 ≈ 5

TopK面试题

1、中垃圾回收机制中如何判断对象需要回收

  1. 引用计数算法(Reference Counting)

            在对象(对象头)中添加一个引用计数器，每当有一个地方引用它时，计数器值就加一; 当引用失效时，计数器值就减一; 任何时刻计数器为零的对象就是不可能再被使用的。引用计数算法虽然占用了一些额外的内存空间来进行计数，但它的原理简单，判定效率也很高，在大多数情况下它都是一个不错的算法。这个看似简单的算法有很多例外情况要考虑，必须要配合大量额外处理才能保证正确地工作，譬如单纯的引用计数就很难解决对象之间相互循环引用的问题。

阅读全文 »

发表于 | 分类于
字数统计: 53 | 阅读时长 ≈ 1

启程

        经过两年的停更，今天决定重新开始。这两年中由于种种原因，不能继续下去。有过快乐，有过悲伤。有舍有得。总之受益良多。加油！！！