Java5 多线程(三)--Lock和Condition实现线程同步通信

1>Lock:

Lock比传统线程模型中的Synchronied方式更加面向对象,与生活中的锁类似,锁本身也应该是一个对象.两个线程执行的代码段要实现同步互斥的效果,它们必须用同一个Lock对象,锁是在代表要操作的资源的类的内部方法中,而不是线程代码中.

上面的输出器Outputer类就可以这样改写:

class Outputer2 {

// 声明一个锁

Lock lock = new ReentrantLock();

public void print(String name) {

//把要互斥的代码写在lock()和unlock()方法之间

lock.lock();

try {

for (int i = 0; i < name.length(); i++) {

System.out.print(name.charAt(i));

}

System.out.println();// 打印完字符串换行

} finally{

//如果中途抛出异常,那么这把锁就没有被解锁,别人就进不来了

//所以写在finally里面

lock.unlock();

}

}

}

读写锁,分为读锁和写锁, 多个读锁不互斥,读锁和写锁互斥,写锁与写锁互斥,这是JVM自己控制的,你只要上好相应的锁即可,如果你的代码只读数据,可以很多人同时读,但不能同时写,那就上读锁;如果你的代码修改数据,只能有一个人在写,且不能同时读取,那就上写锁. 总之,读的时候上读锁,写的时候上写锁!

看如下程序: 新建6个线程,3个线程用来读,3个线程用来写,

final Queue3 q3 = new Queue3();

for (int i = 0; i < 3; i++) {

new Thread() {

public void run() {

while (true) {

q3.get();

}

}

}.start();

new Thread() {

public void run() {

while (true) {

q3.put(new Random().nextInt(10000));

}

}

}.start();

}

然后在编写一个类Queue3 里面有一个读方法和写方法:

class Queue3 {

private Object data = null;// 共享数据，只能有一个线程能写该数据，但可以有多个线程同时读该数据。

//读写锁

ReadWriteLock rwl = new ReentrantReadWriteLock();

// 相当于读操作

public void get() {

rwl.readLock().lock();

try {

System.out.println(Thread.currentThread().getName()

+ " be ready to read data!");

Thread.sleep((long) (Math.random() * 1000));

System.out.println(Thread.currentThread().getName()

+ "have read data :" + data);

} catch (InterruptedException e) {

e.printStackTrace();

} finally {

rwl.readLock().unlock();

}

}

// 相当于写操作

public void put(Object data) {

rwl.writeLock().lock();

try {

System.out.println(Thread.currentThread().getName()

+ " be ready to write data!");

Thread.sleep((long) (Math.random() * 1000));

this.data = data;

System.out.println(Thread.currentThread().getName()

+ " have write data: " + data);

} catch (InterruptedException e) {

e.printStackTrace();

} finally {

rwl.writeLock().unlock();

}

}

}

这样可以实现正常的逻辑,如果我们把读写锁相关的代码注释,发现程序正准备写的时候,就有线程读了,发现准备读的时候,有线程去写,这样不符合我们的逻辑

通过Java5的新特新可以很轻松的解决这样的问题.

查看Java API ReentrantReadWriteLock 上面有经典(缓存)的用法.这是上面的伪代码.

class CachedData {
Object data;
volatile boolean cacheValid;
final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

void processCachedData() {
rwl.readLock().lock();
if (!cacheValid) {
// Must release read lock before acquiring write lock
rwl.readLock().unlock();
rwl.writeLock().lock();
try {
// Recheck state because another thread might have
// acquired write lock and changed state before we did.
if (!cacheValid) {
data = ...
cacheValid = true;
}
// Downgrade by acquiring read lock before releasing write lock
rwl.readLock().lock();
} finally {
rwl.writeLock().unlock(); // Unlock write, still hold read
}
}
try {
use(data);
} finally {
rwl.readLock().unlock();
}
}
}

基于上面的例子,我们可以实现一个缓存系统.

Map<String, Object> cache = new HashMap<String, Object>();

ReadWriteLock rrwl = new ReentrantReadWriteLock();

public Object getData(String key) {

rrwl.readLock().lock();

Object value = null;

try {

value = cache.get(key);

if (value == null) {

rrwl.readLock().unlock();

rrwl.writeLock().lock();

try {

//假设三个线程同时去获取写锁,我们知道只有第一个线程能够获取

//那么其他两个线程只有等了,如果第一个线程按流程执行完后,刚才的两个线程可以得到写锁了,

//然后接着就可以修改数据了(赋值).所以加上判断!

if (value == null) {//为什么还要在这里判断一次.?

value = "hello world";

}

// 降级,通过释放写锁之前获取读锁

rrwl.readLock().lock();

} finally {

rrwl.writeLock().unlock();

}

}

} finally {

rrwl.readLock().unlock();

}

return value;

}

2>Condition:

Condition的功能类似于在传统的线程技术中的,Object.wait()和Object.notify()的功能,在等待Condition时,允许发生"虚假唤醒",这通常作为对基础平台语义的让步,对于大多数应用程序,这带来的实际影响很小,因为Condition应该总是在一个循环中被等待,并测试正被等待的状态声明.某个实现可以随意移除可能的虚假唤醒,但是建议程序员总是假定这些虚假唤醒可能发生,因此总是在一个循环中等待.

一个锁内部可以有多个Condition,即有多路等待和通知,可以参看jdk1.5提供的Lock与Condition实现的可阻塞队列的应用案例,从中要体味算法,还要体味面向对象的封装.在传统的线程机制中,一个监视器对象上只能有一路等待和通知,要想实现多路等待和通知,必须嵌套使用多个同步监视器对象.(如果只用一个Condition,两个放的都在等,一旦一个放进去了,那么它会通知可能会导致另一个放的接着往下走).

我们也可以通过Lock和Condition来实现上面我们讲的例子:

子线程循环10次，接着主线程循环100，接着又回到子线程循环10次，接着再回到主线程又循环100，如此循环50次，请写出程序。

这里只实现其中的一个方法,因为其他的是一样的.

Lock lock = new ReentrantLock();

Condition condition = lock.newCondition();

// 默认子线程先执行

boolean isShouldSub = true;

public void sub(int k) {

lock.lock();//相当于synchronied

try {

while(!isShouldSub) {

try {

condition.await();//然后实现通信

} catch (InterruptedException e) {

e.printStackTrace();

}

}

for (int i = 1; i <= 10; i++) {

System.out

.println("sub thread sequence " + i + " loop of " + k);

}

// 子线程做完了,把它置为false

isShouldSub = false;

// 并且唤醒主线程

condition.signal();

} finally {

lock.unlock();

}

}

可以使用Lock和Condition来实现一个缓冲队列(要区别缓冲和缓存的区别),其实jdk api有这样的例子,如下:

class BoundedBuffer {
final Lock lock = new ReentrantLock();
final Condition notFull = lock.newCondition();
final Condition notEmpty = lock.newCondition();

final Object[] items = new Object[100];
int putptr, takeptr, count;

public void put(Object x) throws InterruptedException {
lock.lock();// 第一步实现互斥
try {
while (count == items.length )//如果没有往数组放,线程阻塞
notFull.await();
items[putptr] = x;
if (++putptr == items.length) putptr = 0 ;//如果putptr已经是数组的最后一个,那么putptr置为0,从第一个开始放

++count ;//放完后,把总数加一
notEmpty.signal();/ /通知其他线程可以取了
} finally {
lock.unlock();
}
}

public Object take() throws InterruptedException {
lock.lock();
try {
while (count == 0)
notEmpty.await();
Object x = items[takeptr];
if (++takeptr == items.length) takeptr = 0;
--count;
notFull.signal();
return x;
} finally {
lock.unlock();
}
}
}
这个逻辑比较好理解,但是我们可以看到上面的程序用了两个Condition呢?用一个Condition似乎也能实现.

public void put(Object x) throws InterruptedException {

//如果有5个线程执行到此方法里面,那么只有一个线程获取到锁
lock.lock(); // 锁住了别的线程就不能进来了,包括下面的take()因为他们用的是同一把锁
try {

//如果已经放满
while (count == items.length)
notFull.await(); //执行到此,锁就释放了,可能这里就有5个线程在此等, 其他线程就可以调用take()方法去取了然后调用signal()然而5个线程中,只有一个线程能被唤醒.该被唤醒的线程执行到signal时候,唤醒其他线程.如果用一个Condition,唤醒的可能就是上面的4个线程,而这个4个线程是往里面(put),而应该唤醒的是去取(take())线程. 因为已经放满了如果再通知线程去放,那么就出现逻辑错误了.所以这里用到两个Condition的妙处!
items[putptr] = x;
if (++putptr == items.length) putptr = 0;
++count;
notEmpty.signal();
} finally {
lock.unlock();
}
}

据此,我们可以改变

子线程循环10次，接着主线程循环100，接着又回到子线程循环10次，接着再回到主线程又循环100，如此循环50次，请写出程序。的例子,这个例子是两个线程之间的跳转,那么如果实现三个线程之间的轮循,比如:线程1循环10,线程2循环100,线程3循环20次,然后又是线程1,接着线程2...一直轮循50次.

class Business3 {

Lock lock = new ReentrantLock();

Condition sub1 = lock.newCondition();

Condition sub2 = lock.newCondition();

Condition sub3 = lock.newCondition();

//默认线程1执行

int shouldSub = 1;

public void sub1(int k) {

lock.lock();//相当于synchronied

try {

while (shouldSub!=1) {

try {

sub1.await();//然后实现通信

} catch (InterruptedException e) {

e.printStackTrace();

}

}

for (int i = 1; i <= 10; i++) {

System.out

.println("sub1 thread sequence " + i + " loop of " + k);

}

// 把值置为2,然线程2可执行

shouldSub = 2;

// 线程1做完后,只唤醒线程2

sub2.signal();

} finally {

lock.unlock();

}

}

public void sub2(int k) {

lock.lock();

try {

while (shouldSub!=2) {

try {

sub2.await();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

for (int i = 1; i <= 100; i++) {

System.out.println("sub2 thread sequence " + i + " loop of "

+ k);

}

// 把值置为3,然线程3可执行

shouldSub = 3;

// 线程2做完后,只唤醒线程3

sub3.signal();

} finally {

lock.unlock();

}

}

public void sub3(int k) {

lock.lock();

try {

while (shouldSub!=3) {

try {

sub3.await();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

for (int i = 1; i <= 20; i++) {

System.out.println("sub3 thread sequence " + i + " loop of "

+ k);

}

// 把值置为1,然线程1可执行

shouldSub = 1;

// 线程3做完后,只唤醒线程1

sub1.signal();

} finally {

lock.unlock();

}

}

转载请注明出处:http://blog.csdn.net/johnny901114/article/details/8695708