java.util.concurrent包(2)——线程池

一、概述
java.util.concurrent中有非常方便的线程池实现,提供的Executor框架包含用于管理实现Runnable任务,Executors类提供了许多不同类型的Executor实现的静态工厂方法。

二、实例
public class MyTask implements Runnable
{
public void run()
{
System.out.println(Thread.currentThread().getName() + "任务正在运行");
}
}

①固定大小线程池newFixedThreadPool
public class FixedThreadPoolTest
{
public static void main(String[] args)
{
// 创建固定大小为5的线程池
ExecutorService threadPool = Executors.newFixedThreadPool(5);
// 模拟执行了20个任务,而线程池中只有5个线程
for (int i = 0; i < 20; i++)
{
try
{
// 一次执行五个任务,其余任务排队
Thread.sleep(20);
threadPool.execute(new MyTask());
}
catch (Exception e)
{
e.printStackTrace();
}
}
threadPool.shutdown();
}
}
pool-1-thread-1任务正在运行
pool-1-thread-2任务正在运行
pool-1-thread-3任务正在运行
pool-1-thread-4任务正在运行
pool-1-thread-5任务正在运行
pool-1-thread-1任务正在运行
pool-1-thread-2任务正在运行
pool-1-thread-3任务正在运行
pool-1-thread-4任务正在运行
pool-1-thread-5任务正在运行
pool-1-thread-1任务正在运行
pool-1-thread-2任务正在运行
pool-1-thread-3任务正在运行
pool-1-thread-4任务正在运行
pool-1-thread-5任务正在运行
pool-1-thread-1任务正在运行
pool-1-thread-2任务正在运行
pool-1-thread-3任务正在运行
pool-1-thread-4任务正在运行
pool-1-thread-5任务正在运行

②不限制大小的线程池newCachedThreadPool
public class CachedThreadPool
{
public static void main(String[] args)
{
// 不限制线程池的大小
// 当以前创建的线程可以使用时会重新使用
ExecutorService threadPool = Executors.newCachedThreadPool();
for (int i = 0; i < 20; i++)
{
threadPool.execute(new MyTask());
}
threadPool.shutdown();
}
}
pool-1-thread-1任务正在运行
pool-1-thread-1任务正在运行
pool-1-thread-1任务正在运行
pool-1-thread-2任务正在运行
pool-1-thread-4任务正在运行
pool-1-thread-3任务正在运行
pool-1-thread-2任务正在运行
pool-1-thread-1任务正在运行
pool-1-thread-6任务正在运行
pool-1-thread-4任务正在运行
pool-1-thread-1任务正在运行
pool-1-thread-3任务正在运行
pool-1-thread-4任务正在运行
pool-1-thread-1任务正在运行
pool-1-thread-5任务正在运行
pool-1-thread-7任务正在运行
pool-1-thread-3任务正在运行
pool-1-thread-2任务正在运行
pool-1-thread-8任务正在运行
pool-1-thread-6任务正在运行

③单线程池newSingleThreadExecutor
public class SingleThreadPool
{
public static void main(String[] args)
{
// 单线程池
ExecutorService threadPool = Executors.newSingleThreadExecutor();
for (int i = 0; i < 20; i++)
{
threadPool.execute(new MyTask());
}
threadPool.shutdown();
}
}pool-1-thread-1任务正在运行
pool-1-thread-1任务正在运行
pool-1-thread-1任务正在运行
pool-1-thread-1任务正在运行
pool-1-thread-1任务正在运行
pool-1-thread-1任务正在运行
pool-1-thread-1任务正在运行
pool-1-thread-1任务正在运行
pool-1-thread-1任务正在运行
pool-1-thread-1任务正在运行
pool-1-thread-1任务正在运行
pool-1-thread-1任务正在运行
pool-1-thread-1任务正在运行
pool-1-thread-1任务正在运行
pool-1-thread-1任务正在运行
pool-1-thread-1任务正在运行
pool-1-thread-1任务正在运行
pool-1-thread-1任务正在运行
pool-1-thread-1任务正在运行
pool-1-thread-1任务正在运行

④定时任务线程池newScheduledThreadPool
public class ScheduledPool
{
public static void main(String[] args)
{
// 定时任务线程池
ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(3);
// 三秒后运行任务
threadPool.schedule(new MyTask(), 3, TimeUnit.SECONDS);
// 五秒钟后运行,每隔两秒钟执行一次
threadPool.scheduleAtFixedRate(new MyTask(), 5, 2, TimeUnit.SECONDS);
}
}

时间: 2024-09-20 18:08:01

java.util.concurrent包(2)——线程池的相关文章

java.util.concurrent包(3)——线程间通信wait/notify和await/signal

一.线程如何停止 使用stop()不安全.它会解除由线程获取的所有锁定,而且如果对象处于一种不连贯状态,那么其他线程能在那种状态下检查和修改它们.结果很难检查出真正的问题所在.suspend()方法容易发生死锁.调用suspend()的时候,目标线程会停下来,但却仍然持有在这之前获得的锁定.此时其他任何线程都不能访问锁定的资源,除非被"挂起"的线程恢复运行.对任何线程来说,如果它们想恢复目标线程,同时又试图使用任何一个锁定的资源,就会造成死锁.所以不应该使用suspend().正确的做

java.util.concurrent包源码阅读(二) java.util.concurrent.atomic包

Aomic数据类型有四种类型:AomicBoolean, AomicInteger, AomicLong, 和AomicReferrence(针对Object的)以及它们的数组类型, 还有一个特殊的AomicStampedReferrence,它不是AomicReferrence的子类,而是利用AomicReferrence实现的一个储存引用和Integer组的扩展类 首先,所有原子操作都是依赖于sun.misc.Unsafe这个类,这个类底层是由C++实现的,利用指针来实现数据操作 关于CAS

为什么java.util.concurrent 包里没有并发的ArrayList实现?

原文链接 作者:Stephen C 译者:郑旭东  校对:方腾飞 问:JDK 5在java.util.concurrent里引入了ConcurrentHashMap,在需要支持高并发的场景,我们可以使用它代替HashMap.但是为什么没有ArrayList的并发实现呢?难道在多线程场景下我们只有Vector这一种线程安全的数组实现可以选择么?为什么在java.util.concurrent 没有一个类可以代替Vector呢? 答:我认为在java.util.concurrent包中没有加入并发的

为什么java.util.concurrent 包里没有并发的ArrayList实现

原文链接 作者:Stephen C 译者:郑旭东  校对:方腾飞 问:JDK 5在java.util.concurrent里引入了ConcurrentHashMap,在需要支持高并发的场景,我们可以使用它代替HashMap.但是为什么没有ArrayList的并发实现呢?难道在多线程场景下我们只有Vector这一种线程安全的数组实现可以选择么?为什么在java.util.concurrent 没有一个类可以代替Vector呢? 答:我认为在java.util.concurrent包中没有加入并发的

java.util.concurrent包源码阅读(一) 源码包的结构

准备花点时间阅读一下java.util.concurrent这个包里面的java代码,大致看了一下,这个包我个人觉得大致可以分为五个部分(如有不对之处,还望指正) 第一部分 Aomic数据类型 这部分都被放在java.util.concurrent.atomic这个包里面,实现了原子化操作的数据类型,包括 Boolean, Integer, Long, 和Referrence这四种类型以及这四种类型的数组类型. 第二部分 锁 这部分都被放在java.util.concurrent.lock这个包

java.util.concurrent包(5)——CountDownLatch使用

Java的concurrent包里面的CountDownLatch其实可以被看作一个计数器,只不过这个计数器的操作是原子操作,同时只能有一个线程去操作这个计数器,也就是同时只能有一个线程去减这个计数器里面的值. 可以向CountDownLatch对象设置一个初始的数字作为计数值,任何调用这个对象上的await()方法都会阻塞,直到这个计数器的计数值被其他的线程减为0为止. CountDownLatch的一个非常典型的应用场景是:有一个任务想要往下执行,但必须要等到其他的任务执行完毕后才可以继续往

java.util.concurrent包(1)——lock和synchronized对比

一.对synchronized的改进 JDK5后引入了线程并发库java.util.concurrent.JSR 166小组花了这么多时间来开发java.util.concurrent.lock框架呢?答案很简单--synchronized同步是不错,但它并不完美,有一些功能性的限制:无法中断一个正在等候获得锁的线程,也无法通过投票得到锁,如果不想等下去也就没法得到锁.同步还要求锁的释放只能在与获得锁所在的堆栈帧相同的堆栈帧中进行,多数情况下这没问题,而且与异常处理交互得很好,但确实存在一些非块

java.util.concurrent包(4)——读写锁ReentrantReadWriteLock

读读之间不互斥,但读写之间,写写之间互斥.提高了效率保证了安全. import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; public class MyQueue {// 共享数据.该数据只能被一个线程写,可以被多个线程同时读private Object data;// 读读之间不互斥,但读写之间,写写之间互斥ReadWriteLock r

java.util.concurrent包(7)——Exchanger使用

Java 并发 API 提供了一种允许2个并发任务间相互交换数据的同步应用.更具体的说,Exchanger类允许在2个线程间定义同步点,当2个线程到达这个点,他们相互交换数据类型,使用第一个线程的数据类型变成第二个的,然后第二个线程的数据类型变成第一个的. 示例1 一个人有零食,另一个人有钱,他们两个想等价交换,对好口号在某个地方相见,一个人先到了之后,必须等另一个人带着需要的东西来了之后,才能开始交换. public class ExchangerTest {public static voi