一、进程
1、什么是进程
通过任务管理器看到了进程的存在，只有运行的程序才会出现进程
进程：
- 就是正在运行的程序，进程是系统进行资源分配和调用的独立单位。
- 每一个进程都有它自己的内存空间和系统资源。
2、多进程有什么意义？
（1）单进程的计算机只能做一件事，而我们现在的计算机都可以做多件事情。
- 举例：一边玩游戏，一遍听音乐
- 现在的计算机都是支持多进程的，就可以在一个时间段内执行多个任务
- 提高CPU的使用率
二、线程
1、什么是线程
在同一个进程内又可以执行多个任务，而这每一个任务就可以看成是一个线程
- 线程是进程的执行单元（执行路径）。是程序使用cpu的基本单位
- 单线程：程序只有一条执行路径
- 多线程：程序有多条执行路径
2、多线程有什么意义
（1）提高程序的使用率。
- 程序的执行其实都是在抢CPU的资源，cpu的使用权。
- 多个进程是在抢这个资源，而其中的某一个进程如果执行路径比较多，就会有更高的几率抢到cpu的执行权
- 线程的执行有随机性
3、线程的生命周期
（1）新建：创建线程
（2）就绪：有执行资格，没有执行权
（3）运行：有执行资格，有执行权
- 阻塞：由于一些操作让线程处于了该状态。没有执行资格，没有执行权。而另一些操作却可以把它给激活后处于就绪状态
（4）死亡：线程对象变成垃圾，等待被回收
图解：
4、实现多线程的两种方式
（1）继承Thread类
- 自定义类MyThread类继承Thread类
- 在MyThread类中重写run()
- 创建MyThread类的对象
- 启动线程对象
package cn.itcast_01; public class MyThread extends Thread { public void run() { for (int i = 0; i < 100; i++) { System.out.println(getName() + ":" + i); } } }
package cn.itcast_01; public class ThreadDemo { public static void main(String[] args) { MyThread t1 = new MyThread(); MyThread t2 = new MyThread(); t1.setName("线程1"); t2.setName("线程2"); t1.start(); t2.start(); } }
问题：
- 为什么重写run（）方法？
run（）里面封装的是被线程执行的代码
- 启动线程对象用的是哪个方法？
start（）
- run（）和start（）方法的区别？
run直接调用仅仅是普通方法
start（）先启动线程，再由jvm调用run（）方法
（2）实现Runnable接口
- 自定义类MyRunnable实现Runnable接口
- 在MyRunnable里面重写run（）
- 创建MyRunnable类的对象
- 创建Thread类的对象，并把上一步骤的对象作为构造参数传递
package cn.itcast_02; public class MyRunnable implements Runnable { public void run() { for(int i = 0; i<100;i++){ System.out.println(Thread.currentThread().getName()+":"+i); } } }
package cn.itcast_02; public class MyRunnableDemo { public static void main(String[] args) { MyRunnable my = new MyRunnable(); Thread t1 = new Thread(my, "线程1"); Thread t2 = new Thread(my,"线程2"); t1.start(); t2.start(); } }
5、有了方式1，为什么还要方式2
实现接口的好处
- 可以避免由于Java单继承带来的局限性
- 可以适合多个相同程序的代码去处理同一个资源的情况，把线程同程序的代码，数据有效分离，较好的体现了面向对象的设计思想。
6、线程安全问题
（1）出现的原因
- 是否是多线程环境
- 是否有共享数据
- 是否有多条语句操作共享数据
（2）如何解决线程安全问题
- 同步代码块
synchronized(对象){
需要同步的代码； }
注意：同步可以解决安全问题的根本原因就在那个对象上，该对象如同锁的功能
多个线程同一把锁，锁对象是任意对象
- 同步方法
把同步加在方法上
锁对象：this
- 静态方法
把同步加载方法上
这里的锁对象是当前类的字节码文件对象
7、死锁问题
两个或者两个以上的线程在争夺资源的过程中，发生的一种相互等待的现象
package cn.itcast_02; public class DieLock extends Thread { private boolean flag; public DieLock(boolean flag) { this.flag = flag; } public void run() { if(flag){ synchronized (MyLock.objA){ System.out.println("if objA"); synchronized (MyLock.objB) { System.out.println("if objB"); } } }else{ synchronized (MyLock.objB){ System.out.println("else objB"); synchronized (MyLock.objA) { System.out.println("else objA"); } } } } }
package cn.itcast_02; public class DieLockDemo { public static void main(String[] args) { DieLock dl1 = new DieLock(true); DieLock dl2 = new DieLock(false); dl1.start(); dl2.start(); } }
（1）死锁产生的原因
- 系统资源的竞争：
通常系统中拥有的不可剥夺资源，其数量不足以满足多个进程运行的需要，使得进程在运行过程中，会因争夺资源而陷入僵局，如磁带机，打印机等。
只有对不可剥夺资源的竞争才可能产生死锁，对可剥夺资源的竞争是不会产生死锁的
- 进程推进顺序法
进程在运行过程中，请求和释放资源的顺序不当，也同样会导致死锁
信号量使用不当也会造成死锁。进程间相互等待对方发来的消息，结果也会使得这些进程间无法向前推进。
例如，进程A等待进程B发的消息，进程B又在等待进程A发的消息，可以看出进程A和进程B不是因为竞争同一资源，而是在等待对方的资源导致死锁
（2）产生死锁的四个必要条件：
- 互斥条件：一个资源每次只能被一个进程使用
- 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放
- 不剥夺条件：进程已获得的资源，在末使用完之前，不能强行剥夺
- 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系
（3）如何避免死锁
- 加锁顺序（线程按照一定的顺序加锁）
当多个需要相同的一些锁，但是按照不同的顺序加锁，死锁就很容易产生
如果能确保所有的线程都是按照相同的顺序获得锁，那么死锁就不会发生
- 加锁时限（线程尝试获取锁的时候加上一定的时限，并释放自己占有的锁）
若一个线程没有在给定的时限内成功获得所有需要的锁，则会进行回退并释放所有已经获得的锁，然后等待一段随机的时间再重试，这段随机的等待时间让其它线程有机会尝试获取相同的这些锁，并且让该应用在没有获得锁的时候可以继续运行（加锁超时后可以先继续运行干点其它事情，再回头来重复之前加锁的逻辑）
- 死锁检测
主要针对那些不可能实现按序加锁并且锁超时也不可行的场景
每当一个线程获得了锁，会在线程和锁相关的数据结构中（map、graph等等）将其记下。除此之外，每当有线程请求锁，也需要记录在这个数据结构中。
当一个线程请求锁失败时，这个线程可以遍历锁的关系图看看是否有死锁发生
做法：
释放所有锁，回退，并且等待一段随机的时间后重试。这个和简单的加锁超时类似，不一样的是只有死锁已经发生了才回退，而不会是因为加锁的请求超时了。虽然有回退和等待，但是如果有大量的线程竞争同一批锁，它们还是会重复地死锁 （编者注：原因同超时类似，不能从根本上减轻竞争）。
一个更好的方案是给这些线程设置优先级，让一个（或几个）线程回退，剩下的线程就像没发生死锁一样继续保持着它们需要的锁。如果赋予这些线程的优先级是固定不变的，同一批线程总是会拥有更高的优先级。为避免这个问题，可以在死锁发生的时候设置随机的优先级。
8、多线程状态转换图
常见的情况：
- 新建---就绪---运行---死亡
- 新建---就绪---运行---就绪---运行---死亡
- 新建---就绪---运行---其他阻塞---就绪---运行---死亡
- 新建---就绪---运行---同步阻塞---就绪---运行---死亡
- 新建---就绪---运行---等待阻塞---同步阻塞---就绪---运行---死亡
9、线程池
程序启动一个新线程成本是比较高的
使用线程池可以很好的提高性能
线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用
方法一：
public class MyRunnable implements Runnable { @Override public void run() { for(int i = 0; i< 100; i++) System.out.println(Thread.currentThread().getName()+":"+i); } }
/* * 线程池的好处： * 如何实现线程的代码？ * A:创建一个线程池对象，控制要创建几个线程对象 * public static ExecutorService newFixedThreadPool(int nThreads) * B:这种线程池的线程可以执行 * 可执行Runnable对象或者Callable对象代表的线程 * 做一个类实现Runnable接口 * C:调用如下方法 * Future<?> submit(Runnable task) * <T> Future<T> submit(Callable<T> task) * */ import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class ExecutorsDemo { public static void main(String[] args) { //创建一个线程池对象，控制要创建几个线程对象 ExecutorService pool = Executors.newFixedThreadPool(2); //可以执行Runnable对象或者CAllable对象表示的线程 pool.submit(new MyRunnable()); pool.submit(new MyRunnable()); //结束线程池 pool.shutdown(); } }
方法二：
import java.util.concurrent.Callable; public class MyCallable implements Callable<Integer> { private int number; public MyCallable(int number) { this.number = number; } public Integer call() throws Exception { int sum = 0; for (int x = 1; x <= number; x++) sum += x; return sum; } }
import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; public class CallableDemo { public static void main(String[] args) throws InterruptedException, ExecutionException { ExecutorService pool = Executors.newFixedThreadPool(2); Future<Integer> f1 = pool.submit(new MyCallable(100)); Future<Integer> f2 = pool.submit(new MyCallable(200)); System.out.println(f1.get()); System.out.println(f2.get()); pool.shutdown(); } }