JsprX

Ubuntu 任务自启动

2021-06-15T00:00:00+00:00

/etc/rc.local

可以直接在 /etc/rc.local中添加开机启动命令,

#!/bin/sh -e
#
# rc.local
#
# This script is executed at the end of each multiuser runlevel.
# Make sure that the script will "exit 0" on success or any other
# value on error.
#
# In order to enable or disable this script just change the execution
# bits.
#
# By default this script does nothing.
sleep 2000
ethtool -s eno1 wol g

/etc/init.d/ 目录

在 /etc/init.d/ 目录下新建一个脚本文件，例如 app1.
```
#!/bin/sh
java -jar /opt/app1.jar &
```
改变脚本文件权限.
```
sudo chmod 755 app1
```

更新启动目录.

sudo update-rc.d app1 defaults

如果需要删除此启动项目，

sudo update-rc.d -f app1 remove

详情可见

man update-rc.d

systemd

Systemd¹ 是一套用于 Linux 基本工具，它提供了一个系统服务管理器，systemd 作为 PID 为 1 的进程启动，全名是 System Daemon.

我们可以在 /etc/systemd/system 目录中新建一个服务 test.service，然后写入：

[Unit]
Description=this is test service

[Service]
Type=simple
ExecStart= <shell command>  #启动命令
ExecStop=<shell command>    #停止命令，可缺省

[Install]
WantedBy=multi-user.target #所有用户组都启动这个任务

service 文件的具体格式，参照 systemd.service

现在我们需要加载 service，并且启动这个 service.

sudo systemctl daemon-reload
sudo systemctl enable test.service
sudo systemctl start test.service

可通过 systemctl status commandname.service 来查看开机自启动项目是否设立成功，也可以在开机之后利用进程监控。

Systemd ↩

虚拟机搭建 Kubenetes

2021-06-10T00:00:00+00:00

准备三台虚拟机，

# Setup daemon.
cat > /etc/docker/daemon.json <<EOF
{
  "exec-opts": ["native.cgroupdriver=systemd"],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m"
  },
  "storage-driver": "overlay2"
}
EOF

kubeadm reset -f
kubeadm init

Flannel

LeetCode:10.正则表达式匹配

2021-05-07T00:00:00+00:00

给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 ‘.’ 和 ’‘ 的正则表达式匹配。 ‘.’ 匹配任意单个字符 ‘’ 匹配零个或多个前面的那一个元素所谓匹配，是要涵盖整个字符串 s的，而不是部分字符串。

示例 1：

输入：s = “aa” p = “a” 输出：false 解释：”a” 无法匹配 “aa” 整个字符串。

示例 2:

输入：s = “aa” p = “a” 输出：true 解释：因为 ‘’ 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 ‘a’。因此，字符串 “aa” 可被视为 ‘a’ 重复了一次。

示例 3：

输入：s = “ab” p = “.” 输出：true 解释：”.” 表示可匹配零个或多个（’*‘）任意字符（’.’）。

示例 4：

输入：s = “aab” p = “c*a*b” 输出：true 解释：因为 ‘’ 表示零个或多个，这里 ‘c’ 为 0 个, ‘a’ 被重复一次。因此可以匹配字符串 “aab”。示例 5：> 输入：s = “mississippi” p = “misisp.” 输出：false

提示：

0 <= s.length <= 20 0 <= p.length <= 30 s 可能为空，且只包含从 a-z 的小写字母。 p 可能为空，且只包含从 a-z 的小写字母，以及字符 . 和 。保证每次出现字符 时，前面都匹配到有效的字符

出栈序列与卡特兰数

2021-04-03T00:00:00+00:00

中午吃饭的时候听到隔壁桌在聊一道题，当时没想出来。事后查了些资料，记录一下。

问题

一个栈的进栈序列为 1, 2, 3, 4, ..., n, 出栈序列有多少种情况？

解题思路

假设计算情况数的函数为$f(n)$,

1) 如果元素1第一个出栈，那么情况一定是1进栈然后立马出栈，此时还剩 2, 3,..., n，有$f(n-1)$种情况。

2) 如果元素1第二个出栈，那么有一个元素比1先出栈，这个元素只能是2，此时还剩3, 4, ..., n,有$f(1) \cdot f(n-2)$种情况。

3) 如果元素1第三个出栈，那么有两个元素比1先出栈，这个元素只能是2或3，此时还剩4, ..., n,有$f(2) \cdot f(n-3)$种情况。

…

n-1) 如果元素1第n-1个出栈，那么有n - 2个元素比1先出栈，这个元素可能是{2, 3, 4, ..., n - 1}中的一个，剩下n，有$f(n-2) \cdot f(1)$种情况。

n) 如果元素1第n个出栈，那么有n - 1个元素比1先出栈，这个元素可能是{2, 3, 4, ..., n}中的一个，有$f(n-1)$种情况。

这样一来，可以推导出，

\[f(n) = \left\{ \begin{aligned} & {1} & , {n \leq 1} \\ & {f(0) \cdot f(n-1) + f(1) \cdot f(n-2) + ... + f(n-2) \cdot f(1) + f(n-1) \cdot f(0)} & , {n > 1} \\ \end{aligned} \right.\]

其实这个函数是卡塔兰数它的公式是，

\[C_n = \frac{1}{n+1}{2n \choose n} = \frac{(2n)!}{(n+1)!n!}\]

用递归实现的时间复杂度会是$O(N^2)$，而借助记忆可以省掉重复计算，而如果借助上面的公式，也可以写出非常简洁的递归或者迭代，下面给出两种计算方法：

借助记忆的 DP，由于每次求C[K]都需要C[0], C[1], ..., C[K-1]，所以没办法使用动滚动数组：

long C(int n) {

    long[] C = new long[n + 1];
    C[0] = 1L;
    for (int i = 1; i < n + 1; i ++) {
        int c = 0;
        for (int j = 0; j < i; j ++) {
            c += C[j] * C[i - j - 1];
        }
        C[i] = c;
    }
    return C[n];
}

借助上面的公式，可以推出$C_n$与$C_{n-1}$的递推公式，

\[C_n = \frac{2 \cdot (2n-1)}{n + 1} \cdot C_{n-1}\]

借助这个递推关系可以递归实现：

long C(int n) {
    if (n == 0 || n == 1) {
        return 1;
    }
    return C(n - 1) * 2 * (2 * n - 1) / (n + 1);
}

由于以上的递归是「自顶向下」的，造成许多重复计算。优化一下，

long C(int n) {
    if (n == 0 || n == 1) {
        return 1;
    }
    long temp = 1;
    for (int i = 2; i < n + 1; i++) {
        temp = temp * (2 * (2 * i - 1) / (i + 1));
    }
    return temp;
}

To Read - 2021-03-07

2021-03-07T00:00:00+00:00

Blog

Books

Bash中’«‘的用法

2021-01-02T00:00:00+00:00

This  type  of  redirection  instructs the shell to read input from the urrent source 
until a line containing only word (with no trailing blanks) is seen. 
All of the lines read up to that point are then used as the standard input for a command.

       The format of here-documents is:

              <<[-]word
                      here-document
              delimiter

       No parameter expansion, command substitution, arithmetic expansion, or pathname expansion is performed on word.  If  any  charac-
       ters  in  word  are  quoted,  the  delimiter  is  the result of quote removal on word, and the lines in the here-document are not
       expanded.  If word is unquoted, all lines of the here-document are subjected to parameter expansion,  command  substitution,  and
       arithmetic  expansion.  In the latter case, the character sequence \<newline> is ignored, and \ must be used to quote the charac-
       ters \, $, and `.

       If the redirection operator is <<-, then all leading tab characters are stripped from input lines and the line containing  delim-
       iter.  This allows here-documents within shell scripts to be indented in a natural fashion.

以上是 man

EOF多行写入文件防止变量替换问题描述# 　　对多个变量及多行输出到文件，存在变量自动替换，当使用cat«EOF不想对内容进行变量替换、命令替换、参数展开等

问题解决# 　　转义特殊字符如 $ `等

一、对 $·\ 进行转义

cat >> a.sh << EOF
echo \`hostname\`
echo $HOME
EOF

二、在分界符EOF前添加反斜杠\，或者用单引号、双引号括起来

cat >> a.sh << \EOF
echo `hostname`
echo $HOME
EOF

cat >> a.sh << "EOF"
echo `hostname`
echo $HOME
EOF

cat >> a.sh << 'EOF'
echo `hostname`
echo $HOME
EOF

ParallelStream 的正确打开方式

2021-01-02T00:00:00+00:00

ParallelStream 是什么

ParallelStream 其实就是一个并行执行的流.它通过默认的ForkJoinPool,¹可能提高你的多线程任务的速度.

The fork/join framework is an implementation of the ExecutorService interface that helps you take advantage of multiple processors. It is designed for work that can be broken into smaller pieces recursively. The goal is to use all the available processing power to enhance the performance of your application.

ParallelStream 的作用

ParallelStream: 具有平行处理能力，处理的过程会分而治之，也就是将一个大任务切分成多个小任务，这表示每个任务都是一个操作。

1
2
3
4
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);

numbers.parallelStream()
       .forEach(out::println);

上面的代码我们的到的不是顺序的1、2、3、4、5…，而是随机的顺序。

如果需要按照原来的顺序便利，可以使用 forEachOrdered() 方法：

1
2
3
4
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);

numbers.parallelStream()
       .forEachOrdered(out::println);

ParallelStream 的实现

ParallelStream 是由 ForkJoin 与 ForkJoinPool 实现的。 ForkJoinPool 使用相对少的线程来处理大量的任务。比如有一个任务需要处理100万的数据，那么这个任务会被分割成两个处理50万数据的任务，以此类推，直到任务单元被分割成一个预设的阈值大小的任务，直到这些子任务被执行完，这个任务才将完成。这和ThreadPoolExecutor的区别是，ThreadPoolExecutor 处理这个100万的任务会需要100万的线程.

ForkJoinPool 默认的大小等于当前机器的 CPU 核心数。可以使用
-Djava.util.concurrent.ForkJoinPool.common.parallelism=N 来设置 ForkJoinPool 的大小。

程序中的 ParallelStream 共用一个 commonForkJoinPool。

关于使用 ParallelStream 的坑

ParallelStream固然有它强大的地方，但同样的，它也存在着陷阱。

1
2
3
4
5
6
 public Object query(List<Request> reqs) {
     Optional<String> result = reqs.stream().parallel().map( -> {
        return client.url(url).get();
      }).findAny();
      return result.get();
}

上面的代码用来获取第一个返回的请求，注意网络请求属于IO操作，这里面存在在被阻塞的风险，故而这段代码的设计是存在问题。前面提到程序中的 ParallelStream 共用一个 commonForkJoinPool，试想如果这里调用的 API 响应比较慢，那么这段代码就会影响到其他使用 ParallelStream 的地方（阻塞其他任务）。这样的后果往往是不可估量的。

如何正确使用 ParallelStream

首先，我们需要考虑需不需要用ParallelStream。
1. 是否需要并行？
2. 任务之间是否是独立的？是否会引起任何竞态条件？
3. 结果是否取决于任务的调用顺序？
考虑过这三个问题后再决定是否使用ParallelStream。
其次，使用指定的不与其他任务冲突的 ForkJoinPool。

1
2
3
4
5
6
7
8
ForkJoinPool forkJoinPool = new ForkJoinPool(3);  
forkJoinPool.submit(() -> {  
    firstRange.parallelStream().forEach((number) -> {
        try {
            Thread.sleep(5);
        } catch (InterruptedException e) { }
    });
});

Fork/Join ↩

编写卓越的代码——防御性编程

2020-12-03T00:00:00+00:00

编写卓越的代码

软件工程师的智慧，就在于他们是否开始意识到：使程序能用和使程序正确，这两者之间有什么样的差别。 – M.A.Jackson, 《程序设计原理》

可用的代码：提供常规输入集，代码给出常规输出；一旦有意外输入，代码崩溃。

正确的代码：对于所有输入集，有正确的输出；

优秀的代码：一定是正确的代码；逻辑容易理解；代码自然；容易维护。

防御性编程

防御性编程是一种细致、谨慎的编程方法。为了开发可靠的软件，我们要设计系统中的每个组件，以使其尽可能地“保护”自己。我们通过明确地在代码中对设想进行检查，击碎了未记录下来的设想。这是一种努力，防止（或至少是观察）我们的代码以将会展现错误行为的方式被调用。

Java 中的实践

java.lang.Integer.parseInt() in Java 8.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static int parseInt(String s, int radix) throws NumberFormatException{
        if (s == null) {
            throw new NumberFormatException("null");
        }
        if (radix < Character.MIN_RADIX) {
            throw new NumberFormatException("radix " + radix +
                                            " less than Character.MIN_RADIX");
        }
        if (radix > Character.MAX_RADIX) {
            throw new NumberFormatException("radix " + radix +
                                            " greater than Character.MAX_RADIX");
        }
      // 主逻辑
}

KMP 字符串匹配

2020-06-10T00:00:00+00:00

⁴

⁵

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
28
29
30
31
32
33
34
35
36
37
void preKmp(char *x, int m, int kmpNext[]) {
   int i, j;

   i = 0;
   j = kmpNext[0] = -1;
   while (i < m) {
      while (j > -1 && x[i] != x[j])
         j = kmpNext[j];
      i++;
      j++;
      if (x[i] == x[j])
         kmpNext[i] = kmpNext[j];
      else
         kmpNext[i] = j;
   }
}


void KMP(char *x, int m, char *y, int n) {
   int i, j, kmpNext[XSIZE];

   /* Preprocessing */
   preKmp(x, m, kmpNext);

   /* Searching */
   i = j = 0;
   while (j < n) {
      while (i > -1 && x[i] != y[j])
         i = kmpNext[i];
      i++;
      j++;
      if (i >= m) {
         OUTPUT(j - i);
         i = kmpNext[i];
      }
   }
}

Bye Bye NPE

2019-07-03T00:00:00+00:00

This led me to suggest that the NULL value is a member of every type, and a NULL check is required on every use of that reference variable, and it may be perhaps a billion dollar mistake. ¹ – Tony Hoare

What’s wrong with NULL

Simply put, NULL reference (or NULL pointer) is a special marker and keyword indicating that something has no value.Programs routinely use NULL pointers to represent conditions such as the end of a list of unknown length or the failure to perform some action; this use of NULL pointers can be compared to NULLable types and to the Nothing value in an option type.It is created by Tony Hoare, a famous British computer scientist.

Simply because it was so easy to implement, many computer language designers use NULL reference. Speaking at a software conference in 2009, Tony Hoare apologized for inventing the NULL reference²

So, what problems does NULL reference cause?

In these languges, etc Java, NULL is above type checks. It slips through them silently, waiting for runtime, to finally burst free in a shower of errors.

1
2
String s = null;
s.toUppercase(); // compile check success, but crashes at runtime.

Null make Ambiguous API.

1
2
3
4
5
6
7
8
// name => phone number
Map<String, String> store = new HashMap<>();
store.put("adam", "911"); 
store.put("Bill", null)

store.get("Adam"); // 911 represent Adam's phone number is 911
store.get("Bill"); // null represent Bill don't have a phone number
store.get("Cathy");// null represent ?

NULL is difficult to debug.We do not need say more about it.

…³

NullPointerException in Java

NullPointerException: NullPointerException is an unchecked exception and extends RuntimeException. A null value can be assigned to an object reference in Java.

NullPointerException is thrown when program attempts to use an object reference that has the null value.

These can be:

Invoking a method from a null object.
Accessing or modifying a null object’s field.
Taking the length of null, as if it were an array.
Accessing or modifying the slots of null object, as if it were an array.
Throwing null, as if it were a Throwable value.
When you try to synchronize over a null object.

Example:

1
2
3
4
5
6
7
// define a String of value null
String a = null

// a is null, does hava a equals method
if (a.equals("OK")) {
    ...
}

Output:

Exception in thread "main" java.lang.NullPointerException
    at Example.main(Example.java:4)

How to avoid NPE

Since Java was created, programmers spent a lot of precious time handling NPE(NullPointerException), which is not some difficult problem.So, let’s look at specific ways to solve these problems.

Check method arguments

1
2
3
void doSomething(String s) {
    ... // some operations
}

Look at the method doSomething(). Suppose s is a null reference, these operations invoke the member methods of argument s, it will throws a NPE.

To avoid this NPE, we can modify the code as below.

1
2
3
4
5
6
void doSomething(String s) {
    if (s == null) {
        return;
    }
    ... // some operations
}

@NotNull

But if we check arguments in each of methods, we may repeat the check operations in different place.So, how do we remind the caller that some arguments can not be null?

Java provides a annotation @NotNull, let us look at how to use it properly.

1
2
3
void doSomething(@NotNull String s) {
    ... // some operations
}

As the annotation @NotNull annotated the argument s, developers would pay attention to the variable to the method whether is null.

Objects

Java 7 provides util type Objects in java.util package to help developers process on objects.These utilities include null-safe or null-tolerant methods for computing the hash code of an object, returning a string for an object, and comparing two objects.

1
2
3
4
String a = null;
String b = "YES";

a.equals(b); // NullPointerException

1
2
3
4
int[] a = null;
int[] b = new int[] {1, 2, 3, 4, 5};

a.equals(b); // NullPointerException

1
2
3
4
String a = null;
String b = "YES";

Objects.equals(a, b); // false

1
2
3
4
int[] a = null;
int[] b = new int[] {1, 2, 3, 4, 5};

a.equals(b); // NullPointerException

Optional

Java 8 has introduced a new class Optional in java.util package.It can help in writing a neat code without using too many null checks.

Static Method Summary

Modifier and Type	Method and Description
static Optional	`empty()` Returns an empty Optional instance.
static Optional	`of(T value)` Returns an Optional with the specified present non-null value.
static Optional	`ofNullable(T value)` Returns an Optional describing the specified value, if non-null, otherwise returns an empty Optional.

We can create a Optional instance by invoking methods in the table above.

ofNullable() method can accept a null reference.

Instance Method Summary

Modifier and Type	Method and Description
boolean	`equals(Object obj)` Indicates whether some other object is “equal to” this Optional.
Optional<T>	`filter(Predicate<? super T> predicate)` If a value is present, and the value matches the given predicate, return an Optional describing the value, otherwise return an empty Optional.
<U> Optional <U>	`flatMap(Function<? super T, Optional<U>> mapper)` If a value is present, apply the provided Optional-bearing mapping function to it, return that result, otherwise return an empty Optional.
T	`get()` If a value is present in this Optional, returns the value, otherwise throws NoSuchElementException.
int	`hashCode()` Returns the hash code value of the present value, if any, or 0 (zero) if no value is present.
void	`ifPresent(Consumer<? super T> consumer)` If a value is present, invoke the specified consumer with the value, otherwise do nothing.
boolean	`isPresent()` Return true if there is a value present, otherwise false.
<U> Optional <U>	`map(Function<? super T, ? extends U> mapper)` If a value is present, apply the provided mapping function to it, and if the result is non-null, return an Optional describing the result.
T	`orElse(T other)` Return the value if present, otherwise return other.
T	`orElseGet(Supplier<? extends T> other)` Return the value if present, otherwise invoke other and return the result of that invocation.
<X extends Throwable> T	`orElseThrow(Supplier<? extends X> exceptionSupplier)` Return the contained value, if present, otherwise throw an exception to be created by the provided supplier.

But if you have to write code like this,

1
2
3
4
5
6
7
8
9
10
11
String getUsername(Long id) {
    if (Objects.isNull(id)) {
        return null;
    }
    User user = userDao.get(id);
    if (Objects.isNull(user)) {
        return null;
    }
    String name = user.getName();
    return name;
}

1
2
3
4
5
6
String getUsername(Long id) {
    return Optional.ofNullable(id)
        .map(id -> userDao.get(id))
        .map(User::getName)
        .orElse(null);
}

Suppose there is a 1-to-many relationship between Campaign and Order. If we use traditional method, check whether variables is null, to implement the feature as below;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
List<Order> findOrdersByCampaignId (Long id) {
    if (Objects.isNull(id)) {
        return Collections.emptyList();
    }

    List<CampaignOrderRel> rels = 
        campaignOrderRelDao.findByCampaignId(id);

    if (Objects.isNull(rels) || rels.isEmpty()) {
        return Collections.emptyList();
    }

    List<Long> orderIds = rels.stream()
        .map(CampaignOrderRel::getOrder)
        .map(Order::getId)
        .collect(Collectors.toList());
    
    if (Objects.isNull(orderIds)) || orderIds.isEmpty()) {
        return Collections.emptyList();
    }

    return orderDao.findByIds(orderIds);
    
}

But if we use Optional,

1
2
3
4
5
6
7
8
9
10
11
List<Order> findOrdersByCampaignId (Long id) {
    return Optional.ofNullable(id)
        .map(campaignOrderRelDao::findByCampaignId)
        .filter(rels -> !rels.isEmpty())
        .map(rels -> rels.stream()
            .map(CampaignOrderRel::getOrder)
            .map(Order::getId)
            .collect(Collectors.toList()))
        .map(orderDao::findByIds)
        .orElseGet(Collections::emptyList);
}

By using Optional, we can specify alternate values to return or alternate code to run. This makes the code more readable because the facts which were hidden are now visible to the developer.

Helpful NullPointerExceptions

While chained statements are nice to look at in the code, they are not NPE friendly. A single statement spread over several lines will give you the line number of the first line in the stack trace regardless of where it occurs.⁴

    Map<String, String> map = new HashMap<>();
    
    map.get("key").toUpperCase();

These kind of chained statement will print only “NullPointerException occurred in line number xyz”. It really is hard to debug such code.

We’ll take a look at how JDK 14 and later version, through JEP 358, will solve this issue.

Most importantly, the detailed exception message is switched off by default in JDK 14, on by default in the later version. To enable it, we need to use the command-line option:

-XX:+ShowCodeDetailsInExceptionMessages

When we enable the feature, the exception message prints the local variable name:

Exception in thread "main" java.lang.NullPointerException: Cannot invoke "String.toUpperCase()" because the return value of "java.util.Map.get(Object)" is null
	at com.jsprx.jdk15.HelpfulNullPointerException.main(HelpfulNullPointerException.java:12)