Concurrent

一、概述
1. Concurrent包是JDK1.5提供的一个用于应对高并发的包
2. 包含5块主要内容：BlockingQueue、 ConcurrentMap、 ExecutorService、 Lock、 Atomic操作

BlockingQueue - 阻塞式队列
一、概述
1. 满足队列的特性:FIFO
2. 阻塞式队列是有界的，既大小固定不变
3. 阻塞：
a. 如果队列已满，则新添元素的线程会被阻塞
b. 如果队列为空，则获取元素的线程会被阻塞

4.方法：

5. BlockingQueue中不允许存储null
6. 适用场景：生产消费

二、实现类

1. ArrayBlockingQueue - 阻塞式顺序队列
   a. 底层是基于数组来存储数据
   b. 使用的时候需要指定容量

2. LinkedBlockingQueue - 阻塞式链式队列
   a. 操作和ArrayBlockingQueue是一样的
   b. 底层是基于节点来存储数据
   c. 在使用的时候可以不指定容量，如果不指定则容量默认为Integer.MAX_VALUE，也因为这个容量比较大，导致在使用过程中很少会将这个队列放满，所以一般认为这个队列是无界的

3. PriorityBlockingQueue - 具有优先级的阻塞式队列
   a. 可以不指定容量，如果不指定，则默认容量是11
   b. 在遍历队列的时候，会对元素进行自然排序，要求元素对应的类要实现Comparable的接口
   c. 如果使用迭代遍历，则不保证排序

4. SynchronousQueue - 同步队列
   a. 使用的时候不需要指定容量，默认容量为1并且只能为1
   b. 一般称这个队列是数据的汇合点

package cn.tedu.blockingqueue;

//import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

public class BlockingQueueDemo {

	public static void main(String[] args) throws InterruptedException {

		// 大小指定之后就不可变
		// ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(3);

		LinkedBlockingQueue<String> queue = new LinkedBlockingQueue<>();
		// 队列为空
		// 抛出异常
		// System.out.println(queue.remove());
		// 返回null
		// System.out.println(queue.poll());
		// 产生阻塞
		// System.out.println(queue.take());
		// 定时阻塞
		System.out.println(queue.poll(5, TimeUnit.SECONDS));

		// 添加元素
		// queue.add("a");
		// queue.add("a");
		// queue.add("a");

		// 队列已满
		// 抛出异常 - IllegalStateException
		// queue.add("b");
		// 返回false
		// boolean b = queue.offer("c");
		// System.out.println(b);
		// 产生阻塞
		// queue.put("d");
		// 定时阻塞
		// queue.offer("e", 5, TimeUnit.SECONDS);
		// System.out.println(queue);

	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

package cn.tedu.blockingqueue;

import java.util.concurrent.PriorityBlockingQueue;

public class PriorityBlockingQueueDemo {

	public static void main(String[] args) throws InterruptedException {

		// PriorityBlockingQueue<String> queue = new PriorityBlockingQueue<>();
		//
		// // 添加元素
		// queue.put("d");
		// queue.put("e");
		// queue.put("a");
		// queue.put("h");
		// queue.put("u");
		// queue.put("r");
		// queue.put("s");

		PriorityBlockingQueue<Student> queue = new PriorityBlockingQueue<>();
		queue.add(new Student("张三", 18, 59));
		queue.add(new Student("李四", 17, 69));
		queue.add(new Student("王五", 20, 48));
		queue.add(new Student("赵六", 15, 62));
		queue.add(new Student("陆七", 25, 40));
		queue.add(new Student("杨八", 10, 18));
		queue.add(new Student("陈九", 19, 61));

		// for (int i = 0; i < 7; i++) {
		// System.out.println(queue.take());
		// }

		// 增强for循环本质上是一种迭代遍历
		for (Student student : queue) {
			System.out.println(student);
		}

	}

}

class Student implements Comparable<Student> {

	private String name;
	private int age;
	private int score;

	public Student(String name, int age, int score) {
		super();
		this.name = name;
		this.age = age;
		this.score = score;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + ", score=" + score + "]";
	}

	// 指定比较规则
	// 按照分数进行降序排序
	// this - o 升序
	// o - this 降序
	@Override
	public int compareTo(Student o) {
		return o.score - this.score;
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

扩展：
BlockingDeque - 阻塞式双端队列 - 允许双向进出