Java8 其它新特性

强制终止进程

当你用Java启动外部进程后，一旦这个进程崩溃，主程序就会陷入很麻烦的境地。现在，Java 8中的Process类提供了两个新方法，可以来帮你管制这些烦人的进程了。
第一个是isAlive()方法，我们可以利用这个方法来判断指定的外部进程是否还存活着。第二个方法更强大，它是destroyForcibly()方法，可以将崩溃或者不再需要的进程强制终止。

StampedLock

看到这个，忍不住有点激动人心。没有人喜欢在代码中使用同步，它会让你的程序效率更低，而且严重的还可能会引起程序崩溃。尽管如此，有时候我们还是不得不使用它。

当多个进程访问一个资源的时候，有多种方法可以进行同步。其中用得最多的一种是ReadWriteLock以及基于它的几种实现。它通过阻塞写线程的方式来允许多个线程并发的读，这样减少了线程之间的竞争。听起来还不错，但实际上这个锁实在是太慢了，尤其是当有许多写线程的时候。

值得高兴的是，现在Java 8中推出了一个新的读写锁，名字叫StampedLock。StampedLock不仅读写更快，而且还提供了很多强大的API来创建乐观锁。这样如果没有写操作在访问临界区域的话，你只需很低的开销就能获取到一个读锁。访问结束后你可以查询锁来判断这期间是否发生了写操作，如果有的话再选择进行重试，升级锁，或者放弃这个操作。

ReentrantReadWriteLock 在沒有任何读写锁时，才可以取得写入锁，这可用于实现了悲观读取（Pessimistic Reading），即如果执行中进行读取时，经常可能有另一执行要写入的需求，为了保持同步，ReentrantReadWriteLock 的读取锁定就可派上用场。

然而，如果读取执行情况很多，写入很少的情况下，使用 ReentrantReadWriteLock 可能会使写入线程遭遇饥饿（Starvation）问题，也就是写入线程吃吃无法竞争到锁定而一直处于等待状态。

StampedLock控制锁有三种模式（写，读，乐观读），一个StampedLock状态是由版本和模式两个部分组成，锁获取方法返回一个数字作为票据stamp，它用相应的锁状态表示并控制访问，数字0表示没有写锁被授权访问。在读锁上分为悲观锁和乐观锁。

所谓的乐观读模式，也就是若读的操作很多，写的操作很少的情况下，你可以乐观地认为，写入与读取同时发生几率很少，因此不悲观地使用完全的读取锁定，程序可以查看读取资料之后，是否遭到写入执行的变更，再采取后续的措施（重新读取变更信息，或者抛出异常），这一个小小改进，可大幅度提高程序的吞吐量！！

下面是java doc提供的StampedLock一个例子


class Point {

    private double x, y;
    private final StampedLock sl = new StampedLock();

    void move(double deltaX, double deltaY) { // an exclusively locked method
        long stamp = sl.writeLock();

        try {
            x += deltaX;
            y += deltaY;
        } finally {
            sl.unlockWrite(stamp);
        }

    }


    //下面看看乐观读锁案例
    double distanceFromOrigin() { // A read-only method

        long stamp = sl.tryOptimisticRead(); //获得一个乐观读锁
        double currentX = x, currentY = y; //将两个字段读入本地局部变量

        if (!sl.validate(stamp)) { //检查发出乐观读锁后同时是否有其他写锁发生？
            stamp = sl.readLock(); //如果没有，我们再次获得一个读悲观锁

            try {
                currentX = x; // 将两个字段读入本地局部变量
                currentY = y; // 将两个字段读入本地局部变量
            } finally {
                sl.unlockRead(stamp);
            }
        }

        return Math.sqrt(currentX * currentX + currentY * currentY);

    }


    /**
     * 下面是悲观读锁案例
     */

    void moveIfAtOrigin(double newX, double newY) { // upgrade
        // Could instead start with optimistic, not read mode
        long stamp = sl.readLock();

        try {
            while (x == 0.0 && y == 0.0) { //循环，检查当前状态是否符合

                long ws = sl.tryConvertToWriteLock(stamp); //将读锁转为写锁
                if (ws != 0 L){ //这是确认转为写锁是否成功
                    stamp = ws; //如果成功 替换票据
                    x = newX; //进行状态改变
                    y = newY; //进行状态改变
                    break;
                } else{ //如果不能成功转换为写锁
                    sl.unlockRead(stamp); //我们显式释放读锁
                    stamp = sl.writeLock(); //显式直接进行写锁 然后再通过循环再试
                }
            }
        } finally {
            sl.unlock(stamp); //释放读锁或写锁
        }
    }

}

并行计数器

这是又是一个多线程应用经常会用到的小工具，它提供了简单高效的新接口来实现多线程的并发读写计数器的功能，和AtomicInteger比起来，它要更快一些。相当赞的工具。

目录遍历

遍历目录树这种事通常都得上Google搜下怎么实现（你很可能用的是Apache.FileUtils）。Java 8给Files类做了一次整容手术，增加了十个新的方法。其中一个是walk()方法，它遍历目录后会创建出一个惰性的流（文件系统很大的情况下非常有用）。

增强的随机数生成

现在经常都在讨论密码或者密钥容易遭受攻击的事。程序的安全性是项很复杂的工程，并且很容易出错。这就是我为什么喜欢这个新的SecureRandom.getinstanceStrong()方法的原因，它能自动选择出当前JVM可用的最佳的随机数生成器。这样减少了获取失败的机率，同时也避免了默认的弱随机数生成器可能会导致密钥或者加密值容易被黑客攻破的问题。

几个新接口说明

Predicate 接口只有一个参数，返回boolean类型。该接口包含多种默认方法来将Predicate组合成其他复杂的逻辑（比如：与，或，非）：

Predicate<String> predicate = (s) -> s.length() > 0;
predicate.test("foo"); // true
predicate.negate().test("foo"); // false
Predicate<Boolean> nonNull = Objects::nonNull;
Predicate<Boolean> isNull = Objects::isNull;
Predicate<String> isEmpty = String::isEmpty;
Predicate<String> isNotEmpty = isEmpty.negate();

Function 接口

Function 接口有一个参数并且返回一个结果，并附带了一些可以和其他函数组合的默认方法（compose, andThen）：

1
2
3

Function<String, Integer> toInteger = Integer::valueOf;
Function<String, String> backToString = toInteger.andThen(String::valueOf);
backToString.apply("123"); // "123"

Supplier 接口

Supplier 接口返回一个任意范型的值，和Function接口不同的是该接口没有任何参数

1 2	Supplier<Person> personSupplier = Person::new; personSupplier.get(); // new Person

Consumer 接口

Consumer 接口表示执行在单个参数上的操作。

1 2	Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.firstName); greeter.accept(new Person("Luke", "Skywalker"));

Comparator 接口

Comparator 是老Java中的经典接口， Java 8在此之上添加了多种默认方法：

Comparator<Person> comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName);
Person p1 = new Person("John", "Doe");
Person p2 = new Person("Alice", "Wonderland");
comparator.compare(p1, p2); // > 0
comparator.reversed().compare(p1, p2); // < 0