Java核心技术卷1-基础知识

引入内部类(inner class)主要有下面三个原因：

1. 内部类可以访问该类定义所在的作用域中数据，包括私有数据。
2. 内部类可以对同一个包中的其他类隐藏起来。
3. 当想要定义一个回调函数且不想编写大量代码时，使用匿名类（anonymous）比较便捷。

关于Java的内部类大概有这么几种：

1. 普通内部类。（可以访问到外围类实例）
2. 静态内部类。(C++嵌套类和静态内部类更相似)
3. 局部类。（通常在方法内使用，可以访问到外围类实例以及方法中final参数）
4. 匿名内部类。（局部类一种特例，方便做一个接口简单扩展）

float类型数值常量后面加上F比如3.042F,而double类型数值常量后面加上D比如3.402D.所有浮点数值计算都遵循IEEE 752规范。Java提供了三种表示溢出或者计算错误的三种特殊浮点数值：

1. 正无穷大 Double.POSITIVE_INFINITY
2. 负无穷大 Double.NEGATIVE_INFINITY
3. NaN(不是数字) Double.NaN. 浮点数/0的话就会得到NaN.判断是否为NaN不应该使用==因为和一个NaN比较始终都是false,而应该使用Double.isNaN(x)

对于较大浮点数应该使用BigDecimal来进行计算。

Java虚拟机规范强调可移植性，对于在任何机器上来说相同的程序得到的结果应该是相同的。但是对于浮点计算的话，比如Intel CPU针对于浮点数计算所有中间结果都使用bit 80表示，而最后截取bit 64,造成和其他CPU计算结果不同。为了达到可移植性，Java规范所有中间结果必须使用bit 64截断，但是遭反对，因此Java提供了strictfp关键字标记某个方法，对于这个方法里面所有浮点数计算，所有中间结果使用64 bit截断，否则使用适合native方式计算。另外一些浮点数计算比如pow2,pow3,sqrt的话，一方面依赖于CPU浮点计算方式，另外一方面依赖于本身算法（如果CPU本身提供这种指令的话就可以使用CPU指令），也会造成不可移植性，比如Math.sqrt.如果希望在这方面也达到同样效果的话，可以使用StrictMath类，底层使用fdlibm，以确保所有平台上得到相同的结果。

Java里面异常都是派生于Throwable，但是分解成为两个分支：

• Error.描述Java运行时系统的内部错误和资源耗尽。应用程序不应该抛出该类型对象。
• Exception.分解为RuntimeException（运行时异常）和其他（编译时异常）。
• RuntimeException包括下面几种情况：
  • 错误类型转换
  • 数组访问越界
  • 访问空指针

Java语言规范将派生于Error或者是RuntimeException的所有异常称为未检查异常(unchecked exception),而将所有其他异常（也就是编译时异常）称为已检查异常(checked). 称为已检查异常原因是因为，Java的异常规格也是作为函数声明的一部分的。因此如果方法foo抛出异常X,那么调用foo的方法要么检查异常X, 要么就在自己的规则里面写上throws X传给上层处理。 无论如何你都是需要面对这个异常的，所以称为已检查。

几种常见的异常操作：

• 抛出异常非常简单，使用new Exception()即可
• 创建异常的话继承Throwable即可，构造参数可以传入message表示这个异常的详细信息。
• 如果重新抛出异常的话会将异常链断开，可以通过调用initCause将原始的cause保存起来，getCause可以取出。这样可以保持异常链完整信息。

几种常见的处理堆栈操作：

• 使用Thread.getStackTrace获得某个线程的堆栈信息
• 使用Thread.getAllStackTrace可以获得所有线程的堆栈信息
• 异常对象可以使用e.printStackTrace打印堆栈信息

使用代理可以动态地生成一些类或者是接口（但是不是动态生成代码）。创建一个代理对象，使用Proxy类的newProxyInstance方法，有下面三个参数：

1. 类加载器(class loader), null表示使用默认加载器。
2. class对象数组，表示想实现的接口。
3. 调用处理器(invocation handler), 可以截获方法调用然后做代理。

调用处理器接口为Object invoke(Object proxy, Method method, Object… args).其中proxy表示代理对象本身，method,args表示调用方法以及参数。

下面是一个覆盖 `Runnable` 接口的代码示例，其中使用到了匿名内部类技术：

class X {
    public static void main(String[] args) throws InterruptedException {
        final Runnable r = new Runnable() {
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("run...");
                }
            }
        };
        Runnable proxy = (Runnable) Proxy.newProxyInstance(r.getClass().getClassLoader(), new Class[]{Runnable.class}, new InvocationHandler() {
            public Object invoke(Object proxy, Method m, Object[] args) {
                System.out.println("entering...");
                try {
                    return m.invoke(r, args);
                } catch (Exception ex) {
                    return null;
                }
            }
        });
        Thread t = new Thread(proxy);
        t.start();
        t.join();
    }
}

下面是一个覆盖 `List` 接口的代码示例：

• 生成一个ArrayList对象，当做目标对象
• 代理 `List` 的接口，但是每次调用之前会打印方法和参数信息

public class ProxyTester implements InvocationHandler {
    Object target;

    public ProxyTester(Object target) {
        this.target = target;
    }

    public static void main(String[] args) {
        ArrayList<Integer> a = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
        InvocationHandler h = new ProxyTester(a);
        Object proxy = Proxy.newProxyInstance(null, new Class[]{List.class}, h);
        List<Integer> b = (List<Integer>) proxy;
        System.out.println(b.size());
        System.out.println(b.get(2));
    }

    @Override
    public Object invoke(final Object proxy, final Method method, final Object[] args) throws Throwable {
        StringBuffer sb = new StringBuffer();
        sb.append("calling " + method.getName() + "(");
        if (args != null) {
            for (Object arg : args) {
                sb.append((arg != null ? arg.toString() : "null") + ", ");
            }
            if (args.length != 0) {
                sb.setLength(sb.length() - 2);
            }
        }
        sb.append(")");
        System.out.println(sb.toString());

        Object res = method.invoke(target, args);
        return res;
    }
}

关于对象代理类：

• Java没有定义代理类的名字，sun虚拟机中的Proxy类将生成一个以字符串$Proxy开头的类名。
• 对于特定的类加载器和预设的一组接口来说，只能够有一个代理类。也就是说，如果使用同一个类加载器刚和接口数组调用newProxyInstance方法两次的话，那么只能够得到同一个类的两个对象。
• 可以使用Proxy.getProxyClass获得对应代理类，通过Proxy.isProxyClass判断某个类是否为代理类。

Class类本身表示这个类的一些元信息。通常拿到这个类的元信息之后，就可以完成一些动态事情比如反射。Java有三种方式可以获得Class类：

1. 对象调用getClass()方法。
2. 字面量直接获取 App.class
3. 通过类名动态查找 Class.forName("java.util.Date")

获得Class之后，就可以获取到这个class内部：

1. fields
2. methods
3. constructors

这样就可以开始做一些反射工作了。

#todo: more about reflection

线程包括下面6种状态，并且切换关系如下：

1. new 线程创建好并且分配资源但是没有运行，调用start进入runnable状态。
2. runnable 正在运行的状态。运行过程中如果调用return或者是exit的话，那么进入terminated状态。
3. terminated 线程已经被终止并且进行资源回收。
4. blocked 在runnable时候，如果acquire lock失败的话那么会进行block状态，当获得锁之后那么返回runnable状态。
5. waiting 在runnable时候，如果等待notification那么进行这个状态，如果notification触发的话那么返回runnable状态。
6. timed waiting 其实和waiting状态差不多，只不过这个notification状态会存在一个超时。

关于4，5，6这三个状态其实可以对应到lock/condition上。通常我们在acquire lock失败之后会进入到blocked状态，通常lock会自带一个 `condition` 变量。 如果这个时候调用 `condition.wait()` 的话，那么就切换到了waiting状态上；而如果调用 `condition.timedWait()` 的话，则切换到了timed waiting状态上。 直到其他进程调用 `condition.signal/signalAll()` 的话，这些waiting状态才会重新到runnable状态，重新去获取锁。

守护线程（daemon）和unix操作系统的daemon有些差别。在Java里面如果还有存活的线程的话，即使main线程完毕那么程序依然不会结束（这个在c/c++程序里面则不然）。如果将线程设置成为daemon状态的话，那么最后剩下的线程都是daemon的话，那么jvm也会自动退出。

Runnable的run方法是不允许抛出任何异常的，对于可检查的异常可以在代码里面完成，而对于不可检查的异常因为不能够处理，因此如果触发的话那么线程终止。而对于可检查异常如果没有处理的话，那么在线程死亡之前，异常会被一个异常处理器处理：

• Thread.UncaughtExceptionHandler接口 `void uncaughtException(Thread t,Throwable e)`
  • 通过setUncaughtExceptionHandler为单个线程安装处理器
  • 也可以通过setDefaultUncaughtExceptionHandler为所有线程安装。
• 默认处理器为空。如果线程安装的话，那么使用该线程的ThreadGroup对象作为异常处理器
  • 如果这个线程存在父线程组，那么交给父线程组处理。
  • 如果Thread.getDefaultUncaughtExceptionHandler为非空的话那么调用。
  • 如果Throwable为ThreadDeath实例，那么什么也不做。
  • 将线程名字和Throwable的stacktrace输出到stderr上面。

synchronized 关键字有两个使用场景：

• 如果作用于对象或者是对象方法的话，那么其实相当是同步这个对象(对象存在一个mutex lock)
• 如果作用于静态字段或者是静态方法的话，那么其实相当是同步这个类(类有一个mutex lock)

一旦理解这点之后，就比较好理解為什麼存在wait, notify, notifyAll这些方法了。其实都是相当于这个lock对应的condition本身提供的方法。 本质上 `synchronized` 关键字的引入是为了使用监视器(monitoring)这个同步概念，但是考虑到性能又做些某些妥协导致存在安全隐患。 我估计production环境下面很少会使用这种同步机制。

volatile关键字为 实例字段 的同步访问提供了一种免锁机制。如果声明一个字段为volatile的话，那么编译器和虚拟机就可以知道这个字段很可能会被另外一个线程并发更新。 关键这个话题需要去阅读Java内存模型的文档，如果不确定的话，还是使用基本的同步机制或者是 `AtomicInteger` 这样的原子操作类。

為什麼要抛弃stop和suspend方法？ 因为这些方法都尝试破坏线程本身正常的行为。比如A，B两个线程同时acquire一个lock，如果A成功之后，B在等待，这个之后A被stop或者是suspend的话，那么情况就变成了死锁。

关于Future的一点个人感想如下： Future这个概念非常好，可以做成一个Callable对象的continuation. 曾经一段时间我非常希望将其当作一个类似Nio下面的Channel对象来看待，因为一旦如此那么便可以使用类似Select/Epoll这种多路复用组件，来管理众多的continuation。可以检测continuation是否ready或者是是否超时，然后触发回调，整个过程和Nio多路复用非常类似，这样在这上面做异步就非常容易了。但是后来考虑清楚了，这件事情是不靠谱的。原因如下：

• 检测continuation是否ready非常容易，只需要把continuation逻辑写在发起的Callable之后即可。因此在JDK里面也有FutureTask并且衍生了一些辅助类比如ExecutorCompletionService, 但是这些组件实际上都是封装，没有解决实际问题。
• 事实上Future和Channel存在本质的不同，Future发起的是一个Callable操作也就是CPU操作，虽然这里面可能有IO操作，但是如果当作通用的CPU操作来看的话，这个操作即使检测到超时也不能够停止，而Channel上read/write是不同的，Channel上面的操作是允许中断的。
• 就像之前所说的，Future本质发起的Callable对象是一个CPU操作，里面可能也带有IO操作，将Callable对象放在线程池里面执行，也就是说实际上需要靠线程池数量来支撑Callable并发，这点和异步是相反思路的。

下面是 `CyclicBarrier` 的一个示例代码。CyclicBarrier和CountDownLatch很类似，只不过它可以循环使用，一旦计数器减少到0又会被重置回去。

public class CyclicBarrierTest {

    public static void main(String[] args) throws InterruptedException {
        CyclicBarrier cb = new CyclicBarrier(10, () -> {
            System.out.println("OK>>>>");
        });
        ExecutorService es = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            final int threadId = i;
            es.submit(() -> {
                for (int j = 0; j < 2; j++) {
                    try {
                        cb.await();
                        System.out.println("thread " + threadId + " started..");
                    } catch (InterruptedException | BrokenBarrierException e) {
                        break;
                    }
                }
            });
        }
        es.shutdown();
        es.awaitTermination(100, TimeUnit.SECONDS);
    }
}

https://waylau.gitbooks.io/essential-java/docs/generics.html

我对于类型擦除的理解是，在生成字节码的时候，类型参数会使用类型上界（比如T extends Comparable<T>，那么 类型上界就是Comparable)来代替。如果没有设定类型上界的话，那么使用Object代替。除非是使用类似C++这样 编译方式（实例化模板来生成代码），否则泛型必须将一部分功能放在运行时，而在编译时能做的就是有限的检查。

泛型被引入到Java语言中，以便在编译时提供更严格的类型检查并支持泛型编程。为了实现泛型，Java编译器将类型擦除应用于：

• 如果类型参数是无界的，则用泛型或对象替换泛型类型中的所有类型参数。因此，生成的字节码仅包含普通的类\接口和方法。
• 如有必要，插入类型铸件以保持类型安全。
• 生成桥接方法以保留扩展泛型类型中的多态性。

类型擦除能够确保不为参数化类型创建新类，因此，泛型不会产生运行时开销。

考虑单链表节点的泛型类。因为T没有设置上界，那么在Java编译器会用Object代替T.

public class Node<T> {

    private T data;
    private Node<T> next;

    public Node(T data, Node<T> next) {
        this.data = data;
        this.next = next;
    }

    public T getData() { return data; }
    // ...
}

如果写成下面这样的话，那么会用Comparable来代替T.

public class Node<T extends Comparable<T>> {

    private T data;
    private Node<T> next;

    public Node(T data, Node<T> next) {
        this.data = data;
        this.next = next;
    }

    public T getData() { return data; }
    // ...
}

总之，需要记住有关Java泛型转换的事实：

1. 虚拟机中没有泛型，只有普通的类和方法
2. 所有的类型都是逗用它们的限定类型替换
3. 桥方法被合成用来保持多态（虚拟机中用参数类型和返回类型确定一个方法）
4. 为了保持类型安全，必要时插入强制类型转换