核心技术：并发 - 版本历史

Eijux：/* 阻塞队列类型 */

2022-11-30T03:07:49Z

阻塞队列类型

←上一版本		2022年11月30日 (三) 11:07的版本
第755行：		第755行：
	public class DelayQueue<E extends Delayed> extends AbstractQueue<E> implements BlockingQueue<E> {		public class DelayQueue<E extends Delayed> extends AbstractQueue<E> implements BlockingQueue<E> {
	</syntaxhighlight>		</syntaxhighlight>
	* JavaSE 7 ~~增加了一个TranSferQueUe~~ 接口，允许生产者线程等待，直到消费者准备就绪可以接收一个元素。		* JavaSE 7 增加了一个 TransferQueue 接口，允许生产者线程等待，直到消费者准备就绪可以接收一个元素。
	*: 如果生产者调用<syntaxhighlight lang="java" inline>q.transfer(~~iteni~~);</syntaxhighlight>；这个调用会阻塞，直到另一个线程将元素（item) 删除。		*: 如果生产者调用<syntaxhighlight lang="java" inline>q.transfer(item i);</syntaxhighlight>；这个调用会阻塞，直到另一个线程将元素（item) 删除。

Eijux：/* 被终止的线程（Terminated） */

2022-11-30T02:31:19Z

被终止的线程（Terminated）

←上一版本		2022年11月30日 (三) 10:31的版本
第149行：		第149行：
	\| style="width:50%;" \| 等待指定线程的终止。【在当前线程调用“s.join();”，则必须等待线程s执行完毕，当前线程才能继续执行】		\| style="width:50%;" \| 等待指定线程的终止。【在当前线程调用“s.join();”，则必须等待线程s执行完毕，当前线程才能继续执行】
	\|-		\|-
	\| style="width:50%;" \| void join(long ~~mi11is~~)		\| style="width:50%;" \| void join(long millis)
	\| style="width:50%;" \| 等待指定的线程死亡或者经过指定的毫秒数。		\| style="width:50%;" \| 等待指定的线程死亡或者经过指定的毫秒数。
	\|-		\|-

Eijux：/* 关于迭代器？ */

2021-12-19T16:30:45Z

关于迭代器？

←上一版本		2021年12月20日 (一) 00:30的版本
第899行：		第899行：

	'''相关方法：'''		'''相关方法：'''
	{\| class="wikitable" style="width:100%;"		{\| class="wikitable mw-collapsible mw-collapsed" style="width:100%;"
	\|-		\|-
	! colspan="2" style="text-align:left;"\| java.util.concurrent.ConcurrentLinkedQueue<E>		! colspan="2" style="text-align:left;"\| java.util.concurrent.ConcurrentLinkedQueue<E>

Eijux：/* 阻塞队列类型 */

2021-12-19T16:29:36Z

阻塞队列类型

←上一版本		2021年12月20日 (一) 00:29的版本
第760行：		第760行：

	'''相关方法：'''		'''相关方法：'''
	{\| class="wikitable" style="width:100%;"		{\| class="wikitable mw-collapsible mw-collapsed" style="width:100%;"
	\|-		\|-
	! colspan="2" style="text-align:left;"\| java.util.concurrent.ArrayBlockingQueue<E>		! colspan="2" style="text-align:left;"\| java.util.concurrent.ArrayBlockingQueue<E>

Eijux：/* 条件对象（Condition） */

2021-10-30T11:01:29Z

条件对象（Condition）

←上一版本		2021年10月30日 (六) 19:01的版本
第342行：		第342行：

	=== 条件对象（Condition） ===		=== 条件对象（Condition） ===
			条件对象用于管理那些已经获得了一个锁但是却不能做有用工作的线程。

	~~条件对象用于管理那些已经获得了一个锁但是却不能做有用工作的线程。~~

	~~==== 使用 ====~~		使用：
	# 一个锁对象可以有一个或多个相关的条件对象，用 '''newCondition''' 方法获得一个条件对象。		# 一个锁对象可以有一个或多个相关的条件对象，用 '''newCondition''' 方法获得一个条件对象。
	#: <syntaxhighlight lang="java">		#: <syntaxhighlight lang="java">
第362行：		第362行：
	</syntaxhighlight>		</syntaxhighlight>
	#: 当前线程现在被阻塞了，并放弃了锁。		#: 当前线程现在被阻塞了，并放弃了锁。
	#: 一旦一个线程调用await方法， ~~它进人该条件的等待集。当锁可用时，该线程不能马上解除阻塞。相反，它处于阻塞状态，直到另一个线程调用同一条件上的signalAll~~ 方法时为止。		#: 一旦一个线程调用await方法，它进人该条件的等待集。当锁可用时，该线程不能马上解除阻塞。相反，它处于阻塞状态，直到另一个线程调用同一条件上的 signalAll 方法时为止。
	# 重新激活因为这一条件而等待的所有线程'''signalAll'''：		# 重新激活因为这一条件而等待的所有线程'''signalAll'''：
	#: <syntaxhighlight lang="java">		#: <syntaxhighlight lang="java">
第369行：		第369行：


	* ~~至关重要的是最终需要某个其他线程调用signalAll~~ 方法		* 至关重要的是最终需要某个其他线程调用 signalAll 方法
	* 调用signalAll 不会立即激活一个等待线程。它仅仅解除等待线程的阻塞，以便这些线程可以在当前线程退出同步方法之后，通过竞争实现对对象的访问。		* 调用 signalAll 不会立即激活一个等待线程。它仅仅解除等待线程的阻塞，以便这些线程可以在当前线程退出同步方法之后，通过竞争实现对对象的访问。


	~~====~~ 示例： ~~====~~		示例：
	<syntaxhighlight lang="java">		<syntaxhighlight lang="java">
	public void transfer(int from, int to, int amount)		public void transfer(int from, int to, int amount)

Eijux：/* synchronized 与 wait、notifyAll */

2021-10-30T10:59:27Z

synchronized 与 wait、notifyAll

←上一版本		2021年10月30日 (六) 18:59的版本
第409行：		第409行：
	</pre>		</pre>

	* '''每一个对象有一个内部锁，并且该锁有一个内部条件。'''		* <big>'''每一个对象有一个内部锁，并且该锁有一个内部条件。'''</big>

	即：		即：
第436行：		第436行：
	</syntaxhighlight>		</syntaxhighlight>

	~~===== 示例 =====~~
			示例：
	<syntaxhighlight lang="java" highlight="4,7,10">		<syntaxhighlight lang="java" highlight="4,7,10">
	class Bank		class Bank

Eijux：/* 示例： */

2021-10-30T10:57:46Z

示例：

←上一版本		2021年10月30日 (六) 18:57的版本
第295行：		第295行：
	* 锁是可重入的，因为线程可以重复地获得已经持有的锁。锁保持一个持有计数（ holdcount ) 来跟踪对lock 方法的嵌套调用。线程在每一次调用lock 都要调用unlock 来释放锁。由于这一特性，被一个锁保护的代码可以调用另一个使用相同的锁的方法。		* 锁是可重入的，因为线程可以重复地获得已经持有的锁。锁保持一个持有计数（ holdcount ) 来跟踪对lock 方法的嵌套调用。线程在每一次调用lock 都要调用unlock 来释放锁。由于这一特性，被一个锁保护的代码可以调用另一个使用相同的锁的方法。

	~~====~~ 示例： ~~====~~		示例：
	<syntaxhighlight lang="java">		<syntaxhighlight lang="java">
	public class Bank {		public class Bank {
第315行：		第315行：
	}		}
	</syntaxhighlight>		</syntaxhighlight>
	~~如上：~~
	# transfer 方法调用getTotalBalance 方法，这也会封锁bankLock 对象，此时bankLock对象的持有计数为2。		# transfer 方法调用getTotalBalance 方法，这也会封锁bankLock 对象，此时bankLock对象的持有计数为2。
	# 当getTotalBalance 方法退出的时候，持有计数变回1。		# 当getTotalBalance 方法退出的时候，持有计数变回1。

Eijux：/* 监视器概念（monitor） */

2021-10-30T10:55:51Z

监视器概念（monitor）

←上一版本		2021年10月30日 (六) 18:55的版本
第531行：		第531行：

	Java中以不是很精确的方式采用了监视器概念：		Java中以不是很精确的方式采用了监视器概念：
	# ~~用synchronized~~ 关键字声明方法		# 用 synchronized 关键字声明方法
	# ~~通过调用wait~~/~~notifyAU~~/notify 来访问条件变量		# 通过调用 wait/notifyAll/notify 来访问条件变量


	Java 对象不同于监视器，从而使得线程的安全性下降：		Java 对象不同于监视器，从而使得线程的安全性下降：
	# ~~域不要求必须是private。~~		# 域不要求必须是 private。
	# ~~方法不要求必须是synchronized。~~		# 方法不要求必须是 synchronized。
	# 内部锁对客户是可用的。【？】		# 内部锁对客户是可用的。【？】

Eijux：/* 相关方法 */

2021-10-30T10:54:21Z

相关方法

←上一版本		2021年10月30日 (六) 18:54的版本
第1,246行：		第1,246行：
	*# “Future<T> submit(Callable<T> task)”：返回的 Future 对象将在计算结果准备好的时候得到它；		*# “Future<T> submit(Callable<T> task)”：返回的 Future 对象将在计算结果准备好的时候得到它；

	==~~== 相关方法 ====~~		'''相关方法：'''
	==~~===~~ java.util.concurrent.Executors =~~====~~		{\| class="wikitable" style="width:100%;"
	* ExecutorService newCachedThreadPool()		\|-
	*: 返回一个带缓存的线程池，该池在必要的时候创建线程， '''在线程空闲60 秒之后终止线程'''。		! colspan="2" style="text-align:left;"\| java.util.concurrent.Executors
	* ExecutorService newFixedThreadPool(int threads)		\|-
	*: 返回一个线程池，该池中的线程数由参数指定。'''空闲线程会一直被保留'''。		\| style="width:50%;" \| ExecutorService newCachedThreadPool()
	* ExecutorService newSingleThreadExecutor()		\| style="width:50%;" \| 返回一个带缓存的线程池，该池在必要的时候创建线程， '''在线程空闲60 秒之后终止线程'''。
	*: 返回一个执行器，它在一个单个的线程中依次执行各个任务。		\|-
	==~~===~~ java.util.concurrent.ExecutorService =~~====~~		\| style="width:50%;" \| ExecutorService newFixedThreadPool(int threads)
	* Future<T > submit(~~Cal1able~~<T> task)		\| style="width:50%;" \| 返回一个线程池，该池中的线程数由参数指定。'''空闲线程会一直被保留'''。
	* Future< T > submit(Runnable task, T result)		\|-
	* Future<?> submit(Runnable task)		\| style="width:50%;" \| ExecutorService newSingleThreadExecutor()
	*: ~~提交指定的任务去执行。~~		\| style="width:50%;" \| 返回一个执行器，它在一个单个的线程中依次执行各个任务。
	* void shutdown()		\|-
	*: 关闭服务，会先完成已经提交的任务而不再接收新的任务。		! colspan="2" style="text-align:left;"\| java.util.concurrent.ExecutorService
	==~~===~~ java.util.concurrent.ThreadPoolExecutor =~~====~~		\|-
	* int getLargestPoolSize()		\| style="width:50%;" \| Future<T> submit(Callable<T> task)
	*: 返回线程池在该执行器生命周期中的最大尺寸。		\| style="width:50%;" rowspan="3" \| 提交指定的任务去执行。
			\|-
			\| style="width:50%;" \| Future<T> submit(Runnable task, T result)
			\|-
			\| style="width:50%;" \| Future<?> submit(Runnable task)
			\|-
			\| style="width:50%;" \| void shutdown()
			\| style="width:50%;" \| 关闭服务，会先完成已经提交的任务而不再接收新的任务。
			\|-
			! colspan="2" style="text-align:left;"\| java.util.concurrent.ThreadPoolExecutor
			\|-
			\| style="width:50%;" \| int getLargestPoolSize()
			\| style="width:50%;" \| 返回线程池在该执行器生命周期中的最大尺寸。
			\|}

	=== 预定执行（ScheduledExecutorService）===		=== 预定执行（ScheduledExecutorService）===

Eijux：/* 相关方法 */

2021-10-30T10:51:23Z

←上一版本		2021年10月30日 (六) 18:51的版本
第1,286行：		第1,286行：
	</syntaxhighlight>		</syntaxhighlight>

	==~~== 相关方法 ====~~		'''相关方法：'''
	==~~===~~ java.util.concurrent.Executors =~~====~~		{\| class="wikitable" style="width:100%;"
	* ScheduledExecutorService newScheduledThreadPool(int threads)		\|-
	*:返回一个线程池，它使用给定的线程数来调度任务。		! colspan="2" style="text-align:left;"\| java.util.concurrent.Executors
	* ScheduledExecutorService newSingleThreadScheduledExecutor( )		\|-
	*:返回一个执行器，它在一个单独线程中调度任务。		\| style="width:50%;" \| ScheduledExecutorService newScheduledThreadPool(int threads)
	==~~===~~ java.util.concurrent.ScheduledExecutorService =~~====~~		\| style="width:50%;" \| 返回一个线程池，它使用给定的线程数来调度任务。
	* ScheduledFuture<V> schedule(~~Cal 1able~~<V> task , long time, Timellnit unit )		\|-
	* ScheduledFuture<?> schedule(Runnable task , long time , TimeUnit unit )		\| style="width:50%;" \| ScheduledExecutorService newSingleThreadScheduledExecutor( )
	*:~~预定在指定的时间之后执行任务。~~		\| style="width:50%;" \| 返回一个执行器，它在一个单独线程中调度任务。
	* ScheduledFuture< ? > scheduleAtFixedRate ( Runnable task , long initialDelay , long period, TimeUnit unit )		\|-
	*:预定在初始的延迟结束后，周期性地运行给定的任务，周期长度是period。		! colspan="2" style="text-align:left;"\| java.util.concurrent.ScheduledExecutorService
	* ScheduledFuture< ?> ~~scheduleWithFixedDel ay~~( Runnable task , long initialDelay , long delay, TimeUnit unit )		\|-
	*:预定在初始的延迟结束后周期性地运行给定的任务，在一次调用完成和下一次调用开始之间有长度为delay 的延迟。		\| style="width:50%;" \| ScheduledFuture<V> schedule(Callable<V> task , long time, Timellnit unit )
			\| style="width:50%;" rowspan="2" \| 预定在指定的时间之后执行任务。
			\|-
			\| style="width:50%;" \| ScheduledFuture<?> schedule(Runnable task , long time , TimeUnit unit )
			\|-
			\| style="width:50%;" \| ScheduledFuture<?> scheduleAtFixedRate(Runnable task , long initialDelay , long period, TimeUnit unit )
			\| style="width:50%;" \| 预定在初始的延迟结束后，周期性地运行给定的任务，周期长度是period。
			\|-
			\| style="width:50%;" \| ScheduledFuture<?> scheduleWithFixedDelay(Runnable task , long initialDelay , long delay, TimeUnit unit )
			\| style="width:50%;" \| 预定在初始的延迟结束后周期性地运行给定的任务，在一次调用完成和下一次调用开始之间有长度为delay 的延迟。
			\|}

	=== 控制任务组 ===		=== 控制任务组 ===

核心技术：并发 - 版本历史

Eijux：​/* 阻塞队列类型 */

Eijux：​/* 被终止的线程（Terminated） */

Eijux：​/* 关于迭代器？ */

Eijux：​/* 阻塞队列类型 */

Eijux：​/* 条件对象（Condition） */

Eijux：​/* synchronized 与 wait、notifyAll */

Eijux：​/* 示例： */

Eijux：​/* 监视器概念（monitor） */

Eijux：​/* 相关方法 */

Eijux：​/* 相关方法 */

Eijux：/* 阻塞队列类型 */

Eijux：/* 被终止的线程（Terminated） */

Eijux：/* 关于迭代器？ */

Eijux：/* 阻塞队列类型 */

Eijux：/* 条件对象（Condition） */

Eijux：/* synchronized 与 wait、notifyAll */

Eijux：/* 示例： */

Eijux：/* 监视器概念（monitor） */

Eijux：/* 相关方法 */

Eijux：/* 相关方法 */