lock与sychronized区别？

lock是cynchronized 的升级，Lock能完成synchronized的所有功能
但在释放锁时后者会自动释放，前者需要在finally中手动释放

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


public class TestLock2 {
   public static void main(String[] args) {
           ReSource rs=new ReSource();
           Produce p=new Produce(rs);
           Custom c=new Custom(rs);
           Thread t=new Thread(p);
           Thread t1=new Thread(p);
           Thread t2=new Thread(c);
           Thread t3=new Thread(c);
           t.start();
           t1.start();
           t2.start();
           t3.start();
}
}
class ReSource
{
        private int count=1;
        private String name;
        private boolean flag=false;
        final Lock lock = new ReentrantLock();
        final Condition notFull  = lock.newCondition();
        final Condition notEmpty = lock.newCondition();


        public  void set(String name)
        {
                lock.lock();
                try{
                        while(flag)
                                try {
                                        notFull.await();
                                } catch (InterruptedException e) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                }
                        this.name=name+"..."+count++;
                        System.out.println(Thread.currentThread().getName()+"生产者"+this.name);
                        flag=true;
                        notEmpty.signal();
                }finally
                {
                        lock.unlock();
                }
               
        }
        public synchronized void get()
        {
                lock.lock();
                try{
                        while(!flag)
                                try {
                                        notEmpty.await();
                                } catch (InterruptedException e) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                }
                       
                        System.out.println(Thread.currentThread().getName()+"消费者"+this.name);
                        flag=false;
                        notFull.signal();
                }finally
                {
                        lock.unlock();
                }
       
        }
}
class Produce implements Runnable
{
        private ReSource rs;
   public  Produce(ReSource rs)
    {
            this.rs=rs;
    }
        @Override
        public void run() {
                // TODO Auto-generated method stub
                while(true)
                {
                        rs.set("+商品+");       
                }
               
        }
       
}
class Custom implements Runnable
{
        private ReSource rs;
           public  Custom(ReSource rs)
            {
                    this.rs=rs;
            }
        @Override
        public void run() {
                // TODO Auto-generated method stub
                while(true)
                {
                        rs.get();
                }
        }
       
}

朋友们 捧捧场 白沉了

JDK1.5中提供了多线程升级解决方案。
将同步synchronized替换成实现Lock操作。
将Object中的wait，notify，notifyAll，替换成了condition对象。

相同点:lock能完成syncharonized所实现的所有功能
不同点:lock有比syncharonized更精确的线程语义和更好的性能。syncharonized会自动释放锁。而LOCK一定要程序员手动释放，并且必须在finally句中释放。