java多线程学习笔记（四）

news/2024/5/20 15:17:56 标签: java, 多线程, 同步锁, 死锁, 线程池

一、线程简介

请看：https://blog.csdn.net/qq_33157666/article/details/103949005

二、线程状态

请看：https://blog.csdn.net/qq_33157666/article/details/103949045

三、线程同步

请看：https://blog.csdn.net/qq_33157666/article/details/103949120

四、死锁

多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题。

示例：

/**
 * 死锁：多个线程互相抱着对方需要的资源，然后形成僵持
 * 
 *
 */
public class DeadLock {

	public static void main(String[] args) {
		Makeup g1=new Makeup(0, "灰姑娘");
		Makeup g2=new Makeup(1, "白雪公主");
		g1.start();
		g2.start();
	}
}

//口红
class Lipstick{
	
}

//镜子
class Mirror{
	
}


class Makeup extends Thread{
	//需要的资源只有一份，用static来保证只有一份
	static Lipstick lipstick=new Lipstick();
	static Mirror mirror=new Mirror();
	
	int choice;//选择
	String girlName;//使用化妆品的人
	
	public Makeup(int choice,String girlName) {
		this.choice=choice;
		this.girlName=girlName;
	}
	
	@Override
	public void run() {
		//化妆
		try {
			makeup();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	//化妆，互相持有对方的锁，就是需要拿到对方的资源
	private void makeup() throws InterruptedException{
		if(choice==0){
			synchronized(lipstick){//获得口红的锁
				System.out.println(this.girlName+"获得口红的锁");
				Thread.sleep(1000);
				
				synchronized (mirror) {//一秒钟后获得镜子的锁，此时是在包住了对方锁
					System.err.println(this.girlName+"获得镜子的锁");
				}
			}
		}else{
			synchronized(mirror){//获得镜子的锁
				System.out.println(this.girlName+"获得镜子的锁");
				Thread.sleep(2000);
				
				synchronized (lipstick) {//一秒钟后获得口红的锁
					System.err.println(this.girlName+"获得口红的锁");
				}
			}
		}
	}
}

运行结果：

可以看到运行结果是处于僵持的状态，程序卡死。

解决办法：

将上面代码中的makeup方法改为：

	//化妆，互相持有对方的锁，就是需要拿到对方的资源
	private void makeup() throws InterruptedException{
		if(choice==0){
			synchronized(lipstick){//获得口红的锁
				System.out.println(this.girlName+"获得口红的锁");
				Thread.sleep(1000);
			}
			synchronized (mirror) {//一秒钟后获得镜子的锁，
				System.err.println(this.girlName+"获得镜子的锁");
			}
		}else{
			synchronized(mirror){//获得镜子的锁
				System.out.println(this.girlName+"获得镜子的锁");
				Thread.sleep(2000);
			}
			synchronized (lipstick) {//一秒钟后获得口红的锁
				System.err.println(this.girlName+"获得口红的锁");
			}
		}
	}

小结：

产生死锁的四个必要条件：

  • 互斥条件：一个资源每次只能被一个进程使用。
  • 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
  • 不剥夺条件：进程已获得的资源，在为使用完之前，不能强行剥夺。
  • 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

 

五、线程通信及线程池

5.1 线程通信

应用场景：生产者和消费者问题

假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中的产品取走消费、

如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止；

如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止。

java提供了几个方法解决线程之间的通信为题：

wait()：表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁

wait(long timeout)：指定等待的毫秒数

notify()：唤醒一个处于等待状态的线程

notifyAll()：唤醒同一个对象上所有调用wait()方法的线程，优先级较高的线程优先调度

方法一：利用缓冲区解决：管程法

管程法：
        生产者：负责生产数据的模块（可能是方法、对象、线程、进程）；
        消费者：负责处理数据的模块（可能是方法、对象、线程、进程）；
        缓冲区：消费者不能直接使用生产这的数据，他们之间有个"缓冲区"；
        生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据。

类似于我们去肯德基买汉堡，如果有做好的汉堡，我们去了可以直接买，如果没有需要等大厨做好，在买。
示例：

/**
 * 并发协作模型"生产者/消费者模式"--》管程法
 * 生产者：负责生产数据的模块（可能是方法、对象、线程、进程）
 * 消费者：负责处理数据的模块（可能是方法、对象、线程、进程）
 * 缓冲区：消费者不能直接使用生产这的数据，他们之间有个"缓冲区"
 * 生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据
 *
 */
public class TestPC {
	public static void main(String[] args) {
		SynContaniner contaniner=new SynContaniner();
		new Productor(contaniner).start();
		new Comsumer(contaniner).start();
	}
}

//生产者
class Productor extends Thread{
	SynContaniner container;
	public Productor(SynContaniner contaniner){
		this.container=contaniner;
	}
	//生产
	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			container.push(new Chicken(i));
			System.out.println("生产了"+i+"只鸡");
		}
	}
}

//消费者
class Comsumer extends Thread{
	SynContaniner container;
	public Comsumer(SynContaniner contaniner){
		this.container=contaniner;
	}
	//消费
	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println("消费了--》"+container.pop().id+"只鸡");
		}
	}
}

//产品
class Chicken{
	int id;//产品编号
	public Chicken(int id){
		this.id=id;
	}
}

//缓冲区
class SynContaniner{
	//需要一个容器大小
	Chicken[] chickens=new Chicken[10];
	//容器计数器
	int count=0;
	
	//生产者放入产品
	public synchronized void push(Chicken chicken){
		//如果容器满了，就需要等待消费者消费
		//System.out.println("生产者："+count+"---"+chickens.length);
		if(count==chickens.length){
			//通知消费者消费，生产者等待
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
		//如果没有满，我们就需要丢入产品
		chickens[count]=chicken;
		count++;
		
		//可以通知消费者消费了
		this.notifyAll();
	}
	
	//消费者消费产品
	public synchronized Chicken pop(){
		//System.out.println("消费者："+count);
		//判断能否消费
		//System.out.println("count:----"+count);
		if(count==0){
			//等待生产者生产，消费者等待
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
		//如果可以消费
		count--;
		Chicken chicken=chickens[count];
		
		//吃完了，通知生产者生产
		this.notifyAll();
		return chicken;
	}
}

方法二：信号灯法，标志位解决

设置一个标志位，如果标志位为true,则生产者生产，生产完把标志位置为false，否则生产者等待；

标志位为false，消费者消费，消费完把标志位置为true，否则等待。

示例：

//测试生产者消费者问题2：信号灯法，标志位解决
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();
		}
	}
}

//产品->节目
class Tv{
	//演员表演，观众等待
	//观众观看，演员等待
	String voice;//演员的节目
	boolean flag=true;
	
	//表演
	public synchronized void play(String voice){
		if(!flag){
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				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) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		System.out.println("观看了:"+voice);
		//通知演员表演
		this.notifyAll();
		this.flag=!this.flag;
	}
}

5.2 线程池

背景：经常创建和销毁线程，使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中交通工具。

好处：

提高响应速度（减少了创建新线程的时间）

降低资源消耗（重复利用线程池中的线程，不需要每次都创建）

便于线程管理：corePoolSize：线程池的大小

                          maximumPoolSize：最大线程数

                          keepAliveTime：线程没有任务时最多保持多长时间会终止

示例：

/**
 * 测试线程池
 *
 */
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());
		service.execute(new MyThread());
		
	}
}

class MyThread implements Runnable{
	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName());
		
	}
}

http://www.niftyadmin.cn/n/1513695.html

相关文章

ASP.net下大文件上传的几个问题讨论

ASP.net下大文件上传的几个问题讨论

我研究这个问题已经很长时间了&#xff0c;ASPUpload的组件以及其它几个组件都使用过&#xff0c;多多少少对这些组件的工作原理有些了解&#xff0c;对于其它一些问题的讨论也都遇到过。前几个星期开发的WebbUpload2.0经过一段时间的测试后&#xff0c;发现它完全是一个超级大…
阅读更多...
基于Arduino控制伺服电机（舵机）

基于Arduino控制伺服电机（舵机）

一&#xff0c;串口监视器的应用 运用到的函数与关键字有&#xff1a;setup,loop,begin,println,print,available,parselnt. 其中begin&#xff0c;avaliable属于Serial库中的库函数&#xff0c;调用格式为 库函数名.需要调用的函数。 setup:只执行一次&#xff0c;ardu…
阅读更多...
求解（暂放.net主页，谢谢支持）

求解（暂放.net主页，谢谢支持）

近来一直做p2p直播项目&#xff0c;目前第一个版本已经接近尾声&#xff0c;基本功能也已经基本完成&#xff0c;忽然产品目标的主管要求在视频播放里面加一个广告链接&#xff0c;就是在视频播放的时候&#xff0c;用户点击播放器的视频画面后自动打开IE窗口连接到指定的网站&…
阅读更多...
基于arduino的多个舵机控制

基于arduino的多个舵机控制

一&#xff0c;setup与外部 首先你想使用舵机就需要去调用arduino ide的Servo这个库函数&#xff0c;第二步定义你的舵机名称采用Servo 舵机名称&#xff0c;我这里有4个舵机就定义了四个。 接下来是setup函数的部分&#xff0c;依旧采用舵机名称.attach()&#xff0c;用来告诉…
阅读更多...
备战蓝桥杯day1__LED跑马灯

备战蓝桥杯day1__LED跑马灯

51单片机于大多数单片机不同&#xff0c;在点亮LED时不是仅仅输出一个高电平就可以解决&#xff0c;需要经过一个74HC138译码器&#xff0c;一个74HC573锁存器。 一&#xff0c;74HC138译码器 有6个输入端口但是我们只需要关注A&#xff0c;B&#xff0c;C端口&#xff0c;由…
阅读更多...
备战蓝桥杯day2__蜂鸣器与继电器

备战蓝桥杯day2__蜂鸣器与继电器

一&#xff0c;元件介绍 1&#xff0c;继电器 当继电器中间的线圈导通时&#xff0c;电生磁把K1吸下来&#xff0c;与m2连接&#xff0c;不导通时K1与m1连接&#xff0c;当继电器工作时&#xff0c;继电器旁边的LED会亮起。我们通过控制N　BELAY端口来控制继电器是否工作&…
阅读更多...
备战蓝桥杯day3__数码管静态显示

备战蓝桥杯day3__数码管静态显示

一&#xff0c;元件介绍 数码管分共阴和共阳&#xff0c;com端用于控制哪个数码管亮&#xff0c;而a&#xff0c;b&#xff0c;c等控制数码管的段码&#xff0c;共阳数码管及段码对应的端口为低电平时&#xff0c;则亮起&#xff0c;共阴与其相反。 二&#xff0c;代码部分 …
阅读更多...
多线程编程中Join与WaitOne的区别

多线程编程中Join与WaitOne的区别

举例说明&#xff1a;Join&#xff1a;在一个线程MainThread中开启一个新的线程NewThread&#xff0c;在完成初始化并启动NewThread的操作后&#xff0c;调用Join&#xff0c;则MainThread堵塞&#xff0c;直到NewThread执行完毕&#xff0c;MainThread才继续执行。 usingSyste…
阅读更多...
最新文章

Copyright @ 2022~2023