Java多线程笔记
文章目录
-
- 线程简介（Process AND Thread）
-
- 本章核心概念
- 线程实现（重点）
-
- 线程创建（Thread、Runnable、Callable）
-
- 1.Thread class 继承Thread类（重点）
-
- 总结：注意
- 案例：网图下载
- 2.Runnable接口 实现Runnable接口（最为重点）
-
- 跟直接extend Thread的区别：
- 小结：注意
- 案例：龟兔赛跑-Race
- 3.Callable接口 实现Callable接口（学习阶段了解）
-
- 案例：修改上面的图片下载
- 实现静态代理对比Thread
- 补充：Lamda表达式
- Lamda小结：注意
- 线程状态(5个)
- 线程同步（重点）
-
-
-
- 死锁产生的条件【重点】
- Lock锁
- 三大不安全例子：
- 补充：JUC包下的CopyOnWriteArrayList
-
-
- 线程通信问题
- 高级主题
- 总结:
-
- 1. 线程创建（3种方式）
- 线程同步
线程简介（Process AND Thread）
1.任务，进程，线程，多线程
- 1.1 任务
- 1.1.1 多任务：
多任务处理是指用户可以在同一时间内运行多个应用程序,每个应用程序被称作一个任务。
现实生活中很多同时要做很多件时间的例子，例如：边吃饭边玩手机，边蹲厕所边玩手机，边听歌边跑步等等。看起来是多个任务都在做，其实本质上我们的大脑在同一时间依旧只做了一件事。
- 1.1.1 多任务：
- 1.2 多线程
- 1.2.1 多线程
在程序中同时运行多个线程，每个线程都是独立运行的，即有自己的执行路径、栈、寄存器等资源，并且可以同步地访问共享数据
原本汽车在一条道路很窄，道路拥挤效率极低，但是为了提高效率，会添加车道。
- 1.2.1 多线程
- 1.3 进程
- 1.3.1 程序概念
程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念 - 1.3.2 进程概念
进程是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位。
- 1.3.1 程序概念
- 1.4 线程
- 1.4.1 线程概念
通常，一个进程可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位。
- 1.4.1 线程概念
本章核心概念
-
- 线程就是独立的执行路径
-
- 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程；
-
- main()称之为主线程，为系统的入口，用于执行整个程序。
-
- 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为的干预的。
-
- 对同一份资源操作时，会存在资源抢夺问题，需要加入并发控制；
-
- 线程会带来额外的开销，如cpu调度时间，并发控制开销。
-
- 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。
线程实现（重点）
线程创建（Thread、Runnable、Callable）
1.Thread class 继承Thread类（重点）
-
- 自定义线程类继承Thread类
-
- 重写run()方法，编写线程执行体
-
- 创建线程对象，调用start()方法启动线程
-
- 例：
- 例：
总结：注意
线程开启不一定立即执行，由CPU调度执行。执行的时候需要调用start()方法，不能直接调用run（）方法。
案例：网图下载
使用多线程下载多个图片。
-
- 导入commons-io 2.6.jar包 https://commons.apache.org/proper/commons-io/
-
- 项目中新建lib目录，并右键jar包 -> Add as Library
- 项目中新建lib目录，并右键jar包 -> Add as Library
-
- 代码示例：
// 实现多线程下载图片
public class TestThread extends Thread{
private String url; // 网络图片地址
private String name; // 保存的文件名
public TestThread(String url,String name){
this.url = url;
this.name = name;
}
@Override
public void run() {
WebDownloader webDownloader = new WebDownloader();
webDownloader.downLoader(url,name);
System.out.println("下载了文件名为：" + name );
}
public static void main(String[] args) {
TestThread thread = new TestThread("https://img0.baidu.com/it/u=3663508195,2907650417&fm=253&app=138&size=w931&n=0&f=JPEG&fmt=auto?sec=1697043600&t=50896d6d3a067f36990a6a406401f13a","2.jpg");
TestThread thread2 = new TestThread("https://img0.baidu.com/it/u=3663508195,2907650417&fm=253&app=138&size=w931&n=0&f=JPEG&fmt=auto?sec=1697043600&t=50896d6d3a067f36990a6a406401f13a","3.jpg");
TestThread thread3 = new TestThread("https://img0.baidu.com/it/u=3663508195,2907650417&fm=253&app=138&size=w931&n=0&f=JPEG&fmt=auto?sec=1697043600&t=50896d6d3a067f36990a6a406401f13a","4.jpg");
thread.start();
thread2.start();
thread3.start();
}
}
class WebDownloader{
// 下载方法
public void downLoader(String url,String name){
try {
FileUtils.copyURLToFile(new URL(url),new File(name));
} catch (IOException e) {
e.printStackTrace();
System.out.println("IO异常，downLoader方法出现问题");
}
}
}
-
- 效果展示：
- 效果展示：
2.Runnable接口 实现Runnable接口（最为重点）
-
- 定义MyRunnable类实现Runnable接口
-
- 实现run()方法，编写线程执行体
-
- 创建线程对象，调用start()方法启动线程（执行线程需要丢入Runnable接口实现类，再调用start方法）
-
- 如图：
- 如图：
跟直接extend Thread的区别：
实现接口的时候再调用方面的区别，Runnable需要多一步把线程对象放到Thread里面
小结：注意
-
- 继承Thread类
- 1.1 子类继承Thread类具备多线程能力
- 1.2 启动线程：子类对象.start()
- 1.3 不建议使用：避免OOP（面向对象程序设计(Object Oriented Programming)）单继承的局限性。
-
- 实现Runnable接口
- 2.1 实现接口Runnable具有多线程能力
- 2.2 启动线程：传入目标对象+Thread对象.start()
- 2.3 推荐使用：避免单继承的局限性，灵活方便，方便同一个对象被多个线程使用
-
- 买车票的例子（多个线程操作同一个资源的情况下，线程不安全，数据紊乱。）
- 买车票的例子（多个线程操作同一个资源的情况下，线程不安全，数据紊乱。）
- 现象（数据紊乱）
案例：龟兔赛跑-Race
public class Race implements Runnable{
// 胜利者
private static String winner;
@Override
public void run() {
// 来个100米的距离
for (int i = 0; i <= 100; i++) {
// 模拟兔子睡觉
if (Thread.currentThread().getName().equals("兔子") && i%10==0){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 判断比赛是否结束
boolean flag = gameOver(i);
// 如果比赛结束，则停止程序
if (flag){
break;
}
System.out.println(Thread.currentThread().getName() + "跑了" + i + "步");
}
}
// 判断是否完成比赛
public boolean gameOver(int steps){
// 判断是否为胜利者
if (winner != null){ // 已经存在胜利者
return true;
}else {
if (steps >= 100){
winner = Thread.currentThread().getName();
System.out.println("winner is" + winner);
return true;
}
}
return false;
}
public static void main(String[] args) {
Race race = new Race();
new Thread(race,"兔子").start();
new Thread(race,"乌龟").start();
}
}
- 效果：
3.Callable接口 实现Callable接口（学习阶段了解）
- 1.
案例：修改上面的图片下载
package com.dapeng.callcable;
import com.dapeng.Demo.TestThread;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;
/**
* @Description 通过Callable接口创建线程
* 好处：
* 1. 可以自定义返回值
* 2. 可以抛出异常
* @Author zhaopeng
* @Date 2023/10/10 16:51
*/
public class testCallable implements Callable<Boolean> {
private String url; // 网络图片地址
private String name; // 保存的文件名
public testCallable(String url,String name){
this.url = url;
this.name = name;
}
@Override
public Boolean call() {
WebDownloader webDownloader = new WebDownloader();
webDownloader.downLoader(url,name);
System.out.println("下载了文件名为：" + name );
return true;
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
testCallable t1 = new testCallable("https://img0.baidu.com/it/u=3663508195,2907650417&fm=253&app=138&size=w931&n=0&f=JPEG&fmt=auto?sec=1697043600&t=50896d6d3a067f36990a6a406401f13a","2.jpg");
testCallable t2 = new testCallable("https://img0.baidu.com/it/u=3663508195,2907650417&fm=253&app=138&size=w931&n=0&f=JPEG&fmt=auto?sec=1697043600&t=50896d6d3a067f36990a6a406401f13a","3.jpg");
testCallable t3 = new testCallable("https://img0.baidu.com/it/u=3663508195,2907650417&fm=253&app=138&size=w931&n=0&f=JPEG&fmt=auto?sec=1697043600&t=50896d6d3a067f36990a6a406401f13a","4.jpg");
// 创建执行服务
ExecutorService ser = Executors.newFixedThreadPool(3);
// 提交执行
Future<Boolean> r1 = ser.submit(t1);
Future<Boolean> r2 = ser.submit(t2);
Future<Boolean> r3 = ser.submit(t3);
// 获取结果
Boolean rs1 = r1.get();
Boolean rs2 = r2.get();
Boolean rs3 = r3.get();
// 关闭服务
ser.shutdownNow();
}
}
class WebDownloader{
// 下载方法
public void downLoader(String url,String name){
try {
FileUtils.copyURLToFile(new URL(url),new File(name));
} catch (IOException e) {
e.printStackTrace();
System.out.println("IO异常，downLoader方法出现问题");
}
}
}
实现静态代理对比Thread
- 总结：
- 1.真实对象和代理对象都要事先同一个接口
-
- 代理对象要代理真实角色
- 好处：
-
- 代理对象可以做很多真实对象做不了的事情
-
- 真实对象专注做自己的事情
-
package com.dapeng.staticProxy;
/**
* @Description
* @Author zhaopeng
* @Date 2023/10/10 17:09
*/
// 总结：静态代理模式总结：
// 真实对象和代理对象都要事先同一个接口
// 代理对象要代理真实角色
// 好处：代理对象可以做很多真实对象做不了的事情
// 真实对象专注做自己的事情
public class staticProxy {
public static void main(String[] args) {
You you = new You(); // 真实对象
// 通过对比发现，括号里面的都是接口或者实现接口的类。
new Thread(()-> System.out.println("斤斤计较")).start();
new WeddingCompany(new You()).HappyMarry();
// WeddingCompany weddingCompany = new WeddingCompany(you);
// weddingCompany.HappyMarry();
}
}
interface Marry{
void HappyMarry();
}
// 真实角色
class You implements Marry{
@Override
public void HappyMarry() {
System.out.println("恭喜你结婚了！！！");
}
}
// 代理角色
class WeddingCompany implements Marry{
// 代理谁--》真实目标角色
private Marry target;
public WeddingCompany(Marry target) {
this.target = target;
}
@Override
public void HappyMarry() {
before();
this.target.HappyMarry(); // 真实对象
after();
}
private void after() {
System.out.println("结婚后，收拾房子");
}
private void before() {
System.out.println("结婚前~~~~收钱");
}
}
补充：Lamda表达式
-
- Lamda表达式概念：如下图
- Lamda表达式概念：如下图
-
- 为什么要使用Lamda表达式：
- 为什么要使用Lamda表达式：
-
- 了解函数式接口：
- 了解函数式接口：
-
- 推导Lamda表达式:
- 推导Lamda表达式:
-
- Lamda简化：
- Lamda简化：
Lamda小结：注意
-
- lamda表达式只能有一行代码的情况下才能简化为一行，如果有多行，那么就用代码块包裹。
-
- 前提是接口为函数式接口。（只有一个方法的接口）
-
- 多个参数也可以去掉参数类型，要去掉都去掉，必须加上括号。
线程状态(5个)
-
- 线程状态：
- 线程状态：
-
- 线程的方法:
- 线程的方法:
-
- 停止线程：
- 3.1 小案例，让线程停止：
- 停止线程：
package com.dapeng.Demo;
/**
* @Description 测试stop
* 1. 建议线程正常停止----> 利用次数，不建议死循环
* 2. 建议使用标志位----> 设置一个标志位
* 3. 不要使用stop或者destory等过时或者JDK不建议使用的方法
* @Author zhaopeng
* @Date 2023/10/11 10:13
*/
public class TestStop implements Runnable{
// 1. 设置一个标志位
private boolean flag = true;
@Override
public void run() {
int i = 0;
while (flag){
System.out.println("run....Thread" + i++);
}
}
// 2. 设置一个公开的方法停止线程，转换标志
public void stop(){
this.flag = false;
}
public static void main(String[] args) {
TestStop testStop = new TestStop();
new Thread(testStop).start();
for (int i = 0; i < 1000; i++) {
System.out.println("main" + i);
if (i==100){
// 调用stop的方法,切换标志位，让线程停止
testStop.stop();
System.out.println("线程停止了...");
}
}
}
}
3.2 效果图：
-
- 线程的休眠：（1000ms = 1s）
- 4.1 模拟网络延时和倒计时案例(写在一起了)
- 线程的休眠：（1000ms = 1s）
package com.dapeng.Demo;
/**
* @Description
* // 模拟网络延时： 放大问题的发生性
* @Author zhaopeng
* @Date 2023/10/11 10:34
*/
public class TestSleep implements Runnable{
// 票数
private int tickNums = 10;
@Override
public void run() {
while (true){
if (tickNums <= 0){
break;
}
// 模拟延时
try{
Thread.sleep(100);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "拿到了第" + tickNums-- + "票");
}
}
/**
* 倒计时
* @throws InterruptedException
*/
public static void tenDown() throws InterruptedException {
int num = 10;
while (true){
Thread.sleep(1000);
System.out.println(num--);
if (num<=0){
break;
}
}
}
public static void main(String[] args) {
// TestSleep ticket = new TestSleep();
//
// new Thread(ticket,"小明").start();
// new Thread(ticket,"老师").start();
// new Thread(ticket,"黄牛").start();
try {
tenDown();
} catch (InterruptedException e) {
System.out.println("倒计时出错");
e.printStackTrace();
}
}
}
-
- 线程的礼让：
- 5.1礼让测试Demo：
- 线程的礼让：
package com.dapeng.Demo;
/**
* @Description
* 测试礼让线程
* 礼让不一定成功，看cpu心情
* @Author zhaopeng
* @Date 2023/10/11 10:50
*/
public class TestYield {
public static void main(String[] args) {
MyYield myYield = new MyYield();
new Thread(myYield,"a").start();
new Thread(myYield,"b").start();
}
}
class MyYield implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "开始线程");
Thread.yield();
System.out.println(Thread.currentThread().getName() + "停止线程");
}
}
-
- Join:
- 6.1 JoinDemo案例：
- Join:
package com.dapeng.Demo;
/**
* @Description
* 测试Join方法
* 想象为插队
* @Author zhaopeng
* @Date 2023/10/11 10:54
*/
public class TestJoin implements Runnable{
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println("线程VIP来了" + i);
}
}
public static void main(String[] args) throws InterruptedException {
// 开启线程
TestJoin testJoin = new TestJoin();
Thread thread = new Thread(testJoin);
thread.start();
// 主线程
for (int i = 0; i < 500; i++) {
if (i == 200){
thread.join();// 插队,main线程阻塞
}
System.out.println("main" + i);
}
}
}
效果图：
-
- 线程状态观测：
- 7.1 观察线程状态Demo：
- 线程状态观测：
package com.dapeng.Demo;
/**
* @Description
* @Author zhaopeng
* @Date 2023/10/11 11:06
*/
public class TestState {
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(() -> {
for (int i = 0; i < 5; i++) {
try {
System.out.println("要进入睡眠了");
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("");
});
// 查看状态：
Thread.State state = thread.getState();
System.out.println(state); // NEW
// 观察启动后
thread.start();
state = thread.getState();
System.out.println("启动后：" + state); // RUN
//只要线程不终止，就一直输出状态
while (state != Thread.State.TERMINATED){
Thread.sleep(100); // 睡眠0.1秒
state = thread.getState(); // 更新线程状态
System.out.println( "睡眠的状态：" + state); // 输入状态
}
}
}
效果：
-
- 线程的优先级：
- 8.1 优先级Demo案例：
- 线程的优先级：
package com.dapeng.Demo;
/**
* @Description
* @Author zhaopeng
* @Date 2023/10/11 11:32
*/
public class TestPriority {
public static void main(String[] args) {
// 主线程默认优先级
System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());
MyPriority myPriority = new MyPriority();
Thread t1 = new Thread(myPriority,"t1");
Thread t2 = new Thread(myPriority,"t2");
Thread t3 = new Thread(myPriority,"t3");
Thread t4 = new Thread(myPriority,"t4");
Thread t5 = new Thread(myPriority,"t5");
// 先设置优先级，再启动
t1.start();
t2.setPriority(1);
t2.start();
t3.setPriority(Thread.MAX_PRIORITY);
t3.start();
t4.setPriority(4);
t4.start();
t5.setPriority(9);
t5.start();
}
}
class MyPriority implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
}
}
效果：
性能倒置：优先级低的线程被cpu调度，但是优先级高的线程在等待（一般不会出现）
-
- 守护(daemon)线程：
- 9.1 守护线程案例Demo：
- 守护(daemon)线程：
package com.dapeng.Demo;
/**
* @Description
* 守护线程测试
* @Author zhaopeng
* @Date 2023/10/11 11:48
*/
public class TestDaemon {
public static void main(String[] args) {
God god = new God();
You you =new You();
Thread godThread = new Thread(god,"god");
godThread.setDaemon(true); // 默认是false表示用户线程，正常的线程都是用户线程。。。true表示守护线程
godThread.start();
new Thread(you,"you").start();
}
}
class God implements Runnable{
@Override
public void run() {
while (true){
System.out.println("上帝再守护你");
}
}
}
class You implements Runnable{
@Override
public void run() {
for (int i = 0; i < 36500; i++) {
System.out.println("你开心活着");
}
System.out.println("========== GoodBye 世界 ======");
}
}
效果：
线程同步（重点）
多个线程操作同一个资源
- 1.并发：同一个对象被多个线程操作
- 1.1 现实生活中，我们会遇到同一个资源，多人都想用的问题。比如食堂排队或者上厕所排队等，最原生的办法就是排队一个一个来。
- 1.2 处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，这个时候我们就需要线程同步，线程同步就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。
-
- 队列和锁：
队列：简单来说就像去食堂排队，如果不排队就会乱了，所以需要依次排队。
锁 ：简单来说，一群人排队上厕所，排好队以后，占着厕所才能安心拉粑粑或者解手。
形成同步的条件就是：队列加锁，可以解决线程的安全性。
- 队列和锁：
-
- 线程同步：
- 线程同步：
-
- 同步方法：
- 4.1同步方法的弊端：
- 4.2 同步块：
- 同步方法：
-
- 死锁：
- 5.1 死锁Demo：
- 死锁：
package com.dapeng.juctest;
/**
* @Description 死锁：多个线程互相抱着对方需要的资源，然后形成僵持
* @Author zhaopeng
* @Date 2023/10/11 16:13
*/
public class DeadLock {
public static void main(String[] args) {
MakeUp makeUp = new MakeUp(0,"女孩");
MakeUp makeUp2 = new MakeUp(2,"女孩222");
makeUp.start();
makeUp2.start();
}
}
// 口红
class Lipstic {
}
// 镜子
class Mirror {
}
// 化妆
class MakeUp extends Thread {
//需要的资源只有一份，用static来保证只有一份
static Lipstic lipstic = new Lipstic();
static Mirror mirror = new Mirror();
int choice; // 选择
String girlname; // 女孩
MakeUp(int choice, String girlname) {
this.choice = choice;
this.girlname = girlname;
}
@Override
public void run() {
// 化妆
try {
makeUp();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
private void makeUp() throws InterruptedException {
if (choice == 0){
synchronized (lipstic){// 获得口红锁
System.out.println(this.girlname + "获得口红锁");
Thread.sleep(1000);
synchronized (mirror){
System.out.println(this.girlname + "获得镜子锁");
}
}
// 解决办法，将里面的同步块拿出来
// synchronized (mirror){
// System.out.println(this.girlname + "获得镜子锁");
// }
}else {
synchronized (mirror){// 获得口红锁
System.out.println(this.girlname + "获得镜子锁");
Thread.sleep(2000);
synchronized (lipstic){
System.out.println(this.girlname + "获得口红锁");
}
}
// 解决办法，将里面的同步块拿出来
// synchronized (lipstic){
// System.out.println(this.girlname + "获得口红锁");
// }
}
}
}
效果：程序卡死。
死锁产生的条件【重点】
- 死锁产生的四个必要条件：
-
- 互斥条件：一个资源每次只能被一个进程使用。
-
- 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
-
- 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺。
-
- 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。
上面列出了死锁的四个必要条件，我们只要想办法破其中的任意一个或多个条件就可以避免死锁发生
- 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。
-
Lock锁
-
- Lock锁
可重入锁（ReentrantLock）
- Lock锁
- Demo：
package com.dapeng.juctest;
import java.util.concurrent.locks.ReentrantLock;
/**
* @Description
* @Author zhaopeng
* @Date 2023/10/11 16:40
*/
public class TestLock {
public static void main(String[] args) {
TestLock2 testLock2 = new TestLock2();
new Thread(testLock2).start();
new Thread(testLock2).start();
new Thread(testLock2).start();
}
}
class TestLock2 implements Runnable {
// 票
int tickNums = 10;
// 定义Lock锁
private final ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true){
try{
// 加锁
lock.lock();
if (tickNums>0){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(tickNums--);
}else {
break;
}
}finally {
lock.unlock();
}
}
}
}
-
- 格式：
-
- synchronized 和 Lock 的对比：
- synchronized 和 Lock 的对比：
三大不安全例子：
-
- 买票不安全Demo：
package com.dapeng.syn;
/**
* @Description
* @Author zhaopeng
* @Date 2023/10/11 14:26
*/
public class UnsafeBuyTickets {
public static void main(String[] args) {
BuyTicket buyTicket = new BuyTicket();
new Thread(buyTicket,"张三").start();
new Thread(buyTicket,"里斯").start();
new Thread(buyTicket,"毛里求斯").start();
}
}
class BuyTicket implements Runnable{
// 票
private int ticketNums = 10;
boolean flag = true;// 外部停止方式
@Override
public void run() {
// 买票
while (flag){
try {
buy();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
// synchronized 同步方法，锁的是this（本身这个类）。 在需要解决并发问题的时候需要加上synchronized
// private synchronized void buy() throws InterruptedException
private void buy() throws InterruptedException {
// 判断是否有票
if (ticketNums <= 0){
flag = false;
return;
}
// 模拟延时
Thread.sleep(100);
// 买票
System.out.println(Thread.currentThread().getName()+"拿到了第" + ticketNums--+"张票");
}
}
效果：
-
- 银行取钱不安全Demo:
package com.dapeng.syn;
/**
* @Description
* @Author zhaopeng
* @Date 2023/10/11 14:38
*/
public class UnsafeBank {
public static void main(String[] args) {
// 账户
Account account = new Account(100, "结婚基金");
Drawing you = new Drawing(account,50,"You");
Drawing wife = new Drawing(account,100,"Wife");
you.start();
wife.start();
}
}
// 账户
class Account{
int money; // 余额
String name; // 卡名
public Account(int money, String name) {
this.money = money;
this.name = name;
}
}
// 银行：模拟取款
class Drawing extends Thread{
Account account; // 账户
// 取了多少钱
int drawingMoney;
// 现在手里多少钱
int nowMoney;
public Drawing(Account account,int drawingMoney,String name){
super(name);
this.account = account;
this.drawingMoney = drawingMoney;
}
// 取钱
@Override
public void run() {
// 如果想解决并发问题，通过添加同步块synchronized(account){}来解决并发问题
// 判断有没有钱
if (account.money - drawingMoney < 0){
System.out.println(this.getName() + "钱不够了，取不了");
return;
}
// 线程睡眠，放大问题发生性
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 卡内余额 = 余额 - 你去的钱
account.money = account.money - drawingMoney;
// 你手里的钱
nowMoney = nowMoney + drawingMoney;
System.out.println(account.name + "余额为："+account.money);
// Thread.currentThread().getName() = this.getName()
System.out.println(this.getName() + "手里的钱" + nowMoney);
super.run();
}
}
效果：
-
- 不安全的List集合Demo:
package com.dapeng.syn;
import java.util.ArrayList;
import java.util.List;
/**
* @Description
*
* // 线程不安全的集合（因为多个线程操作list的时候，可能会把同一个位置给覆盖掉）
* @Author zhaopeng
* @Date 2023/10/11 15:11
*/
public class UnsafeList {
public static void main(String[] args) throws InterruptedException {
List<String> list = new ArrayList<>();
for (int i = 0; i < 10000; i++) {
new Thread(() -> {
// 通过添加同步代码块synchronized(list){}就会安全了
list.add(Thread.currentThread().getName());
}).start();
}
Thread.sleep(4000);
System.out.println(list.size());
}
}
效果：（长度不为10000，因为其中有的List集合某个下标被同时覆盖掉）
补充：JUC包下的CopyOnWriteArrayList
- juc Demo：
package com.dapeng.juctest;
import java.util.concurrent.CopyOnWriteArrayList;
/**
* @Description
* 测试JUC里面的安全集合
* @Author zhaopeng
* @Date 2023/10/11 15:46
*/
public class TestJuc {
public static void main(String[] args) throws InterruptedException {
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
for (int i = 0; i < 10000; i++) {
new Thread(() -> {
list.add(Thread.currentThread().getName());
}).start();
}
Thread.sleep(3000);
System.out.println(list.size());
}
}
线程通信问题
（生产者消费者模式）：生产者（Producer） -----> 数据缓存区 -------> 消费者（Consumer）
-
- 线程通信-分析：
- 线程通信-分析：
-
- Java提供了几个方法解决线程之间的通信问题：
- Java提供了几个方法解决线程之间的通信问题：
- 3.1 解决方式1：管程法：
- 管程法Demo:
package com.dapeng.juctest;
/**
* @Description
* 测试：生产者，消费者-----》利用缓冲区解决：管程法
* 生产者，消费者，缓冲区，产品
* @Author zhaopeng
* @Date 2023/10/11 17:03
*/
public class TestPC {
public static void main(String[] args) {
SynContainer container = new SynContainer();
new Producer(container).start();
new Consumer(container).start();
}
}
// 生产者
class Producer extends Thread{
SynContainer container;
public Producer(SynContainer container){
this.container = container;
}
// 生产
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("生产了" + i + "只鸡");
container.push(new Chicken(i));
}
}
}
// 消费者
class Consumer extends Thread{
SynContainer container;
public Consumer(SynContainer container){
this.container = container;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("消费了第" + container.pop().i + "只鸡");
}
}
}
// 产品
class Chicken{
int i ;
public Chicken(int i){
this.i = i;
}
}
// 缓冲区
class SynContainer{
// 需要一个容器大小
Chicken[] chickens = new Chicken[10];
//容器计数器
int count = 0;
// 生产者放入产品
public synchronized void push(Chicken chicken){
// 如果容器满了，就需要等待消费者消费
if (count == chickens.length){
// 通知消费者消费，生产等待
try {
System.out.println("生产者---------容器满了，赶紧消费");
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 如果没有满，我们就需要丢入产品
chickens[count] = chicken;
count++;
// 可以通知消费者消费了
System.out.println("生产者---------赶紧消费");
this.notifyAll();
}
// 消费者消费产品
public synchronized Chicken pop(){
// 判断能否消费
if (count == 0) {
// 等待生产者生产，消费者等待
try {
System.out.println("消费者---------容器没了，赶紧生产");
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 如果可以消费，消费
count--;
Chicken chicken = chickens[count];
// 吃完了通知生产者生产
System.out.println("消费者---------我吃完了，赶紧生产");
this.notifyAll();
return chicken;
}
}
-
- 2 解决方式2：信号灯法
通过一个标志位来判断，当为ture则可以唤醒，false则等待。
信号灯法Demo：
- 2 解决方式2：信号灯法
package com.dapeng.juctest;
/**
* @Description
* @Author zhaopeng
* @Date 2023/10/11 17:33
*/
public class TestPC2 {
public static void main(String[] args) {
Tv tv = new Tv();
new Player(tv).start();
new Watcher(tv).start();
}
}
// 演员
class Player extends Thread{
Tv tv;
public Player(Tv tv){
this.tv = tv;
}
@Override
public void run() {
for (int i = 0; i < 20; i++) {
if (i%2 == 0){
this.tv.play("喜羊羊与灰太狼");
}else {
this.tv.play("抖音，记录啊哈生活");
}
}
}
}
// 观众
class Watcher extends Thread{
Tv tv;
public Watcher(Tv tv){
this.tv = tv;
}
@Override
public void run() {
for (int i = 0; i < 20; i++) {
tv.watch();
}
}
}
// TV
class Tv{
// 演员表演，观众等待T
// 观众观看，演员等待F
String voice; //节目
boolean flag = true;
// 表演
public synchronized void play(String voice){
// 如果为假，观众观看，演员等待
if (!flag){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("演员表演了" + voice);
// 通知观众观看，
this.notifyAll();
this.voice = voice;
this.flag = !this.flag;
}
// 观看
public synchronized void watch(){
// 如果为真，演员表演，观众等待
if (flag){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 通知观众表演
this.notifyAll();
System.out.println("观众观看了" + voice);
this.flag = !this.flag;
}
}
高级主题
-
- 使用线程池：
线程池Demo：
- 使用线程池：
package com.dapeng.juctest;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @Description
* @Author zhaopeng
* @Date 2023/10/11 17:54
*/
public class TestPool {
public static void main(String[] args) {
// 1. 创建服务，创建线程池
// newFixedThreadPool 参数为：线程池大小
ExecutorService service = Executors.newFixedThreadPool(10);
// 执行
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
//2. 关闭连接
service.shutdown();
}
}
class MyThread implements Runnable{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() +"--"+ i );
}
}
}
总结:
1. 线程创建（3种方式）
package com.dapeng.juctest;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
* @Description 回顾线程的创建
* @Author zhaopeng
* @Date 2023/10/12 8:59
*/
public class TestNew {
public static void main(String[] args) {
new Thread1().start();
new Thread(new Thread2()).start();
FutureTask<String> futureTask = new FutureTask(new Thread3());
new Thread(futureTask).start();
try {
String s = futureTask.get();
System.out.println(s);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
//1. 继承Thread类
class Thread1 extends Thread {
@Override
public void run() {
System.out.println("Thread1");
}
}
// 2. 实现Runnable接口
class Thread2 implements Runnable {
@Override
public void run() {
System.out.println("Thread2");
}
}
// 3. 实现Callable解耦
class Thread3 implements Callable<String> {
@Override
public String call() throws Exception {
System.out.println("Thread3");
return "Thread3";
}
}
线程同步
-
- （JUC安全类型的包）concurrent包下面的一些安全类
-
- 可以通过加synchronized到需要改变的变量的方法或者同步代码块中
-
- 可通过使用JDK5的Lock锁，显式定义锁：private final ReentrantLock lock = new ReentrantLock();