目录

1 并发包

1.1同步容器类

1.1.1Vector与ArrayList区别

1.1.2HasTable与HasMap

1.1.3 synchronizedMap

1.1.4 ConcurrentHashMap

1.1.5 CountDownLatch​​​​​​

1.1.6 CyclicBarrier

1.1.6 Semaphore

2 并发队列

2.1 ConcurrentLinkedQueue

2.2 BlockingQueue

2.3 ArrayBlockingQueue

2.4 LinkedBlockingQueue

2.5 PriorityBlockingQueue

2.6 SynchronousQueue

2.7 使用BlockingQueue模拟生产者与消费者


1 并发包

1.1同步容器类

1.1.1Vector与ArrayList区别

1.1.1.1 ArrayList是最常用的List实现类,内部是通过数组实现的,它允许对元素进行快速随机访问。数组的缺点是每个元素之间不能有间隔,当数组大小不满足时需要增加存储能力,就要讲已经有数组的数据复制到新的存储空间中。当从ArrayList的中间位置插入或者删除元素时,需要对数组进行复制、移动、代价比较高。因此,它适合随机查找和遍历,不适合插入和删除。

1.1.1.2.Vector与ArrayList一样,也是通过数组实现的,不同的是它支持线程的同步,即某一时刻只有一个线程能够写Vector,避免多线程同时写而引起的不一致性,但实现同步需要很高的花费,因此,访问它比访问ArrayList慢

注意: Vector线程安全、ArrayList

Vector源码类

Add方法源码类

    public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}

Arraylist源码

Add方法源码

    public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}

1.1.2HasTable与HasMap

1.1.2.1 HashMap不是线程安全的

HashMap是一个接口 是map接口的子接口,是将键映射到值的对象,其中键和值都是对象,并且不能包含重复键,但可以包含重复值。HashMap允许null key和null value,而hashtable不允许。

1.1.2.2 HashTable是线程安全的一个Collection。

1.1.2.3 HashMap是Hashtable的轻量级实现(非线程安全的实现),他们都完成了Map接口,主要区别在于HashMap允许空(null)键值(key),由于非线程安全,效率上可能高于Hashtable。

HashMap允许将null作为一个entry的key或者value,而Hashtable不允许。

HashMap把Hashtable的contains方法去掉了,改成containsvalue和containsKey。

注意: HashTable线程安全,HashMap线程不安全。

1.1.3 synchronizedMap

Collections.synchronized*(m) 将线程不安全额集合变为线程安全集合

1.1.4 ConcurrentHashMap

ConcurrentMap接口下有俩个重要的实现 :

ConcurrentHashMap

ConcurrentskipListMap (支持并发排序功能。弥补ConcurrentHas hMa p)
ConcurrentHashMap内部使用段(Segment)来表示这些不同的部分,每个段其实就是一个

小的HashTable,它们有自己的锁。只要多个修改操作发生在不同的段上,它们就可以并

发进行。把一个整体分成了16个段(Segment.也就是最高支持16个线程的并发修改操作。

这也是在重线程场景时减小锁的粒度从而降低锁竞争的一种方案。并且代码中大多共享变

量使用volatile关键字声明,目的是第一时间获取修改的内容,性能非常好。

1.1.5 CountDownLatch​​​​​​

CountDownLatch类位于java.util.concurrent包下,利用它可以实现类似计数器的功能。比如有一个任务A,它要等待其他4个任务执行完毕之后才能执行,此时就可以利用CountDownLatch来实现这种功能

public class CountDownLatchDemo {
public static void main(String[] args) throws InterruptedException {
CountDownLatch countDownLatch = new CountDownLatch(2);
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("我是子线程开始执行。。。。");
try {
Thread.sleep(1000);//子线程处理事情
} catch (InterruptedException e) {
e.printStackTrace();
}
countDownLatch.countDown();//每次减一
System.out.println("我是子线程执行结束。。。。");
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("我是子线程开始执行。。。。");
try {
Thread.sleep(1000);//子线程处理事情
} catch (InterruptedException e) {
e.printStackTrace();
}
countDownLatch.countDown();
System.out.println("我是子线程执行结束。。。。");
}
}).start();
countDownLatch.await();//如果不为0,则一直等待
System.out.println("主线程开始执行任务");
for (int i = 0; i < 10; i++) {
System.out.println("main: i="+i);
}
}
}

1.1.6 CyclicBarrier

CyclicBarrier初始化时规定一个数目,然后计算调用了CyclicBarrier.await()进入等待的线程数。当线程数达到了这个数目时,所有进入等待状态的线程被唤醒并继续。

CyclicBarrier就如同他的名字一样,可看成是一个障碍,所有的线程必须到齐后才能一起通过这个障碍。

CyclicBarrier初始时还可带一个Runnable的参数,该Runnable任务在CyclicBarrier的数目达到后,所有其他的线程被唤醒前被执行。

class Writer extends Thread{
CyclicBarrier cyclicBarrier;
public Writer(CyclicBarrier cyclicBarrier){
this.cyclicBarrier=cyclicBarrier;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"开始写入数据.....");
try {
Thread.sleep(1000);//模拟耗时
System.out.println(Thread.currentThread().getName()+"写入数据成功.....");
cyclicBarrier.await();
System.out.println(Thread.currentThread().getName()+"写入数据完毕.....");
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}
}
public class CyclicBarrierDemo {
public static void main(String[] args) {
CyclicBarrier barrier = new CyclicBarrier(5);
for (int i = 0; i < 5; i++) {
new Writer(barrier).start();
}
}
} 输出:
Thread-0开始写入数据.....
Thread-1开始写入数据.....
Thread-2开始写入数据.....
Thread-3开始写入数据.....
Thread-4开始写入数据.....
Thread-0写入数据成功.....
Thread-1写入数据成功.....
Thread-2写入数据成功.....
Thread-4写入数据成功.....
Thread-3写入数据成功.....
Thread-3写入数据完毕.....
Thread-4写入数据完毕.....
Thread-2写入数据完毕.....
Thread-1写入数据完毕.....
Thread-0写入数据完毕.....
如果不加CyclicBarrier则:
Thread-0开始写入数据.....
Thread-1开始写入数据.....
Thread-2开始写入数据.....
Thread-3开始写入数据.....
Thread-4开始写入数据.....
Thread-0写入数据成功.....
Thread-0写入数据完毕.....
Thread-1写入数据成功.....
Thread-1写入数据完毕.....
Thread-2写入数据成功.....
Thread-2写入数据完毕.....
Thread-3写入数据成功.....
Thread-3写入数据完毕.....
Thread-4写入数据成功.....
Thread-4写入数据完毕.....

1.1.6 Semaphore

Semaphore是一种基于计数的信号量,它可以设定一个阈值,基于此,多个线程竞争获取许可信号,做自己的申请后归还,超过阈值后,线程申请许可信号将被阻塞。Semaphore可以用来构建一些对象池,资源池之类的,比如数据库连接池,我们也可以创建计数为1的Semaphore,将其作为一种类似互斥锁的机制,这也叫二元信号量,表示两种互斥状态。用法如下:

availablePermits函数用来获取当前可用的资源数量

wc.acquire();//申请资源

wc.release();//释放资源

案例:

需求: 一个厕所只有3个坑位,但是有10个人来上厕所,那怎么办?假设10的人的编号分别为1-10,并且1号先到厕所,10号最后到厕所。那么1-3号来的时候必然有可用坑位,顺利如厕,4号来的时候需要看看前面3人是否有人出来了,如果有人出来,进去,否则等待。同样的道理,4-10号也需要等待正在上厕所的人出来后才能进去,并且谁先进去这得看等待的人是否有素质,是否能遵守先来先上的规则。

class User extends Thread{
Semaphore wc;
String name; public User(Semaphore wc, String name) {
this.wc = wc;
this.name = name;
} @Override
public void run() {
int availablePermits = wc.availablePermits();
if(availablePermits>0){
System.out.println(name+":天助我也,我有茅坑的哟");
} else {
System.out.println(name+":我靠,居然没有茅坑了");
}
try {
wc.acquire();
System.out.println(name+":终于能上厕所了,倍儿爽!!!!");
Thread.sleep(new Random().nextInt(1000));
System.out.println(name+":厕所上完了");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
wc.release();
}
}
}
public class SemaphoreDemo {
public static void main(String[] args) {
Semaphore semaphore = new Semaphore(3);//最多支持多少个线程
for (int i = 1; i <= 10; i++) {
new User(semaphore, i+"").start();
}
}
} 输出如下:
1:天助我也,我有茅坑的哟
1:终于能上厕所了,倍儿爽!!!!
2:天助我也,我有茅坑的哟
2:终于能上厕所了,倍儿爽!!!!
3:天助我也,我有茅坑的哟
3:终于能上厕所了,倍儿爽!!!!
4:我靠,居然没有茅坑了
5:我靠,居然没有茅坑了
6:我靠,居然没有茅坑了
7:我靠,居然没有茅坑了
8:我靠,居然没有茅坑了
9:我靠,居然没有茅坑了
10:我靠,居然没有茅坑了
1:厕所上完了
4:终于能上厕所了,倍儿爽!!!!
4:厕所上完了
5:终于能上厕所了,倍儿爽!!!!
2:厕所上完了
6:终于能上厕所了,倍儿爽!!!!
3:厕所上完了
7:终于能上厕所了,倍儿爽!!!!
7:厕所上完了
8:终于能上厕所了,倍儿爽!!!!
5:厕所上完了
9:终于能上厕所了,倍儿爽!!!!
6:厕所上完了
10:终于能上厕所了,倍儿爽!!!!
8:厕所上完了
10:厕所上完了
9:厕所上完了

2 并发队列

在并发队列上JDK提供了两套实现,一个是以ConcurrentLinkedQueue为代表的高性能队列,一个是以BlockingQueue接口为代表的阻塞队列,无论哪种都继承自Queue。

2.1 ConcurrentLinkedQueue

ConcurrentLinkedQueue:是一个适用于高并发场景下的队列,通过无所的方式,实现了高并发状态下的高性能,通常ConcurrentLinkedQueue性能好于BlockingQueue。他是一个基于连接节点的无界线程安全队列。该队列的线程遵循FIFO的原则,不允许null元素。

add 和offer() 都是加入元素的方法(在ConcurrentLinkedQueue中这俩个方法没有任何区别)

poll() 和peek() 都是取头元素节点,区别在于前者会删除元素,后者不会。

2.2 BlockingQueue

阻塞队列(BlockingQueue)是一个支持两个附加操作的队列。这两个附加的操作是:

在队列为空时,获取元素的线程会等待队列变为非空。

当队列满时,写入(存储)元素的线程会等待队列可用。

在Java中,BlockingQueue的接口位于java.util.concurrent 包中(在Java5版本开始提供),由上面介绍的阻塞队列的特性可知,阻塞队列是线程安全的。

在新增的Concurrent包中,BlockingQueue很好的解决了多线程中,如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类,为我们快速搭建高质量的多线程程序带来极大的便利。本文详细介绍了BlockingQueue家庭中的所有成员,包括他们各自的功能以及常见使用场景。

常用的队列主要有以下两种:(当然通过不同的实现方式,还可以延伸出很多不同类型的队列,DelayQueue就是其中的一种)

  先进先出(FIFO):先插入的队列的元素也最先出队列,类似于排队的功能。从某种程度上来说这种队列也体现了一种公平性。

  后进先出(LIFO):后插入队列的元素最先出队列,这种队列优先处理最近发生的事件。

多线程环境中,通过队列可以很容易实现数据共享,比如经典的“生产者”和“消费者”模型中,通过队列可以很便利地实现两者之间的数据共享。假设我们有若干生产者线程,另外又有若干个消费者线程。如果生产者线程需要把准备好的数据共享给消费者线程,利用队列的方式来传递数据,就可以很方便地解决他们之间的数据共享问题。但如果生产者和消费者在某个时间段内,万一发生数据处理速度不匹配的情况呢?理想情况下,如果生产者产出数据的速度大于消费者消费的速度,并且当生产出来的数据累积到一定程度的时候,那么生产者必须暂停等待一下(阻塞生产者线程),以便等待消费者线程把累积的数据处理完毕,反之亦然。然而,在concurrent包发布以前,在多线程环境下,我们每个程序员都必须去自己控制这些细节,尤其还要兼顾效率和线程安全,而这会给我们的程序带来不小的复杂度。好在此时,强大的concurrent包横空出世了,而他也给我们带来了强大的BlockingQueue。(在多线程领域:所谓阻塞,在某些情况下会挂起线程(即阻塞),一旦条件满足,被挂起的线程又会自动被唤醒)

2.3 ArrayBlockingQueue

ArrayBlockingQueue是一个有边界的阻塞队列,它的内部实现是一个数组。有边界的意思是它的容量是有限的,我们必须在其初始化的时候指定它的容量大小,容量大小一旦指定就不可改变。

ArrayBlockingQueue是以先进先出的方式存储数据,最新插入的对象是尾部,最新移出的对象是头部。下面是一个初始化和使用ArrayBlockingQueue的例子:

     ArrayBlockingQueue<String> arrays = new ArrayBlockingQueue<String>(3);

     arrays.add("李四");

      arrays.add("张军");

     arrays.add("张军");

     // 添加阻塞队列

     arrays.offer("张三", 1, TimeUnit.SECONDS);

2.4 LinkedBlockingQueue

LinkedBlockingQueue阻塞队列大小的配置是可选的,如果我们初始化时指定一个大小,它就是有边界的,如果不指定,它就是无边界的。说是无边界,其实是采用了默认大小为Integer.MAX_VALUE的容量 。它的内部实现是一个链表。

和ArrayBlockingQueue一样,LinkedBlockingQueue 也是以先进先出的方式存储数据,最新插入的对象是尾部,最新移出的对象是头部。下面是一个初始化和使LinkedBlockingQueue的例子:

LinkedBlockingQueue linkedBlockingQueue = new LinkedBlockingQueue(3);

linkedBlockingQueue.add("张三");

linkedBlockingQueue.add("李四");

linkedBlockingQueue.add("李四");

System.out.println(linkedBlockingQueue.size());

2.5 PriorityBlockingQueue

PriorityBlockingQueue是一个没有边界的队列,它的排序规则和 java.util.PriorityQueue一样。需要注意,PriorityBlockingQueue中允许插入null对象。

所有插入PriorityBlockingQueue的对象必须实现 java.lang.Comparable接口,队列优先级的排序规则就是按照我们对这个接口的实现来定义的。

另外,我们可以从PriorityBlockingQueue获得一个迭代器Iterator,但这个迭代器并不保证按照优先级顺序进行迭代。

2.6 SynchronousQueue

SynchronousQueue队列内部仅允许容纳一个元素。当一个线程插入一个元素后会被阻塞,除非这个元素被另一个线程消费。

2.7 使用BlockingQueue模拟生产者与消费者

class ProducerThread extends Thread{
private BlockingQueue queue;
private volatile boolean flag=true;
private static AtomicInteger count=new AtomicInteger(); public ProducerThread(BlockingQueue queue) {
this.queue = queue;
} @Override
public void run() {
System.out.println("生产者线程启动。。。。。。。");
try{
while (flag){
System.out.println("生产者正在生产队列");
String data=count.incrementAndGet()+"";
//添加队列
boolean offer=queue.offer(data);
if(offer){
System.out.println("生产者添加队列"+data+"成功!");
} else{
System.out.println("生产者添加队列"+data+"失败!");
}
Thread.sleep(1000);
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
System.out.println("生产者线程停止。。。。。。。。");
}
}
public void stopThread(){
this.flag=false;
}
} class ConsumerThread extends Thread{
private BlockingQueue queue;
private volatile boolean flag=true;
private static AtomicInteger count=new AtomicInteger(); public ConsumerThread(BlockingQueue queue) {
this.queue = queue;
} @Override
public void run() {
System.out.println("消费者线程启动。。。。。。。");
try{
while (flag){
//获取完毕后,队列会删除头元素
String data = (String) queue.poll(2, TimeUnit.SECONDS);
if(data!=null){
System.out.println("消费者获取data:"+data+"成功!");
} else{
System.out.println("消费者获取data失败!");
this.flag=false;
}
Thread.sleep(1000);
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
System.out.println("消费者线程停止。。。。。。。。");
}
}
public void stopThread(){
this.flag=false;
}
}
public class ProConDemo {
public static void main(String[] args) throws InterruptedException {
BlockingQueue<String> queue=new LinkedBlockingQueue<>(10);
ProducerThread p1=new ProducerThread(queue);
ProducerThread p2=new ProducerThread(queue); ConsumerThread c1=new ConsumerThread(queue);
// ConsumerThread c2=new ConsumerThread(queue);
p1.start();
p2.start();
c1.start();
Thread.sleep(10*1000);
p1.stopThread();
p2.stopThread();
} } 生产者线程启动。。。。。。。
生产者正在生产队列
生产者添加队列1成功!
生产者线程启动。。。。。。。
生产者正在生产队列
生产者添加队列2成功!
消费者线程启动。。。。。。。
消费者获取data:1成功!
生产者正在生产队列
生产者添加队列3成功!
生产者正在生产队列
生产者添加队列4成功!
消费者获取data:2成功!
生产者正在生产队列
生产者添加队列5成功!
生产者正在生产队列
生产者添加队列6成功!
消费者获取data:3成功!
生产者正在生产队列
生产者添加队列7成功!
生产者正在生产队列
生产者添加队列8成功!
消费者获取data:4成功!
生产者正在生产队列
生产者添加队列9成功!
生产者正在生产队列
生产者添加队列10成功!
消费者获取data:5成功!
生产者正在生产队列
生产者添加队列11成功!
生产者正在生产队列
生产者添加队列12成功!
消费者获取data:6成功!
生产者正在生产队列
生产者添加队列13成功!
生产者正在生产队列
生产者添加队列14成功!
消费者获取data:7成功!
生产者正在生产队列
生产者添加队列15成功!
生产者正在生产队列
生产者添加队列16成功!
消费者获取data:8成功!
生产者正在生产队列
生产者添加队列17成功!
生产者正在生产队列
生产者添加队列18成功!
消费者获取data:9成功!
生产者正在生产队列
生产者添加队列19成功!
生产者正在生产队列
生产者添加队列20失败!
消费者获取data:10成功!
生产者线程停止。。。。。。。。
生产者线程停止。。。。。。。。
消费者获取data:11成功!
消费者获取data:12成功!
消费者获取data:13成功!
消费者获取data:14成功!
消费者获取data:15成功!
消费者获取data:16成功!
消费者获取data:17成功!
消费者获取data:18成功!
消费者获取data:19成功!
消费者获取data失败!
消费者线程停止。。。。。。。。

Java多线程之并发包,并发队列的更多相关文章

  1. Java多线程--JDK并发包(2)

    Java多线程--JDK并发包(2) 线程池 在使用线程池后,创建线程变成了从线程池里获得空闲线程,关闭线程变成了将线程归坏给线程池. JDK有一套Executor框架,大概包括Executor.Ex ...

  2. Java多线程--JDK并发包(1)

    Java多线程--JDK并发包(1) 之前介绍了synchronized关键字,它决定了额一个线程是否可以进入临界区:还有Object类的wait()和notify()方法,起到线程等待和唤醒作用.s ...

  3. Java多线程总结之线程安全队列Queue

    在Java多线程应用中,队列的使用率很高,多数生产消费模型的首选数据结构就是队列.Java提供的线程安全的Queue可以分为阻塞队列和非阻塞队列,其中阻塞队列的典型例子是BlockingQueue,非 ...

  4. 【java】Java多线程总结之线程安全队列Queue【转载】

    原文地址:https://www.cnblogs.com/java-jun-world2099/articles/10165949.html ============================= ...

  5. 跟我学Java多线程——线程池与堵塞队列

    前言 上一篇文章中我们将ThreadPoolExecutor进行了深入的学习和介绍,实际上我们在项目中应用的时候非常少有直接应用ThreadPoolExecutor来创建线程池的.在jdk的api中有 ...

  6. java多线程系列五、并发容器

    一.ConcurrentHashMap 1.为什么要使用ConcurrentHashMap 在多线程环境下,使用HashMap进行put操作会引起死循环,导致CPU利用率接近100%,HashMap在 ...

  7. JAVA多线程提高十二:阻塞队列应用

    一.类相关属性 接口BlockingQueue<E>定义: public interface BlockingQueue<E> extends Queue<E> { ...

  8. 最全java多线程总结3——了解阻塞队列和线程安全集合不

      看了前两篇你肯定已经理解了 java 并发编程的低层构建.然而,在实际编程中,应该经可能的远离低层结构,毕竟太底层的东西用起来是比较容易出错的,特别是并发编程,既难以调试,也难以发现问题,我们还是 ...

  9. java多线程:并发包中的信号量和计数栓的编程模型

    一:信号量的编程模型 package com.yeepay.sxf.test.atomic.test; import java.util.concurrent.Semaphore; /** * 测试信 ...

随机推荐

  1. 安装数据库Typical path for xclock: /usr/X11R6/bin/xclock 错误问题

    [oracle@localhost database]$ ./runInstaller Starting Oracle Universal Installer... Checking Temp spa ...

  2. pt-archiver 归档数据

    pt-archiver 参数说明pt-archiver是Percona-Toolkit工具集中的一个组件,是一个主要用于对MySQL表数据进行归档和清除工具.它可以将数据归档到另一张表或者是一个文件中 ...

  3. 洛谷 P3801 红色的幻想乡

    题目背景 蕾米莉亚的红雾异变失败后,很不甘心. 题目描述 经过上次失败后,蕾米莉亚决定再次发动红雾异变,但为了防止被灵梦退治,她决定将红雾以奇怪的阵势释放. 我们将幻想乡看做是一个n*m的方格地区,一 ...

  4. maven详解 之 pom.xml

    Maven  一个项目管理工具  其作用就是用来管理jar 包的 maven的核心    pom.xml配置文件 <project xmlns="http://maven.apache ...

  5. C#动态获取本机可用串口的两种方式

    1. private void GetSerialPort() //获取串口列表 { RegistryKey keyCom = Registry.LocalMachine.OpenSubKey(&qu ...

  6. JuJu alpha

    JuJu alpha阶段总结博客 JuJu   设想与目标   我们的软件要解决什么问题?是否定义得很清楚?是否对典型用户和典型场景有清晰的描述? 在cao ying researcher给的资料中定 ...

  7. dango 常用 静态文件 中间件 admin管理 上传图片

    静态文件 项目中的CSS.图片.js都是静态文件.一般会将静态文件放到一个单独的目录中,以方便管理.在html页面中调用时,也需要指定静态文件的路径,Django中提供了一种解析的方式配置静态文件路径 ...

  8. MongoDB 3.2 升级至 3.4.6

    MongoDB 升级测试步骤:1.MongoDB版本升级顺序3.2->3.4->3.6->4.0 不能跨版本升级2.升级到3.4后,您不能降级到3.2.7或更早版本.您只能降级到3. ...

  9. MongoDB 副本集搭建

    搭建mongodb副本集 [root@ mongodb]# cd /u02 [root@ u02]# mkdir -p mongodb/data_2777 [root@ u02]# mkdir -p ...

  10. Python基础笔记:input()输入与数据类型转换

    input就是个万能输入,不过input输入的元素都是以str形式保存的,如果要他作为一个整数的话,就需要进行数据类型转换. input的使用 name=input('please input you ...