多线程基础知识笔记
多线程基础知识笔记
一、线程
1.基本概念
- 程序(program):是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码,静态对象。
- 进程(process):是程序的一次执行过程,或是正在运行的一个程序。是一个动态的过程:有它自身的产生、存在和消亡的过程(生命周期)。
- 进程作为资源分配的单位,系统在运行时会为每个进程分配不同的内存区域。
- 线程(tread):进程可以进一步细化为线程,是一个程序内部的一条执行路径。
- 若一个进程同一时间并行执行多个线程,就是支持多线程的。
- 线程作为调度和执行的单位,每个线程拥有独立的运行栈和程序计数器(pc),线程切换的开销小。
- 一个进程中的多个线程共享相同的内存单元/内存地址空间 --> **它们从同一堆中分配对象,可以访问相同的变量和对象。**这就使得线程间的通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。
- 单核CPU与多核CPU的理解:
- 单核CPU,其实是一种假的多线程,因为在一个时间单元内,也只能执行一个线程的任务。例如:有多车道,但收费站只有一个工作人员在收费,只有交了费才能通过,那么CPU就好比收费人员,如果某个人不想交钱,那么收费人员可以把他“挂起“(等他想通了准备好交钱再收费)。但是因为CPU时间单元特别短,因此感觉不出来。
- 多核CPU,才能更好的发挥多线程的效率。
- 一个Java应用程序java.exe,其实至少有三个线程:main() 主线程, gc() 垃圾回收线程, 异常处理线程。当然如果发生异常,会影响主线程。
- 并行与并发
- 并行:多个CPU同时执行多个任务。
- 并发:一个CPU(采用时间片)同时执行多个任务。
2.多线程的优点
- 提高应用程序的响应。对图形化界面更有意义,可增强用户体验。
- 提高计算机系统CPU的利用率。
- 改善程序结构。将即长又复杂的进程分为多个线程。独立运行,利于理解和修改。
3.何时需要多线程
- 程序需要同时执行两个或多个任务。
- 程序需要实现一些需要等待的任务时,如用户输入、文件读写、网络操作、搜索等。
- 需要一些后台运行的程序时。
4.线程的创建
方式一:继承于Thread类
- 创建一个继承于Thread类的子类
- 重写Thread类的run方法 --> 将此线程执行的操作声明在run()中
- 创建Thread类的子类的对象
- 通过对象去调用start方法
例子:
//1.创建一个继承于Thread类的子类
class MyThread extends Thread {
//2.重写Thread类的run方法 --> 将此线程执行的操作声明在run()中
@Override
public void run() {
//该线程的功能
}
}
public class ThreadTest {
public static void main(String[] args) {
//3.创建Thread类的子类的对象
MyThread t1 = new MyThread();
//4.通过对象去调用start方法
t1.sart();
}
}
- 注意:
- 不能通过直接调用run()的方式启动线程(实质上只是方法的调用,单线程)
- 不可让正在启动的线程去执行任何代码(报错IllegalThreadException)。需要重新创建新的线程对象。
方式二:实现Runnable接口
-
创建一个实现了Runnable接口的类
-
实现类去实现Runnable中的抽象方法:run()
-
创建实现类的对象
-
将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象
-
通过Thread类的对象调用start()
(其实调用的是Runnable类型的target)
例子:
//1,创建实现Runnable接口的类 class Mthread implements Runnable { @Override public void run() { //2.重写Runnable中的抽象方法run() } } public class ThreadTest1 { public static void main(String[] args) { //3.创建实现类的对象 MThread mThread = new MThread(); //4.将该对象作为参数传给Thread类的构造器中,创建Thread类的对象 Thread t1 = new Thread(mThread); //5,通过Thread类的对象调用start() t1.start(); } }
方式一和二的对比
-
开发中优先考虑:实现Runnable接口的方式
原因:
- 实现的方式没有类的单继承性的局限性
- 实现的方式更适合来处理多个线程有共享数据的情况
-
其实Thread类本身就继承了Runnable接口,并内置重写了的run()。
方式三:实现Callable接口
-
与Runnable相比,Callable功能更强大一些
- 相比run()方法,可以有返回值
- 方法可以抛出异常
- 支持泛型的返回值
- 需要借助FutureTask类,比如获取返回结果
- FutureTask类
- 实现了Runnable接口
- FutureTask类
1.代码示例(返回100以内偶数和)
//1.创建一个实现Callable的实现类 class NumThread implements Callable{ //2.实现call方法,将此线程需要执行的操作声明在call()中 @Override public Object call() throws Exception { //返回100以内偶数和 int sum = 0; for (int i = 0; i <= 100; i++) { if (i % 2 == 0) { System.out.println(i); sum += i; } } return sum;//这里将int自动装箱为Integer,而Integer类为Object类的子类 } } public class ThreadNew { public static void main(String[] args) { //3.创建Callable接口实现类的对象 NumThread numThread = new NumThread(); //4.将此对象作为参数传递到FutureTask构造器中,创建FutureTask的对象 FutureTask futureTask = new FutureTask(numThread); //5.将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread类的对象,并调用start方法 //启动线程 new Thread(futureTask).start(); try { //6.获取Callable中call方法的返回值(看需求) //get方法获取的返回值即为FutureTask构造器参数Callable实现类重写的call方法的返回值 Object sum = futureTask.get(); System.out.println("总和为" + sum); }catch (InterruptedException e) { e.printStackTrace(); }catch (ExecutionException e) { e.printStackTrace(); } } }
方式四:线程池
-
背景:经常创建和销毁、使用量特别大的资源,比如并发情况下的线程,对性能影响很大。
-
思路:提前创建多个下次你哼,放入线程池中,使用时直接获取,使用完放回池中。可以避免频繁创建销毁、实现重复利用。
-
好处:
- 提高响应速度(减少了创建新线程的时间)
- 降低资源消耗(重复利用线程池中的线程,不需要每次都创建)
- 便于线程管理
- corePoolSize:核心池的大小
- maxmumPoolSize:最大线程数
- keepAliveTime:线程没有任务时最多保持多长时间后会终止
- ……
-
相关API
- JDK 5.0起提供了线程池相关API:ExecutorService和Executors
- ExecutorService: 真正的线程池接口。常见子类ThreadPoolExecutor
- void execute(Runnable command) : 执行任务/命令,没有返回值,一般用来执行 Runnable
- Future submit (Callable task) : 执行任务,有返回值,一般用来执行Callable
- void shtdown() : 关闭线程池
- Executors : 工具类、线程池的工厂类,用于创建并返回不同类型的线程池
- Executors.newCachedThreadPool() : 创建一个可根据需求创建新线程的线程池
- Executors.newFixedThreadPool() : 创建一个可重用固定线程数的线程池
- Executors.newSingleThreadExecutor() : 创建一个只有一个线程的线程池
- Executros.newScheduledThreadPool(n) : 创建一个线程池,它可安排在给定延迟后运行命令或者定期的执行
-
代码示例
class EvenNumbersThread implements Runnable { //返回100以内偶数 @Override public void run() { for (int i = 0; i < 100; i++) { if (i % 2 == 0) { System.out.println(i); } } } } class OddNumbersThread implements Runnable { //返回100以内奇数 @Override public void run() { for (int i = 0; i < 100; i++) { if (i % 2 != 0) { System.out.println(i); } } } } public class ThreadPool { public static void main(String[] args) { //1. 提供值定数量线程的线程池 ExecutorService service = Executors.newFixedThreadPool(10); //2.执行值定线程的操作,需要提供实现Runnable接口或Callable接口的实现类的对象 service.execute(new EvenNumbersThread()); service.execute(new OddNumbersThread()); //3.关闭连接池 service.shutdown(); /* *service.execute();//适用于Runnable *service.submit(Callable callable);//适用于 *Callable */ } }
//使用Callable接口 ... Future submit = service.submit(Callable callable);//返回值为Future类型 //获取并输出callable任务的返回值 System.out.println(submit.get()); ...
- 关于Future类的get()方法
- 返回Callable任务的返回值,如果是
Runnable
任务则返回null get()
方法是阻塞的,如果调用get()
方法时,任务仍在运行,则调用会一直阻塞,直到任务正确执行完毕并且结果可用时才返回- 更重要的是,正在被执行的任务随时可能抛出异常或中断执行,因此我们要将
get()
调用放在try catch
语句块中,并捕捉InterruptedException
或ExecutionException
异常。
- 返回Callable任务的返回值,如果是
- 关于Future类的get()方法
-
关于线程池的属性设置
ExecutorService service = Executors.newFixedThreadPool(10); //ThreadPoolExecutor类继承了AbstractExecutorService抽象类,而该抽象类又实现了ExecutorService接口,故可以做向下转型 ThreadPoolExecutor s1 = (ThreadPoolExecutor) service; /* * corePoolSize:核心池的大小 * maxmumPoolSize:最大线程数 * keepAliveTime:线程没有任务时最多保持多长时间后会终止 */
二、Thread类的有关方法
- void start() : 启动线程,并执行对象的run()方法
- run() : 通常需要重写Thread类中的此方法,将创建的线程要执行的操作声明在此方法中
- String getName() : 返回线程的名称
- void setName(String name) : 设置该线程名称
- static Thread.currentThread() : 返回当前线程。在Thread子类中就是this,通常用于主线程和Runnable实现类
- yield() : 释放当前cpu的执行权
- join() : 在线程a中调用线程b的线程join(),此时线程a进入阻塞状态,直到线程b完全执行完后,线程a才能结束阻塞状态。
- stop() : 已过时。强制结束当前线程。
- sleep(long millitime) : 让当前线程“睡眠”值定的millitime毫秒。在指定的millitime毫秒内,当前线程时阻塞状态。
- isAlive() : 判断当前线程是否存活(返回值为boolean)
三、线程的调度
1. 调度
- 调度策略
- 时间片:
- 抢占式:高优先级的线程抢占CPU
- 时间片:
- Java的调度方法
- 同优先级线程组成先进先出队列(先到先服务),使用时间片策略
- 对高优先级,使用优先调度的抢占式策略
2. 线程的优先级
-
默认配置:
- MAX_PRIORITY:10
- MIN_PRIORITY:1
- NORM_PRIORITY:5
-
设置操作
-
线程对象名.getPriority()
获取线程优先级
-
线程对象名.setPriority()
设置线程优先级
-
-
优先级理解
高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲,高优先级的线程高概率的情况下被执行。并不意味着只有当高优先级的线程执行完后,低优先级的线程才执行
四、线程的状态及其生命周期
-
JDK中用Thread.State类定义了线程的几种状态
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BtZFRF5f-1611720803336)(C:\Users\Olenz\AppData\Roaming\Typora\typora-user-images\image-20210124163428341.png)]
(廖雪峰Java教程)在Java程序中,一个线程对象只能调用一次
start()
方法启动新线程,并在新线程中执行run()
方法。一旦run()
方法执行完毕,线程就结束了。因此,Java线程的状态有以下几种:
- New:新创建的线程,尚未执行;
- Runnable:运行中的线程,正在执行
run()
方法的Java代码;- Blocked:运行中的线程,因为某些操作被阻塞而挂起;
- Waiting:运行中的线程,因为某些操作在等待中;
- Timed Waiting:运行中的线程,因为执行
sleep()
方法正在计时等待;- Terminated:线程已终止,因为
run()
方法执行完毕。用一个状态转移图表示如下:
┌─────────────┐ │ New │ └─────────────┘ │ ▼ ┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┐ ┌─────────────┐ ┌─────────────┐ ││ Runnable │ │ Blocked ││ └─────────────┘ └─────────────┘ │┌─────────────┐ ┌─────────────┐│ │ Waiting │ │Timed Waiting│ │└─────────────┘ └─────────────┘│ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ │ ▼ ┌─────────────┐ │ Terminated │ └─────────────┘
当线程启动后,它可以在
Runnable
、Blocked
、Waiting
和Timed Waiting
这几个状态之间切换,直到最后变成Terminated
状态,线程终止。线程终止的原因有:
- 线程正常终止:
run()
方法执行到return
语句返回;- 线程意外终止:
run()
方法因为未捕获的异常导致线程终止;- 对某个线程的
Thread
实例调用stop()
方法强制终止(强烈不推荐使用)。
五、线程的同步
1. 两种同步方式
-
问题的提出
- 多个线程执行的不确定性引起执行结果的不稳定性
- 多个线程对账本的共享们会造成操作的不完整性,会破坏数据
-
同步方式
-
方式一:synchronized关键字
-
两种方法的创建
-
同步代码块
synchroniazed(同步监视器){ //需要被同步的代码 }
说明:
- 需要被同步的代码:操作共享数据的代码。
- 共享数据:多个线程共同操作的变量。
- 同步监视器(锁):任何一个类的对象都可以充当锁。
要求:
多个线程必须共用同一把锁(线程安全的关键)
-
同步方法
在定义方法时,使用synchronized关键字
-
-
锁
- 非静态的同步方法,同步监视器为:this
- 静态的同步方法,同步监视器为:当前类本身
-
分析
- 解决了线程的安全问题
- 操作同步代码时,只能有一个线程参与,其他线程等待,相当于单线程,效率低
- 在实现Runnable接口创建多线程的方式中,我们可以考虑用this(指该类的实例对象)或当前类来充当同步监视器
-
-
方式二:Lock锁 —— JDK5.0新特性
-
建立方式
-
实例化ReentrantLock
private ReentrantLock lock = new ReentrantLock(); //构造器可选参数fair,若传入true则会保证某个线程不会总是抢占其他线程工作
-
调用锁定方法lock()
lock.lock();
-
调用解锁方法unlock()
lock.unlock();
(廖雪峰Java教程)因为
synchronized
是Java语言层面提供的语法,所以我们不需要考虑异常,而ReentrantLock
是Java代码实现的锁,我们就必须先获取锁,然后在finally
中正确释放锁。如:public class Counter { private final Lock lock = new ReentrantLock(); private int count; public void add(int n) { lock.lock(); try { count += n; } finally { lock.unlock(); } } }
-
-
synchronized和Lock的异同
- 相同:都可解决线程的安全问题
- 不同:
- synchronized是隐式锁,出了作用域会自动释放锁,Lock是显式锁,锁需要手动开启和释放。
- Lock只有代码块锁,synchronized有代码块锁和方法锁
- 使用Lock锁,JVM调整线程的时间花费少,性能更好,并且具有更好的拓展性(提供更多的子类)
-
-
2. 线程安全的单例模式中的懒汉模式
public class DemoTest {
}
class Demo {
private Demo(){}
private static Demo instance = null;
public static Demo getInstance() {
//方式一:效率稍差
synchronized (Demo.class) {
if (instance == null) {
instance = new Demo();
}
return instance;
}
//方式二:效率稍高
if (instance == null) {
synchronized (Demo.class) {
if(instance == null) {
instance = new Demo();
}
}
}
return instance;
//当最先执行的线程实现了new语句后,后续的线程不需要挨个进行synchronized内的if判断(因为一定都是false),则跳过后面的语句直接返回new好的instance。
}
}
3. 线程的死锁问题
-
死锁
- 不同的线程分别占用对方需要的同步资源不放弃,都在等待对方放弃自己需要的同步资源,就形成了线程的死锁。
- 出现死锁后,不会出现异常,不会出现提示,只是所有的线程都处于阻塞状态,无法继续。
-
解决方法
-
专门的算法、原则
-
尽量减少同步资源的定义
-
尽量避免嵌套同步
-
4. wait()、notify()、notifyAll()
-
介绍
- wait() : 一旦执行此方法,当前线程进入阻塞状态,并释放同步监视器。
- notify() : 唤醒被wait()的一个线程(若多个被wait的线程,有先唤醒优先级高的线程,优先级相同则随机)。
- notifyAll() :唤醒所有被wait()的线程。
-
三种方法不用于ReantrantLock方式的线程通信。调用者必须是同步代码块或同步方法中的同步监视器。否则会出现IllegalMontitorStateException
-
三个方法来源于Object类final的。
-
sleep()和wait()的异同
相同点:都可使当前线程进入阻塞状态。
不同点:
- 声明的位置不同:Thread类中调用wait(),Object类中调用sleep()。
- 调用要求不同:sleep()可以在任何需要的场景下调用。wait()必须在同步代码块或同步方法下调用。
- 关于是否释放锁:如果两个方法都使用在同步代码块或同步方法中,wait()会释放锁,sleep()不会释放锁。
5.生产者/消费者问题(线程通信的应用)
-
问题描述:
生产者(Productor)将产品交给店员(Clerk),而消费者(Customer)从店员处取走产品,店员一次只能持有固定数量的产品(比如20),如果生产者试图生产更多的产品,店员会叫停生产者,如果店中有空位放产品了再通知生产者继续生产;如果店中没有产品了,店员会告诉消费者等一下,如果店中有产品了再通知消费者来取走产品。
-
分析
- 多线程问题
- 有共享数据故可能存在线程安全问题(店员或产品)
-
完整代码
class Clerk extends Thread { /** * 店员功能: * 1.接受生产者的产品 * 2.提供消费者产品 * 3.每个店员最多持有20个产品,达到20时,生产者停止生产,达到0时,消费者停止消费 */ private int productsCount = 0; public synchronized void produceProduct() { if (productsCount < 20) { productsCount++; System.out.println(Thread.currentThread().getName() + "开始生产第" + productsCount + "个产品"); notify(); } else { try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } public synchronized void consumeProduct() throws InterruptedException { if (productsCount > 0) { System.out.println(Thread.currentThread().getName() + "开始消费第" + productsCount + "个产品"); productsCount--; notify(); } else { try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } } class Productor extends Thread { /** * 生产者功能: * 每10milli生产1个产品 */ private Clerk clerk; public Productor(Clerk clerk) { this.clerk = clerk; } @Override public void run() { System.out.println(getName() + ":开始生产产品......"); while (true) { try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } clerk.produceProduct(); } } } class Consumer extends Thread { /** * 消费者功能: * 每12milli消费一个产品 */ private Clerk clerk; public Consumer(Clerk clerk) { this.clerk = clerk; } @Override public void run() { System.out.println(getName() + ":开始消费......"); while (true) { try { Thread.sleep(12); } catch (InterruptedException e) { e.printStackTrace(); } try { clerk.consumeProduct(); } catch (InterruptedException e) { e.printStackTrace(); } } } } public class Demo { public static void main(String[] args) { Clerk clerk = new Clerk(); Productor p1 = new Productor(clerk); p1.setName("生产者1"); Consumer c1 = new Consumer(clerk); c1.setName("消费者1"); Consumer c2 = new Consumer(clerk); c2.setName("消费者2"); p1.start(); c1.start(); c2.start(); } }