多线程基础知识笔记
多线程基础知识笔记
一、线程
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(); } }