1、并发和并行是即相似又有区别：
并发：指两个或多个事件在同一时间段内发生。
并行：指两个或多个事件在同一时刻点发生。
在操作系统中，在多道程序环境下，并发性是指在一段时间内宏观上有多个程序在同时运行，但在单CPU系统中，每一时刻却仅能有一道程序执行（时间片即CPU分配给各个程序的时间），故微观上这些程序只能是分时地交替执行。
若计算机系统中有多个CPU，则这些可以并发执行的程序便可被分配到多个处理器上，实现多任务并行执行，即利用每个处理器来处理一个可并发执行的程序，这样，多个程序便可以同时执行，因为是微观的，所以大家在使用电脑的时候感觉就是多个程序是同时执行的。
“多核处理器”电脑可以同时并行地处理多个程序，从而提高了电脑的运行效率。
单核处理器的计算机肯定是不能并行的处理多个任务的，只能是多个任务在单个CPU上并发运行。
同理，线程也是一样的，从宏观角度上理解线程是并行运行的，但是从微观角度上分析却是串行运行的，即一个线程一个线程的去运行，当系统只有一个CPU时，线程会以某种顺序执行多个线程，我们把这种情况称之为线程调度。
2、进程与线程
进程：是指一个内存中运行中的应用程序。每个进程都有自己独立的一块内存空间，一个应用程序可以同时启动多个进程。比如在Windows系统中，一个运行的xxx.exe就是一个进程。
线程：是指进程中的一个执行任务(控制单元)，一个进程可以同时并发运行多个线程；线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。
一个进程至少有一个线程，为了提高效率，可以在一个进程中开启多个执行任务,即多线程。如：多线程下载软件。
多进程：操作系统中同时运行的多个程序。
多线程：在同一个进程中同时运行的多个执行任务。
我们查看Windows环境下的任务管理器：
在操作系统中允许多个任务，每一个任务就是一个进程，每一个进程也可以同时执行多个任务，每一个任务就是线程。
3、进程与线程的区别：
线程是进程的子集，一个进程可以有很多线程，每条线程并行执行不同的任务。不同的进程使用不同的内存空间，而所有的线程共享一片相同的内存空间。
进程：有独立的内存空间，进程中的数据存放空间（堆空间和栈空间）是独立的，至少有一个线程。
线程：堆空间是共享的，栈空间是独立的，线程消耗的资源也比进程小，相互之间可以影响的，又称为轻型进程或进程元。
因为一个进程中的多个线程是并发运行的，那么从微观角度上考虑也是有先后顺序的，那么哪个线程执行完全取决于CPU调度器，程序员是控制不了的。
我们可以把多线程并发性看作是多个线程在瞬间抢CPU资源，谁抢到资源谁就运行，这也造就了多线程的随机性。
Java程序的进程里至少包含主线程和垃圾回收线程(后台线程)。
4、多线程并发
计算机通常只有一个CPU时，在任意时刻只能执行一条计算机指令，每一个线程只有获得CPU的使用权才能执行指令。
所谓多线程并发运行，从宏观上看，其实是各个线程轮流获得CPU的使用权，分别执行各自的任务。
那么在可运行池中，会有多个线程处于就绪状态等到CPU调度，JAVA中JVM就负责了线程的调度。
JVM采用的是抢占式调度，没有采用分时调度，因此可以能造成多线程执行结果的随机性。
多线程作为一种多任务、并发的工作方式，当然有其存在优势：
1）进程之前不能共享内存，而线程之间共享内存(堆内存)则很简单。
2）系统创建进程时需要为该进程重新分配系统资源，创建线程则代价小很多，因此实现多任务并发时，多线程效率更高.
3）Java语言本身内置多线程功能的支持，而不是单纯的作为底层系统的调度方式，从而简化了多线程编程.
比如：多线程下载：
可以理解为一个线程就是一个文件的下载通道，多线程也就是同时开起好几个下载通道。当服务器提供下载服务时，使用下载者是共享带宽的，在优先级相同的情况下，总服务器会对总下载线程进行平均分配。
不难理解，如果你线程多的话，那下载的越快。现流行的下载软件都支持多线程。
多线程是为了同步完成多项任务，不是为了提供程序运行效率，而是通过提高资源使用效率来提高系统的效率。
宽带带宽知识点:
宽带带宽是以位（bit）计算，而下载速度是以字节（Byte）计算，1字节（Byte）等于8位（bit），所以1024kb/s是代表上网带宽为1024千位（1M），而下载速度需要1024千位/秒（1024kb/s）带宽除以8，得出128千字节/秒（128KB/s）。
二、线程的创建与启动1、继承 Thread 类：
1）自定义类继承于 Thread 类，那么该自定义类就是线程类；
2）其覆写 run方法，将线程运行的代码存放在 run方法中；
3）创建自定义类的对象，即线程对象；
4）调用线程对象的 start方法，启动线程。
public class HelloWorld {
public static void main(String[] args) {
for (int i = 1; i hashCodeB){
synchronized (fromAccount) {
System.out.println(Thread.currentThread().getName() + "得到锁" + fromAccount.getName());
synchronized (toAccount) {
transferMoneyHandle(fromAccount, toAccount, money);
}
}
}else if(hashCodeA < hashCodeB){
synchronized (toAccount) {
System.out.println(Thread.currentThread().getName() + "得到锁" + fromAccount.getName());
synchronized (fromAccount) {
transferMoneyHandle(fromAccount, toAccount, money);
}
}
}else {
synchronized (otherLock){
synchronized (fromAccount) {
System.out.println(Thread.currentThread().getName() + "得到锁" + fromAccount.getName());
synchronized (toAccount) {
transferMoneyHandle(fromAccount, toAccount, money);
}
}
}
}
}
private void transferMoneyHandle(Account fromAccount, Account toAccount, double money){
System.out.println(Thread.currentThread().getName() + "得到锁" + toAccount.getName());
if(fromAccount.getMoney() < money) {
System.out.println("余额不足");
} else {
// 进行转账
fromAccount.setMoney(fromAccount.getMoney()-money);
toAccount.setMoney(toAccount.getMoney() + money);
System.out.println("转账后：" + fromAccount.getName() + "有：" + fromAccount.getMoney());
System.out.println("转账后：" + toAccount.getName() + "有：" + toAccount.getMoney());
}
}
}
class Account{
private String name;
private double money;
public Account(String name, double money) {
this.name = name;
this.money = money;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
} 
2、开放调用（针对对象之间协作造成的死锁）
对象之间协作造成的死锁：主要是在调用某个方法时就需要持有锁（即同步方法的使用），并在其方法内部也调用了其他对象带锁的方法，这样就隐式有两个锁，这种方式也很容易就造成死锁。
避免死锁的方法：尽量减小 synchronized 的作用域。使用同步代码块最好仅被用于保护那些涉及共享资源的操作。
3、使用定时锁 - tryLock()（针对永久等待）
ReentrantLock尝试获取锁有返回值tryLock()
tryLock() 方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。
tryLock(long time, TimeUnit unit)方法，在时间期限之内如果还拿不到锁，则返回false。否则返回true。
public class DeakLockTest3 {
public static void main(String[] args) {
final Lock lock = new ReentrantLock();
tryLockDemo tryLockDemo = new tryLockDemo(lock);
new Thread(tryLockDemo,"线程1").start();
new Thread(tryLockDemo,"线程2").start();
new Thread(tryLockDemo,"线程3").start();
}
}
class tryLockDemo implements Runnable{
Lock lock;
public tryLockDemo(Lock lock){
this.lock = lock;
}
@Override
public void run() {
if(lock.tryLock()){//尝试获取锁
try {
System.out.println(Thread.currentThread().getName() + "获取到锁，处理业务！");
} catch (Exception e) {
System.out.println(Thread.currentThread().getName() + "出错了！");
} finally {
// 释放锁
lock.unlock();
}
}else{
//获取不到锁
System.out.println(Thread.currentThread().getName() + "获取不到锁！");
}
}
} 
ends ~
