1、概述
（1）进程：正在进行中的程序（直译）
程序在内存空间中开辟空间。
（2）线程：就是进程中的一个负责程序执行的控制单元（执行路径）
一个进程中可以有多个执行路径，多线程。
一个进程当中至少要有一个线程。
开启多个线程，是为了同时运行多部分代码
每一个线程都有自己运行的内容。这个内容可以成为线程要执行的任务。
2、利弊：
多线程的好处：解决了多部分程序的同时进行
多线程的弊端：线程太多会导致效率的降低。
其实应用程序的执行都是cpu在做着快速的切换完成的。这个切换是随机的。
3、JVM启动时就启动了多个线程，至少有两个线程可以分析的出来
a、执行main函数的线程；
该线程的任务代码都定义在main函数中。主线程的名称就是main
b、负责垃圾回收的线程。
4、线程的状态
线程的状态（四种）：运行，临时阻塞状态，冻结，消亡。
start()开启线程（被创建-->运行）
sleep()、wait()使运行的线程冻结
notify()使冻结的线程运行
stop()使运行的线程结束
CPU的执行资格：代表的是可以被CPU处理，在处理队列中排队
CPU的执行权：代表正在被CPU处理。
运行着的线程具备执行资格并具备着执行权
冻结后的线程释放执行权，同时释放执行资格。
临时阻塞状态，具备着执行资格，但是不具备执行权，正在等待执行权。
开启线程必须有任务。
5、创建线程的目的：是为了开启一条执行路径，去运行指定的代码和其他实现同时运行。而运行的指定代码就是这个执行路径的任务。
jvm创建的主线程的任务都定义在了主函数中， 而自定义的线程它的任务在哪儿呢？
Thread类用于描述线程，线程是需要任务的，所以Thread类也有对任务的描述。
这个任务就通过Thread类中的run方法来体现。也就是说，run方法就是封装自定义线程运行任务的函数，run方法中定义就是线程要运行的任务代码。
开启线程是为了运行指定的代码，继承Thread类，并复写run方法，将运行的代码定义在run方法中即可。
6、如何创建一个线程呢？
（1）创建线程方式一：继承thread类
步骤：
a、定义一个类继承Thread类
b、覆盖Thread类中的run方法。
c、直接创建Thread的子类对象创建线程
d、调用start方法开启线程并调用线程的任务run方法执行
可以通过Thread的getName获取线程的名称 Thread-编号（从0开始）
（2）创建线程的第二种方式：实现Runnable接口；
如果类已经继承了，不能再继承Thread类，那就采用接口实现。可以实现Runnable接口。
Runnable接口里只有run方法，调用run方法，子类中run方法覆盖接口中的run方法；
步骤：
a、定义类实现Runnable接口;
b、覆盖接口中的run方法，将线程的任务代码封装到run方法中;
c、通过Thread类创建线程对象，并将Runnable接口的子类对象作为Thread类的构造函数的参数进行传递。
为什么？因为线程的任务都封装在Runnable接口子类对象的run方法中,所以要在线程对象创建时就必须明确要运行的任务。
d、调用线程对象的start方法开启线程（一个线程不能开启两次，否则会抛出无效线程状态异常 ）。
思考：为什么要给Thread类的构造函数传递Runnable的子类对象？
因为线程的任务都封装在Runnable接口子类对象的run方法中,所以要在线程对象创建时就必须明确要运行的任务
*实现Runable接口的好处：
**将线程的任务从线程的子类中分离出来，进行了单独的封装，按照面向对象的思想将任务封装成对象。
**避免了java单继承的局限性。所以，创建线程的第二种方式较常用。
Runnable的出现，仅仅是将线程的任务进行了对象的封装。
7、线程的安全问题产生的原因：
（1）多个线程访问出现延迟
（2）线程的随机性。
a、多个线程在操作共享的数据
b、操作共享数据的线程代码有多条。
当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算，就会导致线程安全问题的产生.
线程安全问题在理想状态下，不容易出现，但一旦出现，对软件的影响是非常大的。
（3）多线程的使用会出现因CPU切换造成的执行错误，采用同步来解决。
8、同步代码块：
（1）解决思路：就是将多条操作共享数据的线程代码封装起来，当有线程在执行这些代码的时候，其他线程不可以参与运算的，必须要当前线程把这些代码都执行完毕后，其他线程才可以参与运算；
在java中，用同步代码块就可用解决这个问题
同步代码块的格式：
synchronized（对象）{
需要被同步的代码；
}
对象是使所谓的锁。
同步可以解决安全问题的根本原因就在那个对象上。该对象如同锁的功能。
经典例子：火车上的卫生间，有人进去就锁住，出来才解锁。
（2）同步的好处：解决了线程的安全问题。
（3）同步的弊端：相对降低了效率，因为同步外的线程都会判断同步锁。
（4）同步的前提：同步中必须有多个线程并使用同一个锁。
同步前提的作用：当加同步后还是没能解决问题得反思，多个线程是否在同一个锁里。
（5）同步的表现形式：
a、同步代码块
b、同步函数。
在函数上加上synchronized修饰符即为同步函数。
同步函数使用的锁是this
c、同步函数和同步代码块的区别：
同步函数的锁是固定的this
同步代码块的锁是任意的对象。
建议使用同步代码块。
*静态的同步函数
静态的同步函数使用的锁是该函数所属字节码文件对象，可以采用getClass方法获取，也可以用当前类名.class表示。
9、线程间通信：
（1）多个线程在处理同一资源，但是任务却不同。
例子：送煤拉煤的故事。
（2）等待/唤醒机制：
涉及的方法：
wait();让线程处于冻结状态，被wait的线程会被存储到线程池中。
notify();唤醒线程池中的一个线程（任意）。
notifyAll();唤醒线程池中所有线程。
这些方法都必须定义在同步中，因为这些方法是用于操作线程状态的方法。必须要明确到底操作的是哪个锁上的线程。
(3)为什么操作线程的方法wait notify notifyAll定义在了Object类中？
因为这些方法是监控器的方法，监视器其实就是锁。
锁可以是任意的对象，任意的对象调用的方式一定定义在Object里。
(4)经典案例： 多生产者多消费者的问题。
if判断标记，只有一次，会导致不该运行的线程运行了，出现了数据错误的情况
while判断标记，解决了线程获取执行权后是否要运行！
notify只能唤醒一个线程，如果本方唤醒了本方，没有意义，而且while判断标记+notify会导致死锁。
notifyAll保证了本方线程一定能够唤醒对方线程。（弊端）但也同时唤醒了本方，降低了效率。
代码示例：
class Resource {
private String name;
private int count = 1;
private boolean flag = false;
public synchronized void set(String name) {
while (flag) {
try {
this.wait();
} catch (InterruptedException e) {
}
}
this.name = name + count;
count++;
System.out.println(Thread.currentThread().getName() + "...生产者..."
+ this.name);
flag = true;
notifyAll();
}
public synchronized void out() {
while (!flag) {
try {
this.wait();
} catch (InterruptedException e) {
}
}
System.out.println(Thread.currentThread().getName() + "...消费者..."
+ this.name);
flag = false;
notifyAll();
}
}
class Producer implements Runnable {
private Resource r;
public Producer(Resource r) {
this.r = r;
}
@Override
public void run() {
while (true) {
r.set("烤鸭");
}
}
}
class Consumer implements Runnable {
private Resource r;
public Consumer(Resource r) {
this.r = r;
}
@Override
public void run() {
while (true) {
r.out();
}
}
}
public class ProducerConsumerDemo {
public static void main(String[] args) {
Resource r = new Resource();
Producer pro = new Producer(r);
Consumer con = new Consumer(r);
Thread t0 = new Thread(pro);
Thread t1 = new Thread(pro);
Thread t2 = new Thread(con);
Thread t3 = new Thread(con);
t0.start();
t1.start();
t2.start();
t3.start();
}
}
同步代码块对于锁的操作是隐式的。
jdk1.5以后将同步和锁封装成了对象。并将操作锁的隐式方式定义到了对象中，将隐式动作变成了显式动作。
（5）Lock接口：它的出现替代了同步代码块或者同步函数，将同步的隐式锁操作变成了显式锁操作，同时更为灵活，
可以一个锁上加多组监视器。
lock()：获取锁
unlock()：释放锁，通常需要定义在finally代码块中。
（6）Condition接口：出现替代了Object中的wait notify notifyAll方法。
将这些监视器方法单独进行了封装，变成Condition监视器
（7）wait()和sleep()区别：
a、wait可以指定时间也可以不指定时间
sleep必须指定时间
b、在同步中时，对CPU的执行权和锁的处理不同。
wait：释放执行权，释放锁。
sheep：释放执行权，不释放锁。
(8)停止线程方式：
a、stop方法（已过时），不使用；
b、run方法结束。
*怎么控制线程的任务结束呢？
任务中都会有循环结构，只要控制住循环，就可以结束任务。控制循环通常就用定义标记来完成。
*如果线程处于了冻结状态，就无法读取标记，如何结束呢？
可以使用interrupt()方法将线程从冻结状态强制恢复到运行状态中来，让线程具备cpu的执行资格，但是强制动作会发生interrupttedException，记得要处理。
多线程下的单例设计模式
class Single{
private static Single s = null;
private Single(){}
public static Single getInstance(){
if(s==null){//加双重判断是为了解决效率问题
synchronized(Single.class){//加同步是为了解决多线程安全问题
if(s==null){
s = new Single();
}
}
}
return s;
}
}