黑马程序员武汉中心——javaee面试宝典java基础

1、Java基础    
1.1 Collection和Map    
1.2 IO流    
1.3 异常   
1.4 多线程    
1、Java基础
1.1 Collection和Map
(1)掌握Collection和Map的继承体系。

 

 

链表

链表是一种物理上非连续,非顺序的存储结构,数据元素之间的顺序是通过每个元素的指针关联的

链表有一系列节点组成,每个节点一般至少会包含两部分的信息:

1. 元素数据

2. 指向下一个元素的指针

链表分类:

1. 单向链表和双向链表

2. 静态链表(数组实现),动态链表(指针)

链表的操作:创建,插入,删除,输出

链表的特点:

1. 物理 空间不连续,空间开销更大

2. 在运行时可以动态添加

3. 查找元素需要顺序查找

ArrayList和LinkList的区别
ArrayList（数组结构）：

        优点：get和set调用花费常数时间，也就是查询的速度快；

        缺点：新项的插入和现有项的删除代价昂贵，也就是添加删除的速度慢

LinkedList（链表结构）：

        优点：新项的插入和和现有项的删除开销很小，即添加和删除的速度快

        缺点：对get和set的调用花费昂贵，不适合做查询

面试中经常问到一些深入的东西，比如：

·  1. 是否保证线程安全： ArrayList 和 LinkedList 都是不同步的，也就是不保证线程安全；

·  2. 底层数据结构： Arraylist 底层使用的是Object数组；LinkedList 底层使用的是双向循环链表数据结构；

·  3. 插入和删除是否受元素位置的影响： ① ArrayList 采用数组存储，所以插入和删除元素的时间复杂度受元素位置的影响。 比如：执行add(E e)方法的时候， ArrayList 会默认在将指定的元素追加到此列表的末尾，这种情况时间复杂度就是O(1)。但是如果要在指定位置 i 插入和删除元素的话（add(int index, E element)）时间复杂度就为 O(n-i)。因为在进行上述操作的时候集合中第 i 和第 i 个元素之后的(n-i)个元素都要执行向后位/向前移一位的操作。 ② LinkedList 采用链表存储，所以插入，删除元素时间复杂度不受元素位置的影响，都是近似 O（1）而数组为近似 O（n）。

·  4. 是否支持快速随机访问： LinkedList 不支持高效的随机元素访问，而ArrayList 实现了RandmoAccess 接口，所以有随机访问功能。快速随机访问就是通过元素的序号快速获取元素对象(对应于get(int index)方法)。

·  5. 内存空间占用： ArrayList的空 间浪费主要体现在在list列表的结尾会预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗比ArrayList更多的空间（因为要存放直接后继和直接前驱以及数据）。

HashMap底层
就是一个数组结构（Entry<K,V>[] table） 可以看出，Entry就是数组中的元素，每个 Map.Entry其实就是一个key-value对，它持有一个指向下一个元素的引用，这就构成了链表。

hashmap的数据结构 

要知道hashmap是什么，首先要搞清楚它的数据结构，在java编程语言中，最基本的结构就是两种，一个是数组，另外一个是模拟指针（引用），所有的数据结构都可以用这两个基本结构来构造的，hashmap也不例外。Hashmap实际上是一个数组和链表的结合体（在数据结构中，一般称之为“链表散列“），请看下图（横排表示数组，纵排表示数组元素【实际上是一个链表】）。

 

HashMap的工作原理
HashMap基于hashing原理，我们通过put()和get()方法储存和获取对象。当我们将键值对传递给put()方法时，它调用键对象的hashCode()方法来计算hashcode，让后找到bucket位置来储存值对象。当获取对象时，通过键对象的equals()方法找到正确的键值对，然后返回值对象。HashMap使用链表来解决碰撞问题，当发生碰撞了，对象将会储存在链表的下一个节点中。 HashMap在每个链表节点中储存键值对对象。

当两个不同的键对象的hashcode相同时会发生什么？ 它们会储存在同一个bucket位置的链表中。键对象的equals()方法用来找到键值对。

因为HashMap的好处非常多，我曾经在电子商务的应用中使用HashMap作为缓存。因为金融领域非常多的运用Java，也出于性能的考虑，我们会经常用到HashMap和ConcurrentHashMap。

List、Map、Set三个接口，存取元素时，各有什么特点？

List  以特定次序来持有元素，可有重复元素；

Set  无法拥有重复元素,内部排序（无序）；

Map 保存key-value值，value可多值。

Hashmap可以存重复键，重复值吗？  不能存重复键

 |--HashSet是如何保证元素唯一性的呢？

                    |--是通过元素的两个方法，hashCode和equals来完成。

 |--TreeSet：可以对Set集合中的元素进行排序。

|--底层数据结构是二叉树。 保证元素唯一性的依据：compareTo方法return 0.

Comparable和Comparator区别？

1：让元素自身具备比较性，需要元素对象实现Comparable接口，覆盖compareTo方法。 

 * 2：让集合自身具备比较性，需要定义一个实现了Comparator接口的比较器，并覆盖compare方法， 

map集合的两种取出方式？

 //第一种：普遍使用，二次取值  

9.   System.out.println("通过Map.keySet遍历key和value：");  

10.   for (String key : map.keySet()) {  

11.    System.out.println("key= "+ key + " and value= " + map.get(key));  

12.   }  

13.     

 //第二种：推荐，尤其是容量大时  

23.   System.out.println("通过Map.entrySet遍历key和value");  

24.   for (Map.Entry<String, String> entry : map.entrySet()) {  

25.    System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());  

26.   }  

HashMap和Hashtable的区别？

Hashtable是线程安全的 不可以存入null键null值

HashMap线程不安全  可以存入null键null值

Collection 和 Collections的区别？

Collection是集合类的上级接口,继承与他的接口主要有Set 和List.

Collections是工具类

排序算法
##注：从小到大排

##冒泡排序##

特点：效率低，实现简单

public void bubbleSort(int array[]) {

int t = 0;

for (int j = 0; j < array.length - 1 - i; j++)

if (array[j] > array[j + 1]) {

t = array[j];

array[j] = array[j + 1];

array[j + 1] = t;

}

}

##选择排序##

特点：效率低，容易实现。

思想：每一趟从待排序序列选择一个最小的元素放到已排好序序列的末尾，剩下的为待排序序列，重复上述步骤直到完成排序。

public void selectSort(int array[]) {

for (int i = 0; i < array.length - 1; i++){

int index=i;

for (int j = i + 1; j < array.length; j++)

if (array[index] > array[j])

index=j;

if(index!=i){ //找到了比array[i]小的则与array[i]交换位置

t = array[i];

array[i] = array[index];

array[index] = t;

}

}

}

8

1

##插入排序##

特点：效率低，容易实现。

思想：将数组分为两部分，将后部分元素逐一与前部分元素比较，如果前部分元素比array[i]小，就将前部分元素往后移动。当没有比array[i]小的元素，即是合理位置，在此位置插入array[i]

public void insertionSort(int array[]) {

int i, j, t = 0;

for (i = 1; i < array.length; i++) {

if(a[i]<a[i-1]){

t = array[i];

for (j = i - 1; j >= 0 && t < array[j]; j--)

array[j + 1] = array[j];

//插入array[i]

array[j + 1] = t;

}

}

}

6

快速排序

特点：高效，时间复杂度为nlogn。

采用分治法的思想：首先设置一个轴值pivot，然后以这个轴值为划分基准将待排序序列分成比pivot大和比pivot小的两部分，接下来对划分完的子序列进行快排直到子序列为一个元素为止。

public void quickSort(int array[], int low, int high) {// 传入low=0，high=array.length-1;

int pivot, p_pos, i, t;// pivot->位索引;p_pos->轴值。

if (low < high) {

p_pos = low;

pivot = array[p_pos];

for (i = low + 1; i <= high; i++)

if (array[i] > pivot) {

p_pos++;

t = array[p_pos];

array[p_pos] = array[i];

array[i] = t;

}

t = array[low];

array[low] = array[p_pos];

array[p_pos] = t;

// 分而治之

quickSort(array, low, p_pos - 1);// 排序左半部分

quickSort(array, p_pos + 1, high);// 排序右半部分

}

数组
数组分为一维数组和二维数组

数组的语法:

数据类型[] 数组名= new 数据类型[数组长度];

数组类型 数组名[] = new 数组类型[数组长度];

数组元素的表示与赋值:

由于定义数组时,内存分配的是连续空间,所以数组元素在数组里顺序排列编号,该编号即元素下标,它标明了元素在数组中的位置

语法:

数组名[下标值]

数组的初始化

定义,就是在定义数组的同时一并完成赋值操作

语法:

数据类型[] 数组名 ={值1,值2,值3.....值n};

数组类型[] 数组名 = new  数据类型[]{值1,值2,值3,......,值n}

二维数组

定义和操作多维数组的语法与一维数组类似

语法:

数组类型 [] [] 数组名

数组类型 数组 [] []

** Java支持多维数组,但从内存分配原理的角度讲,Java中只有一维数组,没有多维数组

****总结:

数组是可以在内存中连续存储多个元素的结构,数组中的所有元素必须属于相同的数据类型

数组中的元素通过数组下标进行访问,数组下标从0开始

二维数组实际上是一个一维数组,它的每个元素又是一个一维数组

使用Array类提供的方法可以方便地对数组中的元素进行排序,查询等操作

二叉树
二叉树是每个节点最多有两个子树的树结构,通常子树被称作"左子树"和"右子树",左子树和右子树同时也是二叉树,二叉树的子树有左右之分,并且次序不能任意颠倒.二叉树是递归定义的,

特殊二叉树:

斜树:

所有的结点都只有左子树(左斜树),或者只有右子树(右斜树)

满二叉树:

所有的分支结点都存在左子树和右子树,并且所有的叶子结点都在同一层上,这样就是满二叉树.就是完美圆满的意思,关键在于树的平衡.

特点为:

叶子只能出现在最下一层

非叶子节点度一定是

在同样深度的二叉树中,满二叉树的结点个数最多,叶子树最多

完全二叉树:

对一颗具有n个结点的二叉树按层序排号,如果编号为i的结点与同样深度的满二叉树编号为i结点在二叉树中位置完全相同,就是完全二叉树,满二叉树必须是完全二叉树,反过来不一定成立

特点:

叶子结点只能出现在最下一层(满二叉树继承而来)

最下层叶子结点一定集中在左部连续位置

倒数第二层,如有叶子结点,一定出现在右部连续位置

同样结点树的二叉树,完全二叉树的深度最小(满二叉树也是对的)

二叉树的遍历:

从树的根节点出发,按照某种次序依次访问二叉树中所有的结点,使得每个结点被访问仅且一次

前序遍历:

基本思想: 先访问根结点,再先序遍历左子树,最后再先序遍历右子树即根一左一右

中序遍历:

基本思想: 先中序遍历左子树,然后再访问根结点,最后再中序遍历右子树即左一根一右

后序遍历:

基本思想: 先后序遍历左子树,然后再后序遍历右子树,最后再访问根结点即左一右一根

二叉树的作用:

二叉排序树是一种比较有用的折衷方案

数组的搜索比较方便,可以直接用下标,但删除或者插入某些元素就比较麻烦

链表与之相反,删除和插入元素很快,但查找很慢

二叉排序树就既有链表的好处,也有数组的好处

在处理大批量的动态的数据是比较有用

用的最多的应该是平衡二叉树,有种特殊的平衡二叉树红黑树,查找,插入,删除的时间复杂度最坏为O(log n)

平衡二叉树/红黑树就是为了将查找的时间复杂度保证在O(logN)范围内

二叉树之所以重要,是因为它支持或拥有的操作,包括增删改查重要的操作,复杂度比完成同样功能的其他结构更低

（完）

Java的序列化
序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。

序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。

我们有时候将一个java对象变成字节流的形式传出去或者从一个字节流中恢复成一个java对象，例如，要将java对象存储到硬盘或者传送给网络上的其他计算机，这个过程我们可以自己写代码去把一个java对象变成某个格式的字节流再传输，但是，jre本身就提供了这种支持，我们可以调用OutputStream的writeObject方法来做，如果要让java 帮我们做，要被传输的对象必须实现serializable接口，这样，javac编译时就会进行特殊处理，编译的类才可以被writeObject方法操作，这就是所谓的序列化。需要被序列化的类必须实现Serializable接口，该接口是一个mini接口，其中没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的。

例如，在web开发中，如果对象被保存在了Session中，tomcat在重启时要把Session对象序列化到硬盘，这个对象就必须实现Serializable接口。如果对象要经过分布式系统进行网络传输或通过rmi等远程调用，这就需要在网络上传输对象，被传输的对象就必须实现Serializable接口。

什么是GC

1.JVM的gc概述
  gc（garbage collection）：即垃圾收集，是指JVM用于释放那些不再使用的对象所占用的内存。java语言并不要求JVM有gc，也没有规定gc如何工作。不过常用的JVM都有gc，而且大多数gc都使用类似的算法管理内存和执行收集操作。在充分理解了垃圾收集算法和执行过程后，才能有效的优化它的性能。有些垃圾收集专用于特殊的应用程序。比如，实时应用程序主要是为了避免垃圾收集中断，而大多数OLTP应用程序则注重整体效率。理解了应用程序的工作负荷和JVM支持的垃圾收集算法，便可以进行优化配置垃圾收集器。垃圾收集的目的在于清除不再使用的对象，gc通过确定对象是否被活动对象引用来确定是否收集该对象。gc首先要判断该对象是否是时候可以收集，引用计数和对象引用遍历是两种常用的方法。

·引用计数

引用计数存储对特定对象的所有引用数，也就是说，当应用程序创建引用以及引用超出范围时，JVM必须适当增减引用数。当某对象的引用数为0时，便可以进行垃圾收集。

·对象引用遍历

早期的JVM使用引用计数，现在大多数JVM采用对象引用遍历。对象引用遍历从一组对象开始，沿着整个对象图上的每条链接，递归确定可到达（reachable）的对象。如果某对象不能从这些根对象的一个（至少一个）到达，则将它作为垃圾收集。在对象遍历阶段，gc必须记住哪些对象可以到达，以便删除不可到达的对象，这称为标记（marking）对象。下一步，gc要删除不可到达的对象。删除时，有些gc只是简单的扫描堆栈，删除未标记的对象，并释放它们的内存以生成新的对象，这叫做清除（sweeping）。这种方法的问题在于内存会分成好多小段，而它们不足以用于新的对象，但是组合起来却很大。因此，许多gc可以重新组织内存中的对象，并进行压缩（compact），形成可利用的空间。为此，gc需要停止其他的活动。这种方法意味着所有与应用程序相关的工作停止，只有gc运行。结果，在响应期间增减了许多混杂请求。另外，更复杂的 gc不断增加或同时运行以减少或者清除应用程序的中断。有的gc使用单线程完成这项工作，有的则采用多线程以增加效率。

Java语言没有提供释放已分配内存的显示操作方法。

程序员可以手动执行System.gc()，通知GC运行，但是Java语言规范并不保证GC一定会执行。

2.几种垃圾回收机制
·标记－清除收集器

这种收集器首先遍历对象图并标记可到达的对象，然后扫描堆栈以寻找未标记对象并释放它们的内存。这种收集器一般使用单线程工作并停止其他操作。

·标记－压缩收集器

有时也叫标记－清除－压缩收集器，与标记－清除收集器有相同的标记阶段。在第二阶段，则把标记对象复制到堆栈的新域中以便压缩堆栈。这种收集器也停止其他操作。

·复制收集器

这种收集器将堆栈分为两个域，常称为半空间。每次仅使用一半的空间，JVM生成的新对象则放在另一半空间中。gc运行时，它把可到达对象复制到另一半空间，从而压缩了堆栈。这种方法适用于短生存期的对象，持续复制长生存期的对象则导致效率降低。

·增量收集器

 增量收集器把堆栈分为多个域，每次仅从一个域收集垃圾。这会造成较小的应用程序中断。

·分代收集器

 这种收集器把堆栈分为两个或多个域，用以存放不同寿命的对象。JVM生成的新对象一般放在其中的某个域中。过一段时间，继续存在的对象将获得使用期并转入更长寿命的域中。分代收集器对不同的域使用不同的算法以优化性能。

·并发收集器

并发收集器与应用程序同时运行。这些收集器在某点上（比如压缩时）一般都不得不停止其他操作以完成特定的任务，但是因为其他应用程序可进行其他的后台操作，所以中断其他处理的实际时间大大降低。

·并行收集器

并行收集器使用某种传统的算法并使用多线程并行的执行它们的工作。在多CPU机器上使用多线程技术可以显著的提高java应用程序的可扩展性。

Jvm加载class文件的原理机制
1) 装载：查找并加载类的二进制数据；

2)链接：

验证：确保被加载类的正确性；

准备：为类的静态变量分配内存，并将其初始化为默认值；

解析：把类中的符号引用转换为直接引用；

3)初始化：为类的静态变量赋予正确的初始值；

          那为什么我要有验证这一步骤呢？首先如果由编译器生成的class文件，它肯定是符合JVM字节码格式的，但是万一有高手自己写一个class文件，让JVM加载并运行，用于恶意用途，就不妙了，因此这个class文件要先过验证这一关，不符合的话不会让它继续执行的，也是为了安全考虑吧。

        准备阶段和初始化阶段看似有点牟盾，其实是不牟盾的，如果类中有语句：private static int a = 10，它的执行过程是这样的，首先字节码文件被加载到内存后，先进行链接的验证这一步骤，验证通过后准备阶段，给a分配内存，因为变量a是static的，所以此时a等于int类型的默认初始值0，即a=0,然后到解析（后面在说），到初始化这一步骤时，才把a的真正的值10赋给a,此时a=10。类的初始化

类什么时候才被初始化：

1）创建类的实例，也就是new一个对象

2）访问某个类或接口的静态变量，或者对该静态变量赋值

3）调用类的静态方法

4）反射（Class.forName("com.lyj.load")）

5）初始化一个类的子类（会首先初始化子类的父类）

6）JVM启动时标明的启动类，即文件名和类名相同的那个类

         只有这6中情况才会导致类的类的初始化。

     类的初始化步骤：

        1）如果这个类还没有被加载和链接，那先进行加载和链接

        2）假如这个类存在直接父类，并且这个类还没有被初始化（注意：在一个类加载器中，类只能初始化一次），那就初始化直接的父类（不适用于接口）

         3)加入类中存在初始化语句（如static变量和static块），那就依次执行这些初始化语句。

Java的内存泄露问题
一、Java内存回收机制

不论哪种语言的内存分配方式，都需要返回所分配内存的真实地址，也就是返回一个指针到内存块的首地址。Java中对象是采用new或者反射的方法创建的，这些对象的创建都是在堆（Heap）中分配的，所有对象的回收都是由Java虚拟机通过垃圾回收机制完成的。GC为了能够正确释放对象，会监控每个对象的运行状况，对他们的申请、引用、被引用、赋值等状况进行监控，Java会使用有向图的方法进行管理内存，实时监控对象是否可以达到，如果不可到达，则就将其回收，这样也可以消除引用循环的问题。在Java语言中，判断一个内存空间是否符合垃圾收集标准有两个：一个是给对象赋予了空值null，以下再没有调用过，另一个是给对象赋予了新值，这样重新分配了内存空间。

二、Java内存泄露引起原因

首先，什么是内存泄露？内存泄露是指无用对象（不再使用的对象）持续占有内存或无用对象的内存得不到及时释放，从而造成的内存空间的浪费称为内存泄露。内存泄露有时不严重且不易察觉，这样开发者就不知道存在内存泄露，但有时也会很严重，会提示你Out of memory。

那么，Java内存泄露根本原因是什么呢？长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄露，尽管短生命周期对象已经不再需要，但是因为长生命周期对象持有它的引用而导致不能被回收，这就是java中内存泄露的发生场景。具体主要有如下几大类：

1、静态集合类引起内存泄露：

像HashMap、Vector等的使用最容易出现内存泄露，这些静态变量的生命周期和应用程序一致，他们所引用的所有的对象Object也不能被释放，因为他们也将一直被Vector等引用着。

例:

Static Vector v = new Vector(10);

for (int i = 1; i<100; i++)

{

Object o = new Object();

v.add(o);

o = null;

}//

在这个例子中，循环申请Object 对象，并将所申请的对象放入一个Vector 中，如果仅仅释放引用本身（o=null），那么Vector 仍然引用该对象，所以这个对象对GC 来说是不可回收的。因此，如果对象加入到Vector 后，还必须从Vector 中删除，最简单的方法就是将Vector对象设置为null。

2、当集合里面的对象属性被修改后，再调用remove（）方法时不起作用。

例：

public static void main(String[] args)

{

Set<Person> set = new HashSet<Person>();

Person p1 = new Person("唐僧","pwd1",25);

Person p2 = new Person("孙悟空","pwd2",26);

Person p3 = new Person("猪八戒","pwd3",27);

set.add(p1);

set.add(p2);

set.add(p3);

System.out.println("总共有:"+set.size()+" 个元素!"); //结果：总共有:3 个元素!

p3.setAge(2); //修改p3的年龄,此时p3元素对应的hashcode值发生改变

 

set.remove(p3); //此时remove不掉，造成内存泄漏

set.add(p3); //重新添加，居然添加成功

System.out.println("总共有:"+set.size()+" 个元素!"); //结果：总共有:4 个元素!

for (Person person : set)

{

System.out.println(person);

}

}

3、监听器

在java 编程中，我们都需要和监听器打交道，通常一个应用当中会用到很多监听器，我们会调用一个控件的诸如addXXXListener()等方法来增加监听器，但往往在释放对象的时候却没有记住去删除这些监听器，从而增加了内存泄漏的机会。

4、各种连接

比如数据库连接（dataSourse.getConnection()），网络连接(socket)和io连接，除非其显式的调用了其close（）方法将其连接关闭，否则是不会自动被GC 回收的。对于Resultset 和Statement 对象可以不进行显式回收，但Connection 一定要显式回收，因为Connection 在任何时候都无法自动回收，而Connection一旦回收，Resultset 和Statement 对象就会立即为NULL。但是如果使用连接池，情况就不一样了，除了要显式地关闭连接，还必须显式地关闭Resultset Statement 对象（关闭其中一个，另外一个也会关闭），否则就会造成大量的Statement 对象无法释放，从而引起内存泄漏。这种情况下一般都会在try里面去的连接，在finally里面释放连接。

5、内部类和外部模块等的引用

内部类的引用是比较容易遗忘的一种，而且一旦没释放可能导致一系列的后继类对象没有释放。此外程序员还要小心外部模块不经意的引用，例如程序员A 负责A 模块，调用了B 模块的一个方法如：

public void registerMsg(Object b);

这种调用就要非常小心了，传入了一个对象，很可能模块B就保持了对该对象的引用，这时候就需要注意模块B 是否提供相应的操作去除引用。

6、单例模式

不正确使用单例模式是引起内存泄露的一个常见问题，单例对象在被初始化后将在JVM的整个生命周期中存在（以静态变量的方式），如果单例对象持有外部对象的引用，那么这个外部对象将不能被jvm正常回收，导致内存泄露，考虑下面的例子：

class A{

public A(){

B.getInstance().setA(this);

}

....

}

//B类采用单例模式

class B{

private A a;

private static B instance=new B();

public B(){}

public static B getInstance(){

return instance;

}

public void setA(A a){

this.a=a;

}

//getter...

}

显然B采用singleton模式，它持有一个A对象的引用，而这个A类的对象将不能被回收。想象下如果A是个比较复杂的对象或者集合类型会发生什么情况

Java中堆和栈的区别
stack 空间小，速度比较快， 用来放对象的引用

heep 大，一般所有创建的对象都放在这里。

栈(stack):是一个先进后出的数据结构,通常用于保存方法(函数)中的参数,局部变量.

在java中,所有基本类型和引用类型都在栈中存储.栈中数据的生存空间一般在当前scopes内(就是由{...}括起来的区域).

堆(heap):是一个可动态申请的内存空间(其记录空闲内存空间的链表由操作系统维护),C中的malloc语句所产生的内存空间就在堆中.

在java中,所有使用new xxx()构造出来的对象都在堆中存储,当垃圾回收器检测到某对象未被引用,则自动销毁该对象.所以,理论上说java中对象的生存空间是没有限制的,只要有引用类型指向它,则它就可以在任意地方被使用.

1. 栈(stack)与堆(heap)都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。

2. 栈的优势是，存取速度比堆要快，仅次于直接位于CPU中的寄存器。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。另外，栈数据可以共享，详见第3点。堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。

3. Java中的数据类型有两种。

一种是基本类型(primitive types), 共有8种，即int, short, long, byte, float, double, boolean, char(注意，并没有string的基本类型)。 这种类型的定义是通过诸如int a = 3; long b = 255L;的形式来定义的，称为自动变量。值得注意的是，自动变量存的是字面值，不是类的实例，即不是类的引用，这里并没有类的存在。如int a = 3; 这里的a是一个指向int类型的引用，指向3这个字面值。这些字面值的数据，由于大小可知，生存期可知(这些字面值固定定义在某个程序块里面，程序块退出后，字段值就消失了)，出于追求速度的原因，就存在于栈中。

另外，栈有一个很重要的特殊性，就是存在栈中的数据可以共享。假设我们同时定义：

int a = 3;

int b = 3；

编译器先处理int a = 3；首先它会在栈中创建一个变量为a的引用，然后查找有没有字面值为3的地址，没找到，就开辟一个存放3这个字面值的地址，然后将a指向3的地址。接着处理int b = 3；在创建完b的引用变量后，由于在栈中已经有3这个字面值，便将b直接指向3的地址。

这样，就出现了a与b同时均指向3的情况。特别注意的是，这种字面值的引用与类对象的引用不同。

假定两个类对象的引用同时指向一个对象，如果一个对象引用变量修改了这个对象的内部状态，那么另一个对象引用变量也即刻反映出这个变化。

相反，通过字面值的引用来修改其值，不会导致另一个指向此字面值的引用的值也跟着改变的情况。 如上例，我们定义完a与b的值后，再令a=4；那么，b不会等于4，还是等于3。在编译器内部，遇到a=4；时，它就会重新搜索栈中是否有4的字面值，如果没有，重新开辟地址存放4的值；如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b的值。

基本方法 String
1、获取字符串的长度：length()

2、判断字符串的前缀或后缀与已知字符串是否相同

   前缀 startsWith(String s)、后缀 endsWith(String s)

3、比较两个字符串：equals(String s)

4、把字符串转化为相应的数值

   int型 Integer.parseInt(字符串)、long型 Long.parseLong(字符串)

   float型 Folat.valueOf(字符串).floatValue()

   double型 Double.valueOf(字符串).doubleValue()

5、 将数值转化为字符串：valueOf(数值)

6、 字符串检索

    indexOf(Srting s) 从头开始检索

    indexOf(String s ,int startpoint) 从startpoint处开始检索

7、 得到字符串的子字符串

    substring(int startpoint) 从startpoint处开始获取

    substring(int start,int end) 从start到end中间的字符

8、 替换字符串中的字符,去掉字符串前后空格

    replace(char old,char new) 用new替换old

9、 分析字符串

    StringTokenizer(String s)构造一个分析器，使用默认分隔字符（空格，换行，回车，Tab）

    StringTokenizer(String s,String delim) delim是自己定义的分隔符

    nextToken() 逐个获取字符串中的语言符号

    boolean hasMoreTokens() 只要字符串还有语言符号将返回true，否则返回false

    countTokens() 得到一共有多少个语言符号

1.2 IO流
掌握InputStream、OutputStream、Reader、Writer的继承体系。

 

 

1. 基类

InputStream与OutputStream是所有字节型输入输出流的基抽象类,同时也是适配器(原始流处理器)需要适配的对象,也是装饰器(链接流处理器)装饰对象的基类.

2. 原始流处理器

原始流处理器接收Byte数组对象,String对象,FileDescriptor对象将其适配成InputStream,以供其他装饰器使用,他们都继承自InputStream 包括如下几个:

ByteArrayInputStream: 接收Byte数组为流源,为多线程通信提供缓冲区操作功能

FileInputStream: 接收一个File作为流源,用于文件的读取

PipedInputStream: 接收一个PipedOutputStream,与PipedOutputStream配合作为管道使用

StringBufferInputStream: 接收一个String作为流的源(已弃用) 

3. 链接流处理器

链接流处理器可以接收另一个流处理器(InputStream,包括链接流处理器和原始流处理器)作为源,并对其功能进行扩展,所以说他们是装饰器.

4) FilterInputStream继承自InputStream,是所有装饰器的父类,FilterInputStream内部也包含一个InputStream,这个InputStream就是被装饰类--一个原始流处理器,它包括如下几个子类:

BufferedInputStream: 用来将数据读入内存缓冲区,并从此缓冲区提供数据

DataInputStream: 提供基于多字节的读取方法,可以读取原始数据类型(Byte, Int, Long, Double等等)

LineNumberInputStream:  提供具有行计数功能的流处理器

PushbackInputStream:  提供已读取字节"推回"输入流的功能

2) ObjectInputStream: 可以将使用ObjectOutputStream写入的基本数据和对象进行反串行化

3) SequenceInputStream: 可以合并多个InputStream原始流,依次读取这些合并的原始流 

对于OutputStream, Reader, Writer的体系结构也跟InputStream的结构类似

IO流中的设计模式
1.IO中用到的适配器模式

在IO中，如将字符串数据转变成字节数据保存到文件中，将字节数据转变成流数据等都用到了适配器模式，下面以InputStreamReader和OutputStreamWriter类为例介绍适配器模式。

 InputStreamReader和OutputStreamWriter类分别继承了Reader和Writer接口，但要创建它们必须在构造函数中传入一个InputStream和OutputStream的实例，InputStreamReader和OutputStreamWriter的作用也就是将InputStream和OutputStream适配到Reader和Writer。

  InputStreamReader实现了Reader接口，并且持有了InputStream的引用，这是通过StreamDecoder类间接持有的，因为byte到char要经过编码。

       这里，适配器就是InputStreamReader类，而源角色就是InputStream代表的实例对象，目标接口就是Reader类，OutputStreamWriter类也是类似的方式。

       在IO中类似的还有，如StringReader将一个String类适配到Reader接口，ByteArrayInputStream适配器将byte数组适配到InputStream流处理接口。

2.IO中用到的装饰模式

        装饰模式就是对一个类进行装饰，增强其方法行为，在装饰模式中，作为原来的这个类使用者还不应该感受到装饰前与装饰后有什么不同，否则就破坏了原有类的结构了，所以装饰器模式要做到对被装饰类的使用者透明，这是对装饰器模式的一个要求。总之装饰器设计模式就是对于原有功能的扩展

在IO中有许多不同的功能组合情况，这些不同的功能组合都是使用装饰器模式实现的，下面以FilterInputStream为例介绍装饰器模式的使用。

InputStream类就是以抽象组件存在的，而FileInputStream就是具体组件，它实现了抽象组件的所有接口，FilterInputStream类就是装饰角色，它实现了InputStream类的所有接口，并持有InputStream的对象实例的引用，BufferedInputStream是具体的装饰器实现者，这个装饰器类的作用就是使得InputStream读取的数据保存在内存中，而提高读取的性能。类似的还有LineNumberInputStream类，它的作用是提高按行读取数据的功能。

总结

    这两种设计模式看起来都是起到包装一个类或对象的作用，但是使用它 们的目的却不尽相同。适配器模式主要在于将一个接口转变成另一个接口，它的目的是通过改变接口来达到重复使用的目的；而装饰器模式不是要改变被装饰对象的接口，而是保持原有的接口，但是增强原有对象的功能，或改变原有对象的方法而提高性能。

补充☆(3) 高性能的IO体系。

首先得明白什么是同步，异步，阻塞，非阻塞.

1,同步和异步是针对应用程序和内核的交互而言的

2,阻塞和非阻塞是针对于进程在访问数据的时候，根据IO操作的就绪状态来采取的不同方式

总结一句简短的话，同步和异步是目的，阻塞和非阻塞是实现方式。

名词解释 

同步 指的是用户进程触发IO操作并等待或者轮询的去查看IO操作是否就绪 自己上街买衣服，自己亲自干这件事，别的事干不了。 
2) 异步 异步是指用户进程触发IO操作以后便开始做自己的事情，而当IO操作已经完成的时候会得到IO完成的通知（异步的特点就是通知） 告诉朋友自己合适衣服的尺寸，大小，颜色，让朋友委托去卖，然后自己可以去干别的事。（使用异步IO时，Java将IO读写委托给OS处理，需要将数据缓冲区地址和大小传给OS） 
3) 阻塞 所谓阻塞方式的意思是指, 当试图对该文件描述符进行读写时, 如果当时没有东西可读,或者暂时不可写, 程序就进入等待 状态, 直到有东西可读或者可写为止 去公交站充值，发现这个时候，充值员不在（可能上厕所去了），然后我们就在这里等待，一直等到充值员回来为止。（当然现实社会，可不是这样，但是在计算机里确实如此。） 
4) 非阻塞 非阻塞状态下, 如果没有东西可读, 或者不可写, 读写函数马上返回, 而不会等待， 银行里取款办业务时，领取一张小票，领取完后我们自己可以玩玩手机，或者与别人聊聊天，当轮我们时，银行的喇叭会通知，这时候我们就可以去了。

同步阻塞IO（JAVA BIO）： 
    同步并阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。 
同步非阻塞IO(Java NIO) ： 同步非阻塞，服务器实现模式为一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。用户进程也需要时不时的询问IO操作是否就绪，这就要求用户进程不停的去询问。 
异步阻塞IO（Java NIO）：  
   此种方式下是指应用发起一个IO操作以后，不等待内核IO操作的完成，等内核完成IO操作以后会通知应用程序，这其实就是同步和异步最关键的区别，同步必须等待或者主动的去询问IO是否完成，那么为什么说是阻塞的呢？因为此时是通过select系统调用来完成的，而select函数本身的实现方式是阻塞的，而采用select函数有个好处就是它可以同时监听多个文件句柄（如果从UNP的角度看，select属于同步操作。因为select之后，进程还需要读写数据），从而提高系统的并发性！  
（Java AIO(NIO.2)）异步非阻塞IO:  
   在此种模式下，用户进程只需要发起一个IO操作然后立即返回，等IO操作真正的完成以后，应用程序会得到IO操作完成的通知，此时用户进程只需要对数据进行处理就好了，不需要进行实际的IO读写操作，因为真正的IO读取或者写入操作已经由内核完成了。    

1.3 异常
掌握Throwable继承体系。

Java异常体系：

Throwable（异常和错误的顶层父类）

  |----- Error：错误类。表示的是程序在运行过程中出现的错误。错误的发生都属于系统级别。（JVM是运行操作系统上，JVM操作内存是需要借助操作系统，如果内在发生错误，会由操作系统反馈给JVM）

             通常在程序中发生错误的原因是因为程序在书写时存在问题，而JVM运行有问题的代码就会引发内存出错。解决错误的方案：修改源代码

  |----- Exception：异常类。程序在运行过程中，出现了异常现象：数组越界、类型转换异常等。通常在程序中如果发生了异常，是有专门针对异常处理的方案（处理方案是由开发人员自己制定）

                 程序中异常的发生通常是因为程序在操作数据时引发的，解决异常的方案是：声明、捕获

                 （学习以Exception为主，开发也主要以Exception为主）

            提示：声明最终还需要使用捕获来处理异常

异常类的分类：

运行时异常：RuntimeException 

编译时异常：Exception

异常的处理

声明：其实就是程序中遇到异常时，自己不处理，交给其它程序处理

关键字：throws

捕获：其实就是在程序中遇到异常时，不会交给其它程序处理，自己处理

关键字：try 、catch、finally

注意：1，在使用throw抛出异常代码的后面，不能书写任意代码。

      2，如果使用try...catch...finally结构的，catch中抛出异常后面如果有其他语句，执行时先执行finally语句再去执行catch中的其他语句

      3，try..catch..catch结构中必须按照子类到父类的顺序写

1.4 多线程多态的实现机制:
(1) 掌握Executors可以创建的三种线程池的特点及适用范围。

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

2.实现runnable接口

3.使用ExecutorService、Callable、Future实现有返回结果的多线程(JDK5.0以后)

(2) 多线程同步机制。

在需要同步的方法的方法签名中加入synchronized关键字。

使用synchronized块对需要进行同步的代码段进行同步。

使用JDK 5中提供的java.util.concurrent.lock包中的Lock对象。

一段synchronized的代码被一个线程执行之前，他要先拿到执行这段代码的权限，在 java里边就是拿到某个同步对象的锁（一个对象只有一把锁）； 如果这个时候同步对象的锁被其他线程拿走了，他（这个线程）就只能等了（线程阻塞在锁池 等待队列中）。 取到锁后，他就开始执行同步代码(被synchronized修饰的代码）；线程执行完同步代码后马上就把锁还给同步对象，其他在锁池中 等待的某个线程就可以拿到锁执行同步代码了。这样就保证了同步代码在统一时刻只有一个线程在执行。

(3)线程的几种可用状态。

线程在执行过程中，可以处于下面几种状态：

就绪(Runnable):线程准备运行，不一定立马就能开始执行。

运行中(Running)：进程正在执行线程的代码。

等待中(Waiting):线程处于阻塞的状态，等待外部的处理结束。

睡眠中(Sleeping)：线程被强制睡眠。

I/O阻塞(Blocked on I/O)：等待I/O操作完成。

同步阻塞(Blocked on Synchronization)：等待获取锁。

死亡(Dead)：线程完成了执行。

(4)什么是死锁(deadlock)？

两个进程都在等待对方执行完毕才能继续往下执行的时候就发生了死锁。结果就是两个进程都陷入了无限的等待中。

(5)如何确保N个线程可以访问N个资源同时又不导致死锁？

使用多线程的时候，一种非常简单的避免死锁的方式就是：指定获取锁的顺序，并强制线程按照指定的顺序获取锁。因此，如果所有的线程都是以同样的顺序加锁和释放锁，就不会出现死锁了。

(6)解释下多线程:

首先，什么是线程，线程是程序的执行路径，或者可以说是程序的控制单元。 

一个进程可能包含一个或多个进程，当一个进程存在多条执行路径时，就可以将该执行方式称为多线程。 

线程的执行方式大致可分为就绪(wait)，执行(run)，阻塞(block)三个状态，而三个状态的转换实质上是在抢夺cpu资源过程中造成的，正常情况下cpu资源不会被线程独自占用，因此多个线程在运行中相互抢夺资源，造成线程在上述的三个状态之间不断的相互转换。而这也是多线程的执行方式。

(7)线程锁对象详解:

多线程可以同时运行多个任务

但是当多个线程同时访问共享数据时，可能导致数据不同步，甚至错误！

so,不使用线程锁, 可能导致错误

应用场景:

I/O密集型操作 需要资源保持同步

优缺点:

优点:保证资源同步 

缺点:有等待肯定会慢

扩展(死锁与递归锁)

如果多个线程要调用多个对象，而A线程调用A锁占用了A对象，B线程调用了B锁占用了B对象,A线程不能调用B对象，B线程不能调用A对象，于是一直等待。这就造成了线程“死锁”。

Threading模块中，也有一个类，RLock，称之为可重入锁。该锁对象内部维护着一个Lock和一个counter对象。counter对象记录了acquire的次数，使得资源可以被多次require。最后，当所有RLock被release后，其他线程才能获取资源。在同一个线程中，RLock.acquire可以被多次调用，利用该特性，可以解决部分死锁问题。

就是把 lock=threading.Lock()改成lock = threading.RLock();

(8)同步方法的实现方式:

1.同步方法 

    即有synchronized关键字修饰的方法。 

    由于java的每个对象都有一个内置锁，当用此关键字修饰方法时， 

    内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。

    代码如： 

    public synchronized void save(){}

   注： synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类

2.同步代码块 

    即有synchronized关键字修饰的语句块。 

    被该关键字修饰的语句块会自动被加上内置锁，从而实现同步

    代码如： 

    synchronized(object){ 

    }

    注：同步是一种高开销的操作，因此应该尽量减少同步的内容。 

    通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。 

3.使用特殊域变量(volatile)实现线程同步

    a.volatile关键字为域变量的访问提供了一种免锁机制， 

    b.使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新， 

    c.因此每次使用该域就要重新计算，而不是使用寄存器中的值 

    d.volatile不会提供任何原子操作，它也不能用来修饰final类型的变量 

     注：多线程中的非同步问题主要出现在对域的读写上，如果让域自身避免这个问题，则就不需要修改操作该域的方法。 

    用final域，有锁保护的域和volatile域可以避免非同步的问题。 

4.使用重入锁实现线程同步

    在JavaSE5.0中新增了一个java.util.concurrent包来支持同步。 

    ReentrantLock类是可重入、互斥、实现了Lock接口的锁， 

    它与使用synchronized方法和快具有相同的基本行为和语义，并且扩展了其能力

    ReenreantLock类的常用方法有：

        ReentrantLock() : 创建一个ReentrantLock实例 

        lock() : 获得锁 

        unlock() : 释放锁 

    注：ReentrantLock()还有一个可以创建公平锁的构造方法，但由于能大幅度降低程序运行效率，不推荐使用 

  注：关于Lock对象和synchronized关键字的选择： 

        a.最好两个都不用，使用一种java.util.concurrent包提供的机制， 

            能够帮助用户处理所有与锁相关的代码。 

        b.如果synchronized关键字能满足用户的需求，就用synchronized，因为它能简化代码 

        c.如果需要更高级的功能，就用ReentrantLock类，此时要注意及时释放锁，否则会出现死锁，通常在finally代码释放锁 

5.使用局部变量实现线程同步 

    如果使用ThreadLocal管理变量，则每一个使用该变量的线程都获得该变量的副本， 

    副本之间相互独立，这样每一个线程都可以随意修改自己的变量副本，而不会对其他线程产生影响。

    ThreadLocal 类的常用方法

    ThreadLocal() : 创建一个线程本地变量 

    get() : 返回此线程局部变量的当前线程副本中的值 

    initialValue() : 返回此线程局部变量的当前线程的"初始值" 

    set(T value) : 将此线程局部变量的当前线程副本中的值设置为value

注：ThreadLocal与同步机制 

        a.ThreadLocal与同步机制都是为了解决多线程中相同变量的访问冲突问题。 

        b.前者采用以"空间换时间"的方法，后者采用以"时间换空间"的方式 

6.使用阻塞队列实现线程同步

    前面5种同步方式都是在底层实现的线程同步，但是我们在实际开发当中，应当尽量远离底层结构。 

    使用javaSE5.0版本中新增的java.util.concurrent包将有助于简化开发。 

    本小节主要是使用LinkedBlockingQueue<E>来实现线程的同步 

    LinkedBlockingQueue<E>是一个基于已连接节点的，范围任意的blocking queue。 

    队列是先进先出的顺序（FIFO） 

   LinkedBlockingQueue 类常用方法 

    LinkedBlockingQueue() : 创建一个容量为Integer.MAX_VALUE的LinkedBlockingQueue 

    put(E e) : 在队尾添加一个元素，如果队列满则阻塞 

    size() : 返回队列中的元素个数 

    take() : 移除并返回队头元素，如果队列空则阻塞 

7.使用原子变量实现线程同步

需要使用线程同步的根本原因在于对普通变量的操作不是原子的。

那么什么是原子操作呢？

原子操作就是指将读取变量值、修改变量值、保存变量值看成一个整体来操作

即-这几种行为要么同时完成，要么都不完成。

在java的util.concurrent.atomic包中提供了创建了原子类型变量的工具类，

使用该类可以简化线程同步。

其中AtomicInteger 表可以用原子方式更新int的值，可用在应用程序中(如以原子方式增加的计数器)，

但不能用于替换Integer；可扩展Number，允许那些处理机遇数字类的工具和实用工具进行统一访问。

AtomicInteger类常用方法：

AtomicInteger(int initialValue) : 创建具有给定初始值的新的AtomicInteger

addAddGet(int dalta) : 以原子方式将给定值与当前值相加

get() : 获取当前值

(9)sleep方法和wait方法的区别

来自不同的类： wait方法是Object类的方法，sleep方法是Thread类的方法。

对于锁的占用情况不同：最主要是sleep方法没有释放锁，而 wait 方法释放了锁，使得其他线程可以使用同步控制块或者方法。

使用范围： wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用） 　

 唤醒方式：调用sleep()方法的线程通常是睡眠一定时间后，自动醒来。对象调用wait()方法，必须采用notify()或者notifyAll()方法唤醒。

sleep方法

sleep方法属于Thread类中方法，表示让一个线程进入睡眠状态，等待一定的时间之后，自动醒来进入到可运行状态，不会马上进入运行状态，因为线程调度机制恢复线程的运行也需要时间，一个线程对象调用了sleep方法之后，并不会释放他所持有的所有对象锁，所以也就不会影响其他进程对象的运行。但在sleep的过程中有可能被其他对象调用它的interrupt(),产生InterruptedException异常，如果你的程序不捕获这个异常，线程就会异常终止，进入TERMINATED状态，如果你的程序捕获了这个异常，那么程序就会继续执行catch语句块（可能还有finally语句块）以及以后的代码。

注意sleep()方法是一个静态方法，也就是说他只对当前对象有效，通过t.sleep()让t对象进入sleep，这样的做法是错误的，它只会是使当前线程被sleep 而不是t线程。

wait方法

wait属于Object的成员方法，一旦一个对象调用了wait方法，必须要采用notify()和notifyAll()方法唤醒该进程；如果线程拥有某个或某些对象的同步锁，那么在调用了wait()后，这个线程就会释放它持有的所有同步资源，而不限于这个被调用了wait()方法的对象。wait()方法也同样会在wait的过程中有可能被其他对象调用interrupt()方法而产生InterruptedException，效果以及处理方式同sleep()方法。

(10)什么是守护线程?

守护线程（即daemon thread），是个服务线程，准确地来说就是服务其他的线程，这是它的作用——而其他的线程只有一种，那就是用户线程。所以java里线程分2种，

1、守护线程，比如垃圾回收线程，就是最典型的守护线程。

2、用户线程，就是应用程序里的自定义线程。

1、守护线程，专门用于服务其他的线程，如果其他的线程（即用户自定义线程）都执行完毕，连main线程也执行完毕，那么jvm就会退出（即停止运行）——此时，连jvm都停止运行了，守护线程当然也就停止执行了。

2、再换一种说法，如果有用户自定义线程存在的话，jvm就不会退出——此时，守护线程也不能退出，也就是它还要运行，干嘛呢，就是为了执行垃圾回收的任务啊。

用户自定义线程

1、应用程序里的线程，一般都是用户自定义线程。

2、用户也可以在应用程序代码自定义守护线程，只需要调用Thread类的设置方法设置一下即可。

(11)同步和异步的区别:

同步（Sync）

所谓同步，就是发出一个功能调用时，在没有得到结果之前，该调用就不返回或继续执行后续操作。 

根据这个定义，Java中所有方法都是同步调用，应为必须要等到结果后才会继续执行。我们在说同步、异步的时候，一般而言是特指那些需要其他端协作或者需要一定时间完成的任务。 

简单来说，同步就是必须一件一件事做，等前一件做完了才能做下一件事。

异步（Async）

异步与同步相对，当一个异步过程调用发出后，调用者在没有得到结果之前，就可以继续执行后续操作。当这个调用完成后，一般通过状态、通知和回调来通知调用者。对于异步调用，调用的返回并不受调用者控制。 

举个例子简单说明下两者的区别： 

同步：火车站多个窗口卖火车票，假设A窗口当卖第288张时，在这个短暂的过程中，其他窗口都不能卖这张票，也不能继续往下卖，必须这张票处理完其他窗口才能继续卖票。直白点说就是当你看见程序里出现synchronized这个关键字，将任务锁起来，当某个线程进来时，不能让其他线程继续进来，那就代表是同步了。

异步：当我们用手机下载某个视频时，我们大多数人都不会一直等着这个视频下载完，而是在下载的过程看看手机里的其他东西，比如用qq或者是微信聊聊天，这种的就是异步，你执行你的，我执行我的，互不干扰。比如上面卖火车票，如果多个窗口之间互不影响，我行我素，A窗口卖到第288张了，B窗口不管A窗口，自己也卖第288张票，那显然会出错了
本文由黑马程序员武汉校区就业部编著，未经允许不得转载。

 

Java学科资料

链接:  https://pan.baidu.com/s/1Iq8PonEYmNtLEKcVTsSEgA密码: nff8

链接: https://pan.baidu.com/s/1ZqWAWWEJq2TIRdJ_FgEtuA 密码: uc76

链接:  https://pan.baidu.com/s/1NPyLEjXtzB_g-lW_QtOs-g  密码: xmau

PS前五天	链接：https://pan.baidu.com/s/1-YIYeqq08CIm47CnXUtkog 提取码：adc3
PS后五天	链接：https://pan.baidu.com/s/1f-8CSTp30PUtCneg0CWzYw 提取码：eqr7