1、有界缓存的基类
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
|
package cn.xf.cp.ch14;
/**
*
*功能:有界缓存实现基类
*时间:下午2:20:00
*文件:BaseBoundedBuffer.java
*@author Administrator
*
* @param <V>
*/
public class BaseBoundedBuffer<V>
{
private final V[] buf;
private int tail;
private int head;
private int count;
public BaseBoundedBuffer( int capacity)
{
//初始化数组
this .buf = (V[]) new Object[capacity];
}
//放入一个数据,final方法无法被重写
protected synchronized final void doPut(V v)
{
buf[tail] = v;
if (++tail == buf.length)
{
tail = 0 ;
}
//插入一个方法,总量++
++count;
}
/**
* 取出一个数据
* @return
*/
protected synchronized final V doTake()
{
V v = buf[head];
buf[head] = null ;
if (++head == buf.length)
{
head = 0 ;
}
--count;
return v;
}
//通过对count的判断,来确定数组是否是满的
public synchronized final boolean isFull()
{
return count == buf.length;
}
public synchronized final boolean isEmpty()
{
return count == 0 ;
}
}
|
2、判定前提条件再执行操作
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
|
package cn.xf.cp.ch14;
/**
*
*功能:对插入和获取元素操作进行先行检查,然后执行操作,校验不通过不予操作
*时间:下午2:33:41
*文件:GrumpyBoundedBuffer.java
*@author Administrator
*
* @param <V>
*/
public class GrumpyBoundedBuffer<V> extends BaseBoundedBuffer<V>
{
public GrumpyBoundedBuffer( int size)
{
super (size);
}
public synchronized void put(V v) throws Exception
{
//如果是满的队列,就无法插入新的元素
if ( this .isFull())
{
throw new Exception( "队列超出" );
}
this .doPut(v);
}
//同理,队列为空的就无法取出新的元素
public synchronized V take() throws Exception
{
if ( this .isEmpty())
{
throw new Exception( "队列中无元素" );
}
return this .doTake();
}
}
|
3、通过轮询与休眠来实现简单的阻塞
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
|
package cn.xf.cp.ch14;
/**
*
*功能:通过轮询与休眠来实现简单的阻塞
*时间:下午2:55:54
*文件:SleepyBoundedBuffer.java
*@author Administrator
*
* @param <V>
*/
public class SleepyBoundedBuffer<V> extends BaseBoundedBuffer<V>
{
//2s
private static final long SLEEP_GRANULARITY = 2000 ;
public SleepyBoundedBuffer( int capacity)
{
super (capacity);
}
//放入队列的时候
public void put(V v) throws InterruptedException
{
while ( true )
{
//这里不对循环上锁,不然这个锁就无法释放了,不对休眠上锁,休眠上锁,在休眠的时候别人也无法操作,永远都不可能有元素出去
synchronized ( this )
{
//如果队列不是满的,那么就放入元素
if (! this .isFull())
{
this .doPut(v);
return ;
}
}
//否则休眠,退出cpu占用
Thread.sleep(SLEEP_GRANULARITY);
}
}
public V take() throws InterruptedException
{
while ( true )
{
//这里不对循环上锁,不然这个锁就无法释放了,不对休眠上锁,休眠上锁,在休眠的时候别人也无法操作,永远都不可能有新的元素进来
synchronized ( this )
{
//如果数组部位空,那么就可以取出数据
if (! this .isEmpty())
{
return this .doTake();
}
//如果队列为空,休眠几秒再试
}
Thread.sleep(SLEEP_GRANULARITY);
}
}
}
|
4、条件队列
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
|
package cn.xf.cp.ch14;
/**
*
*功能:使用条件队列
*时间:下午3:32:04
*文件:BoundedBuffer.java
*@author Administrator
*
* @param <V>
*/
public class BoundedBuffer<V> extends BaseBoundedBuffer<V>
{
public BoundedBuffer( int capacity)
{
super (capacity);
}
/**
* 放入数据元素
* @param v
* @throws InterruptedException
*/
public synchronized void put(V v) throws InterruptedException
{
while ( this .isFull())
{
//这里挂起程序,会释放锁
this .wait();
}
//如果队列不为满的,那么程序被唤醒之后从新获取锁
this .doPut(v);
//执行结束,唤醒其他队列
this .notifyAll();
}
public synchronized V take() throws InterruptedException
{
while ( this .isEmpty())
{
this .wait();
}
V v = this .doTake();
this .notifyAll();
return v;
}
}
|
感谢阅读,希望能帮助到大家,谢谢大家对本站的支持!