经典问题之生产者-消费者问题——Lock实现

经典问题之生产者-消费者问题——Lock实现。

package com.lzq.newInterview;

import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

//生产者
class Producer implements Runnable {
public Storage storage;

public Producer(Storage s) {
this.storage = s;
}

public void run() {
storage.produce();
}
}

//消费者
class Consumer implements Runnable {
public Storage storage;

public Consumer(Storage s) {
this.storage = s;
}

public void run() {
storage.consume();
}
}

public class Storage {

// 缓存容量
public static final int capacity = 20;

List<Object> storage = new LinkedList<Object>();
ReentrantLock lock = new ReentrantLock();
// 队列满condition
Condition full = lock.newCondition();
// 队列空condition
Condition empty = lock.newCondition();

public void produce() {
try {
// lock 加锁代替 synchronized关键字
lock.lock();
while (storage.size() == capacity) {
// condition full await
full.await();
}
storage.add(new Object());
// wake up empty condition's thread
empty.signal();
System.out.println("produce : size = " + storage.size());
Thread.sleep(200);

} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}

public void consume() {
try {
lock.lock();
while (storage.size() == 0) {
// condition empty await
empty.await();
}
// 这里简化处理，移除首节点
storage.remove(0);
// wake up full condition's thread
full.signal();
System.out.println(" consume : size = " + storage.size());
Thread.sleep(200);
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}

public static void main(String[] args) {
Storage s = new Storage();
ExecutorService pool = Executors.newCachedThreadPool();
for (int i = 0; i < 100; i++) {
Producer p = new Producer(s);
pool.execute(p);
}
for (int i = 0; i < 100; i++) {
Consumer c = new Consumer(s);
pool.execute(c);
}
}
}

部分结果如下：

produce : size = 1

produce : size = 2

produce : size = 3

produce : size = 4

produce : size = 5

produce : size = 6

produce : size = 7

produce : size = 8

produce : size = 9

produce : size = 10

produce : size = 11

produce : size = 12

produce : size = 13

produce : size = 14

produce : size = 15

produce : size = 16

produce : size = 17

produce : size = 18

produce : size = 19

produce : size = 20

consume : size = 19

consume : size = 18

consume : size = 17

consume : size = 16

consume : size = 15

consume : size = 14

consume : size = 13

consume : size = 12

consume : size = 11

consume : size = 10

consume : size = 9

consume : size = 8

consume : size = 7

consume : size = 6

 Lock为java1.5实现同步的新特性，和synchronized一样，可以实现线程的同步。现列出synchronized和lock的用法区别。

一、synchronized和lock的用法区别

 

synchronized：在需要同步的对象中加入此控制，synchronized可以加在方法上，也可以加在特定代码块中，括号中表示需要锁的对象。

 

lock：需要显示指定起始位置和终止位置。一般使用ReentrantLock类做为锁，多个线程中必须要使用一个ReentrantLock类做为对象才能保证锁的生效。且在加锁和解锁处需要通过lock()和unlock()显示指出。所以一般会在finally块中写unlock()以防死锁。

 

用法区别比较简单，这里不赘述了，如果不懂的可以看看Java基本语法。

 
二、synchronized和lock性能区别

 

synchronized是托管给JVM执行的，而lock是java写的控制锁的代码。在Java1.5中，synchronize是性能低效的。因为这是一个重量级操作，需要调用操作接口，导致有可能加锁消耗的系统时间比加锁以外的操作还多。相比之下使用Java提供的Lock对象，性能更高一些。但是到了Java1.6，发生了变化。synchronize在语义上很清晰，可以进行很多优化，有适应自旋，锁消除，锁粗化，轻量级锁，偏向锁等等。导致在Java1.6上synchronize的性能并不比Lock差。官方也表示，他们也更支持synchronize，在未来的版本中还有优化余地。

 

说到这里，还是想提一下这2中机制的具体区别。据我所知，synchronized原始采用的是CPU悲观锁机制，即线程获得的是独占锁。独占锁意味着其他线程只能依靠阻塞来等待线程释放锁。而在CPU转换线程阻塞时会引起线程上下文切换，当有很多线程竞争锁的时候，会引起CPU频繁的上下文切换导致效率很低。

 

而Lock用的是乐观锁方式。所谓乐观锁就是，每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。乐观锁实现的机制就是CAS操作（Compare and Swap）。我们可以进一步研究ReentrantLock的源代码，会发现其中比较重要的获得锁的一个方法是compareAndSetState。这里其实就是调用的CPU提供的特殊指令。

 

现代的CPU提供了指令，可以自动更新共享数据，而且能够检测到其他线程的干扰，而 compareAndSet() 就用这些代替了锁定。这个算法称作非阻塞算法，意思是一个线程的失败或者挂起不应该影响其他线程的失败或挂起的算法。

 

我也只是了解到这一步，具体到CPU的算法如果感兴趣的读者还可以在查阅下，如果有更好的解释也可以给我留言，我也学习下。

 
三、synchronized和lock用途区别

 

synchronized原语和ReentrantLock在一般情况下没有什么区别，但是在非常复杂的同步应用中，请考虑使用ReentrantLock，特别是遇到下面2种需求的时候。

 

1.某个线程在等待一个锁的控制权的这段时间需要中断

2.需要分开处理一些wait-notify，ReentrantLock里面的Condition应用，能够控制notify哪个线程

3.具有公平锁功能，每个到来的线程都将排队等候