这辈子没办法做太多事情，所以每一件都要做到精彩绝伦！

People can't do too many things in my life,so everything will be wonderful

本资料只进行简单介绍说明以及相关重要问题的解答；关于类的详细说明及使用请参考java API文档

本文参考的依据是：JDK API 1.6.0 中文版，下载地址：http://down.51cto.com/data/2300228

1.     多线程

1.1     多线程概述

(1)多线程：一个应用程序有多条执行路径

进程：正在执行的应用程序

线程：进程的执行单元，执行路径

单线程：一个应用程序只有一条执行路径

多线程：一个应用程序有多条执行路径

多进程的意义?

提高CPU的使用率

多线程的意义?

提高应用程序的使用率

(2)Java程序的运行原理及JVM的启动是多线程的吗?

A:Java命令去启动JVM，JVM会启动一个进程，该进程会启动一个主线程。

java 命令会启动java 虚拟机，启动JVM，等于启动了一个应用程序，也就是启动了一个进程。该进程会自动启动一个“主线程” ，然后主线程去调用某个类的 main 方法。所以main方法运行在主线程中。在此之前的所有程序都是单线程的。

B:JVM的启动是多线程的，因为它最低有两个线程启动了，主线程和垃圾回收线程。

1.2     多线程实现

1.2.1       方案一Thread类

l  通过查看API来学习多线程程序的实现

参考Thread类

l  继承Thread类

几个小问题：

为什么要重写run()方法

启动线程使用的是那个方法

线程能不能多次启动

run()和start()方法的区别：

1） start：

用start方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到spu时间片，就开始执行run()方法，这里方法run()称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束，此线程随即终止。

2） run：

run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到写线程的目的。

l  Thread类的基本获取和设置方法

public final String getName()

public final void setName(String name)

其实通过构造方法也可以给线程起名字

思考：

如何获取main方法所在的线程名称呢?

public static Thread currentThread()

l 这样就可以获取任意方法所在的线程名称

1.2.2       方案二Runnable接口

实现Runnable接口

如何获取线程名称

如何给线程设置名称

实现接口方式的好处

可以避免由于Java单继承带来的局限性。

适合多个相同程序的代码去处理同一个资源的情况，把线程同程序的代码，数据有效分离，较好的体现了面向对象的设计思想。

1.2.3       方案3实现Callable接口

实现Callable接口

步骤和1.9线程其他概述中的线程池执行Runnable对象的差不多。

好处：

可以有返回值

可以抛出异常

弊端：

代码比较复杂，所以一般不用

1.3     线程调度

假如我们的计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到 CPU时间片，也就是使用权，才可以执行指令。那么Java是如何对线程进行调用的呢？

线程有两种调度模型：

分时调度模型   所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片

抢占式调度模型   优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些。

Java使用的是抢占式调度模型。

如何设置和获取线程优先级

public final int getPriority()

public final void setPriority(intnewPriority)

a:默认是5

b:范围是1-10

1.4     线程控制

线程休眠

public static void sleep(long millis)

线程加入

public final void join()

线程礼让

public static void yield()

后台线程

public final void setDaemon(boolean on)

中断线程

public final void stop()

public void interrupt()

1.5     线程的生命周期

1.6     多线程案例

某电影院目前正在上映贺岁大片，共有100张票，而它有3个售票窗口售票，请设计一个程序模拟该电影院售票

代码：

/*

*

* 同步的特点：

*             前提：

*                      多个线程

*              解决问题的时候要注意：

*                       多个线程使用的是同一个锁对象

* 同步的好处

*              同步的出现解决了多线程的安全问题。

* 同步的弊端

*              当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。

*/

public class SellTicketDemo {

publicstatic void main(String[] args) {

//创建资源对象

SellTicketst = new SellTicket();

//创建三个线程对象

Threadt1 = new Thread(st, "窗口1");

Threadt2 = new Thread(st, "窗口2");

Threadt3 = new Thread(st, "窗口3");

//启动线程

t1.start();

t2.start();

t3.start();

}

}

public class SellTicket implements Runnable{

//定义100张票

privateint tickets = 100;

//定义同一把锁

privateObject obj = new Object();

@Override

publicvoid run() {

while(true) {

//t1,t2,t3都能走到这里

//假设t1抢到CPU的执行权，t1就要进来

//假设t2抢到CPU的执行权，t2就要进来,发现门是关着的，进不去。所以就等着。

//门(开,关)

synchronized(obj) { // 发现这里的代码将来是会被锁上的，所以t1进来后，就锁了。(关)

if(tickets > 0) {

try{

Thread.sleep(100);// t1就睡眠了

}catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()

+"正在出售第" + (tickets--) + "张票 ");

//窗口1正在出售第100张票

}

}//t1就出来可，然后就开门。(开)

}

}

}

添加：每次卖票延迟100毫秒！

出现问题：相同的票出现多次，还出现了负数的票

1.7     多线程安全问题

上述出现的问题

l  问题

相同的票出现多次

CPU的一次操作必须是原子性的

还出现了负数的票

随机性和延迟导致的

l  注意

线程安全问题在理想状态下，不容易出现，但一旦出现对软件的影响是非常大的。

解决思路：

l  首先想为什么出现问题?(也是我们判断是否有问题的标准)

是否是多线程环境

是否有共享数据

是否有多条语句操作共享数据

l  如何解决多线程安全问题呢?

基本思想：让程序没有安全问题的环境。

怎么实现呢?

把多个语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可。

1.7.1       方案一同步代码块

同步代码块

格式：

synchronized(对象){需要同步的代码;}

同步可以解决安全问题的根本原因就在那个对象上。该对象如同锁的功能。

l  同步的前提

多个线程

多个线程使用的是同一个锁对象

l  同步的好处

同步的出现解决了多线程的安全问题。

l  同步的弊端

当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。

1.7.2       方案二

同步方法

就是把同步关键字加到方法上。

同步方法的锁对象是什么呢?

这里的锁对象是this

如果是静态方法，同步方法的锁对象又是什么呢?

静态同步方法

把同步加在方法上。

这里的锁对象是当前类的字节码文件对象

那么，我们到底使用谁?

如果锁对象是this，就可以考虑使用同步方法。

否则能使用同步代码块的尽量使用同步代码块。

1.8     Lock锁

• 虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock

Lock

void lock()

void unlock()

ReentrantLock

• 死锁问题：

同步弊端

效率低

如果出现了同步嵌套，就容易产生死锁问题

死锁问题及其代码

是指两个或者两个以上的线程在执行的过程中，因争夺资源产生的一种互相等待现象

1.9     线程其他概述

• 等待唤醒机制

• 线程间通信

• 线程的状态转换图

• 线程组

Java中使用ThreadGroup来表示线程组，它可以对一批线程进行分类管理，Java允许程序直接对线程组进行控制。

默认情况下，所有的线程都属于主线程组。

public final ThreadGroup getThreadGroup()

我们也可以给线程设置分组

Thread(ThreadGroup group,Runnable target, String name)

• 线程池

程序启动一个新线程成本是比较高的，因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能，尤其是当程序中要创建大量生存期很短的线程时，更应该考虑使用线程池。

线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。

在JDK5之前，我们必须手动实现自己的线程池，从JDK5开始，Java内置支持线程池

JDK5新增了一个Executors工厂类来产生线程池，有如下几个方法

public static ExecutorService newCachedThreadPool()

public static ExecutorService newFixedThreadPool(int nThreads)

public static ExecutorService newSingleThreadExecutor()

这些方法的返回值是ExecutorService对象，该对象表示一个线程池，可以执行Runnable对象或者Callable对象代表的线程。它提供了如下方法

Future<?> submit(Runnable task)

<T> Future<T> submit(Callable<T> task)

• 匿名内部类方式使用多线程

匿名内部类方式使用多线程

new Thread(){代码…}.start();

New Thread(new Runnable(){代码…}).start();

1.10定时器

定时器是一个应用十分广泛的线程工具，可用于调度多个定时任务以后台线程的方式执行。在Java中，可以通过Timer和TimerTask类来实现定义调度的功能

Timer

public Timer()

public void schedule(TimerTask task,long delay)

public void schedule(TimerTask task,longdelay,long period)

TimerTask

public abstract void run()

public boolean cancel()

开发中：

Quartz是一个完全由java编写的开源调度框架。一般直接使用spring自带的定时器。

2.     设计模式

• 设计模式概述

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。

设计模式不是一种方法和技术，而是一种思想

设计模式和具体的语言无关，学习设计模式就是要建立面向对象的思想，尽可能的面向接口编程，低耦合，高内聚，使设计的程序可复用

学习设计模式能够促进对面向对象思想的理解，反之亦然。它们相辅相成

l 设计模式的几个要素

名字 必须有一个简单，有意义的名字

问题 描述在何时使用模式

解决方案 描述设计的组成部分以及如何解决问题

效果 描述模式的效果以及优缺点

l 设计模式的分类

创建型模式 对象的创建

结构型模式 对象的组成(结构)

行为型模式 对象的行为

2.1     对象的常见设计原则

(1)面试对象的常见设计原则（具体含义可参阅《大话设计模式》或百度）

• 单一职责：其实就是开发人员经常说的”高内聚，低耦合”

也就是说，每个类应该只有一个职责，对外只能提供一种功能，而引起类变化的原因应该只有一个。在设计模式中，所有的设计模式都遵循这一原则。

• 开闭：核心思想是：一个对象对扩展开放，对修改关闭。

其实开闭原则的意思就是：对类的改动是通过增加代码进行的，而不是修改现有代码。

也就是说软件开发人员一旦写出了可以运行的代码，就不应该去改动它，而是要保证它能一直运行下去，如何能够做到这一点呢?这就需要借助于抽象和多态，即把可能变化的内容抽象出来，从而使抽象的部分是相对稳定的，而具体的实现则是可以改变和扩展的

• 里氏替换：

核心思想：在任何父类出现的地方都可以用它的子类来替代。

其实就是说：同一个继承体系中的对象应该有共同的行为特征。

• 依赖注入：

核心思想：要依赖于抽象，不要依赖于具体实现。

其实就是说：在应用程序中，所有的类如果使用或依赖于其他的类，则应该依赖这些其他类的抽象类，而不是这些其他类的具体类。为了实现这一原则，就要求我们在编程的时候针对抽象类或者接口编程，而不是针对具体实现编程。

• 接口分离：

核心思想：不应该强迫程序依赖它们不需要使用的方法。

其实就是说：一个接口不需要提供太多的行为，一个接口应该只提供一种对外的功能，不应该把所有的操作都封装到一个接口中。

• 迪米特：

核心思想：一个对象应当对其他对象尽可能少的了解

其实就是说：降低各个对象之间的耦合，提高系统的可维护性。在模块之间应该只通过接口编程，而不理会模块的内部工作原理，它可以使各个模块耦合度降到最低，促进软件的复用

2.2     设计模式概述和分类

A:经验的总结

B:三类

创建型

结构型

行为型

改进的设计模式

A:简单工厂模式

简单工厂模式概述

又叫静态工厂方法模式，它定义一个具体的工厂类负责创建一些类的实例

优点

客户端不需要在负责对象的创建，从而明确了各个类的职责

缺点

这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期的维护

B:工厂方法模式

工厂方法模式概述

工厂方法模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继承抽象工厂的具体类实现。

优点

客户端不需要在负责对象的创建，从而明确了各个类的职责，如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性

缺点

需要额外的编写代码，增加了工作量

C:单例模式

单例设计思想

保证类在内存中只有一个对象

如何实现类在内存中只有一个对象呢?

构造私有

本身提供一个对象

通过公共的方法让外界访问

单例设计模式分类

l  饿汉式(开发)

l  懒汉式(面试)

线程安全问题

懒加载思想(延迟加载)

单例模式应用类：Runtime类

D：装饰者设计模式

装饰设计模式概述

装饰模式就是使用被装饰类的一个子类的实例，在客户端将这个子类的实例交给装饰类。是继承的替代方案

优点

使用装饰模式，可以提供比继承更灵活的扩展对象的功能，它可以动态的添加对象的功能，并且可以随意的组合这些功能

缺点

正因为可以随意组合，所以就可能出现一些不合理的逻辑

3.     面试题

3.1     多线程有几种实现方案，分别是哪几种?

参照1.2

3.2     同步有几种方式，分别是什么?

参考1.7

3.3     启动一个线程是run()还是start()?它们的区别?

参考1.2.1

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

1、这两个方法来自不同的类分别是Thread和Object

2、最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。

3、wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在

任何地方使用（使用范围）

4、sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常

3.5     为什么wait(),notify(),notifyAll()等方法都定义在Object类中

1，这些方法存在与同步中。

2，使用这些方法时必须要标识所属的同步的锁。

3，锁可以是任意对象，所以任意对象调用的方法一定定义Object类中。

3.6     线程的生命周期图

参考1.5

java基础系列：

java基础（一）java语法

java基础（二）面向对象

java基础（三）继承/多态/接口

java基础（四）常用类/算法

java基础（五）集合/IO流/异常

java基础（六）多线程/设计模式

java基础（七）网络编程/反射/动态代理