一，线程的状态
1.1 线程状态概述
当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，
有几种状态呢？在API中 java.lang.Thread.State 这个枚举中给出了六种线程状态：
| 线程状态 | 导致状态发生条件 |
|---|---|
| NEW(新建) | 线程刚被创建，但是并未启动。还没调用start方法。 |
| Runnable(可运行) | 线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器。 |
| Blocked(锁阻塞) | 当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。 |
| Waiting(无限等待) | 一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。 |
| Timed Waiting(计时等待) | 同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、Object.wait。 |
| Teminated(被终止) | 因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。 |
1.2 Runnable（运行状态）
Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得CPU时间片后变为运行中状态（running）。
1.3 BLOCKED（锁阻塞）
Blocked状态在API中的介绍为：一个正在阻塞等待一个监视器锁（锁对象）的线程处于这一状态。 我们已经学完同步机制，那么这个状态是非常好理解的了。比如，线程A与线程B代码中使用同一锁，如果线程A获 取到锁，线程A进入到Runnable状态，那么线程B就进入到Blocked锁阻塞状态。 这是由Runnable状态进入Blocked状态。除此Waiting以及Time Waiting状态也会在某种情况下进入阻塞状态。
1.4 waiting（等待状态）
进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
1.5 Timed waiting（超时等待）
Timed Waiting在API中的描述为：一个正在限时等待另一个线程执行一个（唤醒）动作的线程处于这一状态。
- 进入 TIMED_WAITING 状态的一种常见情形是调用的 sleep 方法，单独的线程也可以调用，不一定非要有协
作关系。
- 为了让其他线程有机会执行，可以将Thread.sleep()的调用放到线程run()方法之内。这样才能保证该线程执行过程
中会睡眠 。
- sleep与锁无关，线程睡眠到期自动苏醒，并返回到Runnable（可运行）状态。
二，线程通信（等待唤醒机制）
场景模拟：
顾客：告诉老板来份牛肉饺子，顾客进入等待状态
老板：花3s做好饺子，唤醒顾客，吃饺子
案例：创建顾客线程 类
//顾客：先继承thread类
// 告诉老板来份牛肉饺子，顾客进入等待状态
public class GuKe extends Thread {
//将对象当成私有属性 一会儿保证两个线程使用同一个锁
private Object object;
public GuKe(Object object){
this.object=object;
}
//线程操作 需要执行的代码
@Override
public void run() {
while (true) {
synchronized (object) {
//1.告知老板
System.out.println("老板，来份牛肉饺子");
//2.自己进入等待状态
try {
/*使用锁资源去调用wait等待方法 让顾客线程进入等待状态*/
object.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
//唤醒顾客线程的代码执行后，顾客做的事情
System.out.println(Thread.currentThread().getName()+"顾客开始吃饺子");
}
}
}
}
创建老板线程类
/**
* 老板线程 先继承thread类
*/
public class Boss extends Thread{
//将对象当成私有属性 一会儿保证两个线程使用同一个锁
private Object object;
public Boss(Object object){
this.object=object;
}
//老板：花3s做好饺子，唤醒顾客，吃饺子
@Override
public void run() {
while (true){
synchronized (object){
try {
//花3s做好饺子 使用线程休眠模拟 做饺子的时间
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("饺子已经做好了");
//做好饺子，唤醒顾客 使用同一个锁资源调用notify方法唤醒顾客线程。
object.notify();
}
}
}
}
测试类：
/**
* 场景模拟：
* 顾客：告诉老板来份牛肉饺子，顾客进入等待状态
* 老板：花3s做好饺子，唤醒顾客，吃饺子
*
* 注意：
* 老板和顾客都是线程类，都必须要继承Thread类
* 要用同一个同步锁
* 如果保证是同一个锁呢？
* 将Objct对象当成参数传入 顾客和老板的线程类中去
*/
public class Demo02Test {
public static void main(String[] args) {
Object o = new Object();
//创建并开启顾客线程
new GuKe(o).start();
//创建并开启顾客线程
new GuKe(o).start();
//创建并开启老板线程
new Boss(o).start();
}
}
如果是一次 单对单 代码没有问题，可以正常执行，但是只要一多，就出现错乱问题，生产者与消费者不能对应。
2.1 线程通信概述
概念：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。
为什么要处理线程间通信：
多个线程并发执行时, 在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行, 那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据。
如何保证线程间通信有效利用资源：
多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。 就是多个线程在操作同一份数据时， 避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源。而这种手段即—— 等待唤醒机制。
2.2 等待唤醒机制
什么是等待唤醒机制
这是多个线程间的一种协作机制。谈到线程我们经常想到的是线程间的竞争（race），比如去争夺锁，但这并不是故事的全部，线程间也会有协作机制。就好比在公司里你和你的同事们，你们可能存在在晋升时的竞争，但更多时 候你们更多是一起合作以完成某些任务。
就是在一个线程进行了规定操作后，就进入等待状态（wait()）， 等待其他线程执行完他们的指定代码过后 再将其唤醒（notify()）;在有多个线程进行等待时， 如果需要，可以使用 notifyAll()来唤醒所有的等待线程。
wait/notify 就是线程间的一种协作机制。
等待唤醒中的方法
等待唤醒机制就是用于解决线程间通信的问题的，使用到的3个方法的含义如下：
-
wait：线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时的线程状态即是 WAITING。它还要等着别的线程执行一个特别的动作，也即是“通知（notify）”在这个对象 上等待的线程从wait set 中释放出来，重新进入到调度队列（ready queue）中 。
-
notify：则选取所通知对象的 wait 中的一个线程释放；例如，餐馆有空位置后，等候就餐最久的顾客最先入座。
-
notifyAll：则释放所通知对象的 wait 上的全部线程。
注意：
哪怕只通知了一个等待的线程，被通知线程也不能立即恢复执行，因为它当初中断的地方是在同步块内，而 此刻它已经不持有锁，所以她需要再次尝试去获取锁（很可能面临其它线程的竞争），成功后才能在当初调用 wait 方法之后的地方恢复执行。
总结如下：
如果能获取锁，线程就从 WAITING 状态变成 RUNNABLE 状态；
否则，线程就从 WAITING 状态又变成 BLOCKED 状态
调用wait和notify方法需要注意的细节
-
wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
-
wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继承了Object的。
-
wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方法
2.3 生产者与消费者问题
等待唤醒机制其实就是经典的“生产者与消费者”的问题。等待唤醒机制如何有效利用资源。
流程：
看有没有饺子
如果没有饺子—》顾客线程等待----》老板线程做饺子----》唤醒顾客线程—》吃饺子。。。。。。
分析：
需要的类：顾客线程类，老板线程类，资源类(饺子类)
老板线程类：判断有没有饺子
没有：生产饺子（3s生产时间），唤醒顾客线程，修改饺子的状态为true
有：自己等待 , 唤醒顾客线程
顾客线程：判断有没有饺子：
有：吃饺子，修改饺子的状态为false
没有：自己等待，唤醒老板线程做饺子
资源类（饺子）
boolean state = false;默认没有饺子
代码实现：
创建顾客线程：
public class GuKe extends Thread{
private JiaoZi jiaoZi;
public GuKe(JiaoZi jiaoZi){
this.jiaoZi = jiaoZi;
}
@Override
public void run() {
while (true){
System.out.println("顾客告知老板要饺子");
synchronized (jiaoZi) {
if (jiaoZi.isState()==false) {
try {
jiaoZi.wait();//顾客线程等待状态
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//唤醒顾客线程后执行的代码。
System.out.println(Thread.currentThread().getName()+"顾客开始吃饺子");
System.out.println("================================");
jiaoZi.setState(false);//吃完饺子将状态变成false
jiaoZi.notify();
}
}
}
}
创建老板线程
public class Boss extends Thread{
private JiaoZi jiaoZi;
public Boss(JiaoZi jiaoZi){
this.jiaoZi = jiaoZi;
}
@Override
public void run() {
while (true){
synchronized (jiaoZi){
//如果没有
if(jiaoZi.isState()==true){
try {
jiaoZi.wait();//生产好饺子让老板等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("老板生产饺子");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
jiaoZi.setState(true);//将饺子的状态变成true饺子生产好了
jiaoZi.notify();//如果有饺子 唤醒顾客线程吃饺子
}
}
}
}
资源类：
public class JiaoZi {
//定义状态 表示有没有饺子，默认没有饺子
private boolean state = false;
public boolean isState() {
return state;
}
public void setState(boolean state) {
this.state = state;
}
public JiaoZi() {
}
public JiaoZi(boolean state) {
this.state = state;
}
}
测试类：
public class DemoTest {
public static void main(String[] args) {
JiaoZi jiaoZi = new JiaoZi();
//开启顾客线程
new GuKe(jiaoZi).start();
//开启老板线程
new Boss(jiaoZi).start();
}
}
三，线程池
3.1 为什么要使用线程池
我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题：
如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。
那么有没有一种办法使得线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务？
在Java中可以通过线程池来达到这样的效果。
3.2 线程池概述
线程池:其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。
现在：每一次使用线程不在自己创建了，而是从线程池中取线程对象，用完后（调用close()方法）会将取出的线程对象还给线程池，下次如果需要在取。但是，如果在取线程对象时，线程池中没有空闲的线程对象，此时，该操作代码等到有空闲的线程对象了，再取用。
合理利用线程池能够带来的好处：
-
降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
-
提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
-
提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机/宕机)。
3.3 线程池的使用
Java里面线程池的顶级接口是 java.util.concurrent.Executor ，但是严格意义上讲 Executor 并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是 java.util.concurrent.ExecutorService 。 要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优 的，因此在 java.util.concurrent.Executors 线程工厂类里面提供了一些静态工厂，生成一些常用的线程池。官方建议使用Executors工程类来创建线程池对象。
3.3.1 newCachedThreadPool(缓存线程池)
特点：会根据需要创建新线程，如果线程池中有可复用的，会先复用可用的。
这个线程池典型的场景是改善 任务耗时短小的异步任务。
使用execute可以复用可用的线程。如果没有可用线程，会创建新线程并添加到线程池里。
那些1分钟没有被使用的线程将被停止并从缓存里移除。
public static void main(String[] args) {
//创建一个缓存线程池
ExecutorService es = Executors.newCachedThreadPool();
for(int i= 0;i<20;i++){
final int index = i;
//调用execute方法添加要执行的线程任务(操作)
es.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"--->"+index);
}
});
}
}
3.3.2 newFixedThreadPool(int threadCount) 定容线程池
特点：
可以复用指定数目的线程
如果请求的线程数目大于目前idle的，那么多余的请求将被等待，直到线程池中有可用的线程。
如果有任何线程执行过程中停止了，将会新建一个线程代替。
线程池中的线程一直存活，直到显式的使用shutdown关闭。
public static void main(String[] args) {
//创建一个定容线程池线程池
ExecutorService es = Executors.newFixedThreadPool(10);
for(int i= 0;i<200;i++){
final int index = i;
es.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"--->"+index);
}
});
}
}
3.3.3 newScheduledThreadPool(定时线程池)
特点：
支持定时及循环任务执行
延迟定时，延迟的时间间隔是从调用开始，开始计算的，并不受线程执行时间长短的影响
public static void main(String[] args) {
ScheduledExecutorService se = Executors.newScheduledThreadPool(3);
for(int i= 0;i<200;i++){
final int index = i;
se.schedule(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"--->"+index);
}
},5, TimeUnit.SECONDS);
}
}
3.3.4 newSingleThreadScheduledExecutor(单一线程池)
特点：最多只开启一个线程，对于队列中的Runnable，挨个执行
public static void main(String[] args) {
ExecutorService es = Executors.newSingleThreadExecutor();
for(int i= 0;i<200;i++){
final int index = i;
es.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"--->"+index);
}
});
}
}
线程池总结：
缓存线程池： 有就复用 没有就创建 1分钟不用就干掉
定容线程池： 有就复用 没有就等待复用
定时线程池： 支持定时及循环任务执行
单一线程池： 只有一个线程执行。
扫一扫
362
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
