目录
👉 多线程（下）👈
认识线程
什么是线程
一个线程就是一个 "执行流"。每个线程之间都可以按照顺讯执行自己的代码。多个线程之间 "同时" 执行着多份代码。
线程的优点
1. 创建一个新线程的代价要比创建一个新进程小得多
2. 与进程之间的切换相比，线程之间的切换需要操作系统做的工作要少很多
3. 线程占用的资源要比进程少很多
4. 能充分利用多处理器的可并行数量
5. 在等待慢速I/O操作结束的同时，程序可执行其他的计算任务
6. 计算密集型应用，为了能在多处理器系统上运行，将计算分解到多个线程中实现
7. I/O密集型应用，为了提高性能，将I/O操作重叠。线程可以同时等待不同的I/O操作。
线程的实现方式有多种
⭐进程和线程的关系
一个进程中可以有多个线程，多个线程共享进程的堆和方法区 (JDK1.8 之后的元空间)资源，但是每个线程有自己的程序计数器、虚拟机栈 和 本地方法栈。
1.多个进程的内存是隔开的，一个进程中的多个线程，可以共享内存（进程包含线程）
2.进程包含线程，每个进程至少包含一个线程，即主线程
3.进程是系统分配资源的最小单位，线程是系统调度cpu执行的最小单位
4.线程创建，销毁，执行开销小，但不利于资源的管理和保护；而进程正相反。
5.线程（如果有BUG）可能会造成整个进程崩溃，进程间是独立运行的（可能存在进程通信）
6.由于同一进程的各线程间共享内存和文件资源，可以不通过内核进行直接通信。
7.进程有自己的内存地址空间，线程只独享指令流执行的必要资源，如寄存器和栈。
线程和进程最大的不同在于基本上各进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会相互影响。
多线程的优势与缺陷（使用场景与注意事项）
优势
1.充分利用cpu资源，提高执行效率
2.io等阻塞时（如果希望同时接收输入）
缺陷
1.线程的创建/销毁也是具有一定的系统开销，所以一般用于执行耗时比较长的任务
2.增加编码的复杂程度，和se代码执行顺序不一样的地方，线程安全问题
⭐创建线程的方式
继承Thread
package 创建线程;
public class 继承Thread {
public static void main(String[] args) {
//继承的写法1.自定义一个类来继承Thread
//创建一个线程
Mythread mythread = new Mythread();
//运行一个线程，申请系统调度运行
mythread.start();
//继承的写法2.使用一个匿名内部类
Thread t0 = new Thread(){ //属于继承Thread一个没有名称的子类
@Override
public void run() {
System.out.println("匿名内部类 run !");
}
};
t0.start();
}
//继承方式
//1.继承Thread 2.重写run方法（定义要执行的任务代码）
private static class Mythread extends Thread{
@Override
public void run() {
System.out.println("自定义类 run !");
}
}
}实现Runnable接口
package 创建线程;
public class 实现Runnable接口 {
public static void main(String[] args) {
//实现Runnable写法1
Thread t1 = new Thread(new MyRunnable());
t1.start();
//实现Runnable写法2:匿名内部类
Runnable r = new Runnable() { //属于Runnable接口的实现类
@Override
public void run() {
System.out.println("匿名内部类 run !");
}
};
Thread t2 = new Thread(r);
t2.start();
//实现Runnable写法3:常用方法
Thread t3 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("匿名内部类2 run !");
}
});
t3.start();
//实现Runnable写法4:λ表达式
Thread t4 = new Thread(()-> System.out.println("匿名内部类3 run !"));
t4.start();
}
private static class MyRunnable implements Runnable{
@Override
public void run() {
System.out.println("自定义类 run !");
}
}
}实现Callable接口
Callable 是一个 interface . 相当于把线程封装了一个 "返回值". 方便程序猿借助多线程的方式计算结果.
package 创建线程;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class 使用Callable {
public static void main(String[] args) throws ExecutionException, InterruptedException {
Callable<Integer> c = new Callable<Integer>() {
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 0; i < 10000; i++) {
sum += i;
}
return sum;
}
};
FutureTask<Integer> task = new FutureTask<>(c);
new Thread(task).start();
//获取线程的执行结果
int sum = task.get();//当前线程等待，直到线程执行完毕并返回结果
System.out.println(sum);
}
}
相关面试题
Callable提供返回结果，并且可以获取返回结果
Runnable是不提供返回结果的
线程的状态
NEW: 创建态。安排了工作, 还未开始行动
RUNNABLE: 可运行态。又可以分成正在工作中和即将开始工作
BLOCKED:阻塞 这几个都表示排队等着其他事情
WAITING:等待 这几个都表示排队等着其他事情
TIMED_WAITING:超时等待 这几个都表示排队等着其他事情
TERMINATED:销毁态 工作完成了.
Thread类
Thread 类是 JVM 用来管理线程的一个类，换句话说，每个线程都有一个唯一的 Thread 对象与之关联
Thread的常见构造方法
Thread t1 = new Thread();
Thread t2 = new Thread(new MyRunnable());
Thread t3 = new Thread("这是我的名字");
Thread t4 = new Thread(new MyRunnable(), "这是我的名字");Thread的几个常见属性
java进程，至少有一个非后台线程（用户线程）存活，进程才不会退出
//获取线程名称
System.out.println(t.getName());
//获取线程状态
System.out.println(t.getState());
//是否存活：如果启动后销毁前，都是存活
System.out.println(t.isAlive());启动一个线程
thread.start() => 申请系统调度，执行thread中的任务（重写run方法）
package 线程启动;
public class StartVsRun {
public static void main(String[] args) {
//main线程一直处于runnable状态
//t线程:一直处于运行
//main线程只执行了new Thread和new Runnable操作
//while(true){}
//线程对象run只是属于普通对象的实例方法调用，没有启动线程
Thread t = new Thread(new Runnable() {
@Override
public void run() {
while(true){}
}
},"t线程");
t.start();
//t.run();
}
}main方法的执行，也存在一个main线程
1.执行java.exe进程，分配内存
2.创建java虚拟机，执行TestDemo类加载
3.创建一个main线程，执行TestDemo.main()
⭐start()与run()有什么区别
1.start：启动线程的方式
2.run：属于线程任务的描述，只是属于普通对象的实例方法调用，没有启动线程
多个线程同时存在并发并行现象
等待一个线程
package 线程启动;
public class 观察线程的并发并行 {
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("t线程 run !");
//while(true){}
}
},"t线程");
t.start();
//t.join();//main线程一直等待，直到t线程死亡
//t.join(30000);//等待30s或者t线程死亡
System.out.println("t线程 start ，这里是main !");
}
}获取当前线程的引用
package 常用API;
public class CurrentThread {
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
},"T线程").start();
System.out.println(Thread.currentThread().getName());
}
}
休眠当前线程
package 常用API;
public class Sleep {
public static void main(String[] args) {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(3000);
System.out.println(Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"T线程");
t.start();
}
}
中断一个线程
自定义标志位
package 中断;
public class 自定义标志位 {
//先设计一个标志位，表示是否被中断
public static volatile boolean isStop = false;
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
try {
//判断条件加上标志位
for (int i = 0; i < 10 && !isStop; i++) {
System.out.println(i);
//时间长了就没法中断
Thread.sleep(10000);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t.start();
//中断t线程
Thread.sleep(3000);
isStop=true;
}
}Interrupt中断退出
package 中断;
public class Interrupt中断退出 {
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
try {
//判断条件加上标志位
//获取当前线程的中断标志位
while (!Thread.currentThread().isInterrupted()){
for (int i = 0; i < 10; i++) {
System.out.println(i);
Thread.sleep(1000);
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t.start();
//中断t线程
Thread.sleep(3000);
t.interrupt();
}
}
Interrupt中断忽略
package 中断;
public class Interrupt中断忽略 {
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
while (!Thread.currentThread().isInterrupted()){
try {
for (int i = 0; i < 10; i++) {
System.out.println(i);
Thread.sleep(1000);
}
}catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
t.start();
//中断t线程
Thread.sleep(3000);
t.interrupt();
}
}
使用注意事项
1.java中断，是以中断标志位的方式来执行
2.interrupt是发起中断的动作，但线程是否被中断，由自己代码是否判断标志位来决定
3.线程如果处于某些等待/超时等待的方式（会显示抛异常InterruptedException），都是允许被中断
中断的方式是：a.抛异常来中断 b.抛异常之后，会重置、还原中断标志位
线程安全
⭐保证线程安全的思路
1.使用没有共享资源的模型
2.适用共享资源只读不写的模型
（1）不需要写共享资源的模型
（2）使用不可变对象
3.⭐直面线程安全
（1）保证原子性
（2）保证顺序性
（3）保证可见性
java多线程使用的内存
//静态变量i1：方法区
//0：Integer缓存（堆）
private static int i1 = 0;
//常量i2：方法区
//1：Integer缓存（堆）
private static final int i2 = 1;
//静态变量o：方法区
//new Object();
private static Object o = new Object();
//实例变量i3：和对象生命周期一样
//3：Integer缓存（堆）
public int i3 = 3;
public static void main(String[] args){
//x：栈
//3：栈
int x = 3;
//ox：栈
//new Object：堆
Object ox = new Object();
}
线程安全问题
如果多线程环境下代码运行的结果是符合我们预期的，即在单线程环境应该的结果，则说这个程序是线程安全的。
观察线程不安全
package 线程安全;
public class 不安全的 {
private static int count = 0;
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 100000; i++) {
count++;
}
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 100000; i++) {
count++;
}
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(count);
//每次都不一样
}
}什么情况下会线程不安全
多个线程执行共享变量的操作
1.都是读，使用值进行判断，打印等操作（不存在线程安全问题）
2.至少一个线程写，线程不安全
⭐线程不安全的原因是什么
原子性
多行命令是不可拆分的最小执行单位，就具有原子性
例如：
再java中，某些特殊的代码，java中只有一行，但是编译为字节码，或jvm翻译字节码为机器码，可能有多行
n++;n--;++n;--n（1）从内存读取到cpu的寄存器（2）修改（3）写回内存
Object o = new Object()（1）分配/申请对象需要的内存空间（2）初始化对象（赋值给变量/引用）
这些即使是一行代码，也不具有原子性
可见性
jmm（java内存模型）为java程序屏蔽了不同硬件及操作系统访问内存的差异（同意了访问内存的操作）
访问内存就规定了两个概念
（1）主存：线程共享的（2）工作内存：线程私有的
多个线程操作共享变量的方式，还是需要加载到cpu寄存器，所以：
多个线程并发并行操作即使使用一个共享变量，也是互相不可见的
代码的有序性
执行字节码指令或者执行机器码指令，都可能为了提高执行效率，使用指令重排序的方式来执行
如何解决线程不安全问题
设计多线程代码的原则：满足线程安全的前提下，尽可能的提高运行效率
写操作
某个线程，对共享变量的写操作，可以通过加锁来保证线程安全
加锁可以解决：原子性、可见性、有序性
两种加锁方式：
synchronized关键字：申请对给定的java对象，对象头加锁
lock：是一个锁的接口，他的实现类提供了锁这样的对象，可以调用方法来加锁/释放锁
读操作
如果某个线程，对共享变量是读操作，使用volatile关键字就可以保证线程安全
volatile可以解决：可见性，有序性（读操作本身就具有原子性）
如果对共享变量的写操作，不依赖任何变量，也可以使用volatile保证线程安全
例如：
n++：依赖自身共享变量，不能使用volatile保证安全
flag = true：使用常量复制，本身就是原子性的，再加上volatile，保证可见性和有序性，就是安全的
synchronized关键字
语法
package Synchronized;
public class 语法 {
//synchronized语法三：同步静态方法
public static synchronized void t2(){
}
public static void t2_equals(){
synchronized (语法.class){
}
}
//synchronized语法二：同步实例方法
public synchronized void t1(){
}
public void t1_equals(){
//当前类的某个实例对象，谁调用我这个实例方法，this就是谁
synchronized (this){
}
}
//类加载：还会在堆中生成一个类对象
public static void main(String[] args) {
Class c = String.class;
//执行当前类的类加载，在堆中会生成一个语法.class的类对象
Class<语法> c1 = 语法.class;
Class<语法> c2 = 语法.class;
System.out.println(c1==c2);
//synchronized语法一：同步代码块
Object someOne = new Object();
synchronized (someOne) {
}
//也可以使用类对象
synchronized (语法.class){
}
}
}
特性
互斥
某一个线程执行同一个对象加锁的同步代码，排斥另一个线程加锁，满足最小执行单位
synchronized 会起到互斥效果, 某个线程执行到某个对象的 synchronized 中时, 其他线程如果也执行到同一个对象 synchronized 就会阻塞等待
1.进入 synchronized 修饰的代码块, 相当于加锁
2.退出 synchronized 修饰的代码块, 相当于解锁
synchronized用的锁是存在Java对象头里的
刷新内存
1. 获得互斥锁
2. 从主内存拷贝变量的最新副本到工作的内存
3. 执行代码
4. 将更改后的共享变量的值刷新到主内存
5. 释放互斥锁
可重入
//不可重入
// 第一次加锁, 加锁成功
lock();
// 第二次加锁, 锁已经被占用, 阻塞等待.
lock();
//可重入
synchronized(synchronized线程安全.class){
synchronized(synchronized线程安全.class){
count++;
}
}判断synchronized是否能达到同步互斥的作用
package 线程安全;
public class Synchronized线程安全 {
private static int count;
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10000; i++) {
synchronized (Synchronized线程安全.class) {
count++;
}
}
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10000; i++) {
synchronized (Synchronized线程安全.class) {
count++;
}
}
}
});
t1.start();
t2.start();
//main线程等待t1，t2都执行完
t1.join();
t2.join();
//看看count的值
System.out.println(count);
}
}
java标准库中的线程安全类
Java 标准库中很多都是线程不安全的. 这些类可能会涉及到多线程修改共享数据, 又没有任何加锁措施
ArrayList
LinkedList
HashMap
TreeMap
HashSet
TreeSet
StringBuilder
但是还有一些是线程安全的. 使用了一些锁机制来控制.
Vector (不推荐使用)
HashTable (不推荐使用)
ConcurrentHashMap
StringBuffer
还有的虽然没有加锁, 但是不涉及 "修改", 仍然是线程安全的
String
⭐volatile关键字
语法
private static volatile boolean 是否被中断 = false;作用
1.保证可见性
代码在写入 volatile 修饰的变量的时候
（1）改变线程工作内存中volatile变量副本的值
（2）将改变后的副本的值从工作内存刷新到主内存
代码在读取 volatile 修饰的变量的时候
（1）从主内存中读取volatile变量的最新值到线程的工作内存中
（2）从工作内存中读取volatile变量的副本
2.禁止指令重排序，简历内存保障
3.不保证原子性操作
某些即存在读，也存在写的操作，代码全部加锁效率较低，所以可以对共享变量的读操作使用volatile保证线程安全，写操作加锁，这样不仅满足线程安全，效率也高（读读操作并发并行，写写操作互斥）
wait()和notify()
注意: wait, notify, notifyAll 都是 Object 类的方法
wait()方法
wait 做的事情:
1.使当前执行代码的线程进行等待. (把线程放到等待队列中)
2.释放当前的锁
3.满足一定条件时被唤醒, 重新尝试获取这个锁.
wait 要搭配 synchronized 来使用. 脱离 synchronized 使用 wait 会直接抛出异常.
wait 结束等待的条件:
1.其他线程调用该对象的 notify 方法.
2.wait 等待时间超时 (wait 方法提供一个带有 timeout 参数的版本, 来指定等待时间).
3.其他线程调用该等待线程的 interrupted 方法, 导致 wait 抛出InterruptedException 异常.
notify()方法
notify 方法是唤醒等待的线程.
1.方法notify()也要在同步方法或同步块中调用，该方法是用来通知那些可能等待该对象的对象
2.锁的其它线程，对其发出通知notify，并使它们重新获取该对象的对象锁。
如果有多个线程等待，则有线程调度器随机挑选出一个呈 wait 状态的线程。(并没有 "先来后
到")
3.在notify()方法后，当前线程不会马上释放该对象锁，要等到执行notify()方法的线程将程序执行完，也就是退出同步代码块之后才会释放对象锁。
notifyAll()方法
notify方法只是唤醒某一个等待线程. 使用notifyAll方法可以一次唤醒所有的等待线程.
虽然是同时唤醒 3 个线程, 但是这 3 个线程需要竞争锁. 所以并不是同时执行, 而仍然是有先有后的执行.
package 线程通信;
public class 简单使用 {
public static void main(String[] args) throws InterruptedException {
Object lock = new Object();
new Thread(new Runnable() {
@Override
public void run() {
try {
synchronized (lock) {
//先做一些事情
System.out.println("线程1：步骤1");
//在某些条件下，就需要等待
lock.wait();
//被唤醒，就做另一些事情
System.out.println("线程1：步骤2");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
/**
* 执行顺序：
* 线程1 synchronized -> wait
* 线程2 synchronized -> notify
* 线程1 wait 往下
*/
Thread.sleep(100);
new Thread(new Runnable() {
@Override
public void run() {
synchronized (lock){
//做一些事情
System.out.println("线程2：步骤1");
//通知线程1：唤醒执行
lock.notify();
//做另一些事情
System.out.println("线程2：步骤2");
}
}
}).start();
}
}生产者消费者模型（面包店）
package 线程通信;
/**
* 模拟面包店买卖面包：
* 面包店库存最大上限：100
* 3个面包师傅，每个师傅每次生产5个，需要一直生产
* 10个消费者，每个消费者每次消费2个，需要一直消费
*/
public class 面包店 {
//共享变量：当前库存数
private static int STORE;
private static final Object lock = new Object();
public static void main(String[] args) {
//面包师傅
for (int i = 0; i < 3; i++) {
new Thread(new Runnable() {
@Override
public void run() {
//一直生产
while (true){
try {
//准备生产
synchronized (lock){
//不满足生产条件
while (STORE + 5 > 100){
lock.wait();
}
//满足生产条件
STORE += 5;//生产
System.out.printf("%s 生产了5个面包，当前库存：%s\n",
Thread.currentThread().getName(),
STORE);
lock.notifyAll();
Thread.sleep(1000);//间隔一段时间打印
}
Thread.sleep(100);//涉及jvm对synchronized优化，暂时不管
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}, "面包师傅["+(i+1)+"]").start();
}
//消费者
for (int i = 0; i < 10; i++) {
new Thread(new Runnable() {
@Override
public void run() {
//一直消费
while (true){
try {
//准备消费
synchronized (lock){
//不满足消费条件
while (STORE - 2 < 0){
lock.wait();
}
//满足消费条件
STORE -= 2;//消费
System.out.printf("%s 消费了2个面包，当前库存：%s\n",
Thread.currentThread().getName(),
STORE);
lock.notifyAll();
Thread.sleep(1000);//间隔一段时间打印
}
Thread.sleep(100);//涉及jvm对synchronized优化，暂时不管
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}, "消费者["+(i+1)+"]").start();
}
}
}
⭐wait 和 sleep 的对比
其实理论上 wait 和 sleep 完全是没有可比性的，因为一个是用于线程之间的通信的，一个是让线程阻塞一段时间
唯一的相同点就是都可以让线程放弃执行一段时间
1. wait 需要搭配 synchronized 使用. sleep 不需要
2. wait 是 Object 的方法 sleep 是 Thread 的静态方法
多线程案例
单例模式
单例模式是设计模式的一种
某个类，提供给别处使用的时候，只能使用同一个实例化对象
⭐如何用代码来实现单例模式
1.饿汉式：类加载的同时，就创建实例，即使不使用，也会创建对象，占用内存空间
2.懒汉式：类加载的时候不创建实例，第一次使用才创建实例
3.双重校验锁：双重if判定，降低锁竞争效率
饿汉式
package 单例模式;
public class 饿汉式 {
private static 饿汉式 instance = new 饿汉式();
private 饿汉式(){}
private static 饿汉式 getInstance(){
return instance;
}
public static void main(String[] args) {
//这里模拟是别的地方使用单例的对象
饿汉式 instance1 = 饿汉式.getInstance();
饿汉式 instance2 = 饿汉式.getInstance();
System.out.println(instance1 == instance2);
}
}懒汉式_多线程效率低
package 单例模式;
public class 懒汉式_多线程效率低 {
private static 懒汉式_多线程效率低 instance;
private 懒汉式_多线程效率低(){}
public synchronized static 懒汉式_多线程效率低 getInstance(){
if(instance == null){
instance = new 懒汉式_多线程效率低();
}
return instance;
}
}懒汉式
package 单例模式;
public class 懒汉式 {
private static 懒汉式 instance;
private 懒汉式(){}
public static 懒汉式 getInstance(){
if(instance == null){
instance = new 懒汉式();
}
return instance;
}
}双重校验锁
package 单例模式;
public class 双重校验锁 {
private volatile static 双重校验锁 instance;
//读也要保证线程安全
private 双重校验锁(){}
public static 双重校验锁 getInstance(){
if(instance == null){//如果是空，尝试加锁
synchronized (双重校验锁.class) {//使用同一个对象，保证多线程同步互斥
if(instance == null) {//如果是空，保证单例的要求
instance = new 双重校验锁();
}
}
}
return instance;//读
}
}
⭐阻塞队列
特性
满足队列的结构和特性，链表或者数组结构，先进先出，满足线程安全
（1）入队：队列满了，就需要等待
（2）出队：队列空了，就需要等待
好处
（1）削峰：生产过快，可能消费不过来，使用阻塞队列进行缓冲
（2）解耦：双方不相互依赖（耦合是指生产的东西直接让消费者执行）
jdk提供的api
BlockingQueue是阻塞队列的接口
LinkedBlockingQueue();//无边界
LinkedBlockingQueue(int);//有边界
ArrayBlockingQueue(int);//有边界
实现
可以通过循环数组来实现
1.数组长度（capacity）
2.有效负荷（size）
3.放元素的索引（取模）
4.取元素的索引（取模）
package 线程通信;
import java.util.Random;
public class 阻塞队列 {
//循环数组：存取元素
private int[] elements;
//有效负荷
private int size;
//放元素的索引
private int putIndex;
//取元素的索引
private int takeIndex;
/**
* @param capacity 容量
*/
public 阻塞队列(int capacity){
elements = new int[capacity];
}
/**
* 放元素到阻塞队列：需要保证线程安全，如果队列满了，需要等待
* @param element
*/
public synchronized void put(int element) throws InterruptedException {
//如果满了，就等
while(elements.length == size){
wait();
}
//如果不满，就放
elements[putIndex] = element;
//放的索引往后移动一位（取模是在最后一个位置就往首位移动）
putIndex = (putIndex+1) % elements.length;
//有效负荷+1
size++;
//通知wait等待的线程
notifyAll();
}
/**
* 取元素：需要保证线程安全，如果队列是空，需要等待
* @return
*/
public synchronized int take() throws InterruptedException {
//如果是空，就等
while(size == 0){
wait();
}
//如果不空，就取
int element = elements[takeIndex];
//取的索引往后移动一位（取模是在最后一个位置就往首位移动）
takeIndex = (takeIndex+1) % elements.length;
//有效负荷-1
size--;
//通知wait等待的线程
notifyAll();
return element;
}
public static void main(String[] args) throws InterruptedException {
阻塞队列 queue = new 阻塞队列(20);
new Thread(new Runnable() {
@Override
public void run() {
//模拟消费者
while (true){
try {
int e = queue.take();
System.out.println("取到的数字："+e);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
Thread.sleep(100);
new Thread(new Runnable() {
@Override
public void run() {
//模拟生产者
while (true){
try {
queue.put(new Random().nextInt());
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
}
}定时器
定时器也是软件开发中的一个重要组件. 类似于一个 "闹钟". 达到一个设定的时间之后, 就执行某个指定好的代码
jdk提供的api
标准库中提供了一个 Timer 类.Timer 类的核心方法为 schedule .
schedule 包含两个参数. 第一个参数指定即将要执行的任务代码, 第二个参数指定多长时间之后执行 (单位为毫秒).
Timer timer = new Timer();
timer.schedule(new TimerTask() {
@Override
public void run() {
System.out.println("hello");
}
}, 3000);⭐线程池
什么是线程池
线程池就是创建若干个可执行的线程放入一个池（容器）中，有任务需要处理时，会提交到线程池中的任务队列，处理完之后线程并不会被销毁，而是仍然在线程池中等待下一个任务。
线程池的优势是什么
线程的创建以及销毁都有性能消耗，使用线程池可以实现线程复用，减少性能消耗
jdk的原生线程池api
package 线程池;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorDemo {
public static void main(String[] args) {
//创建一个线程池：开了一个快递公司
ThreadPoolExecutor pool = new ThreadPoolExecutor(
5,
10,
60,
TimeUnit.SECONDS,
//一般不使用无边界的阻塞队列：因为内存有限
new ArrayBlockingQueue<>(10000),
//拒绝策略：一般最多使用CallerRunsPolicy，或自己实现
new ThreadPoolExecutor.AbortPolicy()
);
pool.execute(new Runnable() {
@Override
public void run() {
System.out.println("hello");
}
});
}
}
创建线程池的几种方式
package 线程池;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ExecutorServiceDemo {
public static void main(String[] args) {
//固定大小的线程池
ExecutorService fixed = Executors.newFixedThreadPool(4);
//单线程池
ExecutorService single = Executors.newSingleThreadExecutor();
//缓存的线程池
ExecutorService cached = Executors.newCachedThreadPool();
//计划任务的线程池
ExecutorService scheduled = Executors.newScheduledThreadPool(4);
}
}
自行实现的线程池
package 线程池;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class 自行实现的线程池 {
//阻塞队列：仓库
private BlockingQueue<Runnable> queue;
public 自行实现的线程池(int count, int capacity) {
this.queue = new ArrayBlockingQueue<>(capacity);
//线程池创建，就创建线程来不停取任务并执行
for (int i = 0; i < count; i++) {
new Thread(new Runnable() {
@Override
public void run() {
//不停的从仓库中取任务：如果取不到就等待
while (true){
try {
Runnable task = queue.take();
task.run();//执行任务
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
}
}
public void execute(Runnable task){
try {
queue.put(task);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
自行实现的线程池 pool = new 自行实现的线程池(5, 1000);
pool.execute(new Runnable() {
@Override
public void run() {
System.out.println("hello");
}
});
}
}线程池的工作流程
292
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
