多线程，线程通信和线程池

黎亿

于 2020-08-24 22:05:18 发布

阅读量133

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_41280118/article/details/108209914

版权

多线程，线程通信和线程池

1. 多线程

1.1 线程状态

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cvDPblFe-1598277876567)(G:\JavaEE2005\Day24\img\线程的五种状态.png)]

1.2 Object类中的方法

wait();
	1. 在哪一个线程中执行，哪一个线程就进入休眠状态【调用方法者为锁对象】
	2. wait方法可以让当前线程进入休眠状态，同时【打开锁对象】
	
notify();
	1. 唤醒一个线程，和当前调用方法【锁对象】相关线程
	2. notify方法在唤醒线程的过程中，可以打开【锁对象】
	
notifyAll();
	1. 唤醒和当前调用方法【锁对象】相关所有线程
	2. notifyAll方法在唤醒所有线程的过程中，同时会开启锁对象。

2. 线程通信生产者消费者案例

2.1 分析问题

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Qzf1zdX2-1598277876572)(img/生产者消费者图例.png)]

2.2 代码实现

package com.qfedu.a_thread;

class Producer implements Runnable {

	Goods goods;

	public Producer() {
	}

	public Producer(Goods goods) {
		this.goods = goods;
	}

	@Override
	public void run() {
		while (true) {
			synchronized (goods) {
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e1) {
					// TODO Auto-generated catch block
					e1.printStackTrace();
				}
				
				// 商品需要生产
				if (goods.isProduct()) {
					if (Math.random() > 0.5) {
						goods.setName("吉利星越");
						goods.setPrice(10);
					} else {
						goods.setName("领克05");
						goods.setPrice(15);
					}
					System.out.println("生产者生产:" + goods.getName() + " 价格" + goods.getPrice());
					// 修改生产标记
					goods.setProduct(false);

					// 唤醒消费者
					goods.notify();
					System.out.println("唤醒消费者");
				} else {
					// 生产者进入休眠状态
					System.out.println("生产者休眠");
					try {
						goods.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
		}
	}

}

class Customer implements Runnable {

	Goods goods;

	public Customer() {
	}

	public Customer(Goods goods) {
		this.goods = goods;
	}

	@Override
	public void run() {
		while (true) {
			synchronized (goods) {
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e1) {
					// TODO Auto-generated catch block
					e1.printStackTrace();
				}
				// 消费者买买买状态
				if (!goods.isProduct()) {
					System.out.println("消费者购买:" + goods.getName() + " 价格" + goods.getPrice());

					// 修改生产标记
					goods.setProduct(true);

					// 唤醒生产者
					System.out.println("唤醒生产者");
					goods.notify();
				} else {
					// 消费者进入休眠状态
					System.out.println("消费者休眠");
					try {
						goods.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
		}
	}

}

class Goods {
	private String name;
	private int price;
	private boolean product;

	public Goods() {
	}

	public Goods(String name, int price, boolean product) {
		this.name = name;
		this.price = price;
		this.product = product;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getPrice() {
		return price;
	}

	public void setPrice(int price) {
		this.price = price;
	}

	public boolean isProduct() {
		return product;
	}

	public void setProduct(boolean product) {
		this.product = product;
	}
}

public class Demo1 {
	public static void main(String[] args) {
		Goods goods = new Goods("领克05", 15, true);

		Producer producer = new Producer(goods);
		Customer customer = new Customer(goods);

		System.out.println(producer.goods);
		System.out.println(customer.goods);

		new Thread(producer).start();
		new Thread(customer).start();

	}
}

3. 线程池

3.1 线程池需求

目前情况下操作线程对象
	1. 继承Thread类，重写run方法，创建对象，start方法启动线程
	2. 遵从Runnable接口，实现run方法，创建Thread类对象，start启动线程
	以上两种方式，都是在确定run方法之后(What will be run 跑啥)！！！后期线程在运行的过程中，任务是明确的无法替换的！！！

生活中的例子:
	吃饭
		服务员
		在提供服务的过程中，需要监视每一个桌子
		如果发现有顾客需要提供服务，立马执行！！！
	
	一个餐厅10张桌子，有5个服务员
	5个服务员我们可以看做是5个线程，具体做什么任务，由用户指定。

3.2 线程池工作图例

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gSqwrDcY-1598277876578)(img/线程池执行操作流程.png)]

3.3 低端版线程池方法和操作

class Executors
public static ExecutorService newFixedThreadPool(int nThreads);
	得到一个线程池对象，传入参数为当前线程池中默认存在的线程对象有多少个。

ExecutorService
Future<?> submit(Runnable task);
	提交任务给当前线程池，需要的参数是Runnable接口对象。

package com.qfedu.a_thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/*
 * 线程池使用
 */
public class Demo4 {
	public static void main(String[] args) {
		/*
		 * 得到了一个线程池，目前线程池中有5个线程对象
		 */
		ExecutorService threadPool = Executors.newFixedThreadPool(5);
		
		System.out.println(threadPool);
		/*
		 * java.util.concurrent.ThreadPoolExecutor@7852e922
		 * [Running, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 0]
		 * 线程池状态 Running 正在运行 
		 * pool size = 0  当前线程池线程容量
		 * active threads 目前正在运行线程对象
		 * queued tasks 排队任务
		 * completed tasks 完成任务
		 */
		
		threadPool.submit(new Runnable() {			
			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName());
				System.out.println("线程池对象执行代码中");	
			}
		});
		
		threadPool.submit(() -> {
			System.out.println(Thread.currentThread().getName());
			System.out.println("线程池对象执行代码中");	
		});
		
		System.out.println(threadPool);
	}
}

4. Lambda表达式【重点 JDK1.8新特征】

4.1 说重点

接口和实现类
	interface A {
		void testA();
	}
	
	class TypeA implements A {
		@Override
		public void testA() {
			Sout("测试");
		}
	}
	
	main() {
		new TypeA().testA();
	}
	1. 实现了一个类
	2. 完成对应方法
	3. 创建实现类对象
	4. 调用方法 【核心】

Lambda表达式！！！
	C语言 方法指针
	PHP JS 匿名方法
	Objective-C Block代码块
基本格式:
	(参数名字) -> {
		和正常完成方法一致！！！
	}

4.2 无参数无返回值Lambda

package com.qfedu.b_lambda;

/*
 * 函数式接口 有且只允许在接口中有一个未实现方法
 */
@FunctionalInterface
interface A {
	void test();
}

public class Demo1 {
	public static void main(String[] args) {
		// 匿名内部类作为方法的参数
		testInterface(new A() {
			
			@Override
			public void test() {
				System.out.println("匿名内部类 low~~~");
			}
		});
		
		// 无参数无返回值lambda表达式使用，因为有且只有一句话，大括号可以省略
		testInterface(() -> System.out.println("无参数无返回值lambda"));
	}
	
	public static void testInterface(A a) {
		a.test();
	}
}

4.3 有参数无返回值Lambda

package com.qfedu.b_lambda;

import java.util.ArrayList;
import java.util.Comparator;

@FunctionalInterface
interface B {
	/*
	 * 有参数无返回值方法，并且参数数据类型有传入参数类型 本身决定
	 */
	void test(String str);
}

public class Demo2 {
	public static void main(String[] args) {
		testInterface("测试", new B() {

			@Override
			public void test(String str) {
				System.out.println(str);
			}
		});

		/*
		 * lambda表达式参数需要养成习惯 1. 缺省数据类型 2. 脑补数据类型，自定义参数名字
		 */
		testInterface("abcdefg", (s) -> {
			String str = s.toUpperCase();
			System.out.println(str);
		});

		System.out.println();
		ArrayList<SinglePerson> list = new ArrayList<SinglePerson>();

		list.add(new SinglePerson("苟磊", 16, '男'));
		list.add(new SinglePerson("46号技师", 14, '男'));
		list.add(new SinglePerson("翘臀", 12, '男'));
		list.add(new SinglePerson("骚磊", 1, '男'));
		list.add(new SinglePerson("花魁", 0, '男'));
		list.add(new SinglePerson("猴王", 6, '男'));

		list.sort(new Comparator<SinglePerson>() {
			@Override
			public int compare(SinglePerson o1, SinglePerson o2) {
				return o1.getAge() - o2.getAge();
			}
		});

		// Lambda表达式
		list.sort((o1, o2) -> o1.getAge() - o2.getAge());

		list.sort(Comparator.comparingInt(SinglePerson::getAge));

		for (SinglePerson singlePerson : list) {
			System.out.println(singlePerson);
		}
	}

	public static void testInterface(String t, B b) {
		b.test(t);
	}
}

4.4 无参数有返回值Lambda

package com.qfedu.b_lambda;

@FunctionalInterface
interface C<T> {
	T get();
}

public class Demo3 {
	public static void main(String[] args) {
		testInferface(new C<Integer>() {

			@Override
			public Integer get() {
				return 1;
			}
		});
		
		// 如果return是一句话，可以省略大括号和return关键字
		testInferface(() -> {
			return 5;
		});
		
		testInferface(() -> 5);
		
		/*
		 * main方法中的局部变量
		 */
		int[] arr = {1, 3, 5, 7, 19, 2, 4, 6, 8, 10};
		
		testInferface(() -> {
			/*
			 * lambda表达式可以使用当前所处大括号以内的局部变量
			 */
			int maxIndex = 0;
			// 找出数组中最大值
			for (int i = 1; i < arr.length; i++) {
				if (arr[maxIndex] < arr[i]) {
					maxIndex = i;
				}
			}
			
			return maxIndex;
		}); 
	}
	
	private static void testInferface(C c) {
		System.out.println(c.get());
	}
}

4.5 有参数有返回值Lambda

package com.qfedu.b_lambda;

import java.util.ArrayList;

interface D<T> {
	boolean test(T t);
}

public class Demo4 {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<String>();
		
		list.add("锅包肉");
		list.add("酱肘子");
		list.add("回锅肉");
		list.add("红烧肉");
		list.add("拍黄瓜");
		list.add("韭菜炒千张");
		list.add("煎焖闷子");
		
		/*
		 * 1. Lambda表达式
		 * 2. Stream流式操作
		 * 3. 方法引用
		 * 4. 函数式接口
		 */
		list.stream()
			.filter((s) -> s.contains("肉"))
			.filter(s -> s.startsWith("锅"))
			.forEach(System.out::println);
	}
}

黎亿

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
多线程，线程通信和线程池

多线程，线程通信和线程池1. 多线程1.1 线程状态[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cvDPblFe-1598277876567)(G:\JavaEE2005\Day24\img\线程的五种状态.png)]1.2 Object类中的方法wait(); 1. 在哪一个线程中执行，哪一个线程就进入休眠状态【调用方法者为锁对象】 2. wait方法可以让当前线程进入休眠状态，同时【打开锁对象】 notify(); 1. 唤醒一个线程，和当前调用方法
复制链接

扫一扫