- 💒 多线程
- 🚏 线程的简介
- 🚀 普通方法调用和多线程
- 🚄 程序、进程与线程
- 🚒 Process与Thread (进程与线程)
- 🚤 核心概念
- 🚏 线程的创建(重点)
- 🚀 三种创建方式
- 🚄 方式一: Thread(重点)
- 🚬 查看JDK8文档
- 🚬 如何实现
- 🚬 代码实现
- 🚬 案例:多线程同步下载图片
- 🚒 方式二:Runnable(核心重点)
- 🚬 如何实现
- 🚬 代码实现
- 🚬 案例:多线程同步下载图片
- 🚬 Thread 与 Runnable 的对比
- 🚬 小结
- 🚤 初步认识并发问题:多个线程同时 *** 作同一个对象 (案例火车站抢票)
- 🚬 案例龟兔赛跑
- 🚗 方式三:Callable(了解)
- 🚬 步骤:
- 🚬 演示:利用Callable改造图片案例
- 🚬 总结:
- 🚏 Lamda表达式
- 🚀 理解Functional Interface(函数式接口)
- 🚄 为什么要使用lambda表达式
- 🚒 lambda表达式推导(无参)
- 🚤 lambda表达式推导(有参)
- 🚬 精髓:
- 🚬 总结:
- 🚏 静态代理
- 🚬 总结:
- 🚬 好处:
- 🚏 线程的状态
- 🚀 线程的五大状态
- 🚄 线程方法
- 🚬 线程的停止
- 🚭 总结:
- 🚬 线程休眠 sleep()
- 🚭 火车站抢票(同上)
- 🚭 打印当前系统的时间
- 🚭 模拟倒计时
- 🚬 线程礼让 yield()
- 🚬 合并线程 Join
- 🚬 线程状态观测
- 🚬 线程优先级
- 🚭 源码
- 🚭 问题:性能倒置
- 🚬 守护线程
- 🚏 线程的同步(重点难点)
- 🚀 并发:同一个对象 被多个线程同时 *** 作
- 🚄 队列和锁
- 🚒 线程同步 synchronized
- 🚤 三大不安全案例
- 🚬 不安全的购票系统
- 🚬 不安全的取钱
- 🚬 不安全的集合
- 🚏 同步方法同步代码块
- 🚀 同步方法
- 🚬 同步方法的弊端
- 🚄 同步代码块(主要增删改查的对象)
- 🚒 同步块和同步方法锁的对象是什么?
- 🚤 解决三大线程不安全案例
- 🚬 安全的购票系统
- 🚭 核心代码
- 🚬 安全的取钱
- 🚭 核心代码
- 🚬 安全的集合
- 🚭 核心代码
- 🚗 JUC
- 🚬 CopyOnWriteArrayList
- 🚬 CopyOnWriteArrayList 和 synchronized
💒 多线程 🚏 线程的简介 🚀 普通方法调用和多线程 🚄 程序、进程与线程😹 作者: gh-xiaohe
😻 gh-xiaohe的博客
😽 觉得博主文章写的不错的话,希望大家三连(✌关注,✌点赞,✌评论),多多支持一下!!!
在 *** 作系统中运行的程序就是进程,比如:QQ、播放器、游戏、IDE等等
一个进程可以有多个线程,比如:视频中同时听声音,看视频,看d幕等等
🚒 Process与Thread (进程与线程)-
说起进程,就不得不说下程序。程序是指令和数据的有序集合,其本身没有任何运行的含义,是一个静态的概念。
-
而进程则是执行程序的一次执行过程,它是一个动态的概念。是系统资源分配的单位
-
通常在一个进程中可以包含若干个线程,当然一个进程中至少有一个线程,不然没有存在的意义。线程是CPU调度和执行的的单位。
- 线程就是独立的执行路径;
- 在程序运行时,即使没有自己创建线程,后台也会有多个线程,如主线程,gc线程;
- main()称之为主线程,为系统的入口,用于执行整个程序;在一个进程中,如果开辟了多个线程,线程的运行由调度器安排调度,调度器是与 *** 作系统紧密相关的,先后顺序是不能人为的干预的。
- 对同一份资源 *** 作时,会存在资源抢夺的问题,需要加入并发控制;
- 线程会带来额外的开销,如cpu调度时间,并发控制开销。
- 每个线程在自己的工作内存交互,内存控制不当会造成数据不一致
//创建线程方式一: 继承Thread类 , 重写run方法 , 调用start开启线程
//总结:注意,线程开启不一定立即执行,由CPU调度执行
public class _01Thread1 extends Thread {
//run 方法线程体
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("我在看代码..." + i);
}
}
public static void main(String[] args) {
//main线程 , 主线程
//创建线程对象
_01Thread1 t1 = new _01Thread1();
//调用start()方法开启线程
t1.start();
for (int i = 0; i < 10; i++) {
System.out.println("我在学习多线程..." + i);
}
}
}
🚬 案例:多线程同步下载图片
//练习Thread , 实现多线程同步下载图片
public class _01ThreadText extends Thread {
private String url;//网络图片地址
private String name;//保存的文件名称
public _01ThreadText(String url, String name) {
this.url = url;
this.name = name;
}
//下载图片的线程执行体
@Override
public void run() {
webDownloader1 webDownloader = new webDownloader1();
webDownloader.download(url, name);
System.out.println("下载了文件名为:" + name );
}
public static void main(String[] args) {
_01ThreadText t1= new _01ThreadText("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fc-ssl.duitang.com%2Fuploads%2Fblog%2F202105%2F10%2F20210510123852_26086.thumb.1000_0.jpg&refer=http%3A%2F%2Fc-ssl.duitang.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=auto?", "小迪1 .jpg");
_01ThreadText t2= new _01ThreadText("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fup.enterdesk.com%2Fedpic_source%2F2e%2F76%2Ff6%2F2e76f6f8a07e60425ae2ccd5cfc8c673.jpg&refer=http%3A%2F%2Fup.enterdesk.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=auto?sec=1654566996&t=487060a146876381cba58a0f825f4986", "小迪2 .jpg");
_01ThreadText t3= new _01ThreadText("http://www.kaotop.com/file/tupian/20220511/spanspan 小迪3 .jpg");
t1.start();
t2.start();
t3.start();
//理想下载顺序 t1、t2、t3 实际并非如此, 因为线程是异步执行的, 所以不一定会按照顺序执行
/*
下载了文件名为:小迪3 .jpg
下载了文件名为:小迪1 .jpg
下载了文件名为:小迪2 .jpg
每次结果都不一样, 因为线程是异步执行的
*/
}
}
//下载器
class webDownloader1 {
//下载方法
public void download(String url, String name) {
//下载代码
//文件工具类 拷贝网页url地址 到一个文件 文件名
try {
FileUtils.copyURLToFile(new URL(url), new File(name));
} catch (IOException e) {
e.printStackTrace();
System.out.println("Io异常,download方法出现问题");
}
}
}
🚒 方式二:Runnable(核心重点)
🚬 如何实现
🚬 代码实现
//创建线程方式二: 实现Runnable接口 , 重写run方法 , 执行线程需要丢入runnable接口实现类 , 调用start() 方法
public class _02Runnable1 implements Runnable {
//run 方法线程体
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println("我在看代码..." + i);
}
}
public static void main(String[] args) {
//main线程 , 主线程
//创建runnable接口实现类对象
_02Runnable1 a02Runnable1 = new _02Runnable1();
//创建线程对象,通过线程对象来开启我们的线程 代理
//方式一:
// Thread thread = new Thread(runnable1);
// thread.start();
//方式二:
new Thread(a02Runnable1).start();
for (int i = 0; i < 20; i++) {
System.out.println("我在学习多线程..." + i);
}
}
}
🚬 案例:多线程同步下载图片
public class _02RunnableText implements Runnable {
private String url;//网络图片地址
private String name;//保存的文件名称
public _02RunnableText(String url, String name) {
this.url = url;
this.name = name;
}
//下载图片的线程执行体
@Override
public void run() {
webDownloader2 webDownloader = new webDownloader2();
webDownloader.download(url, name);
System.out.println("下载了文件名为:" + name );
}
public static void main(String[] args) {
_02RunnableText t1= new _02RunnableText("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fc-ssl.duitang.com%2Fuploads%2Fblog%2F202105%2F10%2F20210510123852_26086.thumb.1000_0.jpg&refer=http%3A%2F%2Fc-ssl.duitang.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=auto?", "小迪1 .jpg");
_02RunnableText t2= new _02RunnableText("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fup.enterdesk.com%2Fedpic_source%2F2e%2F76%2Ff6%2F2e76f6f8a07e60425ae2ccd5cfc8c673.jpg&refer=http%3A%2F%2Fup.enterdesk.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=auto?sec=1654566996&t=487060a146876381cba58a0f825f4986", "小迪2 .jpg");
_02RunnableText t3= new _02RunnableText("http://www.kaotop.com/file/tupian/20220511/spanspan 小迪3 .jpg");
new Thread(t1).start();
new Thread(t2).start();
new Thread(t3).start();
//理想下载顺序 t1、t2、t3 实际并非如此, 因为线程是异步执行的, 所以不一定会按照顺序执行
/*
下载了文件名为:小迪3 .jpg
下载了文件名为:小迪1 .jpg
下载了文件名为:小迪2 .jpg
每次结果都不一样, 因为线程是异步执行的
*/
}
}
//下载器
class webDownloader2 {
//下载方法
public void download(String url, String name) {
//下载代码
//文件工具类 拷贝网页url地址 到一个文件 文件名
try {
FileUtils.copyURLToFile(new URL(url), new File(name));
} catch (IOException e) {
e.printStackTrace();
System.out.println("Io异常,download方法出现问题");
}
}
}
🚬 Thread 与 Runnable 的对比
发现问题:多个线程 *** 作同一个资源的情况下,线程不安全,数据紊乱。
火车站抢票
// 多个线程同时 *** 作同一个对象
// 火车票的列子
// 发现问题:多个线程 *** 作同一个资源的情况下,线程不安全,数据紊乱。
public class _03TestRunnable implements Runnable {
//票数
private int ticketNums= 10;
@Override
public void run() {
while (true) {
if (ticketNums <= 0) {
break;
}
//模拟延迟
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "-->拿到了第" + ticketNums-- + "张票");
}
}
public static void main(String[] args) {
_03TestRunnable ticket = new _03TestRunnable();
new Thread(ticket, "小明").start();
new Thread(ticket, "老师").start();
new Thread(ticket, "黄牛党").start();
}
}
🚬 案例龟兔赛跑
//模拟龟兔赛跑
public class _3TestRace implements Runnable {
//胜利者
private static String winner;
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
//模拟兔子休息
if (Thread.currentThread().getName().equals("兔子") && i % 10 == 0) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//判断比赛是否结束
boolean flag = gameOver(i);
//如果比赛结束,就停止程序
if (flag) {
break;
}
System.out.println(Thread.currentThread().getName() + "------>跑了" + i + "步");
}
}
//判断是否完成比赛
private boolean gameOver(int steps) {
//判断是否有胜利者
if (winner != null) {//已经存在胜利者
return true;
}
{
if (steps >= 100) {
winner = Thread.currentThread().getName();
System.out.println("winner is" + winner);//输出胜利者
return true;
}
}
return false;
}
public static void main(String[] args) {
_3TestRace testRace = new _3TestRace();
new Thread(testRace, "兔子").start();
new Thread(testRace, "乌龟").start();
}
}
🚗 方式三:Callable(了解)
🚬 步骤:
1、实现Callable接口,需要返回值类型
2、重写call方法,需要抛出异常
3、创建目标对象
4、创建执行服务:ExecutorService ser = Executors.newFixedThreadPool(3);//创建一个可重用固定线程数的线程池
5、提交执行:Future result1 = ser.submit(t1);
6、获取结果:boolean r1 = result1.get();
7、关闭服务:ser.shutdownNow();
🚬 演示:利用Callable改造图片案例
//线程创建方式三:实现Callable接口
public class _04Callable implements Callable<Boolean> {
private String url;//网络图片地址
private String name;//保存的文件名称
public _04Callable(String url, String name) {
this.url = url;
this.name = name;
}
//下载图片的线程执行体
@Override
public Boolean call() {
webDownloader webDownloader = new webDownloader();
webDownloader.download(url, name);
System.out.println("下载了文件名为:" + name);
return true;
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
_04Callable t1 = new _04Callable("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fc-ssl.duitang.com%2Fuploads%2Fblog%2F202105%2F10%2F20210510123852_26086.thumb.1000_0.jpg&refer=http%3A%2F%2Fc-ssl.duitang.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=auto?", "小迪1 .jpg");
_04Callable t2 = new _04Callable("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fup.enterdesk.com%2Fedpic_source%2F2e%2F76%2Ff6%2F2e76f6f8a07e60425ae2ccd5cfc8c673.jpg&refer=http%3A%2F%2Fup.enterdesk.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=auto?sec=1654566996&t=487060a146876381cba58a0f825f4986", "小迪2 .jpg");
_04Callable t3 = new _04Callable("http://www.kaotop.com/file/tupian/20220511/span span 小迪3 .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 result1 = r1.get();
boolean result2 = r2.get();
boolean result3 = r3.get();
//关闭服务:
ser.shutdown();
System.out.println("result1:" + result1);
System.out.println("result2:" + result2);
System.out.println("result3:" + result3);
}
}
//下载器
class webDownloader {
//下载方法
public void download(String url, String name) {
//下载代码
//文件工具类 拷贝网页url地址 到一个文件 文件名
try {
FileUtils.copyURLToFile(new URL(url), new File(name));
} catch (IOException e) {
e.printStackTrace();
System.out.println("Io异常,download方法出现问题");
}
}
}
🚬 总结:
- 1.可以定义返回值
- 2.可以抛出异常
-
函数式接口的定义:
-
任何接口,如果只包含唯一一个抽象方法,那么它就是一个函数式接口。
-
public interface Runnable { public abstract void run(); }
-
对于函数式接口,我们可以通过lambda表达式来创建该接口的对象。
-
避免匿名内部类定义过多
-
可以让你的代码看起来很简洁
-
去掉了一堆没有意义的代码,只留下核心的逻辑。
-
也许你会说,我看了Lambda表达式,不但不觉得简洁,反而觉得更乱,看不懂了。那是因为我们还没有习惯,用的多了,看习惯了,就好了。
//推到 lambda 表达式(无参)
public class TestLambda1 {
//3.静态内部类
static class Like2 implements ILike {
@Override
public void lambda() {
System.out.println("I Like Lambda2");
}
}
public static void main(String[] args) {
ILike iLike = new Like();
iLike.lambda();
iLike = new Like2();
iLike.lambda();
//4.局部内部类
class Like3 implements ILike {
@Override
public void lambda() {
System.out.println("I Like Lambda3");
}
}
iLike = new Like3();
iLike.lambda();
//5.匿名内部类 没有类名 必须使用接口或者父类
iLike = new ILike() {
@Override
public void lambda() {
System.out.println("I Like Lambda4");
}
};
iLike.lambda();
//6.用lambda简化 省略了匿名内部类 前提:任何接口 只包含一个抽象方法 这样子写就可以是一个函数式接口
iLike = () -> {
System.out.println("I Like Lambda5");
};
iLike.lambda();
}
}
//1.定义一个函数式接口
interface ILike {
void lambda();
}
//2.实体类
class Like implements ILike {
@Override
public void lambda() {
System.out.println("I Like Lambda");
}
}
🚤 lambda表达式推导(有参)
package com.gh._03lambda;
//推到 lambda 表达式(有参)
public class TestLambda2 {
//3.静态内部类
static class Love2 implements ILove {
@Override
public void love(int a) {
System.out.println("我爱你" + a);
}
}
public static void main(String[] args) {
//4.局部内部类
class Love3 implements ILove {
@Override
public void love(int a) {
System.out.println("我爱你" + a);
}
}
//5.匿名内部类
ILove love4 = new ILove() {
@Override
public void love(int a) {
System.out.println("我爱你" + a);
}
};
Love love1 = new Love();
love1.love(520);
Love2 love2 = new Love2();
love2.love( 5201314);
new Love3().love(1314520);
love4.love(521);
//6.lambda 表达式
//lambda 带参数类型
ILove love5 = (int a) -> {
System.out.println("I Love you - " + a);
};
//lambda 不带参数类型
ILove love6 = (a) -> {
System.out.println("I Love you - " + a);
};
//lambda 去掉括号
ILove love7 = a -> {
System.out.println("I Love you - " + a);
};
//lambda 去掉大括号
ILove love8 = a -> System.out.println("I Love you - " + a);
love5.love(5521);
love6.love(6521);
love7.love(7521);
love8.love(8521);
}
}
//1.定义一个函数式接口
interface ILove {
void love(int a);
}
//2.实体类
class Love implements ILove {
@Override
public void love(int a) {
System.out.println("我爱你" + a);
}
}
🚬 精髓:
//6.lambda 表达式
//lambda 带参数类型
ILove love5 = (int a) -> {
System.out.println("I Love you - " + a);
};
//lambda 不带参数类型
ILove love6 = (a) -> {
System.out.println("I Love you - " + a);
};
//lambda 去掉括号
ILove love7 = a -> {
System.out.println("I Love you - " + a);
};
//lambda 去掉大括号
ILove love8 = a -> System.out.println("I Love you - " + a);
love5.love(5521);
love6.love(6521);
love7.love(7521);
love8.love(8521);
🚬 总结:
- lambda 表达式 只有一行代码的时候 可以简化 为一行 多行 使用改代码快 {}
- 接口是函数式接口
- 多个参数 可以去掉参数类型(要去掉就需要全部去掉) 但是需要加括号
个人博客有详细讲解静态代理和动态代理
public class StaticProxy {
public static void main(String[] args) {
new Thread(()->System.out.println("我爱你")).start();
new WeddingCompany(new You()).HappyMarry();
// WeddingCompany weddingCompany = new WeddingCompany(new You());
// weddingCompany.HappyMarry();
}
}
interface Marry {
void HappyMarry(); // 结婚方法
}
//真实对象
class You implements Marry {
@Override
public void HappyMarry() {
System.out.println("我要结婚了");
}
}
//代理对象
class WeddingCompany implements Marry {
private Marry marry;
public WeddingCompany(Marry marry) {
this.marry = marry;
}
@Override
public void HappyMarry() {
before();
this.marry.HappyMarry();//调用真实角色的结婚方法
after();
}
private void after() {
System.out.println("结婚后,收尾款");
}
private void before() {
System.out.println("结婚前,布置现场");
}
}
🚬 总结:
- 真实对象和代理对象都要实现同一个接口
- 代理对象要代理真是对象
- 代理对象可以做的更多
- 真实对象可以专注的做自己想做的事情
方法 | 说明 |
---|---|
setPrioirity(int newPriority) | 更改线程的优先级 |
static void sleep(long millis) | 在指定的毫秒数内让当前正在执行的线程休眠 |
void join()(插队) | 等待该线程终止 |
static void yield()(重新竞争) | 暂停当前正在执行的线程对象,并执行其他线程 |
void interrupt())(停止线程不建议使用) | 中断线程,禁止使用此方法 |
boolean isAlive() | 测试线程是否处于活动状态 |
- 不推荐使用JDK提供的stop()、destroy()方法。【已废弃】
- 建议使用一个标志位进行终止变量当flag=false,则终止线程运行。
🚭 举例
//要让线程自己停止下来
/*
测试stop
1.建议线程正常停止---> 利用次数,不建议使用死循环。
2.建议使用标志位---> 设置一个标志位
3.不要使用stop或者destroy等过时或者JDK不建议使用的方法
*/
public class _1Stop 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) {
_1Stop testStop = new _1Stop();
new Thread(testStop).start();
for (int i = 0; i < 100; i++) {
System.out.println("main Thread"+i);
if (i == 20) {
//3.调用stop方法,切换标志位,停止运行
testStop.stop();
System.out.println("线程停止");
}
}
}
}
🚭 总结:
- 建议线程正常停止—> 利用次数,不建议使用死循环。
- 建议使用标志位—> 设置一个标志位
- 不要使用stop或者destroy等过时或者JDK不建议使用的方法
-
sleep(时间)指定当前线程阻塞的毫秒数;
-
sleep存在异常InterruptedException;
-
sleep时间达到后线程进入就绪状态;
-
sleep可以模拟网络延时,倒计时等。
-
每一个对象都有一个锁,sleep不会释放锁;
public class _2sleep2 {
public static void main(String[] args) {
//打印当前系统的时间
Date startTime = new Date(System.currentTimeMillis());//获取当前时间
while (true) {
try {
Thread.sleep(1000);//线程休眠1秒
System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(startTime));
startTime = new Date(System.currentTimeMillis());//更新当前时间
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
🚭 模拟倒计时
//模拟倒计时
public class _2sleep2 {
public static void main(String[] args) {
try {
tenDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//模拟倒计时
public static void tenDown() throws InterruptedException {
int i = 10;
while (true) {
Thread.sleep(1000);
System.out.println(i--);
if (i <= 0) {
break;
}
}
}
}
🚬 线程礼让 yield()
- 礼让线程,让当前正在执行的线程暂停,但不阻塞
- 将线程从运行状态转为就绪状态
- 让cpu重新调度,礼让不一定成功!看CPU心情
// 线程礼让
public class Yield {
// 礼让不一定成功看cpu的调度
public static void main(String[] args) {
MyYield yield = new MyYield();
new Thread(yield, "A").start();
new Thread(yield, "B").start();
}
}
class MyYield implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " start");
Thread.yield();// 线程礼让
System.out.println(Thread.currentThread().getName() + " end");
}
}
🚬 合并线程 Join
- Join合并线程,待此线程执行完毕后,在执行其他线程,其他线程阻塞
- 可以想像成插队
/*
* 测试线程强制执行 join
* join合成线程, 特此线程执行完成之后,再之心其他线程,其他线程阻塞
*
* 想想成为插队
* */
public class _04Join implements Runnable{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("我是vip我先执行" + i);
}
}
public static void main(String[] args) throws InterruptedException {
//启动线程
_04Join join = new _04Join();
Thread thread = new Thread(join);
thread.start();
//主线程
for (int i = 0; i < 20; i++) {
if (i == 5) {
thread.join(); // 插队 主线程 i=5 时,vip 线程进行插队
}
System.out.println("我是主线程" + i);
}
}
}
🚬 线程状态观测
JDk文档查看
//观察测试线程的状态
public class _05State {
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(() -> {
for (int i = 0; i < 2; i++) { // 让线程先停止 2s
try {
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); // running 正在运行
// 只要不停止就一直输出状态
while (state != Thread.State.TERMINATED) {// 当线程状态不是终止状态时
Thread.sleep(100);
state = thread.getState();// 更新线程状态
System.out.println(state);// 输出线程状态
}
// 观察终止后
state = thread.getState(); // 终止状态
System.out.println(state); // terminated 终止
}
}
🚬 线程优先级
// 线程的优先级
public class _06Priority {
//线程优先级: 这里是概率分配 所以以后先设置优先级 再开启线程
public static void main(String[] args) {
System.out.println(Thread.currentThread().getName() + "-->" + Thread.currentThread().getPriority()); //主线程的优先级是5
MyPriority myPriority = new MyPriority();
Thread t1 = new Thread(myPriority, "线程1");
Thread t2 = new Thread(myPriority, "线程2");
Thread t3 = new Thread(myPriority, "线程3");
Thread t4 = new Thread(myPriority, "线程4");
Thread t5 = new Thread(myPriority, "线程5");
Thread t6 = new Thread(myPriority, "线程6");
Thread t7 = new Thread(myPriority, "线程7");
Thread t8 = new Thread(myPriority, "线程8");
//先设置优先级 在启动线程
t1.start();
t2.setPriority(1);
t2.start();
t3.setPriority(4);
t3.start();
t4.setPriority(Thread.MAX_PRIORITY);//最高优先级 10
t4.start();
t5.setPriority(Thread.MIN_PRIORITY);//最低优先级 1
t5.start();
t6.setPriority(Thread.NORM_PRIORITY);//正常优先级 5
t6.start();
// t7.setPriority(-1);//设置优先级为-1 会报错
// t7.start();
//
// t8.setPriority(11);//设置优先级为11 会报错
// t8.start();
}
}
class MyPriority implements Runnable {
@Override
public void run() {
//获取当前线程的名字和优先级
System.out.println(Thread.currentThread().getName() + "--->" + Thread.currentThread().getPriority());
}
}
🚭 源码
🚭 问题:性能倒置
优先级(性能低)低的线程先执行、优先级(性能高)高的线程后执行
🚬 守护线程- 线程分为用户线程 和守护线程
- 虚拟机必须确保用户线程执行完毕
- 虚拟机不用等待守护线程执行完毕
- 如:后台记录 *** 作日志,监控内存,垃圾回收机制…
//测试守护线程
//上帝守护者你
public class _07Daemon {
public static void main(String[] args) {
God god = new God();
You you = new You();
Thread thread = new Thread(god);
thread.setDaemon(true);//设置为守护线程
//这里的原因 是虚拟机关闭需要一定的时间 虚拟机不用等待守护线程执行完毕
thread.start(); //上帝守护线程启动
new Thread(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! world");
}
}
🚏 线程的同步(重点难点)
🚀 并发:同一个对象 被多个线程同时 *** 作
现实举例:
🚄 队列和锁队列加锁才可以保证线程同步的的安全性
🚒 线程同步 synchronized 🚤 三大不安全案例 🚬 不安全的购票系统// 线程不安全的购票程序
public class _01UnsafeBuyTicket {
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 ticketNum = 10;
boolean flag = true;// 外部停止方法
@Override
public void run() {
// 循环购票
while (flag) { // 判断是否停止
try {
buyTicket();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
private void buyTicket() throws InterruptedException {
// 判断是否还有票
if (ticketNum <= 0) {
flag = false;
return;
}
Thread.sleep(100);
// 购买票
System.out.println(Thread.currentThread().getName() + "购买了第" + ticketNum-- + "张票");
}
}
🚬 不安全的取钱
// 不安全的取钱
// 两个人去银行取钱,一个人取钱时,另一个人可能正在取钱,所以不安全
public class _02UnsafeBank {
public static void main(String[] args) {
// 账户
Account account = new Account(100,"结婚基金");
Drawing you = new Drawing(account,50,"你");
Drawing girlFriend = new Drawing(account,100,"girlFriend");
girlFriend.setPriority(Thread.MAX_PRIORITY);
girlFriend.start();
you.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() {
// 判断有没有钱
if(account.money - drawingMoney < 0) {
System.out.println(Thread.currentThread().getName() + " 余额不足,无法取款");
return;
}
// sleep 方法可以放大问题的发生的概率
try {
sleep(500);
} 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()
// why? 继承了Thread类,继承有Thread类的全部方法,可以调用this,Thread里面有getName()方法,getName()获取线程名称
// Thread.currentThread() 也是返回一个 Thread对象
System.out.println(this.getName() + "手里的钱:" + nowMoney + "元");
}
}
🚬 不安全的集合
//线程不安全的集合 ArrayList 线程不安全
public class _03UnsafeList {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
for (int i = 0; i < 10000; i++) {
new Thread(()->{
list.add(Thread.currentThread().getName());
}).start();
}
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());//输出线程的大小
}
}
// 两个线程同一瞬间 *** 作用一个位置
// 把两个数组添加到同一个位置,就把数据给覆盖掉了,所以就会少元素
🚏 同步方法同步代码块
🚀 同步方法
- 由于我们可以通过private关键字来保证数据对象只能被方法访问,所以我们只需要针对方法提出一套机制,这套机制就是synchronized关键字,它包括两种用法:
synchronized方法
和synchronized块
- 同步方法:public synchronized void method(int args) {}
- synchronized方法控制对“对象”的访问,每个对象对应一把锁,每个synchronized方法都必须获得调用该方法的对象的锁才能执行,否则线程会阻塞,方法一旦执行,就独占该锁,直到该方法返回才释放锁,后面被阻塞的线程才能获得这个锁,继续执行
- 缺陷:若将一个大的方法申明为synchronized将会影响效率
一个方法中有 只读 A代码 修改 B 代码
,方法里面需要修改的内容才需要锁,锁太多浪费资源。影响效率
-
同步块:synchronized(Obj){}
-
(Obj) 称之为同步监视器
- Obj可以是任何对象,但是推荐使用共享资源作为同步监视器同步方法中无需指定
- 同步监视器,因为同步方法的同步监视器就是this,就是这个对象本身,或者是class[反射中讲解]
-
同步监视器的执行过程
- 1.第一个线程访问,锁定同步监视器,执行其中代码
- 2.第二个线程访问,发现同步监视器被锁定,无法访问
- 3.第一个线程访问完毕,解锁同步监视器
- 4.第二个线程访问,发现同步监视器没有锁,然后锁定并访问
- Synchronized方法默认锁的是对象本身。类本身
- 同步块可以锁任何对象
- 对于普通同步方法,锁是当前实例对象。如果有多个实例那么锁对象必然不同否则无法实现同步。
// 线程不安全的购票程序
public class _01UnsafeBuyTicket {
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 ticketNum = 10;
boolean flag = true;// 外部停止方法
@Override
public void run() {
// 循环购票
while (flag) { // 判断是否停止
try {
buyTicket();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
private void buyTicket() throws InterruptedException {
// 判断是否还有票
if (ticketNum <= 0) {
flag = false;
return;
}
Thread.sleep(100);
// 购买票
System.out.println(Thread.currentThread().getName() + "购买了第" + ticketNum-- + "张票");
}
}
🚭 核心代码
//买票方法
//synchronized 同步方法,锁住的是当前对象 this
private synchronized void buyTicket() throws InterruptedException {
if (ticketNum <= 0) {
flag = false;
return;
}
Thread.sleep(1000);
// 购买票
System.out.println(Thread.currentThread().getName() + "购买了第" + ticketNum-- + "张票");
}
🚬 安全的取钱
// 不安全的取钱
// 两个人去银行取钱,一个人取钱时,另一个人可能正在取钱,所以不安全
public class _02UnsafeBank {
public static void main(String[] args) {
// 账户
Account account = new Account(100,"结婚基金");
Drawing you = new Drawing(account,50,"你");
Drawing girlFriend = new Drawing(account,100,"girlFriend");
girlFriend.setPriority(Thread.MAX_PRIORITY);
girlFriend.start();
you.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() {
// 判断有没有钱
if(account.money - drawingMoney < 0) {
System.out.println(Thread.currentThread().getName() + " 余额不足,无法取款");
return;
}
// sleep 方法可以放大问题的发生的概率
// try {
// sleep(500);
// } 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()
// why? 继承了Thread类,继承有Thread类的全部方法,可以调用this,Thread里面有getName()方法,getName()获取线程名称
// Thread.currentThread() 也是返回一个 Thread对象
System.out.println(this.getName() + "手里的钱:" + nowMoney + "元");
}
}
🚭 核心代码
//取钱 *** 作
// 在取钱的run方法中 添加synchronized关键字
// 依旧存在问题
// 原因:锁的一个run 方法 this 是 Drawing 银行 但是 *** 作的增删改查对象是 Account 银行?
// 不是 锁另外一个对象 应该锁 账户 而不是 银行
// synchronized 关键字锁的是 this 对象本身
@Override
public void run() {
//锁的对象就是变化的量,需要增删改的对象
synchronized (account) { // 如果锁的是 this 锁的是银行
// 判断有没有钱
if(account.money - drawingMoney < 0) {
System.out.println(Thread.currentThread().getName() + " 余额不足,无法取款");
return;
}
// sleep 方法可以放大问题的发生的概率
try {
sleep(500);
} 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()
// why? 继承了Thread类,继承有Thread类的全部方法,可以调用this,Thread里面有getName()方法,getName()获取线程名称
// Thread.currentThread() 也是返回一个 Thread对象
System.out.println(this.getName() + "手里的钱:" + nowMoney + "元");
}
}
创建了两个银行账户,这两个账户对象都是独立的,只是共享一个Account对象数据,给Run方法加了锁,锁的是当前对象,但这两个银行账户的当前对象是自己。
实际上应该通过synchronized代码块的方式,把Account对象锁了,假如you对象先拿到执行权,进入run方法,锁定Account对象,qirlFriend对象执行run方法时,就拿不到,Account对象,她就只能等着,等you对象释放了Account,她才能继续执行.
🚬 安全的集合//线程不安全的集合 ArrayList 线程不安全
public class _03feList {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
for (int i = 0; i < 10000; i++) {
new Thread(()->{
synchronized (list) {
list.add(Thread.currentThread().getName());
}
}).start();
}
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());//输出线程的大小
}
}
// 两个线程同一瞬间 *** 作用一个位置
// 把两个数组添加到同一个位置,就把数据给覆盖掉了,所以就会少元素
🚭 核心代码
🚗 JUC
🚬 CopyOnWriteArrayList
java.util.concurrent* 并发包
//测试juc包下的 安全的线程包 java.util.concurrent* 并发包
// JUC安全类型的集合
public class _04TestJUC {
public static void main(String[] args) {
// 线程安全的集合
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
for (int i = 0; i < 10000; i++) {
new Thread(() -> {
list.add(Thread.currentThread().getName());
}).start();
}
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
}
}
🚬 CopyOnWriteArrayList 和 synchronized
欢迎分享,转载请注明来源:内存溢出
评论列表(0条)