多线程学习笔记（狂神说视频15-20）

最新推荐文章于 2023-07-19 20:23:29 发布
最新推荐文章于 2023-07-19 20:23:29 发布
阅读量340 收藏 3
点赞数
分类专栏： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43824233/article/details/106190415
版权

15观测线程状态

在这里插入图片描述
在这里插入图片描述

package demo3;
//观察测试线程的状态
public class teststate {

	public static void main(String[] args) throws Exception{
		// TODO Auto-generated method stub
		Thread t = new Thread(()-> {
			for(int i=0;i<5;i++)
			{
				try {
					Thread.sleep(1000);
				}catch(InterruptedException e)
				{
					e.printStackTrace();
				}
			}
			System.out.println("..........");
		});
		
		//观察状态
		Thread.State state = t.getState();
		System.out.println(state);//NEW
		
		//观察启动后
		t.start();//启动线程
		state = t.getState();
		System.out.println(state);
		while(state!= Thread.State.TERMINATED)//线程不是终止状态
		{
			Thread.sleep(100);
			state = t.getState();//更新状态
			System.out.println(state);
		}
		
		t.start();//停止之后就不能启动了
	}

}

运行结果：
在这里插入图片描述

16线程的优先级(priority)

线程优先级高，不一定先调用
在这里插入图片描述

package demo3;
//测试线程的优先级
public class TestPriority {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//主线程默认的优先级
		System.out.println(Thread.currentThread().getName()+"->"+Thread.currentThread().getPriority());
		
		MyPriority m =new MyPriority();
		Thread t1 = new Thread(m);
		Thread t2 = new Thread(m);
		Thread t3 = new Thread(m);
		Thread t4 = new Thread(m);
		Thread t5 = new Thread(m);
		Thread t6 = new Thread(m);
		Thread t7 = new Thread(m);
		
		//先设置优先级，再启动
		t1.start();
		
		t2.setPriority(1);
		t2.start();
		
		t3.setPriority(4);
		t3.start();
		
		t4.setPriority(Thread.MAX_PRIORITY);//=10
		t4.start();
		
		t5.setPriority(7);
		t5.start();
		
		t6.setPriority(9);
		t6.start();
	}

}

class MyPriority implements Runnable{
	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName()+"->"+Thread.currentThread().getPriority());
	}
}

运行结果：
在这里插入图片描述

17守护线程(daemon)

hhhhhh，这个例子还是莽有趣的
在这里插入图片描述

package demo3;
//测试守护线程
//上帝守护你
public class TestDaemon {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		God god = new God();
		You you = new You();
		Thread t = new Thread(god);
		t.setDaemon(true);//默认false是用户线程，正常的线程都是用户线程
		t.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("再见world");
	}
}

运行结果：
在这里插入图片描述

18线程同步机制

并发：同一个对象被多个线程同时操作
线程同步：其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。
在这里插入图片描述

19三大不安全案例

package demo3;
//不安全的买票
public class UnsafeBuyTiket {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BuyTicket station = new BuyTicket();
		new Thread(station,"苦逼的我").start();
		new Thread(station,"牛逼的大家").start();
		new Thread(station,"可恶的黄牛").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();
			}
		}
	}
	private void buy() throws InterruptedException{
		//判断是否有票
		if(ticketNums<=0)
		{
			return;
		}
		
		//模拟延时
		Thread.sleep(100);
		//买票
		System.out.println(Thread.currentThread().getName()+"拿到了"+ticketNums--+"票");
	}
}

运行结果（出现-1张票）：
在这里插入图片描述

package demo3;
//不安全的取钱
//两个人去银行取钱，账户
public class UnsafeBank {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Account a = new Account(100,"结婚基金");
		
		Drawing you = new Drawing(a,50,"你");
		Drawing girl = new Drawing(a,100,"girl");
		
		you.start();
		girl.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 {
			Thread.sleep(1000);
		}catch(Exception e)
		{
			e.printStackTrace();
		}
		//卡内余额=余额-你取的钱
		account.money = account.money-drawingMoney;
		//你手里的钱
		nowMoney = nowMoney + drawingMoney;
		System.out.println(account.name+"余额为"+account.money);
		
		//这两个操作等价
		//System.out.println(this.getName()+Thread.currentThread().getName());
		System.out.println(this.getName()+"手里的钱"+nowMoney);
	}
}

运行结果（存款为负数）：
在这里插入图片描述

package demo3;

import java.util.ArrayList;
import java.util.List;

//线程不安全的集合
public class UnsafeList {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<String> list = new ArrayList<String>();
		for(int i=0;i<10000;i++)
		{
			new Thread(()->{
				list.add(Thread.currentThread().getName());
			}).start();
		}
		try {
			Thread.sleep(3000);
		}catch(Exception e)
		{
			e.printStackTrace();
		}
		System.out.println(list.size());
	}

}

运行结果（不足10000，因为存在两个线程同时看到一个标志，于是name就被覆盖掉了）：
在这里插入图片描述

20同步方法及同步块(synchronized)(把不安全的改成安全的)

package demo3;
//不安全的买票
public class UnsafeBuyTiket {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BuyTicket station = new BuyTicket();
		new Thread(station,"苦逼的我").start();
		new Thread(station,"牛逼的大家").start();
		new Thread(station,"可恶的黄牛").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();
			}
		}
	}
	//同步方法，锁的是this
	private synchronized void buy() throws InterruptedException{
		//判断是否有票
		if(ticketNums<=0)
		{
			return;
		}
		
		//模拟延时
		Thread.sleep(100);
		//买票
		System.out.println(Thread.currentThread().getName()+"拿到了"+ticketNums--+"票");
	}
}

运行结果（-1没了）：
在这里插入图片描述

package demo3;
//不安全的取钱
//两个人去银行取钱，账户
public class UnsafeBank {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Account a = new Account(100,"结婚基金");
		
		Drawing you = new Drawing(a,50,"你");
		Drawing girl = new Drawing(a,100,"girl");
		
		you.start();
		girl.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(Thread.currentThread().getName()+"钱不够");
				return;
			}
			//sleep可以放大问题的发生性
			try {
				Thread.sleep(1000);
			}catch(Exception e)
			{
				e.printStackTrace();
			}
			//卡内余额=余额-你取的钱
			account.money = account.money-drawingMoney;
			//你手里的钱
			nowMoney = nowMoney + drawingMoney;
			System.out.println(account.name+"余额为"+account.money);
			
			//这两个操作等价
			//System.out.println(this.getName()+Thread.currentThread().getName());
			System.out.println(this.getName()+"手里的钱"+nowMoney);
		
		}
	}
}

运行结果（存款不会为负数了）：
在这里插入图片描述

package demo3;

import java.util.ArrayList;
import java.util.List;

//线程不安全的集合
public class UnsafeList {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		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(Exception e)
		{
			e.printStackTrace();
		}
		System.out.println(list.size());
	}

}

运行结果（list.size（）=10000）：
在这里插入图片描述

陌丶尘
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程
hjh3132778226的博客
04-09 995
多线程 文章目录多线程一、多线程简介1.多任务2.多线程3.程序.进程.线程4.Process与Thread5.核心概念二、线程实现1.线程创建（三种方法）1.1继承Thread类(重要)案例1.2实现Runnable接口案例龟兔赛跑:1.3实现Callable接口（了解）好处1.4Thread和Runnable对比2.静态代理实现: 结婚案例总结好处3.Lamda表达式函数式接口的定义:练习:练习2:总结:三、线程状态1.线程五大状态:2.线程方法2.1停止线程案例:测试stop2.2线程休眠案例:模拟网
狂神说多线程笔记
weixin_41963554的博客
09-26 3076
狂神说多线程笔记 bilibli视频地址：https://www.bilibili.com/video/BV1V4411p7EF/ 1.基本概念 Process和Thread 程序：指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。 进程：是执行程序的一次执行过程，是一个动态的概念。是系统资源分配的单位。 ​ 一个进程可以包含有多个线程（如视频中同时听到声音、看到图像，还可以看弹幕） ​ 一个进程至少有一个线程，否则无存在的意义。 线程：CPU调度和执行的单
狂神说多线程详解.rar
05-06
狂神说多线程详解笔记
【狂神说Java】Java多线程详细笔记(全)
Martin-share的博客
01-13 635
【狂神说Java】Java多线程笔记
狂神说Java学习笔记——多线程
weixin_65098078的博客
07-19 808
狂神说Java学习笔记——多线程
狂神多线程详解笔记
qq_46541289的博客
08-01 480
- 线程就是独立的执行路径; - 在程序运行时，即使没有自己创建线程，启台也会有多个线程，如主线程，gc线程
多线程-狂神说Java学习笔记
07-19
本学习笔记将深入探讨Java多线程的相关知识，包括其原理、实现方式、同步机制以及常见问题。 ### 一、多线程的基本概念 多线程是指在一个程序中存在两个或更多的执行线程，这些线程共享同一内存空间，但各自拥有...
Java多线程详解（超详细）_狂神说笔记完整版_项目代码_适合小白随课程学习
08-08
Java多线程详解 在Java编程中，多线程是一种重要的技术，它使得程序能够同时执行多个任务，提高系统的效率和响应性。本教程将详细讲解Java中的多线程概念，包括...通过实践和不断学习，你将成为一个多线程编程的专家。
狂神说笔记内容.zip
08-15
【狂神说Java入门笔记】是一份针对初学者的详细教程资源，主要涵盖了Java语言的基础知识，旨在帮助学习者从零开始掌握Java编程。压缩包内的"JavaSE：Java入门.pdf"是主体教程文档，而"说明.txt"则包含了一些关于文件...
狂神JUC并发笔记大全+Linux等资料
08-07
狂神JUC并发笔记大全+Linux等资料
JavaSE回顾总结（狂神说java）.xmind
05-11
javaSE回顾总结，学习笔记，查漏补缺。 Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程 Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点 。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等.
狂神说Java学习笔记-GUI
07-17
【Java GUI】(图形用户界面，Graphical User Interface)是Java编程中不可或缺的一部分，...对于初学者来说，"狂神说Java学习笔记"将是一个宝贵的资源，其中包含的源代码和图片能够直观地展示如何将理论转化为实际应用。
2021-3-27 狂神说java 之 多线程详解
fggsgnhz的博客
03-30 170
线程简介 进程（process）和线程（Thread） 程序：是指令和数据的有序集合，本身没有任何运行的含义，是一个静态概念 进程：是执行程序的一次执行过程，他是个动态的概念。是系统资源分配的单位 线程：通常在一个进程中可以包含若干个线程，线程之间互相不影响，线程是CPU调度和执行的单位（main函数，就是主线程） 多线程：很多多线程是模拟出来的，真正的多线程是指多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就有同
Java 多线程学习笔记（狂神）
Java后端技术栈
11-03 350
文章目录 1、线程简介 2、线程实现 2.1 继承 Thread 类，重写 run 方法 2.2 继承 Runnable 接口，创建 Tread 对象 2.3 实现 Callable 接口（了解） 2.4 Lamda 表达式 2.5 静态代理模式 3、线程的 5 种状态 3.1 线程的一些常用方法 3.1.1 线程休眠——sleep() 3.1.2 线程礼让——yield() 3.1.2 合并线程——Join() 3.2 停止....
多线程【狂神说Java笔记】
forever_lover_的博客
10-23 486
多线程【狂神说java笔记】 基本概念Thread实现 Runnable小结实现callable接口Lamda表达式线程状态线程休眠礼让线程Join线程优先级守护线程 (daemon)线程同步同步方法同步块死锁线程协作解决方式1使用线程池其他文章： 视频链接：【狂神说Java】多线程详解 基本概念 进程 进程就是执行程序的一次执行过程,它是一个动态的概念,是系统资源分配的单位。 通常在一个进程中可以包含若干个线程,当然一个进程中至少有一个线程,不然没有存在的意义,线程是CPU调度和执行的单位。
B站【狂神说Java笔记】-多线程
这个人很懒，什么都没有留下。
11-13 257
1.任务 2.进程 3.多线程 4.Thread 和Runnable小结 5.案例：龟兔赛跑 6.静态代理 7.Lambda表达式 8.线程状态 9.线程休眠（sleep） 10.线程礼让（yield） 11.线程强制执行：（join） 12.线程优先级 13.守护(daemon)线程 14.队列和锁 15.死锁 16.Lock（锁） 17.线程池 ......
狂神说java多线程笔记
最新发布
10-11
狂神在他的Java多线程笔记中，详细介绍了Java多线程的相关知识，包括线程的创建、启动、停止、等待、唤醒等操作，以及线程安全、锁、同步等概念和技术。 在Java多线程中，线程的创建有两种方式：继承Thread类和实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值