1.线程与进程
进程
是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间
线程
1、是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少有一个线程
2、线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程
何时需要多线程
1、程序需要同时执行两个或多个任务。
2、程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。
3、需要一些后台运行的程序时。
2.线程调度
分时调度
所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
抢占式调度：高优先级的线程抢占CPU
1、优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。
2、CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是 在同一时刻运行。 其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。
线程的优先级
MAX_PRIORITY（10）;
MIN _PRIORITY （1）;
NORM_PRIORITY （5）;
涉及的方法：
getPriority() ：返回线程优先值
setPriority(int newPriority) ：改变线程的优先级
线程创建时继承父线程的优先级
3.同步与异步
同步:排队执行 , 效率低但是安全.
异步:同时执行 , 效率高但是数据不安全
4.并发与并行
并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）。
5.创建线程的三种方式
一： 继承Thread类
1)定义子类继承Thread类。
2)子类中重写Thread类中的run方法。
3)创建Thread子类对象，即创建了线程对象。
4)调用线程对象start方法：启动线程，调用run方法
二 ：实现Runnable接口
1）定义子类，实现Runnable接口。
2）子类中重写Runnable接口中的run方法。
3）通过Thread类含参构造器创建线程对象。
4）将Runnable接口的子类对象作为实际参数传递给Thread类的构造方法中。
5）调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。
三：Callable使用
编写类实现Callable接口 , 实现call方法
class XXX implements Callable {
@Override
public call() throws Exception {
return T;
}
}创建FutureTask对象 , 并传入第一步编写的Callable类对象
FutureTask future = new FutureTask<>(callable);通过Thread,启动线程
new Thread(future).start();
实现Runnable与继承Thread相比有如下优势
1.通过创建任务，然后给线程分配任务的方式实现多线程，更适合多个线程同时执行任务的情况
2，可以避免单继承所带来的局限性
3，任务与线程是分离的，提高了程序的健壮性
4，后期学习的线程池技术，接受Runnable类型的任务，不接受Thread类型的线程
线程的生命周期
新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件
运行：当就绪的线程被调度并获得处理器资源时,便进入运行状态， run()方法定义了线程的操作和功能
阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
死亡：线程完成了它的全部工作或线程被提前强制性地中止
6.多线程的安全问题解决方式
同步代码块
1）synchronized (对象){
// 需要被同步的代码；
}
2）synchronized还可以放在方法声明中，表示整个方法
为同步方法。
例如：
public synchronized void show (String name){
….
}
同步锁(Lock)
简介：Lock是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。在实现线程安全的控制中，比较常用的是ReentrantLock(可重入锁)，可以显式加锁、释放锁。
class A {
private final ReentrantLock lock = new ReenTrantLock();
public void m() {
lock.lock();
try {
// 保证线程安全的代码;
} finally {
lock.unlock();
}
}
}
小结：释放锁的操作
1、当前线程的同步方法、同步代码块执行结束
2、当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。
3、当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束
4、当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。
7、线程的死锁
死锁
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
解决方法
1、专门的算法、原则
2、尽量减少同步资源的定义
8、线程的通信
wait() 与 notify() 和 notifyAll()
1、wait()：令当前线程挂起并放弃CPU、同步资源，使别的线程可访问并修改共享资源，而当前线程排队等候再次对资源的访问
2、notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待
3、notifyAll ()：唤醒正在排队等待资源的所有线程结束等待.
注意：Java.lang.Object提供的这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报java.lang.IllegalMonitorStateException异常
wait() 方法
1、在当前线程中调用方法： 对象名.wait()
2、使当前线程进入等待（某对象）状态 ，直到另一线程对该对象发出 notify (或notifyAll) 为止。
3、调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）
4、调用此方法后，当前线程将释放对象监控权 ，然后进入等待
5、在当前线程被notify后，要重新获得监控权，然后从断点处继续代码的执行。
notify()/notifyAll()
1、在当前线程中调用方法： 对象名.notify()
2、功能：唤醒等待该对象监控权的一个线程。
3、调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）
线程通信例子
/**
* 多线程通信问题, 生产者与消费者问题
* @param args
*/
public static void main(String[] args) {
Food f = new Food();
new Cook(f).start();
new Waiter(f).start();
}
//厨师
static class Cook extends Thread{
private Food f;
public Cook(Food f) {
this.f = f;
}
@Override
public void run() {
for(int i=0;i<100;i++){
if(i%2==0){
f.setNameAndSaste("老干妈小米粥","香辣味");
}else{
f.setNameAndSaste("煎饼果子","甜辣味");
}
}
}
}
//服务生
static class Waiter extends Thread{
private Food f;
public Waiter(Food f) {
this.f = f;
}
@Override
public void run() {
for(int i=0;i<100;i++){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
f.get();
}
}
}
//食物
static class Food{
private String name;
private String taste;
//true 表示可以生产
private boolean flag = true;
public synchronized void setNameAndSaste(String name,String taste){
if(flag) {
this.name = name;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.taste = taste;
flag = false;
this.notifyAll();
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public synchronized void get(){
if(!flag) {
System.out.println("服务员端走的菜的名称是:" + name + ",味道:" + taste);
flag = true;
this.notifyAll();
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
结果
9、线程池
系统启动一个新线程的成本是比较高的，因为它涉及与os交互。这种情况下，系统启动时即创建大量空闲的线程，就可以很好地提高性能，尤其是当程序需要创建大量生存期很短暂的线程时。
除此之外，使用线程池可以有效地控制系统中并发线程的数量。避免因并发创建的线程过多，导致系统性能下降，JVM崩溃。
Java 5以前，需要手动创建自己的线程池；Java 5开始，新增了Executors工厂类产生线程池。
使用线程池执行线程任务的步骤如下：
1.调用Executors 类的静态方法newFixedThreadPool(int nThreads)，创建一个可重用的、具有固定线程数的线程池ExecutorService对象
2.创建Runnable实例，作为线程执行任务
3.调用ExecutorService对象的submit()提交Runnable实例
4.调用ExecutorService对象的shutDown()方法关闭线程池。
Runnable 与 Callable
接口定义
//Callable接口
public interface Callable {
V call() throws Exception;
}
//Runnable接口
public interface Runnable {
public abstract void run();
}
Runnable 与 Callable的相同点
都是接口
都可以编写多线程程序
都采用Thread.start()启动线程
Runnable 与 Callable的不同点
Runnable没有返回值；Callable可以返回执行结果
Callable接口的call()允许抛出异常；Runnable的run()不能抛出
Callable获取返回值
Callalble接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。
