博客

java多线程学习笔记（四）

  • Post author:
  • Post category: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());
		
	}
}


版权声明：本文为qq_33157666原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
Tags: