多线程_进程和线程，并发与并行，线程优先级，守护线程，实现线程的四种方式，线程周期；线程同步，线程中的锁，Lock类，死锁，生产者和消费者案例
Java多线程
文章目录
- Java多线程
-
- 1 多线程
-
- 1.1进程和线程
- 1.2 并发与并行
- 1.3 计算机中的核心数和线程数
- 1.4 线程调度
- 1.5 线程优先级
- 1.6 守护线程
- 1.7 Java中实现多线程的四种方式
-
- 1.7.1 继承Thread类
- 1.7.2 实现Runnable接口
- 1.7.3 实现Callable接口
- 1.7.4 线程池
-
- 1.7.4.1 Executors默认线程池
- 1.7.4.2 Executors创建指定上限的线程池
- 1.7.4.3 线程池ThreadPoolExecutor
- 1.7.4.4 参数：任务的拒绝策略
- 1.8 线程周期
- 2 线程同步
-
- 2.1 线程导致的安全问题
- 2.2 解决方法
-
- 2.2.1 同步代码块
- 2.2.2 同步方法
- 2.2.3 注意事项 `重要`
-
- 1 锁的指定
- 2 锁的使用
- 3 释放锁的操作
- 4 不会释放锁的操作
- 3 了解线程安全的类
- 4 Lock锁
- 5 死锁（操作系统知识点）
-
- 5.1 定义
- 5.2 产生的原因
-
- 5.2.1 两大原因
- 5.2.2 四个必要条件
- 5.3 处理死锁的基本方法
-
- 5.3.1 预防死锁
- 5.3.2 避免死锁
- 6 经典案例
-
- 6.1 生产者和消费者问题
1 多线程
1.1进程和线程
- 进程：
- 是内存中正在运行的程序（进程即运行的程序）
- 是系统进行资源分配和调用的独立单位
- 进程都有它自己的内存空间，具体分为代码区、数据区和堆栈区，进程之间的地址空间是隔离的，互不影响
- 线程：
- 是进程中的单个顺序控制流，是一条执行路径，是一个执行单元
- 每个线程拥有独立的运行栈和程序计数器（PC）
- 单线程：一个进程如果只有一条执行路径，则称为单线程程序
- 多线程：一个进程如果有多条执行路径，则称为多线程程序
- 进程与线程的关系
- 本质区别：进程是操作系统资源分配的基本单位，而线程是**处理器任务调度和执行（CPU）**的基本单位。
- 包含关系：一个进程至少有一个线程，线程是进程的一部分，所以线程也被称为轻权进程或者轻量级进程。
- 资源开销：每个进程都有独立的地址空间，进程之间的切换会有较大的开销；线程可以看做轻量级的进程，同一个进程内的线程共享进程的地址空间，每个线程都有自己独立的运行栈和程序计数器，线程之间切换的开销小。
- 影响关系：一个进程崩溃后，在保护模式下其他进程不会被影响，但是一个线程崩溃可能导致整个进程被操作系统杀掉，所以多进程要比多线程健壮。
我们可以用工厂来做比对：
1.2 并发与并行
-
并行是指两个或者多个事件在同一时刻发生（多个CPU同时执行多个任务）
-
并发是指两个或多个事件在同一时间间隔发生（一个CPU通过分发时间片，同时执行多个任务）
-
并发+并行效果
1.3 计算机中的核心数和线程数
可通过如下代码获取电脑的配置信息，核心数和线程数
public class SystemInfo {
public static void main(String[] args) {
// 获取操作系统MXBean
OperatingSystemMXBean osBean = ManagementFactory.getOperatingSystemMXBean();
// 获取处理器核心数
int availableProcessors = osBean.getAvailableProcessors();
System.out.println("CPU核心数：" + availableProcessors);
// 获取线程数
ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
int threadCount = threadMXBean.getThreadCount();
System.out.println("线程数：" + threadCount);
}
}
输出数据：
-
单核心单线程：CPU在多个线程之间做高速的切换（具体如何切换需要依据相关的算法），这样轮流去执行多个线程 效率低
-
多核心多线程：可以同时执行多个线程，多个线程在多个任务之间做高速的切换，速度是单线程的多倍，换句话说，每个任务被执行到几率都被提高了多倍 效率高
1.4 线程调度
-
两种调度方式
- 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
- 抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些
-
Java使用的是抢占式调度模型
-
随机性
假如计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的
1.5 线程优先级
| 方法名 | 说明 |
|---|---|
| final int getPriority() | 返回此线程的优先级 |
| final void setPriority(int newPriority) | 更改此线程的优先级线程默认优先级是5；线程优先级的范围是：1-10 |
JDK中的线程优先级：
注意：设置了优先级并不一定说先执行完哪个任务后执行完哪个任务，只能说优先级高的在抢占的过程中获取CPU的可能性大一些
可能的执行结果1：
可能的执行结果2：
1.6 守护线程
| 方法名 | 说明 |
|---|---|
| void setDaemon(boolean on) | 将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出 |
| 在Java中，线程分为两种类型：用户线程（User Thread）和守护线程（Daemon Thread） |
守护线程是为了支持用户线程的工作而存在的
守护线程具有以下特点：
- 在用户线程结束时自动结束： 当所有的用户线程执行完毕，不管守护线程是否执行完毕，Java虚拟机都会自动退出。
- 没有执行完的守护线程会被强制终止： 如果所有的用户线程都执行完毕，而守护线程还没有执行完毕，Java虚拟机会强制终止守护线程。因此，守护线程不应该执行一些需要确保执行完毕的任务，例如写文件操作。
1.7 Java中实现多线程的四种方式
1.7.1 继承Thread类
- 定义
- 继承Thread类
- 重写run()方法 → run()是用来封装被线程执行的代码
- 使用
- 创建MyThread类的对象
- 启动线程
启动线程两种方法：
| 方法名 | 说明 |
|---|---|
| void run() | 在线程开启后，此方法将被调用执行 |
| void start() | 使此线程开始执行，Java虚拟机会调用run方法() |
-
run()方法和start()方法的区别？
-
run()：封装线程执行的代码，直接调用，相当于普通方法的调用
-
start()：启动线程；然后由JVM调用此线程的run()方法
-
public class MyThread extends Thread {
@Override
public void run() {
for(int i=0; i<100; i++) {
System.out.print(i+" ");
}
}
}
public class MyThreadDemo {
public static void main(String[] args) {
MyThread my1 = new MyThread();
MyThread my2 = new MyThread();
// my1.run();
// my2.run();
//void start() 导致此线程开始执行; Java虚拟机调用此线程的run方法
my1.start();
my2.start();
}
}
运行结果：
如果是调用run()方法来执行：
很显然，先执行了my1.run()，再执行了my2.run()
即，调用run为并发执行，调用start为并行执行。
1.7.2 实现Runnable接口
-
定义
-
实现实现Runnable接口
-
重写run()方法
-
-
使用
-
创建MyRunnable类的对象
-
创建Thread类的对象，把MyRunnable对象作为构造方法的参数
-
启动线程（仍可以选择start或者run，由上面可知，选择start能实现并行）
-
Thread构造方法：
| 方法名 | 说明 |
|---|---|
| Thread(Runnable target) | 分配一个新的Thread对象 |
| Thread(Runnable target, String name) | 分配一个新的Thread对象，name为线程名称 |
public class MyRunnable implements Runnable {
@Override
public void run() {
for(int i=0; i<100; i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
public class MyRunnableDemo {
public static void main(String[] args) {
//创建MyRunnable类的对象
MyRunnable my = new MyRunnable();
//创建Thread类的对象，把MyRunnable对象作为构造方法的参数
//Thread(Runnable target)
// Thread t1 = new Thread(my);
// Thread t2 = new Thread(my);
//Thread(Runnable target, String name)
Thread t1 = new Thread(my,"高铁");
Thread t2 = new Thread(my,"飞机");
//启动线程
t1.start();
t2.start();
}
}
- 相比继承Thread类，实现Runnable接口的好处
- 避免了Java单继承的局限性
- 适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好的体现了面向对象的设计思想
1.7.3 实现Callable接口
泛型V通常为执行结果的返回值
作用管理多线程运行的结果
| 方法名 | 说明 |
|---|---|
| V call() | 计算结果，如果无法计算结果，则抛出一个异常 |
| FutureTask(Callable callable) | 创建一个 FutureTask，一旦运行就执行给定的 Callable |
| V get() | 如有必要，等待计算完成，然后获取其结果 |
- 实现步骤
- 定义一个类MyCallable实现Callable接口
- 在MyCallable类中重写call()方法
- 创建MyCallable类的对象 → MyCallable的对象表示多线程要执行的任务
- 创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数 → FutureTask的对象作用管理多线程运行的结果
- 创建Thread类的对象，把FutureTask对象作为构造方法的参数
- 启动线程
- 再调用get方法，就可以获取线程结束之后的结果
使用 FutureTask 的一个主要优势是，它可以在任务执行的同时允许你获取多线程的执行结果；
注意，必须要在线程执行之后才可以获取结果，即必须要调用完start()函数之后，才可以获取结果。
public class MyCallable implements Callable<String> {
@Override
public String call() throws Exception {
for (int i = 0; i < 100; i++) {
System.out.println("执行第"+i+"次");
}
//返回值就表示线程运行完毕之后的结果
return "返回的结果";
}
}
public class Demo2 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//线程开启之后需要执行里面的call方法
// System.out.println("hhhhhhhhhhhh");
MyCallable mc = new MyCallable();
//Thread t1 = new Thread(mc);
//可以获取线程执行完毕之后的结果.也可以作为参数传递给Thread对象
FutureTask<String> ft = new FutureTask<>(mc);
//创建线程对象
Thread t1 = new Thread(ft);
//开启线程
t1.start();
String s = ft.get();
System.out.println("结果："+s);
}
}
程序执行结果：
1.7.4 线程池
一个容纳多个线程的容器，其中的线程可以反复使用；
省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。
线程池原理：
JDK对线程池也进行了相关的实现，在真实企业开发中我们也很少去自定义线程池，而是使用JDK中自带的线程池
我们可以使用Executors中所提供的静态方法来创建线程池
| 函数名称 | 作用 |
|---|---|
| static ExecutorService newCachedThreadPool() | 创建一个默认的线程池 |
| static newFixedThreadPool(int nThreads) | 创建一个指定最多线程数量的线程池 |
1.7.4.1 Executors默认线程池
Executors 可以帮助我们创建线程池对象
ExecutorService 可以帮助我们控制线程池
package com.itheima.mythreadpool;
//static ExecutorService newCachedThreadPool() 创建一个默认的线程池
//static newFixedThreadPool(int nThreads) 创建一个指定最多线程数量的线程池
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class MyThreadPoolDemo {
public static void main(String[] args) throws InterruptedException {
//1,创建一个默认的线程池对象.池子中默认是空的.默认最多可以容纳int类型的最大值.
ExecutorService executorService = Executors.newCachedThreadPool();
//Executors --- 可以帮助我们创建线程池对象
//ExecutorService --- 可以帮助我们控制线程池
executorService.submit(()->{ //这里重写了里面的接口
System.out.println(Thread.currentThread().getName() + "在执行了");
});
//Thread.sleep(2000);
executorService.submit(()->{
System.out.println(Thread.currentThread().getName() + "在执行了");
});
executorService.shutdown();
}
}
如果保留代码：Thread.sleep(2000)
运行结果：
如果注释掉代码：Thread.sleep(2000)
运行的结果：
1.7.4.2 Executors创建指定上限的线程池
static ExecutorService newFixedThreadPool(int nThreads) 创建一个指定最多线程数量的线程池
getPoolSize() 获取线程池的当前线程数（当前池中的活动线程数）
package com.itheima.mythreadpool;
//static ExecutorService newFixedThreadPool(int nThreads)
//创建一个指定最多线程数量的线程池
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
public class MyThreadPoolDemo2 {
public static void main(String[] args) {
//参数不是初始值而是最大值
ExecutorService executorService = Executors.newFixedThreadPool(10);
ThreadPoolExecutor pool = (ThreadPoolExecutor) executorService;
System.out.println(pool.getPoolSize());//0
executorService.submit(()->{
System.out.println(Thread.currentThread().getName() + "在执行了");
});
executorService.submit(()->{
System.out.println(Thread.currentThread().getName() + "在执行了");
});
System.out.println(pool.getPoolSize());//2
executorService.shutdown();
}
}
运行结果：
1.7.4.3 线程池ThreadPoolExecutor
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor (核心线程数量, 最大线程数量, 空闲线程最大存活时间, 任务队列, 创建线程工厂, 任务的拒绝策略) 创建线程池对象；
threadPoolExecutor.submit(Callable) 传入一个自定义接口，提交到线程池里面。
package com.itheima.mythreadpool;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class MyThreadPoolDemo3 {
// 参数一：核心线程数量
// 参数二：最大线程数
// 参数三：空闲线程最大存活时间
// 参数四：时间单位
// 参数五：任务队列，线程池通常包含一个任务队列，用于存放等待执行的任务
// 参数六：创建线程工厂
// 参数七：任务的拒绝策略
public static void main(String[] args) {
ThreadPoolExecutor pool = new ThreadPoolExecutor(2,5,2,TimeUnit.SECONDS,new ArrayBlockingQueue<>(10), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
pool.submit(new MyRunnable());
pool.submit(new MyRunnable());
pool.shutdown();
}
}
1.7.4.4 参数：任务的拒绝策略
RejectedExecutionHandler是jdk提供的一个任务拒绝策略接口，它下面存在4个子类。
| 拒绝策略接口 | 解释 |
|---|---|
| ThreadPoolExecutor.AbortPolicy | 丢弃任务并抛出RejectedExecutionException异常。是默认的策略 |
| ThreadPoolExecutor.DiscardPolicy | 丢弃任务，但是不抛出异常 这是不推荐的做法 |
| ThreadPoolExecutor.DiscardOldestPolicy | 抛弃队列中等待最久的任务 然后把当前任务加入队列中 |
| ThreadPoolExecutor.CallerRunsPolicy | 调用任务的run()方法绕过线程池直接执行 |
注：明确线程池最多可执行的任务数 = 队列容量 + 最大线程数（线程池通常包含一个任务队列，用于存放等待执行的任务）
public class ThreadPoolExecutorDemo01 {
public static void main(String[] args) {
/**
* 核心线程数量为1 ， 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s
*/
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS ,
new ArrayBlockingQueue<>(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.AbortPolicy()) ;
// 提交5个任务，而该线程池最多可以处理4个任务，当我们使用AbortPolicy这个任务处理策略的时候，就会抛出异常
for(int x = 0 ; x < 5 ; x++) {
threadPoolExecutor.submit(() -> {
System.out.println(Thread.currentThread().getName() + "---->> 执行了任务");
});
}
}
}
控制台输出结果
控制台报错，仅仅执行了4个任务，有一个任务被丢弃了
1.8 线程周期
线程的生命周期：
其中的其他阻塞式方法包括：
-
sleep(long time)：用于使当前线程暂时休眠（阻塞）指定的时间 -
join()：用于等待调用该方法的线程执行完毕 -
wait()：用于在某个对象上等待，同时释放对象的锁 -
suspend()：用于暂停线程的执行。但是，suspend方法已被废弃（deprecated），不推荐使用。因为在调用suspend方法时，线程会被挂起，并且可能导致死锁或其他问题。替代方案是使用wait和notify等机制进行线程间的协作
方法时间到，阻塞方式结束的方式包括：
sleep()时间到join()结束notify()/notifyAll()resume()：恢复被suspend()挂起的线程。但resume()方法也已经被废弃（deprecated），不再推荐使用，因为它容易导致死锁等问题。在现代的 Java 编程中，不应该使用suspend()和resume()
2 线程同步
进程之间的两种制约关系：同步与互斥
同步（直接制约）：多个进程若有执行顺序的之间的要求，则我们称之为两个进程有同步关系
互斥（间接制约）：若多个进程要求访问临界资源，而临界资源一次只能由一个进程访问，因此而产生的竞争关系称为互斥
2.1 线程导致的安全问题
线程执行的随机性会导致一些安全问题。
最经典的一个例子：电影院卖票。共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票
出现的问题：
-
相同的票出现了多次
分析原因：
while (true) { //tickets = 100; //t1,t2,t3 //假设t1线程抢到CPU的执行权 if (tickets > 0) { //通过sleep()方法来模拟出票时间 try { Thread.sleep(100); //t1线程休息100毫秒 //t2线程抢到了CPU的执行权，t2线程就开始执行，执行到这里的时候，t2线程休息100毫秒 //t3线程抢到了CPU的执行权，t3线程就开始执行，执行到这里的时候，t3线程休息100毫秒 } catch (InterruptedException e) { e.printStackTrace(); } //假设线程按照顺序醒过来 //t1抢到CPU的执行权，在控制台输出：窗口1正在出售第100张票 System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票"); //t2抢到CPU的执行权，在控制台输出：窗口2正在出售第100张票 //t3抢到CPU的执行权，在控制台输出：窗口3正在出售第100张票 tickets--; //如果这三个线程还是按照顺序来，这里就执行了3次--的操作，最终票就变成了97 } } -
出现了负数的票
分析原因：
while (true) { //tickets = 1; //t1,t2,t3 //假设t1线程抢到CPU的执行权 if (tickets > 0) { //通过sleep()方法来模拟出票时间 try { Thread.sleep(100); //t1线程休息100毫秒 //t2线程抢到了CPU的执行权，t2线程就开始执行，执行到这里的时候，t2线程休息100毫秒 //t3线程抢到了CPU的执行权，t3线程就开始执行，执行到这里的时候，t3线程休息100毫秒 } catch (InterruptedException e) { e.printStackTrace(); } //假设线程按照顺序醒过来 //t1抢到了CPU的执行权，在控制台输出：窗口1正在出售第1张票 //假设t1继续拥有CPU的执行权，就会执行tickets--;操作，tickets = 0; //t2抢到了CPU的执行权，在控制台输出：窗口1正在出售第0张票 //假设t2继续拥有CPU的执行权，就会执行tickets--;操作，tickets = -1; //t3抢到了CPU的执行权，在控制台输出：窗口3正在出售第-1张票 //假设t2继续拥有CPU的执行权，就会执行tickets--;操作，tickets = -2; System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票"); tickets--; } }
2.2 解决方法
-
安全问题出现的条件
-
是多线程环境
-
有共享数据
-
有多条语句操作共享数据
-
-
如何解决多线程安全问题呢?
- 基本思想：让程序没有安全问题的环境（破环三个条件中的一个）
-
怎么实现呢?
- 把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可
- Java提供了同步代码块的方式来解决
- Java还提供了同步方法的方式来解决
2.2.1 同步代码块
-
同步代码块格式：
synchronized(任意对象) { 多条语句操作共享数据的代码 }synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁
-
同步的好处和弊端
-
好处：解决了多线程的数据安全问题
-
弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率
-
public class SellTicket implements Runnable {
private int tickets = 100;
private Object obj = new Object();
@Override
public void run() {
while (true) {
//tickets = 100;
//t1,t2,t3
//假设t1抢到了CPU的执行权
//假设t2抢到了CPU的执行权
synchronized (obj) {
//t1进来后，就会把这段代码给锁起来
if (tickets > 0) {
try {
Thread.sleep(100);
//t1休息100毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}
//窗口1正在出售第100张票
System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
tickets--; //tickets = 99;
}
}
//t1出来了，这段代码的锁就被释放了
}
}
}
为什么要有这个obj？
这里的obj是一把锁。多个线程共用这一把锁，才能保证共享资源的安全
2.2.2 同步方法
同步方法会在方法级别进行同步，确保在同一时刻只有一个线程能够执行该方法
-
一般同步方法
就是把synchronized关键字加到方法上
修饰符 synchronized 返回值类型 方法名(方法参数) { 方法体； }同步方法的锁对象是：this
private synchronized void sellTicket() { if (tickets > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票"); tickets--; } } -
静态同步方法：就是把synchronized关键字加到静态方法上
修饰符 static synchronized 返回值类型 方法名(方法参数) { 方法体； }同步静态方法的锁对象是：类名.class
private static synchronized void sellTicket() { if (tickets > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票"); tickets--; } }
2.2.3 注意事项 重要
1 锁的指定
-
任意对象都可以作为同步锁
-
同步代码块中：自己指定，很多时候是this或类名.class
-
同步方法中：非静态方法用this，静态方法类名.class
2 锁的使用
-
必须保证使用同一个资源的多个线程共用一把锁，破坏这条规则将无法保证共享资源的安全
-
一个线程类中的所有静态方法共用同一把锁（类名.class），所有非静态方法共用同一把锁（this）
3 释放锁的操作
- 当前线程的同步方法、同步代码块执行结束
- 当前线程在同步代码块、同步方法中遇到
break、return终止了该代码块、 该方法的继续执行 - 当前线程在同步代码块、同步方法中出现了
未处理的Error或Exception，导致异常结束 - 当前线程在同步代码块、同步方法中执行了线程对象的
wait()方法，当前线程暂停，并释放锁
4 不会释放锁的操作
- 线程执行同步代码块或同步方法时，程序调用``Thread.sleep()、 Thread.yield()`方法暂停当前线程的执行
- 线程执行同步代码块时，其他线程调用了该线程的
suspend()方法将该线程 挂起，该线程不会释放锁（同步监视器）。 - 应尽量避免使用
suspend()和resume()来控制线程
3 了解线程安全的类
-
StringBuffer
-
线程安全，可变的字符序列
-
从版本JDK 5开始，被StringBuilder 替代。 通常应该使用StringBuilder类，因为它支持所有相同的操作，但它更快，因为它不执行同步
-
-
Vector
- 从Java 2平台v1.2开始，该类改进了List接口，使其成为Java Collections Framework的成员。 与新的集合实现不同， Vector被同步。 如果不需要线程安全的实现，建议使用ArrayList代替Vector
-
Hashtable
- 该类实现了一个哈希表，它将键映射到值。 任何非null对象都可以用作键或者值
- 从Java 2平台v1.2开始，该类进行了改进，实现了Map接口，使其成为Java Collections Framework的成员。 与新的集合实现不同， Hashtable被同步。 如果不需要线程安全的实现，建议使用HashMap代替Hashtable
4 Lock锁
-
lock锁锁什么？
锁住了同步代码块的部分
-
为什么引入lock锁？
虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock
Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化
-
ReentrantLock构造方法
方法名 说明 ReentrantLock() 创建一个ReentrantLock的实例 -
加锁解锁方法
方法名 说明 void lock() 获得锁 void unlock() 释放锁
public class SellTicket implements Runnable {
private int tickets = 100;
private Lock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
try {
lock.lock();
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
tickets--;
}
} finally {
lock.unlock();
}
}
}
}
public class SellTicketDemo {
public static void main(String[] args) {
SellTicket st = new SellTicket();
Thread t1 = new Thread(st, "窗口1");
Thread t2 = new Thread(st, "窗口2");
Thread t3 = new Thread(st, "窗口3");
t1.start();
t2.start();
t3.start();
}
}
5 死锁（操作系统知识点）
5.1 定义
死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞现象，若无外力作用，它们都将无法推进下去
5.2 产生的原因
5.2.1 两大原因
- 竞争不可剥夺资源（可剥夺资源不会产生死锁）
- 进程推进顺序不当
5.2.2 四个必要条件
- 互斥条件
- 请求和保持条件
- 不可剥夺条件
- 循环等待条件
5.3 处理死锁的基本方法
5.3.1 预防死锁
事先预防的方法。通过设置某些限制条件，去破坏产生死锁的四个必要条件中的一个或几个
-
破坏互斥条件
就是在系统里取消互斥。若资源不被一个进程独占使用，那么死锁是肯定不会发生的。但一般来说，所列的四个条件中，“互斥”条件很难破坏，但是可以利用spooling技术破坏。
-
破坏请求和保持条件
即在进程在其运行之前一次申请所需求的所有资源，在它的资源未满足前，不分配资源，不投入运行
-
破坏不可剥夺条件
即破坏“不可抢占“条件，就是允许对资源实行抢夺
-
破坏循环等待条件
破坏”循环等待“条件的一种方法，是将系统中的所有资源统一编号，进程可在任何时候提出资源申请，但所有的申请必须按照资源的编号顺序（升序）提出。这样做就能保证系统不出现死锁。
5.3.2 避免死锁
在资源动态分配的过程中，用某种方法防止系统进入不安全状态，从而避免发生死锁
其中，银行家算法是一种最有代表性的避免死锁的算法
6 经典案例
6.1 生产者和消费者问题
生产者消费者模式是一个十分经典的多线程协作的模式。
所谓生产者消费者问题，实际上主要是包含了两类线程：
-
一类是生产者线程用于生产数据
-
一类是消费者线程用于消费数据
为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库
-
生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为
-
消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为
- Object类的等待和唤醒方法
| 方法名 | 说明 |
|---|---|
| void wait() | 导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法 |
| void notify() | 唤醒正在等待对象监视器的单个线程 |
| void notifyAll() | 唤醒正在等待对象监视器的所有线程 |
wait()、notify()、和notifyAll()是Java中用于实现线程间协作的方法，它们是Object类的成员方法，因此可以被任何Java对象调用。这些方法必须在同步块或同步方法中调用，因为它们依赖于对象的监视器（monitor）synchronized (obj) { // some code obj.wait(); // 释放obj的锁，线程进入等待状态 // some code after notify }synchronized (obj) { // some code obj.notify(); // 唤醒等待在obj上的一个线程 // or obj.notifyAll(); 唤醒等待在obj上的所有线程 // some code after notify }对象的监视器，即对象的内部锁。每个对象都有一个内部锁，但内部锁不是对象的属性，是Java中用于管理多线程访问共享资源的机制。当一个线程进入同步代码块或同步方法时，它会自动获取对象的内部锁，并在退出同步代码块或方法时释放这个锁。这种机制确保了同一时刻只有一个线程能够执行被锁保护的代码。
-
生产者消费者案例中包含的类：
奶箱类(Box)：定义一个成员变量，表示第x瓶奶，提供存储牛奶和获取牛奶的操作
生产者类(Producer)：实现Runnable接口，重写run()方法，调用存储牛奶的操作
消费者类(Customer)：实现Runnable接口，重写run()方法，调用获取牛奶的操作
测试类(BoxDemo)：里面有main方法，main方法中的代码步骤如下
①创建奶箱对象，这是共享数据区域
②创建消费者创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
③对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作
④创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
⑤启动线程
-
代码实现
public class Box { //定义一个成员变量，表示第x瓶奶 private int milk; //定义一个成员变量，表示奶箱的状态 private boolean state = false; //提供存储牛奶和获取牛奶的操作 public synchronized void put(int milk) { //如果有牛奶，等待消费 if(state) { try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } } //如果没有牛奶，就生产牛奶 this.milk = milk; System.out.println("送奶工将第" + this.milk + "瓶奶放入奶箱"); //生产完毕之后，修改奶箱状态 state = true; //唤醒其他等待的线程 notifyAll(); } public synchronized void get() { //如果没有牛奶，等待生产 if(!state) { try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } } //如果有牛奶，就消费牛奶 System.out.println("用户拿到第" + this.milk + "瓶奶"); //消费完毕之后，修改奶箱状态 state = false; //唤醒其他等待的线程 notifyAll(); } } public class Producer implements Runnable { private Box b; public Producer(Box b) { this.b = b; } @Override public void run() { for(int i=1; i<=30; i++) { b.put(i); } } } public class Customer implements Runnable { private Box b; public Customer(Box b) { this.b = b; } @Override public void run() { while (true) { b.get(); } } } public class BoxDemo { public static void main(String[] args) { //创建奶箱对象，这是共享数据区域 Box b = new Box(); //创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作 Producer p = new Producer(b); //创建消费者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作 Customer c = new Customer(b); //创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递 Thread t1 = new Thread(p); Thread t2 = new Thread(c); //启动线程 t1.start(); t2.start(); } } -
运行结果：
