仓储模型
需求:
生产者线程不断的生产面包放入仓库
消费者线程不断的从仓库中取出面包
做到先生产的面包先卖出
分析:
生产者线程、消费者线程、面包类、仓库类
先生产的面包先卖出 – 队列模式(LinkedList)
场景:一个生产者,一个消费者
public static void main(String[] args) {
Store store = new Store();
Producer p = new Producer(store);
Consumer c = new Consumer(store);
p.start();
c.start();
}
public class Store {
这里赋予仓库最大的限度为20
private static final int MAX_INIT_CAPACITY = 20;
private int curCapacity;//初始容量
private int maxCapacity;//最大容量
private LinkedList<Cake> list;
public Store() {
this(MAX_INIT_CAPACITY);
}
public Store(int maxCapacity) {
this.maxCapacity = maxCapacity;
list = new LinkedList<>();
}
//入库 - 生产者线程不断的调用
public synchronized void push(Cake cake){
if(curCapacity >= maxCapacity){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
curCapacity++;
list.add(cake);
System.out.println("入库,当前容量为:" + curCapacity);
notify();
}
//出库 - 消费者线程不断的调用
public synchronized Cake pop(){
if(curCapacity <= 0){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
curCapacity--;
Cake cake = list.removeFirst();
System.out.println("出库,当前容量为:" + curCapacity + " -- " + cake);
notify();
return cake;
}
}
public class Cake {
private String brand;//品牌
private String datetime;//日期时间
public Cake(String brand, String datetime) {
this.brand = brand;
this.datetime = datetime;
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public String getDatetime() {
return datetime;
}
public void setDatetime(String datetime) {
this.datetime = datetime;
}
@Override
public String toString() {
return brand + " -- " + datetime;
}
}
public class Producer extends Thread{//生产者继承Thread
private Store store;//定义了一个名为 store 的变量,该变量是一个 Store 类型的对象,并且是私有的。
public Producer(Store store) {
this.store = store;
}
@Override
public void run() {
while(true){
Cake cake = new Cake("好利来", LocalDateTime.now().toString());
store.push(cake);
}
}
}
public class Consumer extends Thread{
//消费者继承Thread
private Store store;
public Consumer(Store store) {
this.store = store;
}
@Override
public void run() {
while(true){
store.pop();
}
}
}
场景:多个生产者,多个消费者
public static void main(String[] args) {
Store store = new Store();
Producer p1 = new Producer(store);
Producer p2 = new Producer(store);
Consumer c1 = new Consumer(store);
Consumer c2 = new Consumer(store);
p1.start();
p2.start();
c1.start();
c2.start();
}
public class Store {
private static final int MAX_INIT_CAPACITY = 20;
private int curCapacity;
private int maxCapacity;
private LinkedList<Cake> list;
public Store() {
this(MAX_INIT_CAPACITY);
}
public Store(int maxCapacity) {
this.maxCapacity = maxCapacity;
list = new LinkedList<>();
}
//入库 - 生产者线程不断的调用
public synchronized void push(Cake cake){
while(curCapacity >= maxCapacity){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
curCapacity++;
list.add(cake);
System.out.println("入库,当前容量为:" + curCapacity);
notifyAll();
}
//出库 - 消费者线程不断的调用
public synchronized Cake pop(){
while(curCapacity <= 0){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
curCapacity--;
Cake cake = list.removeFirst();
System.out.println("出库,当前容量为:" + curCapacity + " -- " + cake);
notifyAll();
return cake;
}
}
public class Cake {
private String brand;
private String datetime;
public Cake(String brand, String datetime) {
this.brand = brand;
this.datetime = datetime;
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public String getDatetime() {
return datetime;
}
public void setDatetime(String datetime) {
this.datetime = datetime;
}
@Override
public String toString() {
return brand + " -- " + datetime;
}
}
public class Producer extends Thread{
private Store store;
public Producer(Store store) {
this.store = store;
}
@Override
public void run() {
while(true){
Cake cake = new Cake("好利来", LocalDateTime.now().toString());
store.push(cake);
}
}
}
public class Consumer extends Thread{
private Store store;
public Consumer(Store store) {
this.store = store;
}
@Override
public void run() {
while(true){
store.pop();
}
}
}
使用Java自带的线程池
Executors:线程池的工具类
ExecutorService:线程池的接口
public static void main(String[] args) {
//创建单个线程的线程池
ExecutorService pool = Executors.newSingleThreadExecutor();
for (int i = 1; i <= 100; i++) {
//提交任务
pool.execute(new Task(i));
}
//关闭线程池
pool.shutdown();
}
public static void main(String[] args) {
//创建指定线程个数的线程池
ExecutorService pool = Executors.newFixedThreadPool(3);
for (int i = 1; i <= 100; i++) {
//提交任务
pool.execute(new Task(i));
}
//关闭线程池
pool.shutdown();
}
public static void main(String[] args) {
//创建可缓存的线程池(该线程池里有0个线程,任务等待就会创建新的线程去服务他,60秒没有工作的线程认为是闲置线程会被回收)
ExecutorService pool = Executors.newCachedThreadPool();
for (int i = 1; i <= 100; i++) {
//提交任务
pool.execute(new Task(i));
}
//关闭线程池
pool.shutdown();
}
public static void main(String[] args) throws InterruptedException {
//创建延迟任务的线程池
ScheduledExecutorService pool = Executors.newScheduledThreadPool(3);
//设置延迟时间
pool.awaitTermination(5, TimeUnit.SECONDS);
for (int i = 1; i <= 100; i++) {
//提交任务
pool.execute(new Task(i));
}
//关闭线程池
pool.shutdown();
}
线程
需求:计算任务,一个包含了2万个整数的数组,分拆了多个线程来进行并行计算,最后汇总出计算的结果。
注意:
1.使用带返回值的任务类方式解决该需求
2.带有返回值的任务类和线程池联合使用
public static void main(String[] args) throws InterruptedException, ExecutionException {
//创建数组,并初始化数据
int[] arr = new int[20000];
for (int i = 0; i < arr.length; i++) {
arr[i] = i+1;
}
//创建线程池
FastThreadPool pool = new FastThreadPool(4, 4, 60, TimeUnit.SECONDS, 20);
//创建任务
Task task1 = new Task(arr, 0, 5000);
Task task2 = new Task(arr, 5000, 10000);
Task task3 = new Task(arr, 10000, 15000);
Task task4 = new Task(arr, 15000, 20000);
//提交任务,并返回Future对象(带有返回值的任务类返回的数据就存在Future对象)
Future<Integer> f1 = pool.submit(task1);
Future<Integer> f2 = pool.submit(task2);
Future<Integer> f3 = pool.submit(task3);
Future<Integer> f4 = pool.submit(task4);
//合并线程结果
System.out.println(f1.get() + f2.get() + f3.get() + f4.get());
pool.shutdown();
}
public class Task implements Callable<Integer>{
private int[] arr;
private int startIndex;
private int endIndex;
public Task(int[] arr, int startIndex, int endIndex) {
this.arr = arr;
this.startIndex = startIndex;
this.endIndex = endIndex;
}
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = startIndex; i < endIndex; i++) {
sum += arr[i];
}
return sum;
}
}
自定义线程池
public static void main(String[] args) {
ThreadPoolExecutor pool = new ThreadPoolExecutor(
5, //核心线程数
20, //最大线程数
60, //闲置时间
TimeUnit.SECONDS,//时间单位
new ArrayBlockingQueue<>(20),//任务队列 - 有界队列
new ThreadFactory() {//自定义线程工厂(可以给线程定义名称和优先级...)
private int count = 1;
@Override
public Thread newThread(Runnable r) {
Thread t = new Thread(r, "线程" + count);
t.setPriority(Thread.MAX_PRIORITY);
count++;
return t;
}
},
new RejectedExecutionHandler() {
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
System.out.println("任务被拒绝了...");
}
});
//闲置时间到后,核心线程和普通线程都会被销毁
//不设置该方法,闲置时间到后只会销毁普通线程
//经验:不用该方法,因为把所有的线程都销毁,就没有线程复用率这个概念了
//pool.allowCoreThreadTimeOut(true);
for (int i = 1; i <= 100; i++) {
//提交任务
pool.execute(new Task(i));
}
//关闭线程池
pool.shutdown();
}
public class Task implements Runnable{
private int num;
public Task(int num) {
this.num = num;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "线程被执行了任务" + num);
}
}