Java - 线程、多线程、线程池总结
一、多线程技术概括:
线程与进程
进程
- 是指一个内存中运行的应用程序,每个进程都有一个独立的内存空间线程。比如:在Windows系统中,一个运行的exe就是一个进程。
线程
- 是进程中的一个执行路径,共享一个内存空间,线程之间可以自由切换,并发执行. 一个进程最少有一个线程。
- 线程实际上是在进程基础之上的进一步划分,一个进程启动之后,里面的若干执行路径又可以划分 成若干个线程
线程调度
分时调度:
- 所有线程轮流使用 CPU 的使用权,平均分配每个线程占用 CPU 的时间。
抢占式调度
- 优先让优先级高的线程使用 CPU,如果线程的优先级相同,那么会随机选择一个(线程随机性),Java使用的为抢占式调度。
- CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言,某个时刻,只能执行一个线程,而CPU的在多个线程间切换速度相对我们的感觉要快,看上去就是在同一时刻运行。其实,多线程程序并不能提高程序的运行速度,但能够提高程序运行效率,让CPU的使用率更高。
同步与异步
-
同步:线程安全,排队执行,效率低但是安全
-
异步:线程不安全 ,同时执行,效率高但是数据不安全
并发与并行
- 并发:指两个或多个事件在同一时间段内发生。
- 并行:指两个或多个事件在同一时刻发生(同时发生)。
二、多线程技术
标题创建线程的两种方式
1.继承Thread
类,扩展线程。
class DemoThread extends Thread {
@Override
public void run() {
super.run();
}
}
DemoThread t = new DemoThread();
t.start();
- 继承Thread类,覆盖run()方法。
- 创建线程对象并用start()方法启动线程。
2.实现Runnable接口
- 实现Runnable 与 继承 Thread 相比有如下优势:
1.通过创建任务,然后给线程非配的方式来实现的多线程 ,跟适合多个线程同时执行相同任务的情况。
2.可以避免单继承带来的局限性。
3.任务与线程本身是分离的,提高了程序的健壮性。
4.后续学习的线程池技术,接受Runnable类型的任务,不接受Thread类型的线程。
public class MyRunnable implements Runnable {
@Override
public void run() {
for (int i=0;i<10;i++){
System.out.println("锄禾日当午"+i);
}
}
}
//1. 创建一个任务对象
MyRunnable mr = new MyRunnable();
//2. 创建一个线程,并为其分配一个任务
Thread t = new Thread(mr);
//3. 执行这个线程。
t.start();
for (int a=0;a<10;a++){
System.out.println("上山打老虎"+a);
}
设置和获取线程名称:
currentThread()
获取当前线程对象
getName();
获取当前对象名称
setName();
设置当前对象名称
public static void main(String[] args) {
System.out.println((Thread.currentThread().getName()));
Thread t = new Thread(new MyRunnable());
new Thread(new MyRunnable(),"哈哈").start();
new Thread(new MyRunnable()).start();
new Thread(new MyRunnable()).start();
}
static class MyRunnable implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName());;
}
}
线程的休眠 sleep
for (int i=1;i<11;i++){
System.out.println(i);
Thread.sleep(1000); //休眠时间为1000毫秒
}
线程阻塞
可以参考:https://blog.csdn.net/Sunshine_2211468152/article/details/87299708
线程的中断
- 如果线程需要执行一个长时间任务,就可能需要能中断线程。中断线程就是其他线程给该线程发一个信号,该线程收到信号后结束执行run()方法,使得自身线程能立刻结束运行。
re.interrupt()
中断
public static void main(String[] args) {
Thread t1 = new Thread(new MyRunnable());
t1.start();
for (int i=1;i<=5;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
t1.interrupt(); //t1中断
}
static class MyRunnable implements Runnable{
@Override
public void run() {
for (int i=1;i<=10;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
System.out.println("发现了中断,我们死亡");
return;
//e.printStackTrace();
}
}
}
}
守护线程
- 线程:分为守护线程和用户线程
- 用户线程:当一个进程不包括任何的存活的用户线程时,进行结束。
- 守护线程:守护用户线程的,当最后一个用户线程结束时,所有守护线程自动死亡。
ts.setDaemon(true)
守护线程必须放在线程开始前面
线程安全问题
线程不安全
线程同步:synchronized
1.同步代码块
格式:
synchronized(锁对象){
}
- 锁对象:任何对象都可以打上锁的标记。 要看同一把锁才可以保证线程安全 其中一个线程执行的时候,其他线程不能插足。
2.同步方法
-
给方法添加synchronized 就可以排队执行
-
如果不是静态的方法:
锁对象是this
-
如果是静态的方法:
锁对象就是.class
-
同步代码块 和同步方法 是隐式锁
显示锁 Lock 子类 ReentrantLock
Lock l = new ReentrantLock();
l.lock
; 锁定锁
l.unlock
; 解开锁
显示锁 和 隐式锁 的区别
- 出身不同:(原始的构成)
synchronized
:Java中的关键字,是由jvm 来维护的。是JVM层面的锁
Lock
:是JDK5以后才出现的具体的类。使用lock是调用对应点API 。是API层面的锁
一句话概述:
可以把`synchronized`理解为官二代或是星二代。从娘胎出来自带光环的。 `lock`就是我们普通努力上进的人。
- 使用方式不同:
所谓的显示和隐式就是在使用的时候,使用者要不要手动写代码去获取锁和释放锁的操作。
synchronized
不需要写其他的代码。是由系统维护的,如果非逻辑问题的话,是不会出现死锁的。
lock
我们使用者是需要手动获取锁的释放锁。 如果没有释放锁,就有可能导致出现死锁的现象。
手动获取锁方法:lock.lock()
释放锁:lock.unlock()
需要配合try/finally语句来完成。
用生活中的一个case来形容这个不同:
官二代和普通人的你正在进入机关大院的时候待遇。 官二代不需要出示什么证件就可以进入,但是你需要手动出示证件在可以进入。
3.等待是否可中断
synchronized
是不可中断的。除非抛出异常或者正常运行完成。
lock
可以中断的。中断方式:
- 调用设置超时方法 tryLock(long timeout,timeUnit unit)
- 调用lockIntreeuptibly()放在代码块中,然后调用interrupt()方法可以中断。
生活中小case来理解这一区别:
官二代一般不会做饭。都会去餐厅点餐等待着餐厅出餐。普通人的你既可以去餐厅等待,如果等待时间长的话,你就可以回去自己做饭了。
4.加锁的时候是否公平
synchronized
:非公平锁
lock
:两者都是可以的。默认是非公平锁。在其构造方法的时候可以传入Boolean值。
true
:公平锁
false
:非公平锁
生活中小case来理解这个区别:
官二代一般都不排队,喜欢插队的。普通人的你虽然也喜欢插队。但是如果遇到让排队的情况下,你还是会排队的。
5.锁绑定多个条件来condition
synchronized
:没有。要么随机唤醒一个线程,要么是唤醒所有等待的线程。
lock
:用来实现分组唤醒需要唤醒的线程,可以精确的唤醒,而不是像sync那样,不能精确唤醒线程。
6.从性能比较
synchronized
是托管给JVM执行的,低效能的 不过现在正在优化。
lock
是Java写的控制锁的代码。 性能更高一些。
7.从使用锁的方式比较
公平锁和非公平锁
- 公平锁:排队进行;
- 不公平锁:不排队,同时进行,比较乱
线程死锁
- 一个线程可以获取一个锁后,再继续获取另一个锁。
- 在获取多个锁的时候,不同线程获取多个不同对象的锁可能导致死锁。
- 两个线程各自持有不同的锁,然后各自试图获取对方手里的锁,造成了双方无限等待下去,这就是死锁。
多线程通信问题
- 等待唤醒机制:(
wait()
\notify()
) notifyALL()
方法会唤醒在此对象监视器上等待的所有线程。wait()
在其他线程调用此对象的notify()
方法或者notifyALL
方法前,导致当前线程等待。
三、线程池
线程池 Executors
- 如果并发的线程数量很多,并且每个线程都是执行一个时间很短的任务就结束了,这样频繁创建线程 就会大大降低系统的效率,因为频繁创建线程和销毁线程需要时间. 线程池就是一个容纳多个线程的容器,池中的线程可以反复使用,省去了频繁创建线程对象的操作,节省了大量的时间和资源。
线程池的好处
- 降低资源消耗。
- 提高响应速度。
- 提高线程的可管理性。
Java中的四种线程池 . ExecutorService
1. 缓存线程池
/**
* 缓存线程池.
* (长度无限制)
* 执行流程:
* 1. 判断线程池是否存在空闲线程
* 2. 存在则使用
* 3. 不存在,则创建线程 并放入线程池, 然后使用
*/
ExecutorService service = Executors.newCachedThreadPool();
//向线程池中 加入 新的任务
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
}
});
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
}
});
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
}
});
2. 定长线程池
/**
* 定长线程池.
* (长度是指定的数值)
* 执行流程:
* 1. 判断线程池是否存在空闲线程
* 2. 存在则使用
* 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
* 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
*/
ExecutorService service = Executors.newFixedThreadPool(2);
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
}
});
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
}
});
3. 单线程线程池
效果与定长线程池 创建时传入数值1 效果一致.
/**
* 单线程线程池.
* 执行流程:
* 1. 判断线程池 的那个线程 是否空闲
* 2. 空闲则使用
* 4. 不空闲,则等待 池中的单个线程空闲后 使用
*/
ExecutorService service = Executors.newSingleThreadExecutor();
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
}
});
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
}
});
4. 周期性任务定长线程池
public static void main(String[] args) {
/**
* 周期任务 定长线程池.
* 执行流程:
* 1. 判断线程池是否存在空闲线程
* 2. 存在则使用
* 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
* 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
*
* 周期性任务执行时:
* 定时执行, 当某个时机触发时, 自动执行某任务 .
*/
ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
/**
* 定时执行
* 参数1. runnable类型的任务
* 参数2. 时长数字
* 参数3. 时长数字的单位
*/
/*service.schedule(new Runnable() {
@Override
public void run() {
System.out.println("俩人相视一笑~ 嘿嘿嘿");
}
},5,TimeUnit.SECONDS);
*/
/**
* 周期执行
* 参数1. runnable类型的任务
* 参数2. 时长数字(延迟执行的时长)
* 参数3. 周期时长(每次执行的间隔时间)
* 参数4. 时长数字的单位
*/
service.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("俩人相视一笑~ 嘿嘿嘿");
}
},5,2,TimeUnit.SECONDS);
}