多线程集合队列等等

对于许多线程问题,可以通过使用一个或多个队列以优雅且安全的方式将其形式化。当试图向队列添加元素而队列已满,或是想从队列移出元素而队列为空的时候, 阻塞队列( blocking queue)导致线程阻塞。在协调多个线程之间的合作时,阻塞队列是一个有用的工具。工作者线程可以周期性地将中间结果存储在阻塞队列中。其他的工作者线程移出中间结果并进一步加以修改。队列会自动地平衡负载。

add 添加一个元素 如果队列满,则抛出IllegalStateException异常
element 返回队列的头元素 如果队列空,抛出NoSuchElementException异常
offer 添加一个元素并返回true 如果队列满,返回false
peek 返回队列的头元素 如果队列空,则返回null
poll 移出并返回队列的头元素 如果队列空,则返回null
put 添加一个元素 如果队列满,则阻塞
remove 移出并返回头元素 如果队列空,则抛出NoSuchElementException异常
take 移出并返回头元素 如果队列空,则阻塞

当试图向满的队列中添加或从空的队列中移出元素时, add、 remove和element操作抛出异常。一定要使用offer、 poll和peek方法作为替代。向这些队列中插入null值是非法的。
默认情况下,LinkedBlockingQueue的容量是没有上边界的,但是,也可以选择指定最大容量。 LinkedBlockingDeque是一个双端的版本。ArrayBlockingQueue在构造时需要指定容量,并且有一个可选的参数来指定是否需要公平性。
PriorityBlockingQueue是一个带优先级的队列,而不是先进先出队列。元素按照它们的优先级顺序被移出。该队列是没有容量上限,但是,如果队列是空的,取元素的操作会阻塞。注意,不需要显式的线程同步。我们使用队列数据结构作为一种同步机制。

如果多线程要并发地修改一个数据结构,例如散列表,那么很容易会破坏这个数据结构。
可以通过提供锁来保护共享数据结构,但是选择线程安全的实现作为替代可能更容易些。阻塞队列就是线程安全的集合。
java.util.concurrent包提供了映像、有序集和队列的高效实现: ConcurrentHashMap、ConcurrentSkipListMap、 ConcurrentSkipListSet和ConcurrentLinkedQueue。这些集合使用复杂的算法,通过允许并发地访问数据结构的不同部分来使竞争极小化。与大多数集合不同, size方法不必在常量时间内操作。确定这样的集合当前的大小通常需要遍历。
CopyOnWriteArrayList和CopyOnWriteArraySet是线程安全的集合。

List<T> list =  Collections.synchronizedList(new ArrayList<T>());
Map<K, V> map = Collections.synchronizedMap(new HashMap<K, V>());

结果集合的方法使用锁加以保护,提供了线程的安全访问。应该确保没有任何线程通过原始的非同步方法访问数据结构。最便利的方法是确保不保存任何指向原始对象的引用,简单地构造一个集合并立即传递给包装器。最好使用java.util.concurrent包中定义的集合,不使用同步包装器中的。


Runnable封装一个异步运行的任务,可以把它想像成为一个没有参数和返回值的异步方法。Callable与Runnable类似,但是有返回值。 Callable接口是一个参数化的类型,只有一个方法call。

interface Callable<V>{
      V call() throws Exception;
} 
Future保存异步计算的结果。可以启动一个计算,将Future对象交给某个线程,然后忘掉它。 Future对象的所有者在结果计算好之后就可以获得它。

Future<V>{
 V get();
 v get(time,Timeunit);
 void cancel(boolean);
 boolean isCancelled();
 boolean isDone();
}
第一个get方法的调用被阻塞,直到计算完成。如果在计算完成之前,第二个方法的调用超时,抛出一个TimeoutException异常。如果运行该计算的线程被中断,两个方法都将抛出InterruptedException。如果计算已经完成,那么get方法立即返回.

如果计算还在进行,isDone方法返回false;如果完成了,则返回true。可以用cancel方法取消该计算。如果计算还没有开始,它被取消且不再开始。如果计算处于运行之中,那么如果boolean参数为true,它就被中断。

FutureTask包装器是一种非常便利的机制,可将Callable转换成Future和Runnable,它同时实现二者的接口。

Callable<V> a = new......;
FutureTask<v> b = new FutureTask<V>(a);
Thread c = new Thread(b);这里是runnable
c.start();
.....
V d = b.get();//这里是future

构建一个新的线程是有一定代价的,因为涉及与操作系统的交互。如果程序中创建了大量的生命期很短的线程,应该使用线程池(threadpool)。一个线程池中包含许多准备运行的空闲线程。将Runnable对象交给线程池,就会有一个线程调用run方法。当run方法退出时,线程不会死亡,而是在池中准备为下一个请求提供服务。
另一个使用线程池的理由是减少并发线程的数目。创建大量线程会大大降低性能甚至使虚拟机崩溃。如果有一个会创建许多线程的算法,应该使用一个线程数“固定的”线程池以限制并发线程的总数。


执行器( Executor)类有许多静态工厂方法用来构建线程池
newCachedThreadPool 必要时创建新线程;空闲线程会被保留60秒
newFixedThreadPool 该池包含固定数量的线程;空闲线程会一直被保留
newSingleThreadExecutor 只有一个线程的“池”,该线程顺序执行每一个提交的任务
newScheduledThreadPool 用于预定执行而构建的固定线程池,替代java.util.Timer
newSingleThreadScheduledExecutor 用于预定执行而构建的单线程“池

newCachedThreadPool方法构建了一个线程池,对于每个任务,如果有空闲线程可用,立即让它执行任务,如果没有可用的空闲线程,则创建一个新线程。 newFixedThreadPool方法构建一个具有固定大小的线程池。如果提交的任务数多于空闲的线程数,那么把得不到服务的任务放置到队列中。当其他任务完成以后再运行它们。 newSingleThreadExecutor是一个退化了的大小为1的线程池:由一个线程执行提交的任务,一个接着一个。这 3个方法返回实现了ExecutorService接口的ThreadPoolExecutor类的对象。

可用下面的方法之一将一个Runnable对象或Callable对象提交给ExecutorService:

Future<?> submit(runnable);
Future<T> submit(runnable,T result);
Future<T> submit(Callable);

该池会在方便的时候尽早执行提交的任务。调用submit时,会得到一个Future对象,可用来查询该任务的状态。
第一个submit方法返回一个奇怪样子的Future<?>。可以使用这样一个对象来调用isDone、cancel或isCancelled。但是, get方法在完成的时候只是简单地返回null。
第二个的Submit也提交一个Runnable,并且Future的get方法在完成的时候返回指定的result对象。
第三个的Submit提交一个Callable,并且返回的Future对象将在计算结果准备好的时候得到它。

当用完一个线程池的时候,调用shutdown。该方法启动该池的关闭序列。被关闭的执行器不再接受新的任务。当所有任务都完成以后,线程池中的线程死亡。另一种方法是调用shutdownNow。该池取消尚未开始的所有任务并试图中断正在运行的线程。

下面总结了在使用连接池时应该做的事:
1)调用Executors类中静态的方法newCachedThreadPool或newFixedThreadPool。
2)调用submit提交Runnable或Callable对象。
3)如果想要取消一个任务,或如果提交Callable对象,那就要保存好返回的Future对象。
4)当不再提交任何任务时,调用 shutdown.


ExecutorService pool = Executors.newCachedThreadPool();
Future<V> a = pool.submit(new Runnable());
Future<V> b = pool.submit(new Runnable(),5);
Future<V> c = pool.submit(new Callable());
pool.shutdown();
((ThreadPoolExecutor)pool).getLargestPoolSize();//返回线程池在该执行器生命周期中的最大尺寸。

ScheduledExecutorService接口具有为预定执行( Scheduled Execution)或重复执行任务而设计的方法。它是一种允许使用线程池机制的java.util.Timer的泛化。Executors类的newScheduledThreadPool和newSingleThreadScheduledExecutor方法将返回实现了
ScheduledExecutorService接口的对象。

可以预定Runnable或Callable在初始的延迟之后只运行一次。也可以预定一个Runnable对象周期性地运行。

invokeAll方法提交所有对象到一个Callable对象的集合中,并返回一个Future对象的列表,代表所有任务的解决方案。当计算结果可获得时,可以像下面这样对结果进行处理:

List<Callable<V>>a=...;
List<Future<V>>list = pool.invokeAll(a);
for(){
    xxx.get();
}
这个方法的缺点是如果第一个任务恰巧花去了很多时间,则可能不得不进行等待。以结果按可获得的顺序保存起来更有实际意义。可以用ExecutorCompletionService来进行排列.用常规的方法获得一个执行器。然后,构建一个ExecutorCompletionService,提交任务给完成服务( completion service)。该服务管理Future对象的阻塞队列,其中包含已经提交的任务的执行结果(当这些结果成为可用时)。

同步器

CyclicBarrier允许线程集等待直至其中预定数目的线程到达一个公共障栅( barrier),然后可以选择执行一个处理障栅的动作,

什么时候使用:当大量的线程需要在它们的结果可用之前完成时。

CountDownLatch允许线程集等待直到计数器减为0

使用:当一个或多个线程需要等待直到指定数目的事件发生

Exchanger允许两个线程在要交换的对象准备好时交换对象

使用:当两个线程工作在同一数据结构的两个实例上的时候,一个向实例添加数据而另一个从实例清除数据

Semaphore允许线程集等待直到被允许继续运行为止

使用:限制访问资源的线程总数。如果许可数是1,常常阻塞线程直到另一个线程给出许可为止

SynchronousQueue允许一个线程把对象交给另一个线程
使用:在没有显式同步的情况下,当两个线程准备好将一个对象从一个线程传递到另一个时


这些机制具有为线程之间的共用集结点模式( common rendezvous patterns)提供的“预置功能”(canned functionality)。如果有一个相互合作的线程集满足这些行为模式之一,那么应该直接重用合适的库类而不要试图提供手工的锁与条件的集合。

### 多线程编程面试常见问题及解答 #### 1. **什么是线程安全?如何保证线程安全?** 线程安全是指当多个线程访问某个类时,无论运行环境采用何种调度方式或者这些线程将如何交替执行,并且在主存中是否存在初值,该类都能表现出正确的行为[^1]。 为了实现线程安全,可以采取以下几种策略: - 使用同步关键字 `synchronized` 来保护共享资源的访问。 - 利用不可变对象(Immutable Objects),因为它们的状态不会改变,因此天然具备线程安全性。 - 借助原子变量(Atomic Variables)来处理简单的状态更新操作。 #### 2. **为什么我们调用 `start()` 方法时会执行 `run()` 方法,而不是直接调用 `run()` 方法?** 当我们创建一个新的线程并调用其 `start()` 方法时,JVM 将负责启动新的线程,并由新线程去执行 `run()` 方法中的逻辑。如果直接调用 `run()` 方法,则它只是作为一个普通的函数被执行,在当前线程上下文中完成工作,而并不会真正开启另一个独立的新线程[^2]。 #### 3. **`wait()` 和 `sleep()` 的区别是什么?** 两者的最大差异在于:`wait()` 调用会使当前线程放弃所持有的;然而,`sleep(long millis)` 不会让出任何,仅仅让当前线程进入休眠状态一段时间之后再恢复运行。此外,`wait()` 主要应用于线程间的协作场景下,比如生产者消费者模式里头;相对而言,`sleep()` 更适合用来短暂延迟某些计算过程以便于其他任务有机会获得 CPU 时间片。 #### 4. **Java 中有哪些机制支持多线程通信?** 主要通过以下几个方面来进行进程间通讯: - Object 类里的三个方法——`wait()`, `notify()`, 及 `notifyAll()` 提供了一种基本形式上的条件队列管理功能; - Lock 接口及其子接口 ReentrantLock 所提供的高级特性如公平设置、尝试定等提供了更灵活可控的方式; - BlockingQueue 是一种特殊的集合框架组件,能够很好地解决生产消费模型下的数据交换需求。 #### 5. **死是如何产生的?怎样预防死的发生?** 死发生的原因主要是由于两个或更多线程互相持有对方所需要的资源而不肯释放造成的僵局现象。具体来说满足四个必要条件即可形成死:互斥使用资源、占有并请求额外资源、不剥夺原则以及循环等待关系。防止死的方法有多种途径可以选择,例如按照一定顺序获取、超时自动释放机制或者是银行家算法提前检测潜在风险等等。 ```java // 死示例代码 public class DeadlockExample { private final Object lockA = new Object(); private final Object lockB = new Object(); public void threadOneTask() throws InterruptedException{ synchronized(lockA){ System.out.println("Thread One: Holding lock A..."); Thread.sleep(10); // Simulate some work synchronized(lockB){ System.out.println("Thread One: Holding both locks"); } } } public void threadTwoTask(){ synchronized(lockB){ System.out.println("Thread Two: Holding lock B..."); try { Thread.sleep(10); } catch (InterruptedException e){} synchronized(lockA){ System.out.println("Thread Two: Holding both locks"); } } } } ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值