多线程的用途

程序的某一部分正在等一个事件或资源，而你又不想让它把整个程序都给阻塞了。因此你可以创建一个与该事件或资源相关的线程，让它与主程序分开来运行，例如在运算的同时，监视键盘的输入。

多线程的缺点

共享资源时，会降低运行效率；额外的消耗CPU资源；使用不当会抛出异常、或引发一些不正常状态；与平台有一定的相关性。

线程的状态

1.       new：线程刚刚建好，还未启动。

2.       runable：排在队列中等待被分配CPU时间片。

3.       dead：被中止的状态。

4.       blocked：由于非CPU时间片原因而不能运行的线程（如sleep（）、wait（）、IO问题）

实现方法

1.       创造一个类去实现runable接口，并重写run（）方法，然后实例化出来一个对象A，然后在主程序中用A作为参数创建一个Thread类的对象，调用其中的start（）来启动线程。（翁恺与孙鑫推荐用此种方法创建线程）

2.       从Thread类中派生出一个类，重写run（）方法，然后在主线程中创建一个对象，调用其中的start（）方法来启动线程。（BruceEckel则推荐用此种方法创建线程）

主要函数

start（）：启动一个进程。

stop（）：结束一个进程，由于它不会释放对象的锁，所以现在已经不提倡使用它了。

suspend（）：挂起进程。（不推荐使用）

resume（）：唤醒进程。（不推荐使用）

interrupt（）：打断

yield（）：主动放弃CPU的占用，也可能在未执行到此语句时，被虚拟机强制放弃，所以一般不能用来严格控制线程。

sleep（）：暂停线程一段时间，然后重新进入CPU使用序列排队，所以并不能准确地设定线程的暂停时间，所设定的时间只是最少的使用时间（异常情况不算）。另外，一定要放在try域中。

setPriority（）：设置线程的优先级。

getPriority（）：获取线程的优先级。由不同操作系统的优先级设定不太一样，所以对优先级的操作最好使用MIN_PRIORITY, NORM_PRIORITY, 和MIN_PRORITY来表示。

setDaemon（）：用于将线程设置为Daemon线程，但必须在线程启动之前。

isDaemon（）：判断线程是否为Daemon线程。

isAlive（）：判断线程是否还存在。

join（）：用于不同线程间的联系，当一个线程1调用另一个线程2的join（）方法，那么线程1在线程2结束前就会被挂起（除非设置timeout）。由于也可以被interrupt（）打断，所以也要放在try域中。

currentThread（）：获得当前线程，即执行此方法的线程。

getName（）：获得线程的名字。

getThreadGroup（）：获得线程所属的线程组。

Daemon线程

Daemon线程在后台运行，当所有的非Daemon线程结束了，Daemon线程也随之结束，另外在Daemon线程中创建的线程，都默认设置为Daemon线程。

解决共享资源冲突

防止资源冲突的两种方法：同步块和同步方法。

同步块：需要将要同步的代码放到synchronized（object）{}中，由于每个对象均有一个监视器（锁），所以其中的object可为任意类的对象，静态方法则默认使用类的Class对象。

同步方法：将需要同步的代码放到某一方法中，且将方法设置为synchronized。

进程间的协作

当发生nodify（）的时候，发生wait（）的地方才可以继续运行，且它们必须放在同一个对象的同步块或同步方法之中。

wait（）后将当前线程放到一个等待队列中，nodify（）后从等待队列中随意激活一个。

线程组

线程组是一个装线程的容器。用Joshua Bloch，也就是负责修补和改进JDK 1.2的Java容器类库的那位Sun的软件架构师，的话来讲，它的意义可以概括为：“最好把线程组看成是一次不成功的实验，或者就当它根本不存在。”

Java运行时的几个系统线程

Referrence Handler：系统用来控制引用的线程。（优先级：10）

Finalizer：垃圾收集器。（优先级：8）

Singnal Dispatcher：信号分配器。（优先级：10）

Compiler Thread：用于优化。（优先级：10）

其他一些小问题

※     JAVA中只有除long和double以外的基本类型的赋值和返回式原子操作，其他的操作即使看上去非常像原子操作，我们也最好加上synchronized，这也算是JAVA与C++的一点不同之处吧。最安全的原子操作只有读取和对primitive赋值这两种。

※     如果你要防止访问资源冲突，就索性把类中的所有的方法全都synchronize了，因为判断哪些方法该synchronize很难的，而且synchronize对性能的影响也不大。

※     对象使用完之后，要记得赋值为null，也就是释放其内存空间。

※     Thread类的对象不会因为没有引用而被垃圾收集起收集掉，直到其线程结束。

※     volatile标记用来排除优化，否则，编译器仅会读取缓存中的变量。

参考：《Think In JAVA第三版》、翁恺java教学视频、孙鑫java教学视频。

引用

Java中的对象定义都是定义为一个引用，其本身并不存储对象的数值，只是存储指向对象内存块儿的指针，其本质就是不能运算的指针。

Break 跳出双层循环

格式：break 标号

具有部分goto语句功能，用于跳出循环，尤其是双层循环。

This关键字

this关键字可以为已调用了其方法的那个对象生成相应的句柄，即调用这个函数的那个对象就是this。this可以在一个构造函数中调用另一个构造函数，但只能调用一个。

af ( int a ){}  //构造函数1（即被调用的构造函数）

af ( int a , String b){ this(a); }   //构造函数2

finalize() 在运行垃圾回收器之前运行的函数

静态的东西属于类，动态的东西属于对象。

对象初始化的顺序

1.       创建一个对象时，先要找到其对应的.class文件。

2.       检查对象是否有父类。如果有父类，则需要执行父类中的静态初始化。

3.       执行类自己本身的静态初始化。

4.       new语句首先会在内存内分配一个足够的空间，且全部清0。

5.       依次执行父类中的定义初始化和构造函数。

6.       依次执行父类中的定义初始化和构造函数。（完成）

静态初始化块

static{     c1 = new cpu(1);

              c2 = new cpu(2);   }

定义初始化(用于无名类的构造函数)

{     c1 = new cpu(1);

       c2 = new cpu(2);   }

每个编译单元都是以.java为结尾的文件，在一个编译单元里，只可以有一个public类，且这个类的名字必须与原文件的文件名相同。

类的访问说明符

1.       public：   界面访问

2.       private：  不能接触

3.       protect：  某种友好

4.       friengly： 缺省包

静态的成员变量由父类和子类共同使用，其他变量则各有一套。

绑定

动态绑定（Java常用）：在程序的运行中才决定要执行的函数为哪一个函数，优点是使用灵活，缺点是执行效率低。

静态绑定（C/C++常用）：在程序运行之前就已经确定需要执行的函数，有缺点与动态相反。

Final

final的成员变量：只可赋值一次，有时会用作Java中的常量。

final的函数变量：防止继承者改变其实现。

final的类：不可继承。

抽象类和抽象方法

n         抽象类作用仅是表达接口，其所有方法都是没有函数体的声明，且不能产生对象。

n         包含一个抽象方法的类就是一个抽象类。

n         没有抽象方法的类也可以是一个抽象类。

n         从抽象类中继承的类必须覆盖所有的抽象方法，否则仍是一个抽象类。

接口

n         接口是一个所有方法全是抽象方法的类。

n         接口可以继承，且可以实现多继承，但只可以从接口中继承。

n         无论是否声明，接口中的所有方法全是public的，所有成员变量全是public static final的，其变量的值都需在编译前确定。

n         一个类可以在继承其他类的同时实现多个接口。

内部类（inner class）

n         内部类就是就是写在类中（甚至写在类内函数中）的类，其基本等同于类内的成员函数，包括可以加访问说明符、可以访问私有变量等特性。

n         源文件编译后，内部类将成为独立的.class文件。

n         私有内部类往往用于提供接口的同时隐藏自己的实现细节。

                                               图1