ArrayList
1.ArrayList构造一个默认初始容量为10的空列表。
2.自动容量1.5倍。
3.单线程中才使用而在多线程中可以选择Vector。
ArrayList和LinkedList的大致区别：
1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
2.对于随机访问get，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
3.对于在列表中间新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动 数据。
HashMap
1.线程不安全
2.默认初始容量16，必须为2的幂
3.加载因子默认0.75
4.多线程中使用ConcurrentHashMap
BlockingQueue 阻塞队列
在多线程领域：所谓阻塞，在某些情况下会挂起线程（即阻塞），一旦条件满足，被挂起的线程又会自动被唤醒
BlockingQueue的核心方法：
1)offer(anObject):表示如果可能的话,将anObject加到BlockingQueue里,即如果BlockingQueue可以容纳,则返回true,否则返回false.
3)poll(time):取走BlockingQueue里排在首位的对象,若不能立即取出,则可以等time参数规定的时间,取不到时返回null
2)put(anObject):把anObject加到BlockingQueue里,如果BlockQueue没有空间,则调用此方法的线程被阻断直到BlockingQueue里面有空间再继续
4)take():取走BlockingQueue里排在首位的对象,若BlockingQueue为空,阻断进入等待状态直到Blocking有新的对象被加入为止
作为开发者，我们需要注意的是，如果构造一个LinkedBlockingQueue对象，而没有指定其容量大小，LinkedBlockingQueue会默认一个类似无限大小的容量（Integer.MAX_VALUE），这样的话，如果生产者的速度一旦大于消费者的速度，也许还没有等到队列满阻塞产生，系统内存就有可能已被消耗殆尽了。
import
java.util.concurrent.BlockingQueue;
import
java.util.concurrent.ExecutorService;
import
java.util.concurrent.Executors;
import
java.util.concurrent.LinkedBlockingQueue;
/**
* @author jackyuj
*/
public
class
BlockingQueueTest {
public
static
void
main(String[] args)
throws
InterruptedException {
// 声明一个容量为10的缓存队列
BlockingQueue<String> queue =
new
LinkedBlockingQueue<String>(
10
);
Producer producer1 =
new
Producer(queue);
Producer producer2 =
new
Producer(queue);
Producer producer3 =
new
Producer(queue);
Consumer consumer =
new
Consumer(queue);
// 借助Executors
ExecutorService service = Executors.newCachedThreadPool();
// 启动线程
service.execute(producer1);
service.execute(producer2);
service.execute(producer3);
service.execute(consumer);
// 执行10s
Thread.sleep(
10
*
1000
);
producer1.stop();
producer2.stop();
producer3.stop();
Thread.sleep(
2000
);
// 退出Executor
service.shutdown();
}
}
|
|
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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
|
import
java.util.Random;
import
java.util.concurrent.BlockingQueue;
import
java.util.concurrent.TimeUnit;
/**
* 消费者线程
*
* @author jackyuj
*/
public
class
Consumer
implements
Runnable {
public
Consumer(BlockingQueue<String> queue) {
this
.queue = queue;
}
public
void
run() {
System.out.println(
"启动消费者线程！"
);
Random r =
new
Random();
boolean
isRunning =
true
;
try
{
while
(isRunning) {
System.out.println(
"正从队列获取数据..."
);
String data = queue.poll(
2
, TimeUnit.SECONDS);
if
(
null
!= data) {
System.out.println(
"拿到数据："
+ data);
System.out.println(
"正在消费数据："
+ data);
Thread.sleep(r.nextInt(DEFAULT_RANGE_FOR_SLEEP));
}
else
{
// 超过2s还没数据，认为所有生产线程都已经退出，自动退出消费线程。
isRunning =
false
;
}
}
}
catch
(InterruptedException e) {
e.printStackTrace();
Thread.currentThread().interrupt();
}
finally
{
System.out.println(
"退出消费者线程！"
);
}
}
private
BlockingQueue<String> queue;
private
static
final
int
DEFAULT_RANGE_FOR_SLEEP =
1000
;
}
import
java.util.Random;
import
java.util.concurrent.BlockingQueue;
import
java.util.concurrent.TimeUnit;
import
java.util.concurrent.atomic.AtomicInteger;
/**
* 生产者线程
*
* @author jackyuj
*/
public
class
Producer
implements
Runnable {
public
Producer(BlockingQueue queue) {
this
.queue = queue;
}
public
void
run() {
String data =
null
;
Random r =
new
Random();
System.out.println(
"启动生产者线程！"
);
try
{
while
(isRunning) {
System.out.println(
"正在生产数据..."
);
Thread.sleep(r.nextInt(DEFAULT_RANGE_FOR_SLEEP));
data =
"data:"
+ count.incrementAndGet();
System.out.println(
"将数据："
+ data +
"放入队列..."
);
if
(!queue.offer(data,
2
, TimeUnit.SECONDS)) {
System.out.println(
"放入数据失败："
+ data);
}
}
}
catch
(InterruptedException e) {
e.printStackTrace();
Thread.currentThread().interrupt();
}
finally
{
System.out.println(
"退出生产者线程！"
);
}
}
public
void
stop() {
isRunning =
false
;
}
private
volatile
boolean
isRunning =
true
;
private
BlockingQueue queue;
private
static
AtomicInteger count =
new
AtomicInteger();
private
static
final
int
DEFAULT_RANGE_FOR_SLEEP =
1000
;
|