Java中Synchronized和Lock的使用和区别

Lock的锁定是通过代码实现的，而 synchronized 是在 JVM 层面上实现的

synchronized在锁定时如果方法块抛出异常，JVM 会自动将锁释放掉，不会因为出了异常没有释放锁造成线程死锁。但是 Lock 的话就享受不到 JVM 带来自动的功能，出现异常时必须在 finally 将锁释放掉，否则将会引起死锁。

在资源竞争不是很激烈的情况下，偶尔会有同步的情形下，synchronized是很合适的。原因在于，编译程序通常会尽可能的进行优化synchronize，另外可读性非常好，不管用没用过5.0多线程包的程序员都能理解。 

ReentrantLock

ReentrantLock提供了多样化的同步，比如有时间限制的同步，可以被Interrupt的同步（synchronized的同步是不能Interrupt的）等。在资源竞争不激烈的情形下，性能稍微比synchronized差点点。但是当同步非常激烈的时候，synchronized的性能一下子能下降好几十倍。而ReentrantLock确还能维持常态。 

synchronized和lock用途区别
synchronized原语和ReentrantLock在一般情况下没有什么区别，但是在非常复杂的同步应用中，请考虑使用ReentrantLock，特别是遇到下面2种需求的时候。
 
1.某个线程在等待一个锁的控制权的这段时间需要中断
2.需要分开处理一些wait-notify，ReentrantLock里面的Condition应用，能够控制notify哪个线程
3.具有公平锁功能，每个到来的线程都将排队等候
Atomic

和上面的类似，不激烈情况下，性能比synchronized略逊，而激烈的时候，也能维持常态。激烈的时候，Atomic的性能会优于ReentrantLock一倍左右。但是其有一个缺点，就是只能同步一个值，一段代码中只能出现一个Atomic的变量，多于一个同步无效。因为他不能在多个Atomic之间同步。 

Lock的使用参见下面的代码（把lock换成synchronized的效果是一样的）：

[java] view
plain copy

import java.util.concurrent.TimeUnit;  

import java.util.concurrent.locks.Lock;  

import java.util.concurrent.locks.ReentrantLock;  

  

public class Resource3 {  

  

    private Lock lock = new ReentrantLock();  

  

    public void f() {  

  

        // other operations should not be locked...  

  

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

                + ":not synchronized in f()");  

        lock.lock();  

        try {  

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

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

                        + ":synchronized in f()");  

                try {  

                    TimeUnit.SECONDS.sleep(3);  

                } catch (InterruptedException e) {  

                    e.printStackTrace();  

                }  

            }  

        } finally {  

            lock.unlock();  

        }  

    }  

  

    public void g() {  

  

        // other operations should not be locked...  

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

                + ":not synchronized in g()");  

        lock.lock();  

        try {  

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

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

                        + ":synchronized in g()");  

                try {  

                    TimeUnit.SECONDS.sleep(3);  

                } catch (InterruptedException e) {  

                    e.printStackTrace();  

                }  

            }  

        } finally {  

            lock.unlock();  

        }  

    }  

  

    public void h() {  

        // other operations should not be locked...  

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

                + ":not synchronized in h()");  

        lock.lock();  

        try {  

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

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

                        + ":synchronized in h()");  

                try {  

                    TimeUnit.SECONDS.sleep(3);  

                } catch (InterruptedException e) {  

                    e.printStackTrace();  

                }  

            }  

        } finally {  

            lock.unlock();  

        }  

    }  

  

    public static void main(String[] args) {  

  

        final Resource3 rs = new Resource3();  

        new Thread() {  

            public void run() {  

                rs.f();  

            }  

        }.start();  

        new Thread() {  

            public void run() {  

                rs.g();  

            }  

        }.start();  

        rs.h();  

    }  

}