Java中Synchronized和Lock的使用

>> syncrhoized ，reentrantLock 各自特点和比对:

    synchronized： 

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

    ReentrantLock: 

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

    Atomic: 

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

    所以，我们写同步的时候，优先考虑synchronized，如果有特殊需要，再进一步优化。ReentrantLock和Atomic如果用的不好，不仅不能提高性能，还可能带来灾难。

---------------------------------------------------------

主要相同点：Lock能完成Synchronized所实现的所有功能。

主要不同点：Lock有比Synchronized更精确的线程予以和更好的性能。Synchronized会自动释放锁，但是Lock一定要求程序员手工释放，并且必须在finally从句中释放。

synchronized 修饰方法时 表示同一个对象在不同的线程中 表现为同步队列

如果实例化不同的对象 那么synchronized就不会出现同步效果了。

1.对象的锁 

所有对象都自动含有单一的锁。 

JVM负责跟踪对象被加锁的次数。如果一个对象被解锁，其计数变为0。在任务（线程）第一次给对象加锁的时候，计数变为1。每当这个相同的任务（线程）在此对象上获得锁时，计数会递增。 

只有首先获得锁的任务（线程）才能继续获取该对象上的多个锁。 

每当任务离开一个synchronized方法，计数递减，当计数为0的时候，锁被完全释放，此时别的任务就可以使用此资源。 

2.synchronized同步块 

2.1同步到单一对象锁 

当使用同步块时，如果方法下的同步块都同步到一个对象上的锁，则所有的任务（线程）只能互斥的进入这些同步块。

----------------------------------------------

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

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

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

ReentrantLock

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

    }  

}