synchronized关键字与lock的使用举例。

/**
 * synchronized 基于阻塞的方法，通过唤醒等待的线程，需要进行上下文切换，当有很多线程阻塞获取锁的时候，会引起线程频繁的上下文切换。
 * Lock通过CAS循环等待的机制，乐观的假设去获取锁，获取失败继续循环获取锁，可能需要无限消耗CPU。
 * 当代码逻辑很复杂时，需要1 ， 用到锁的中断功能时。 2 ， 需要考虑等待队列中的公平性。 3， 需要定向通知某个线程，通过reentrantLock的condition，可以通知处于某个condition的线程。
 * 
 * @author pc
 *
 */
public class CompareSynchronizedLock {
public static void main(String[] args){
Buffer buffer = new Buffer();

final Write write = new Write(buffer);
final Read read = new Read(buffer);
write.start();
read.start();
new Thread(new Runnable(){
public void run(){
long now = System.currentTimeMillis();
while(true){
if (System.currentTimeMillis() - now > 5000){
read.interrupt();
break;
}
}
}
}).start();
}
}
class Buffer{
private Object object ;
ReentrantLock lock = new ReentrantLock();

public Buffer(){
object = this;
}
public void write(){
lock.lock();
//synchronized(object)
{
long start = System.currentTimeMillis();
while(true){
if (System.currentTimeMillis() - start  > 500000){
break;
}
}
}
lock.unlock();
}

public void read(){
//synchronized(object)
try {
lock.lockInterruptibly();// 可响应中断请求。
System.out.println("read data.");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally{
lock.unlock();
}
}
}
class Write extends Thread{// 具体的操作
Buffer buffer;
public Write(Buffer buffer){
this.buffer = buffer;
}

public void run(){
buffer.write();
}
}
class Read extends Thread{// 具体的操作在buffer中
Buffer buffer;
public Read(Buffer buffer){
this.buffer = buffer;
}

public void run(){
buffer.read();
}

}