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+"获得口红的锁");
				}
			}
		}
	}
}

运行结果:

java多线程学习笔记(四)_第1张图片

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

解决办法:

将上面代码中的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());
		
	}
}

你可能感兴趣的:(java基础)