1.基本概念
1.1程序、进程、线程的区分：
程序（program)
本质是一段静态的代码、静态对象。
进程（process)
程序的一次执行过程，或正在运行的一个程序，是动态的过程。
进程是资源分配的单位，系统在运行时会为每个分配不同的内存区域。
线程(thread)
线程是调度和执行的单位，每个线程拥有独立的运行栈和程序计数器（PC）。
一个进程中的多个线程共享相同的内存单元/内存地址空间。
一个进程中的线程可以访问相同的变量和对象。
注：Java的应用程序java.exe至少有三个线程：main主线程、gc垃圾回收线程、异常处理线程。
1.2并行与并发
并行：多个CPU同时执行多个任务
并发：一个CPU（分割时间片）同时执行多个任务
2.线程的创建与启动
2.1Thread类(java.lang.Thread)
构造器：
Thread():创建Thread对象
Thread(String threadname):创建进程并指定进程名称
Thread(Runable target):创建指定目标对象的进程，它实现了Runnable接口的run方法
Thrad(Runnable target,String name):创建指定对象的进程并指定名称
属性
static int MAX _PRIORITY 属性值：10 最大优先级
static int MIN _PRIORITY 属性值：1 最小优先级
static int NORM _PRIORITY 属性值：5 普通优先级
方法名
static Thread currentThread():返回当前线程
static void yield():线程让步，让步给优先级更高的线程
static void sleep(long mills):线程等待，但会抛出InterruptedException异常
void stop():已过时，强制停止当前线程
void run()：需被子类重写的方法
void start()：启动并调用run()方法
void join():在线程A中调用线程B的join(),则会阻塞线程A直到线程B执行完成
boolean isAlive():判断线程是否还在
boolean islnterruopted():判断线程是否被中断
int getPriority():返回线程优先级
viod setPriority(int priority):设置线程优先级
String getName():返回线程名称
void setName(String name):设置名称
2.3线程分类
Java中的线程分为用户线程和守护线程。main线程就是用户线程，gc线程就是守护线程，
守护线程会依赖用户线程而存在，当用户线程执行完毕时，守护线程也会停止执行。
用户线程可以通过setDaemon(true)来设置为守护线程，当JVM中都是守护线程时，当前JVM将退出。
2.4创建线程的方式
线程创建方式一共有4种，后两种在JDK5.0之后新增。
2.4.1继承Thread类(java.lang.Thread)
定义子类继承Thread类
子类中重写Thread类的run方法
创建线程对象，调用对象的start方法来启动线程(执行run方法）
注：
若手动调用run方法，则只是普通方法，而不是多线程模式
实际中的方法由JVM调用
一个线程对象只能调用一次start方法，若重复调用会抛出异常“Iegal Thread State Exception”
2.4.2实现Runnable接口(java.lang.runnable)
问:为什么要实现Runnable接口？
-Java不支持多继承；-不打算重写Thread类的其它方法。
定义类实现Runnable接口
1 package com.imooc.runnable;
2 class PrintRunnable implements Runnable{
3 /*
4 * (non-Javadoc)
5 * @see java.lang.Runnable#run()
6 * 核心操作
7 * 1.定义一类A去实现Runnable接口
8 * 2.实现Runnable中的run方法
9 * 3.Runnable无法直接用getName()方法
10 * 需要调用Thread的一个静态方法为Thread currentThread()表示当前线程，进而调用gatName()方法
11 * Thread.currentThread().getName();
12 * 4.在主方法，先去定义类A的对象B，类A不能直接调用start()方法，启动线程只能是Thread和它的子类
13 *所以先创建Thread对象C，用B作为参数 Thread t1 = new Thread(pr);
14 */
15 @Override
16 public void run() {
17 int i=1;
18 while(i <= 10)
19 System.out.println(Thread.currentThread().getName()+"正在运行！"+(i++));
20
21 }
22
23 }
24 public class Test {
25
26 public static void main(String[] args) {
27 PrintRunnable pr = new PrintRunnable();
28 Thread t1 = new Thread(pr);
29 t1.start();
30 PrintRunnable pr1 = new PrintRunnable();
31 Thread t2 = new Thread(pr1);
32 t2.start();
33 }
34
35 }
实现类需要重写Runnable接口的run方法
将实现类的对象作为参数传递给Thread类的构造器创建线程对象。
调用线程对象的start方法（启动线程、调用当前线程的run方法）
2.4.3实现Callable接口（java.util.concurrent.Callable)
Callable接口
Callable接口相比Runnable接口，功能更加强大。实现Callable接口的类需要重写call()方法。
call()方法支持泛型的返回值，可以抛出异常，同时可以借助Future Task来获取返回结果。
Future接口(java.util.concurrent.Future)
可以对具体的Runnable,Callable任务的执行结果进行取消、查询是否完成、获取结果等操作
FutureTask类是Future接口的唯一实现类。
FutureTask类是Future接口唯一实现类。
FutureTask类同时实现了Runnable接口和Future接口。它可以作为Runnable被线程执行，也可以作为Future得到Callable.call()的返回值。
2.4.4使用线程池
背景
经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
思路
提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建
销毁、实现重复利用。类似生活中的公共交通工具。
好处
提高重复利用。类似生活中的公共交通工具。
降低资源消耗（重复利用线程池中线程，不需要每次都创建）
便于线程管理
ExecutorService:线程池接口，常用实现类ThreadPoolExecutor可用于设置线程池属性
方法
void exeute(Runnable command):执行任务或命令，一般用来执行Runnable
Future submit(callable task):执行任务，一般用来执行Callable
void shutdown():关闭线程池
Executors:工具类、线程池的工厂类，应用于创建并返回不同类型的线程
方法
static ExecutorService newCachedThreadPool():创建一个可根据需要新线程的线程池
static ExecutorService newFixedThreadPool(n):创建一个可重用固定线程数的线程池
static ExecutorService newSingleThreadExecutor():创建一个只有一个线程的线程池
static ScheduledExecutorService newScheduledThreadPool(n):创建一个线程池，可安排在给定延迟后运行或定期执行
2.4.5各线程创建方式的比较
继承Thread类VS实现Runnadle接口
在开发中更推荐使用实现Runnable接口的方式。这样可以避免类单继承性的限制，同时更适合处理多线程间的数据共享
Thread类其实也是实现了Runnable接口的
3.线程的生命周期
JDK中用Thread.State类定义线程的几种状态
新建
就绪
运行
阻塞
死亡
4.线程同步
4.1出现原因
多线程执行时用于共享数据时，会造成操作的不完整而破坏数据，实例见TestThreadBug..java。
1 class TestThreaBug {
2 public static void main(String [] args) {
3 Ticket ticket = new Ticket();
4
5 //3个线程同时售票
6 Thread t1 = new Thead(ticket,"t1窗口“）;
7 Thread t2 = new Thead(ticket,"t2窗口”）；
8 Thread t3 = new Thead(ticket,"t3窗口");
9
10 t1.start();
11 t2.start();
12 t3.start();
13 }
14 }
15
16 class Ticket implements Ruunable {
17 private int tick = 20;
18
19 @Override
20 public void run() {
21 while(true) {
22 if(true > 0) {
23 System.out.println(Thred.currentThread().getName() + "售出车票，剩余车票”
24 }else
25 break;
26 }
27 }
28 }
4.2解决方法：同步机制（synchronized)
4.2.1同步代码块
局限性：操作同步代码时，只能有一个线程参与，其他线程等待，相当于是一个单线程的过程，效率低。
synchronized(同步监视器){
//需要被同步的代码，即操作共享数据的代码
}
同步监视器，也成为锁。可以是任何类的对象，但多个线程必须使用相同的锁。
线程间通信产生的问题
wait()方法：中断方法的执行，使线程等待 notify()方法：唤醒处于等待的某一个线程，使其结束等待 notifyAll()方法：唤醒所有处于等待的线程，使它们结束等待
1 package com.imooc.queue;
2
3 public class Queue {
4 private int n;
5 boolean flag = false;
6 public synchronized int get() {
7 if(!flag) {
8 try {
9 wait();
10 } catch (InterruptedException e) {
11 // TODO Auto-generated catch block
12 e.printStackTrace();
13 }
14 }
15 System.out.println("消费："+n);
16 flag = false;//消费完毕，容器中没有数据。
17 notifyAll();
18 return n;
19 }
20
21 public synchronized void set(int n) {
22 if(flag) {
23 try {
24 wait();
25 } catch (InterruptedException e) {
26 // TODO Auto-generated catch block
27 e.printStackTrace();
28 }
29 }
30 System.out.println("生产："+n);
31 this.n = n;
32 flag = true;//生产完毕，容器中没有数据。
33 notifyAll();
34 }
35
36
37 }
1 package com.imooc.queue;
2
3 public class Producer implements Runnable {
4 Queue queue;
5 Producer(Queue queue){
6 this.queue = queue;
7 }
8 @Override
9 public void run() {
10 int i = 0;
11 while(true) {
12 queue.set(i++);
13 try {
14 Thread.sleep(1000);
15 } catch (InterruptedException e) {
16 e.printStackTrace();
17 }
18 }
19 }
20
21 }
1 package com.imooc.queue;
2
3 public class Consumer implements Runnable {
4 Queue queue;
5 Consumer(Queue queue){
6 this.queue = queue;
7 }
8
9 @Override
10 public void run() {
11 while (true) {
12 queue.get();
13 try {
14 Thread.sleep(1000);
15 } catch (InterruptedException e) {
16 // TODO Auto-generated catch block
17 e.printStackTrace();
18 }
19 }
20 }
21
22
23 }
1 package com.imooc.queue;
2
3 public class Test {
4
5 public static void main(String[] args) {
6 Queue queue = new Queue();
7 new Thread(new Producer(queue)).start();
8 new Thread(new Consumer(queue)).start();
9
10 }
11
12 }
1、notifyAll方法是唤醒所有线程，本线程不可能把自己唤醒，如果能执行到唤醒这一步就证明自己实在运行的状态。 2、notify()方法是随机唤醒一个线程，notifyAll()方法是唤醒所有线程，因为线程的随机性，一般用notifyAll() 3、此案例可以理解为必须生产者生产，然后消费者才能消费 可以通过一个中间布尔值变量来进行控制， 当flag=true时,说明生产者已经生产完毕，无需进行生产者方法，执行wait()方法，使线程等待， 当flag=false时,说明消费者已经消费完毕，无需进行消费者方法，执行wait()方法，使线程等待， 注：在执行消费者方法时，消费者消费完毕，此时消费者线程正处于运行状态，生产者线程处于等待阻塞状态，需要执行notifyAll方法来将生产者的线程唤醒，反之亦然。