Java 基础知识

网络上的两个程序通过一个双向的通信实现数据的交换，这个双向链路的一端称为一个Socket。Socket 也称之为套接字，可以用来实现不同虚拟机或者不同计算机之间的通信。在Java中，Socket可以分为两种类型：面向连接的Socket通信协议（TCP， Transmission Control Protocol，传输控制协议）和面向无连接的Socket 通信（UDP，User Datagram Protocol, 用户数据报协议）。任何一个Socket都是由 IP地址和端口号唯一确定的。

基于TCP的通信过程：

首先，Sever 端的Listen （监听）指定的某个端口是否有连接请求，
其次，Client 端向Sever端发出Connect（连接）请求；
最后，Sever端向Client端发回Accept（接受）消息。

至此，一个连接就建立起来了。双方都可以通过Send, Write等方法与对方通信。

Socket的生命周期可以分为三个阶段：打开Socket，使用Socket收发数据，关闭Socket。在Java中，使用SeverSocket 作为服务器端，Socket作为客户端来实现通信。

7.4 java NIO

非阻塞(Nonblocking IO, NIO) 代替了Socket传统的通信模式。

NIO 通过Selector、Channel 和Buffer 来实现，主要采用了Reactor（反应器）的设计模式。

Channel 可以被看作一个双向通道，Selector实现了一个线程来管理多个通道。

7.5 Java 序列化

Java提供的两种对象持久化的方式，为序列化和外部序列化。

序列化（Serialization）

序列化是一种将对象以一串字符描述的过程，用于解决在对对象流进行读写操作时所引发的问题，序列化可以将对象的状态写在流流里进行网络传输，在需要时可以通过流里面信息重构一个一样的对象。

所有的序列化都必须实现Serializable接口，他不包含任何方法，使用一个输出流构造一个对象。

序列化的特点：

a: 如果一个类能够被序列化，那么他的子类也能够被序列化

b: static代表静态变量，是类的成员，transient 代表对象的临时数据，因此被声明为这两种类型的数据是不能被序列化的。

需要序列化的情况：

a: 需要通过网络来传输对象，或者对象的状态需要被永久的存储；

b: 序列化可以实现深复制，即可以复制引用的对象。

外部序列化

与序列化主要的区别在于是内置的API ，只需要实现Serialization接口，其余的需要开发者自己编写。

7.6 System.out.println()

System.out.println(1+2+” ”); 3

System.out.println( “ ”+ 1+2); 12

八、Java平台与内存管理

8.1 Java是平台独立语言

保证Java平台独立性的是“中间码”和“JVM”（Java virtual machine）；

Java程序被编译后并不是直接生成能够在硬件平台上执行的代码，而是生成一个“中间码”。不同的平台装有不同的JVM，由JVM把“中间码”负责翻译成硬件能够执行的代码。

8.2 Java平台与其他平台的差别

8.3 JVM加载class文件的原理机制

类的加载：隐式加载：使用new()等方式创建一个类；显示加载：class.forName()

ClassLoader和他的子类实现类的加载

类在加载时可分为三类：基础类，扩展类和自定义类

步骤可分为三步：

装载。根据查找路径找到相对应的class文件并导入
链接：a:检查，检查待加载class文件的正确性

b:准备，给类中的静态变量分配存储空间

c:解析，将符号引用转变为直接引用

初始化。对静态变量和静态代码块执行初始化工作。

8.4 GC 垃圾回收机制（Garbage Collection，GC）

主要完成三项任务：

分配内存
确保被引用对象的内存不被错误的回收
回收不再被引用对象的内存空间

垃圾回收算法：

引用计数算法(Reference Counting Collector)
追踪回收算法(Tracing Collector)
压缩回收算法(Compacting Collector)
复制回收算法(Coping Collector)
按代回收算法(Generational Collector)

8.5 Java的内存泄漏问题

主要是有给对象赋予新值，重新分配了内存空间

引起内存泄漏的主要原因有：

静态集合类：生命周期和程序一样长
各种连接：数据库不显示的关闭
监听器：释放对象的同时没有删除监听器
变量不合理的作用域：变量定义的作用域大于其使用域
单例模式可能会造成内存泄漏

8.6 Java中堆和栈的区别

堆和栈都是存放数据的地方。变量分为基本数据类型和引用类型，基本数据类型的变量以及对象的引用变量，其内存都分配在栈上，变量出了作用域就会自动释放，而引用类型的变量，其内存往往分配在堆上或者常量池（例如字符串常量和基本数据类型常量），需要通过new() 等方式进行创建。

栈的内存主要用来存放基本数据类型与引用变量

堆的内存主要用来存放运行时创建的对象

九、容器

9.1 Java Collections 的框架

Java Collections框架中包含了大量集合接口以及实现这些接口的实现类和操作他们的的算法啊（排序，查找，反转，替换，复制，取极值等），主要有List（列表），Queue（队列），Set（集合），Stack（栈），Map（映射表）。其中List，Queue，Set，Stack都继承自Collection接口。

Set 里面的元素不可重复，HashSet，TreeSet实现了Set接口
List里面的元素存储有序，LinkedList，ArrayList，Vector实现了List接口
Map提供了键值一一映射关系，HashMap，TreeMap，LinkedHashMap，

9.2 迭代器

迭代器（Iterator）是一个对象，他可以遍历并选择序列中的对象，它提供了一种访问一个容器（container）对象中的各个元素而又不比显示细节的方法。

注意事项：

使用容器的iterator()方法返回一个Iterator，然后通过Iterator的next()方法访问返回的第一个元素
使用Iterator的hasNext()方法判断容器是否还有元素
remove() 方法删除迭代器返回的元素

9.3 ArrayList、Vector和LinkedList

ArrayList和Vector都是开辟一个连续的存储空间，插入效率不高，当元素超过时，会动态的增加原来的1.5倍和2倍（可以改变）的存储单元，ArrayList没有同步的方法，Vector的绝大多数方法都是直接或者间接同步的，因此ArrayList不是线程安全的，Vector是线程安全的，性能上不如ArrayList。

LinkedList采用双向列表实现，访问效率底下，但是插入效率很好。

9.4 HashTable，HashMap，TreeMap和WeakHashMap

HashMap 和 HashTable

HashMap是HashTable的轻量级实现（非线程安全的实现），允许一条null值
HashMap去掉了HashTable的contains方法，改为containsvalue和containsKey,
HashTable是线程安全的，而HashMap不支持线程同步，
HashTable 使用Enumeration, HashMap使用Iterator
采用的hash/rehash算法几乎一样，效率差不多
HashTable 的hash是11，增加是old x 2 + 1 ，HashMap的hash默认是16，增加为2的指数
hash值使用的不同，HashTable直接使用对象的hashcode。

9.5 自定义的HashMap 和HashTable的key需要注意

键不能够重复

需要注意事项：
1）如需要根据对象的相关属性来自定义对象是否相等，需要重写equals()，一旦重写了equals()，就必须要重写hasCode()方法；

当自定义类的多项作为HashMap（HashTable）的key值时，最好把这个类设计为不可变类；

如果两个key相等，则有相同的hashCode，反之不成立

9.6 Collection 和Collections

Collection是一个集合接口

Collections是针对集合类的一个包装类，提供了一系列静态方法以实现对各种集合的搜索，排序，线程安全等操作。

十、多线程

10.1 线程，进程

线程是指程序在执行过程中，能够执行程序代码的一个执行单元，有四种状态：运行，就绪，挂起，结束

进程是指一段正在执行的程序，一个进程可以拥有多个线程，各个线程之间共享程序的内存空间，但是各个线程拥有自己的栈空间，

在操作系统级别上，程序的执行都是以进程为单位的

多线程的优点：

使用多线程可以减少程序的响应时间
与进程相比，线程的创建和切换开销比较小
多线程可以更好的利用多核CPU，资源利用充分
使用多线程能简化程序的结构，使程序便于理解和维护

10.2 同步和异步

多线程里面数据共享的问题

要实现同步，必须获得每一个线程对象的锁，获得锁可以保证在一个时刻只有一个线程可以进入临界区，并且在该锁释放之前，其他线程不能进入临界区，当其他线程想要获得该对象的锁，只能进入等候队列，只有拥有该对象锁的线程退出临界区时，锁才会被释放，等待队列中优先级最高的线程才能够获得该对象锁，进入数据临界区

实现同步的方式：1）利用同步代码块；2）利用同步方法

关键字synchronized实现同步，开销太大，有可能造成死锁

异步与非阻塞相似，不比关心其他线程的状态或者行为

10.3 实现Java多线程

实现的三种方法：

1）继承Thread类，重写run()方法

class MyThread extends Thread{

public void run(){

System.ouot.println(“Thread body”);//线程的内容

}

public class Test{

public static void main(String[] args){

MyThread mythread = new MyThread();

mythread.start();//开启线程

}

2）实现Runnable接口，并实现该接口的run()方法

a: 自定义类并实现Runnbale接口，实现run()方法

b: 创建Thread对象爱那个，用实现Runnable接口的对象作为参数实例化该Thread 对象

c: 调用Thread 的start() 方法

class MyThrad implememnts Runnable{

public void run(){

System.out.println(“Thread body”);

}

public class Test{

public static void main(String[] args){

MyThread thread = new MyThread();

Thread t = new Thread(thread);

t.start();

}

3）实现Callable接口，重写call()方法

能够返回值，主要的特点

a: Callable 可以在任务结束后提供一个返回值，Runnable 无法提供这个功能

b: Callable 中的call() 方法可以抛出异常，Runnable不能够抛出异常

c: 运行Callable可以拿到一个Future对象，表示一步计算结果

public class CallableAndFuture{

public static class CallableTest implements Callable<String>{

public String call() throws Exception{

return “Hello World”;

}

public static void main(String[] args){

ExecutorService threadPool = Executors.newSingleThreadExecutor();

//启动线程

Future<String> future = threadPool.submit(new CallableTest());

try{

System.out.println(“wating thread to finish”);

System.out.println(future.get());

}catch(Exception e){

e.printStackTrace():

}

10.4 run() 方法与start() 方法

start()方法可以异步的调用一个线程，但是run() 方法是同步的调用函数，

在一个线程中使用start() 方法时，可以启动另外一个已经准备就绪的线程，但是使用run() 方法时，相当于调用了一个函数，不会启动别的线程。

E:\Java_Code\src\ThinkingInJava\TestThreads.java

10.5 多线程同步的方法

三种同步机制：

1）synchronized 关键字

每个对象都有一个对象锁与之关联，该锁表明对象在任意时刻只允许被一个线程所拥有，当一个线程调用对象的一段synchronized代码时，需要先获得该对象的锁，然后执行相应的代码，结束后释放锁。

synchronized有两种用法，还可以作用于静态方法，类或者某个实例

a: synchronized方法。在方法的申明前加入synchronized关键字

public synchronized void mutiThreadAccess();

b: synchronized块。

synchronized（ syncObject）{

//访问syncObject 的代码

}

2）wait() 方法与 notify()方法

在synchronized 代码块被执行时，对象的wait() 方法可以释放对象锁，notify()可以唤醒等待队列中的第一个线程并允许该线程去获取对象锁，notifyAll() 方法可以唤醒所有等待队列中的线程，并让他们去竞争该对象的锁。

3）Lock

Lock接口，实现类ReentrantLock

实现方法：

a: lock()，以阻塞的方法获取锁，，获取到锁，立即返回，该对象正在被其他线程持有锁，等待获取到后返回。

b: tryLock（）。以非阻塞的方式获取锁，尝试性的方式获取锁，如果获取到，立刻返回true，否则，立刻返回false

c: tryLock（long tirmout, TimeUnit unit）。

d: lockInterruptibly()。

10.6 sleep() 和wait()

区别主要有：

1）原理不同。sleep() 方法是线程Thread的静态方法，是线程用来控制自身流程的，他会使自身暂停一段时间，而把执行机会让给其他线程，等到计时时间一到，就会苏醒；wait() 方法是Object类的方法，用于线程间通信，调用该方法会使拥有该对象锁的进程进入等待状态，直到其他线程调用notify方法（notifyAll），或者开发人员自定义时间。

2）对锁的处理机制不同

sleep（）不会释放锁，而wait方法会使得线程释放掉他所占用的锁

3）使用区域不同

wait() 必须放在同步方法或者同步语句块中，而sleep可以放在线程的任意地方