java多线程集合（java多线程操作集合）

今天给各位分享java多线程集合的知识，其中也会对java多线程操作集合进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

微信号：cloud7591
如需了解更多，欢迎添加客服微信咨询。
复制微信号

本文目录一览：

• 1、java并发(1)线程模型
• 2、多线程环境下如何正确使用Java集合类
• 3、Java多线程（五）之BlockingQueue深入分析
• 4、告诉你什么是java多线程界说及线程平安
• 5、什么是Java多线程

java并发(1)线程模型

程序并不能单独运行，只有将程序装载到内存中，系统为它分配资源才能运行，而这种执行的程序就称之为进程。程序和进程的区别就在于：程序是指令的集合，它是进程运行的静态描述文本；进程是程序的一次执行活动，属于动态概念

主要归咎于两点. 一个是由实现决定的,一个是由需求决定的.

线程由线程ID，程序计数器(PC）[用于指向内存中的程序指令]，寄存器集合[由于存放本地变量和临时变量]和堆栈[用于存放方法指令和方法参数等]组成。

以 Unix/Linux 的体系架构为例。

因为操作系统的资源是有限的，如果访问资源的操作过多，必然会消耗过多的资源，而且如果不对这些操作加以区分，很可能造成资源访问的冲突。所以，为了减少有限资源的访问和使用冲突，对不同的操作赋予不同的执行等级(有多大能力做多大的事)，用户态(User Mode)和内核态(Kernel Mode)。

运行于用户态的进程可以执行的操作和访问的资源都会受到极大的限制，而运行在内核态的进程则可以执行任何操作并且在资源的使用上没有限制。

并发 ：一个时间段内有很多的线程或进程在执行，但何时间点上都只有一个在执行，多个线程或进程争抢时间片轮流执行。

并行 ：一个时间段和时间点上都有多个线程或进程在执行。

线程有三种模型, 一对一,多对一,多对多.具体参考 一篇文章读懂Java多线程模型 , 这里只描述一对一的情况.

每个用户线程都映射到一个内核线程，每个线程都成为一个独立的调度单元，由内核调度器独立调度，一个线程的阻塞不会影响到其他线程，从而保障整个进程继续工作.

JVM 没有限定 Java 线程需要使用哪种线程模型来实现， JVM 只是封装了底层操作系统的差异，而不同的操作系统可能使用不同的线程模型，例如 Linux 和 windows 可能使用了一对一模型，solaris 和 unix 某些版本可能使用多对多模型。所以一谈到 Java 语言的多线程模型，需要针对具体 JVM 实现。

Sun JDK 1.2开始，线程模型都是基于操作系统原生线程模型来实现，它的 Window 版和 Linux 版都是使用系统的 1:1 的线程模型实现的。

多线程环境下如何正确使用Java集合类

一般不要多个线程同时处理一个集合，如果非要这么做的话。

使用synchronized。对处理集合的代码部分使用synchronized。

使用线程安全的集合类，Vector、HashTable、ConcurrentLinkedQueue、 ConcurrentHashMap、CopyOnWriteArrayList、 CopyOnWriteArraySet 等。

也可以调用Collections.synchronizedMap、Collections.synchronizedList、Collections.synchronizedSet等方法使集合线程安全。

Java多线程（五）之BlockingQueue深入分析

一 概述

BlockingQueue作为线程容器 可以为线程同步提供有力的保障

二 BlockingQueue定义的常用方法

BlockingQueue定义的常用方法如下

抛出异常 特殊值 阻塞 超时

插入 add（e） offer（e） put（e） offer（e time unit）

移除 remove（） poll（） take（） poll（time unit）

检查 element（） peek（） 不可用 不可用

）add（anObject） 把anObject加到BlockingQueue里 即如果BlockingQueue可以容纳 则返回true 否则招聘异常

）offer（anObject） 表示如果可能的话 将anObject加到BlockingQueue里 即如果BlockingQueue可以容纳 则返回true 否则返回false

）put（anObject） 把anObject加到BlockingQueue里 如果BlockQueue没有空间 则调用此方法的线程被阻断直到BlockingQueue里面有空间再继续

）poll（time） 取走BlockingQueue里排在首位的对象 若不能立即取出 则可以等time参数规定的时间 取不到时返回null

）take（） 取走BlockingQueue里排在首位的对象 若BlockingQueue为空 阻断进入等待状态直到Blocking有新的对象被加入为止

其中 BlockingQueue 不接受null 元素 试图add put 或offer 一个null 元素时 某些实现会抛出NullPointerException null 被用作指示poll 操作失败的警戒值

三 BlockingQueue的几个注意点

【 】BlockingQueue 可以是限定容量的 它在任意给定时间都可以有一个remainingCapacity 超出此容量 便无法无阻塞地put 附加元素 没有任何内部容量约束的BlockingQueue 总是报告Integer MAX_VALUE 的剩余容量

【 】BlockingQueue 实现主要用于生产者 使用者队列 但它另外还支持Collection 接口 因此 举例来说 使用remove（x） 从队列中移除任意一个元素是有可能的 然而 这种操作通常不 会有效执行 只能有计划地偶尔使用 比如在取消排队信息时

【 】BlockingQueue 实现是线程安全的 所有排队方法都可以使用内部锁或其他形式的并发控制来自动达到它们的目的 然而 大量的 Collection 操作（addAll containsAll retainAll 和removeAll）没有 必要自动执行 除非在实现中特别说明 因此 举例来说 在只添加了c 中的一些元素后 addAll（c） 有可能失败（抛出一个异常）

【 】BlockingQueue 实质上不 支持使用任何一种 close 或 shutdown 操作来指示不再添加任何项 这种功能的需求和使用有依赖于实现的倾向 例如 一种常用的策略是 对于生产者 插入特殊的end of stream 或 poison 对象 并根据使用者获取这些对象的时间来对它们进行解释

四 简要概述BlockingQueue常用的四个实现类

）ArrayBlockingQueue:规定大小的BlockingQueue 其构造函数必须带一个int参数来指明其大小 其所含的对象是以FIFO（先入先出）顺序排序的

）LinkedBlockingQueue:大小不定的BlockingQueue 若其构造函数带一个规定大小的参数 生成的BlockingQueue有大小限制 若不带大小参数 所生成的BlockingQueue的大小由Integer MAX_VALUE来决定 其所含的对象是以FIFO（先入先出）顺序排序的

）PriorityBlockingQueue:类似于LinkedBlockQueue 但其所含对象的排序不是FIFO 而是依据对象的自然排序顺序或者是构造函数的Comparator决定的顺序

）SynchronousQueue:特殊的BlockingQueue 对其的操作必须是放和取交替完成的

其中LinkedBlockingQueue和ArrayBlockingQueue比较起来 它们背后所用的数据结构不一样 导致LinkedBlockingQueue的数据吞吐量要大于ArrayBlockingQueue 但在线程数量很大时其性能的可预见性低于ArrayBlockingQueue

五 具体BlockingQueue的实现类的内部细节

有耐心的同学请看具体实现类细节

ArrayBlockingQueue

ArrayBlockingQueue是一个由数组支持的有界阻塞队列 此队列按 FIFO（先进先出）原则对元素进行排序 队列的头部 是在队列中存在时间最长的元素 队列的尾部 是在队列中存在时间最短的元素 新元素插入到队列的尾部 队列检索操作则是从队列头部开始获得元素

这是一个典型的 有界缓存区 固定大小的数组在其中保持生产者插入的元素和使用者提取的元素 一旦创建了这样的缓存区 就不能再增加其容量 试图向已满队列中放入元素会导致放入操作受阻塞 试图从空队列中检索元素将导致类似阻塞

ArrayBlockingQueue创建的时候需要指定容量capacity（可以存储的最大的元素个数 因为它不会自动扩容）以及是否为公平锁（fair参数）

在创建ArrayBlockingQueue的时候默认创建的是非公平锁 不过我们可以在它的构造函数里指定 这里调用ReentrantLock的构造函数创建锁的时候 调用了

public ReentrantLock（boolean fair） {

sync = （fair）？ new FairSync（） : new NonfairSync（）

}

FairSync/ NonfairSync是ReentrantLock的内部类

线程按顺序请求获得公平锁 而一个非公平锁可以闯入 且当它尚未进入等待队列 就会和等待队列head结点的线程发生竞争 如果锁的状态可用 请求非公平锁的线程可在等待队列中向前跳跃 获得该锁 内部锁synchronized没有提供确定的公平性保证

分三点来讲这个类

添加新元素的方法 add/put/offer

该类的几个实例变量 takeIndex/putIndex/count/

Condition实现

添加新元素的方法 add/put/offer

首先 谈到添加元素的方法 首先得分析以下该类同步机制中用到的锁

Java代码

[java]

lock = new ReentrantLock（fair）

notEmpty = lock newCondition（） //Condition Variable

notFull =  lock newCondition（） //Condition Variable

这三个都是该类的实例变量 只有一个锁lock 然后lock实例化出两个Condition notEmpty/noFull分别用来协调多线程的读写操作

Java代码

[java]

public boolean offer（E e） {

if （e == null） throw new NullPointerException（）

final ReentrantLock lock = this lock;//每个对象对应一个显示的锁

lock lock（） //请求锁直到获得锁（不可以被interrupte）

try {

if （count == items length）//如果队列已经满了

return false;

else {

insert（e）

return true;

}

} finally {

lock unlock（） //

}

}

看insert方法

private void insert（E x） {

items[putIndex] = x;

//增加全局index的值

/*

Inc方法体内部

final int inc（int i） {

return （++i == items length）？ : i;

}

这里可以看出ArrayBlockingQueue采用从前到后向内部数组插入的方式插入新元素的 如果插完了 putIndex可能重新变为 （在已经执行了移除操作的前提下 否则在之前的判断中队列为满）

*/

putIndex = inc（putIndex）

++count;

notEmpty signal（） //wake up one waiting thread

}

Java代码

[java]

public void put（E e） throws InterruptedException {

if （e == null） throw new NullPointerException（）

final E[] items = ems;

final ReentrantLock lock = this lock;

lock lockInterruptibly（） //请求锁直到得到锁或者变为interrupted

try {

try {

while （count == items length）//如果满了 当前线程进入noFull对应的等waiting状态

notFull await（）

} catch （InterruptedException ie） {

notFull signal（） // propagate to non interrupted thread

throw ie;

}

insert（e）

} finally {

lock unlock（）

}

}

Java代码

[java]

public boolean offer（E e long timeout TimeUnit unit）

throws InterruptedException {

if （e == null） throw new NullPointerException（）

long nanos = unit toNanos（timeout）

final ReentrantLock lock = this lock;

lock lockInterruptibly（）

try {

for （ ） {

if （count != items length） {

insert（e）

return true;

}

if （nanos = ）

return false;

try {

//如果没有被 signal/interruptes 需要等待nanos时间才返回

nanos = notFull awaitNanos（nanos）

} catch （InterruptedException ie） {

notFull signal（） // propagate to non interrupted thread

throw ie;

}

}

} finally {

lock unlock（）

}

}

Java代码

[java]

public boolean add（E e） {

return super add（e）

}

父类

public boolean add（E e） {

if （offer（e））

return true;

else

throw new IllegalStateException（ Queue full ）

}

该类的几个实例变量 takeIndex/putIndex/count

Java代码

[java]

用三个数字来维护这个队列中的数据变更

/** items index for next take poll or remove */

private int takeIndex;

/** items index for next put offer or add */

private int putIndex;

/** Number of items in the queue */

private int count;

提取元素的三个方法take/poll/remove内部都调用了这个方法

Java代码

[java]

private E extract（） {

final E[] items = ems;

E x = items[takeIndex];

items[takeIndex] = null;//移除已经被提取出的元素

takeIndex = inc（takeIndex） //策略和添加元素时相同

count;

notFull signal（） //提醒其他在notFull这个Condition上waiting的线程可以尝试工作了

return x;

}

从这个方法里可见 tabkeIndex维护一个可以提取/移除元素的索引位置 因为takeIndex是从 递增的 所以这个类是FIFO队列

putIndex维护一个可以插入的元素的位置索引

count显然是维护队列中已经存在的元素总数

Condition实现

Condition现在的实现只有ncurrent locks AbstractQueueSynchoronizer内部的ConditionObject 并且通过ReentranLock的newCondition（）方法暴露出来 这是因为Condition的await（）/sinal（）一般在lock lock（）与lock unlock（）之间执行 当执行condition await（）方法时 它会首先释放掉本线程持有的锁 然后自己进入等待队列 直到sinal（） 唤醒后又会重新试图去拿到锁 拿到后执行await（）下的代码 其中释放当前锁和得到当前锁都需要ReentranLock的tryAcquire（int arg）方法来判定 并且享受ReentranLock的重进入特性

Java代码

[java]

public final void await（） throws InterruptedException {

if （Thread interrupted（））

throw new InterruptedException（）

//加一个新的condition等待节点

Node node = addConditionWaiter（）

//释放自己的锁

int savedState = fullyRelease（node）

int interruptMode = ;

while （！isOnSyncQueue（node）） {

//如果当前线程 等待状态时CONDITION park住当前线程 等待condition的signal来解除

LockSupport park（this）

if （（interruptMode = checkInterruptWhileWaiting（node）） != ）

break;

}

if （acquireQueued（node savedState） interruptMode != THROW_IE）

interruptMode = REINTERRUPT;

if （node nextWaiter != null）

unlinkCancelledWaiters（）

if （interruptMode != ）

reportInterruptAfterWait（interruptMode）

}

SynchronousQueue

一种阻塞队列 其中每个 put 必须等待一个 take 反之亦然 同步队列没有任何内部容量 甚至连一个队列的容量都没有 不能在同步队列上进行 peek 因为仅在试图要取得元素时 该元素才存在 除非另一个线程试图移除某个元素 否则也不能（使用任何方法）添加元素 也不能迭代队列 因为其中没有元素可用于迭代 队列的头 是尝试添加到队列中的首个已排队线程元素 如果没有已排队线程 则不添加元素并且头为 null 对于其他Collection 方法（例如 contains） SynchronousQueue 作为一个空集合 此队列不允许 null 元素

同步队列类似于 CSP 和 Ada 中使用的 rendezvous 信道 它非常适合于传递性设计 在这种设计中 在一个线程中运行的对象要将某些信息 事件或任务传递给在另一个线程中运行的对象 它就必须与该对象同步

对于正在等待的生产者和使用者线程而言 此类支持可选的公平排序策略 默认情况下不保证这种排序 但是 使用公平设置为 true 所构造的队列可保证线程以 FIFO 的顺序进行访问 公平通常会降低吞吐量 但是可以减小可变性并避免得不到服务

LinkedBlockingQueue

一个基于已链接节点的 范围任意的 blocking queue 此队列按 FIFO（先进先出）排序元素 队列的头部 是在队列中时间最长的元素 队列的尾部 是在队列中时间最短的元素 新元素插入到队列的尾部 并且队列检索操作会获得位于队列头部的元素 链接队列的吞吐量通常要高于基于数组的队列 但是在大多数并发应用程序中 其可预知的性能要低

单向链表结构的队列 如果不指定容量默认为Integer MAX_VALUE 通过putLock和takeLock两个锁进行同步 两个锁分别实例化notFull和notEmpty两个Condtion 用来协调多线程的存取动作 其中某些方法（如remove toArray toString clear等）的同步需要同时获得这两个锁 并且总是先putLock lock紧接着takeLock lock（在同一方法fullyLock中） 这样的顺序是为了避免可能出现的死锁情况（我也想不明白为什么会是这样？）

PriorityBlockingQueue

一个无界的阻塞队列 它使用与类 PriorityQueue 相同的顺序规则 并且提供了阻塞检索的操作 虽然此队列逻辑上是无界的 但是由于资源被耗尽 所以试图执行添加操作可能会失败（导致 OutOfMemoryError） 此类不允许使用 null 元素 依赖自然顺序的优先级队列也不允许插入不可比较的对象（因为这样做会抛出ClassCastException）

看它的三个属性 就基本能看懂这个类了

Java代码

[java]

private final PriorityQueue q;

private final ReentrantLock lock = new ReentrantLock（true）

private final Condition notEmpty = lock newCondition（）

lock说明本类使用一个lock来同步读写等操作

notEmpty协调队列是否有新元素提供 而队列满了以后会调用PriorityQueue的grow方法来扩容

DelayQueue

Delayed 元素的一个无界阻塞队列 只有在延迟期满时才能从中提取元素 该队列的头部 是延迟期满后保存时间最长的 Delayed 元素 如果延迟都还没有期满 则队列没有头部 并且 poll 将返回 null 当一个元素的getDelay（TimeUnit NANOSECONDS） 方法返回一个小于或等于零的值时 则出现期满 此队列不允许使用 null 元素

Delayed接口继承自Comparable 我们插入的E元素都要实现这个接口

DelayQueue的设计目的间API文档

An unbounded blocking queue of Delayed elements in which an element can only be taken when its delay has expired The head of the queue is that Delayed element whose delay expired furthest in the past If no delay has expired there is no head and poll will returnnull Expiration occurs when an element s getDelay（TimeUnit NANOSECONDS） method returns a value less than or equal to zero Even though unexpired elements cannot be removed using take or poll they are otherwise treated as normal elements For example the size method returns the count of both expired and unexpired elements This queue does not permit null elements

因为DelayQueue构造函数了里限定死不允许传入parator（之前的PriorityBlockingQueue中没有限定死） 即只能在pare方法里定义优先级的比较规则 再看上面这段英文 The head of the queue is that Delayed element whose delay expired furthest in the past 说明pare方法实现的时候要保证最先加入的元素最早结束延时 而 Expiration occurs when an element s getDelay（TimeUnit NANOSECONDS） method returns a value less than or equal to zero 说明getDelay方法的实现必须保证延时到了返回的值变为= 的int

上面这段英文中 还说明了 在poll/take的时候 队列中元素会判定这个elment有没有达到超时时间 如果没有达到 poll返回null 而take进入等待状态 但是 除了这两个方法 队列中的元素会被当做正常的元素来对待 例如 size方法返回所有元素的数量 而不管它们有没有达到超时时间 而协调的Condition available只对take和poll是有意义的

另外需要补充的是 在ScheduledThreadPoolExecutor中工作队列类型是它的内部类DelayedWorkQueue 而DelayedWorkQueue的Task容器是DelayQueue类型 而ScheduledFutureTask作为Delay的实现类作为Runnable的封装后的Task类 也就是说ScheduledThreadPoolExecutor是通过DelayQueue优先级判定规则来执行任务的

BlockingDque+LinkedBlockingQueue

lishixinzhi/Article/program/Java/gj/201311/27544

告诉你什么是java多线程界说及线程平安

a1.程序:指令和数据的byte序列,eg:qq.exe;a2.进程:正在运行的程序(如QQ);a3.一个进程中可能有一到多个线程.

线程的概念：Thread 每个正在系统上运行的程序都是一个进程。每个进程包含一到多个线程。进程也可能是整个程序或者是部分程序的动态执行。

线程是一组指令的集合，或者是程序的特殊段，它可以在程序里独立执行。也可以把它理解为代码运行的上下文。

所以线程基本上是轻量级的进程，它负责在单个程序里执行多任务。通常由操作系统负责多个线程的调度和执行。

多线程的概念： 多线程是为了同步完成多项任务，不是为了提高运行效率，而是为了提高资源使用效率来提高系统的效率。

线程是在同一时间需要完成多项任务的时候实现的。

多线程的优点：使用线程可以把占据长时间的程序中的任务放到后台去处理

用户界面可以更加吸引人，这样比如用户点击了一个按钮去触发某些事件的处理，可以弹出一个进度条来显示处理的进度 ·

程序的运行速度可能加快 ·在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较有用了。

什么是Java多线程

多线程的概念？

说起多线程，那么就不得不说什么是线程，而说起线程，又不得不说什么是进程。

进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。

进程可以简单的理解为一个可以独立运行的程序单位。它是线程的集合，进程就是有一个或多个线程构成的，每一个线程都是进程中的一条执行路径。

那么多线程就很容易理解：多线程就是指一个进程中同时有多个执行路径（线程）正在执行。

为什么要使用多线程？

1.在一个程序中，有很多的操作是非常耗时的，如数据库读写操作，IO操作等，如果使用单线程，那么程序就必须等待这些操作执行完成之后才能执行其他操作。使用多线程，可以在将耗时任务放在后台继续执行的同时，同时执行其他操作。

2.可以提高程序的效率。

3.在一些等待的任务上，如用户输入，文件读取等，多线程就非常有用了。

缺点：

1.使用太多线程，是很耗系统资源，因为线程需要开辟内存。更多线程需要更多内存。

2.影响系统性能，因为操作系统需要在线程之间来回切换。

3.需要考虑线程操作对程序的影响，如线程挂起，中止等操作对程序的影响。

4.线程使用不当会发生很多问题。

总结：多线程是异步的，但这不代表多线程真的是几个线程是在同时进行，实际上是系统不断地在各个线程之间来回的切换（因为系统切换的速度非常的快，所以给我们在同时运行的错觉）。

2.多线程与高并发的联系。

高并发：高并发指的是一种系统运行过程中遇到的一种“短时间内遇到大量操作请求”的情况，主要发生在web系统集中大量访问或者socket端口集中性收到大量请求（例如：12306的抢票情况；天猫双十一活动）。该情况的发生会导致系统在这段时间内执行大量操作，例如对资源的请求，数据库的操作等。如果高并发处理不好，不仅仅降低了用户的体验度（请求响应时间过长），同时可能导致系统宕机，严重的甚至导致OOM异常，系统停止工作等。如果要想系统能够适应高并发状态，则需要从各个方面进行系统优化，包括，硬件、网络、系统架构、开发语言的选取、数据结构的运用、算法优化、数据库优化……。

而多线程只是在同/异步角度上解决高并发问题的其中的一个方法手段，是在同一时刻利用计算机闲置资源的一种方式。

多线程在高并发问题中的作用就是充分利用计算机资源，使计算机的资源在每一时刻都能达到最大的利用率，不至于浪费计算机资源使其闲置。

3.线程的创建，停止，常用方法介绍。

1.线程的创建：

线程创建主要有2种方式，一种是继承Thread类，重写run方法即可；（Thread类实现了Runable接口）

另一种则是实现Runable接口，也需要重写run方法。

线程的启动，调用start（）方法即可。 我们也可以直接使用线程对象的run方法，不过直接使用，run方法就只是一个普通的方法了。

其他的还有： 通过匿名内部类的方法创建；实现Callable接口。。。。。

2.线程常用方法：

currentThread()方法：该方法返回当前线程的信息 .getName（）可以返回线程名称。

isAlive()方法：该方法判断当前线程是否处于活动状态。

sleep()方法：该方法是让“当前正在执行的线程“休眠指定的时间，正在执行的线程是指this.currentThread()返回的线程。

getId()方法：该方法是获取线程的唯一标识。

3.线程的停止：

在java中，停止线程并不简单，不想for。。break那样说停就停，需要一定的技巧。

线程的停止有3种方法：

1.线程正常终止，即run()方法运行结束正常停止。

2.使用interrupt方法中断线程。

3.使用stop方法暴力停止线程。

interrupt方法中断线程介绍：

interrupt方法其实并不是直接中断线程，只是给线程添加一个中断标志。

判断线程是否是停止状态：

this.interrupted(); 判断当前线程是否已经中断。（判断的是这个方法所在的代码对应的线程，而不是调用对象对应的线程）

this.isInterrupted(); 判断线程是否已经中断。（谁调用，判断谁）

注：.interrupted()与isInterrupted()的区别：

interrupted()方法判断的是所在代码对应的线程是否中断，而后者判断的是调用对象对应的线程是否停止

前者执行后有清除状态的功能（如连续调用两次时，第一次返回true，则第二次会返回false）

后者没有清除状态的功能（两次返回都为true）

真正停止线程的方法：

异常法：

在run方法中 使用 this.interrupted();判断线程终止状态，如果为true则 throw new interruptedException()然后捕获该异常即可停止线程。

return停止线程：

在run方法中 使用 this.interrupted();判断线程终止状态，如果为true则return停止线程。 （建议使用异常法停止线程，因为还可以在catch中使线程向上抛，让线程停止的事件得以传播）。

暴力法：

使用stop()方法强行停止线程（强烈不建议使用，会造成很多不可预估的后果，已经被标记为过时）

（使用stop方法会抛出 java.lang.ThreadDeath 异常，并且stop方法会释放锁，很容易造成数据不一致）

注：在休眠中停止线程：

在sleep状态下停止线程 会报异常，并且会清除线程状态值为false；

先停止后sleep，同样会报异常 sleep interrupted；

4.守护线程。

希望对您有所帮助！~

java多线程集合的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java多线程操作集合、java多线程集合的信息别忘了在本站进行查找喔。