目录
👉 多线程(下)👈
认识线程
什么是线程
一个线程就是一个 "执行流"。每个线程之间都可以按照顺讯执行自己的代码。多个线程之间 "同时" 执行着多份代码。
线程的优点
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");
}
});
}
}