本文介绍了Java中newCachedThreadPool, newFixedThreadPool和newSingleThreadExecutor的区别，并通过实例展示了如何使用MyTask和各种BlockingQueue（如ArrayBlockingQueue, DelayQueue, PriorityQueue和SynchronousQueue）。同时探讨了阻塞队列在并发场景中的关键作用。
本章概述：本章主要讲了newFixedThreadPool，newSingleThreadExecutor，newCachedThreadPool等类型的接口，初步了解线程池在Java中的应用。
目录
本章概述：
一、newCachedThreadPool
package com.tengsent.class4.thread_pool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @Auther: Yu Panpan
* @Date: 2022/4/20 - 04 - 20 - 17:27
* @Description: com.tengsent.class4.thread_pool
* @version: 1.0
*/
public class CachedThreadPoolDemo {
public static void main(String[] args) {
//创建线程池对象
ExecutorService executorService = Executors.newCachedThreadPool();
//提交任务
for (int i = 0; i < 20; i++) {
executorService.execute(new MyTask());
}
//关闭资源（线程池）
executorService.shutdown();
}
}
二、newFixedThreadPool
package com.tengsent.class4.thread_pool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @Auther: Yu Panpan
* @Date: 2022/4/20 - 04 - 20 - 17:51
* @Description: com.tengsent.class4.thread_pool
* @version: 1.0
*/
public class FixedThreadPoolDemo {
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(5);
for (int i = 0; i <20 ; i++) {
executorService.execute(new MyTask());
}
executorService.shutdown();
}
}
三、newSingleThreadExecutor
package com.tengsent.class4.thread_pool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @Auther: Yu Panpan
* @Date: 2022/4/20 - 04 - 20 - 18:03
* @Description: com.tengsent.class4.thread_pool
* @version: 1.0
*/
public class SingleThreadExecutorDemo {
public static void main(String[] args) {
ExecutorService executorService = Executors.newSingleThreadExecutor();
for (int i = 0; i < 200; i++) {
executorService.execute(new MyTask());
}
executorService.shutdown();
}
}
四、MyTask
package com.tengsent.class4.thread_pool;
/**
* @Auther: Yu Panpan
* @Date: 2022/4/20 - 04 - 20 - 17:33
* @Description: com.tengsent.class4.thread_pool
* @version: 1.0
*/
public class MyTask implements Runnable {
@Override
public void run() {
// try {
// Thread.sleep(200);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
System.out.println(Thread.currentThread().getName() + " is running!");
}
}
五、blockingqueue
1、ArrayBlockingQueue
1）、Consumer
package com.tengsent.class4.blockingqueue.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class Consumer implements Runnable {
private BlockingQueue<Integer> blockingQueue;
public Consumer(BlockingQueue<Integer> blockingQueue) {
this.blockingQueue = blockingQueue;
}
public void run() {
try {
while(true) {
System.out.println("取出来的元素是："+blockingQueue.take());
}
} catch (Exception e) {
System.out.println("消费者在等待新产品的时候被打断了！");
e.printStackTrace();
}
}
}2）、Mainclass
package com.tengsent.class4.blockingqueue.ArrayBlockingQueue;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class MainClass {
public static void main(String[] args) {
BlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<Integer>(3,true);
Producer producerPut = new Producer(blockingQueue);
Consumer consumer = new Consumer(blockingQueue);
// ProducerOffer producerOffer = new ProducerOffer(blockingQueue);
new Thread(producerPut).start();
new Thread(consumer).start();
}
}3）、Producer
package com.tengsent.class4.blockingqueue.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class Producer implements Runnable {
private BlockingQueue<Integer> blockingQueue;
private static int element = 0;
public Producer(BlockingQueue<Integer> blockingQueue) {
this.blockingQueue = blockingQueue;
}
public void run() {
try {
while(element < 20) {
System.out.println("将要放进去的元素是："+element);
blockingQueue.put(element++);
}
} catch (Exception e) {
System.out.println("生产者在等待空闲空间的时候被打断了！");
e.printStackTrace();
}
System.out.println("生产者已经终止了生产过程！");
}
}2、delayqueue
1）、DelayQueueTest
package com.tengsent.class4.blockingqueue.delayqueue;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;
public class DelayQueueTest {
public static void main(String[] args) {
DelayQueue<DelayTask> queue = new DelayQueue<>();
queue.add(new DelayTask("1", 1000L, TimeUnit.MILLISECONDS));
queue.add(new DelayTask("2", 1000L, TimeUnit.MILLISECONDS));
queue.add(new DelayTask("3", 1000L, TimeUnit.MILLISECONDS));
System.out.println("queue put done");
while(!queue.isEmpty()) {
try {
DelayTask task = queue.take();
System.out.println(task.name + ":" + System.currentTimeMillis());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class DelayTask implements Delayed {
public String name;
public Long delayTime;
public TimeUnit delayTimeUnit;
public Long executeTime;//ms
DelayTask(String name, long delayTime, TimeUnit delayTimeUnit) {
this.name = name;
this.delayTime = delayTime;
this.delayTimeUnit = delayTimeUnit;
this.executeTime = System.currentTimeMillis() + delayTimeUnit.toMillis(delayTime);
}
@Override
public int compareTo(Delayed o) {
if(this.getDelay(TimeUnit.MILLISECONDS) > o.getDelay(TimeUnit.MILLISECONDS)) {
return 1;
}else if(this.getDelay(TimeUnit.MILLISECONDS) < o.getDelay(TimeUnit.MILLISECONDS)) {
return -1;
}
return 0;
}
@Override
public long getDelay(TimeUnit unit) {
return unit.convert(executeTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
}
}
3、priorityqueue
1）、Task
package com.tengsent.class4.blockingqueue.priorityqueue;
public class Task implements Comparable<Task> {
private int id;
private String name;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public int compareTo(Task task) {
return this.id > task.id ? 1 : (this.id < task.id ? -1 : 0);
}
public String toString() {
return this.id + "," + this.name;
}
}2）、UsePriorityBlockingQueue
package com.tengsent.class4.blockingqueue.priorityqueue;
import java.util.concurrent.PriorityBlockingQueue;
public class UsePriorityBlockingQueue {
public static void main(String[] args) throws Exception{
PriorityBlockingQueue<Task> q = new PriorityBlockingQueue<Task>();
Task t1 = new Task();
t1.setId(3);
t1.setName("id为3");
Task t2 = new Task();
t2.setId(4);
t2.setName("id为4");
Task t3 = new Task();
t3.setId(1);
t3.setName("id为1");
q.add(t1); //3
q.add(t2); //4
q.add(t3); //1
System.out.println("容器：" + q);
System.out.println(q.take().getId());
System.out.println("容器：" + q);
}
}
4、Synchronousqueue
1）、SynchronousQueueExample
package com.tengsent.class4.blockingqueue.Synchronousqueue;
import java.util.Random;
import java.util.UUID;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;
public class SynchronousQueueExample {
static class SynchronousQueueProducer implements Runnable {
protected BlockingQueue<String> blockingQueue;
final Random random = new Random();
public SynchronousQueueProducer(BlockingQueue<String> queue) {
this.blockingQueue = queue;
}
@Override
public void run() {
while (true) {
try {
String data = UUID.randomUUID().toString();
System.out.println(Thread.currentThread().getName() + "---Put: " + data);
blockingQueue.put(data);
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
static class SynchronousQueueConsumer implements Runnable {
protected BlockingQueue<String> blockingQueue;
public SynchronousQueueConsumer(BlockingQueue<String> queue) {
this.blockingQueue = queue;
}
@Override
public void run() {
while (true) {
try {
String data = blockingQueue.take();
System.out.println(Thread.currentThread().getName()
+ " take(): " + data);
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public static void main(String[] args) {
final BlockingQueue<String> synchronousQueue = new SynchronousQueue<String>();
SynchronousQueueProducer queueProducer = new SynchronousQueueProducer(
synchronousQueue);
new Thread(queueProducer).start();
SynchronousQueueConsumer queueConsumer1 = new SynchronousQueueConsumer(
synchronousQueue);
new Thread(queueConsumer1).start();
SynchronousQueueConsumer queueConsumer2 = new SynchronousQueueConsumer(
synchronousQueue);
new Thread(queueConsumer2).start();
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
