Android 线程synchronized与Lock的简述

java中使用锁的两个基本工具是 synchronized 和 Lock。

一.synchronized

1.synchronized既可以同步方法也可以同步代码块

// 同步的方法
pubilc synchronized void test() {

}

//同步代码块上
public void test() {
     synchronized(obj) {
          System.out.println("===");
     }
}

2.synchronized 用在方法和代码块上有什么区别

synchronized 用在方法名上，当某个线程调用此方法时，会获取该实例的对象锁，方法未结束之前，其他线程只能去等待。当这个方法执行完时，才会释放对象锁。其他线程才有机会去抢占这把锁，去执行方法test,但是发生这一切的基础应当是所有线程使用的同一个对象实例，才能实现互斥的现象。否则synchronized关键字将失去意义。

 
但是如果该方法为类方法，即其修饰符为static，那么synchronized 意味着某个调用此方法的线程当前会拥有该类的锁，只要该线程持续在当前方法内运行，其他线程依然无法获得方法的使用权！
 

synchronized 用在代码块的使用方式，当线程运行到该代码块内，就会拥有obj对象的对象锁，如果多个线程共享同一个Object对象，那么此时就会形成互斥！特别的，当obj == this时，表示当前调用该方法的实例对象。即
 
public void test() {
     ...
     synchronized(this) {
          // todo your code
     }
     ...
}
 
此时，其效果等同于
public synchronized void test() {
     // todo your code
}
 
 
使用synchronized代码块，可以只对需要同步的代码进行同步，这样可以大大的提高效率。
 
小结：
使用synchronized 代码块相比方法有两点优势：
1、可以只对需要同步的使用。
2、与wait()/notify()/nitifyAll()一起使用时，比较方便。

2.wait() 与notify()/notifyAll()
 
这三个方法都是Object的方法，并不是线程的方法。
wait():释放占有的对象锁，线程进入等待池，释放cpu,而其他正在等待的线程即可抢占此锁，获得锁的线程即可运行程序。而sleep()不同的是，线程调用此方法后，会休眠一段时间，休眠期间，会暂时释放cpu，但并不释放对象锁。也就是说，在休眠期间，其他线程依然无法进入此代码内部。休眠结束，线程重新获得cpu,执行代码。wait()和sleep()最大的不同在于wait()会释放对象锁，而sleep()不会。
 

notify(): 该方法会唤醒因为调用对象的wait()而等待的线程，其实就是对对象锁的唤醒，从而使得wait()的线程可以有机会获取对象锁。调用notify()后，并不会立即释放锁，而是继续执行当前代码，直到synchronized中的代码全部执行完毕，才会释放对象锁。JVM则会在等待的线程中调度一个线程去获得对象锁，执行代码。需要注意的是，wait()和notify()必须在synchronized代码块中调用。
 

notifyAll()则是唤醒所有等待的线程。
 
为了说明这一点，举例如下：

两个线程依次打印"A""B",总共打印10次。
 
public class Consumer implements Runnable {
 
     @Override
     public synchronized void run() {
            int count = 10;
            while(count > 0) {
                 synchronized (Test. obj) {
                     System. out.print( "B");
                     count --;
                     Test. obj.notify(); // 主动释放对象锁
                      try {
                           Test. obj.wait();
                     } catch (InterruptedException e) {
                           e.printStackTrace();
                     }
                }
                
           }
     }
}
 

public class Produce implements Runnable {
 
     @Override
     public void run() {
            int count = 10;
            while(count > 0) {
                 synchronized (Test. obj) {
                     System. out.print( "A");
                     count --;
                     Test. obj.notify();
                      try {
                           Test. obj.wait();
                     } catch (InterruptedException e) {
                           e.printStackTrace();
                     }
                }
                
           }
 
     }
 
}
 

测试类如下：
 
public class Test {
 
     public static final Object obj = new Object();

     public static void main(String[] args) {
            new Thread( new Produce()).start();
            new Thread( new Consumer()).start();
           
     }
}
 

这里使用static obj作为锁的对象，当线程Produce启动时（假如Produce首先获得锁，则Consumer会等待），打印“A”后，会先主动释放锁，然后阻塞自己。Consumer获得对象锁，打印“B”，然后释放锁，阻塞自己，那么Produce又会获得锁，然后...一直循环下去，直到count = 0 这样，使用Synchronized和wait()以及notify()就可以达到线程同步的目的。

二.Lock

1.ReentrantLock 类

java.util.concurrent.lock 中的 Lock 框架是锁定的一个抽象，它允许把锁定的实现作为 Java 类，而不是作为语言的特性来实现。这就为 Lock 的多种实现留下了空间，各种实现可能有不同的调度算法、性能特性或者锁定语义。 ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，但是添加了类似锁投票、定时锁等候和可中断锁等候的一些特性。此外，它还提供了在激烈争用情况下更佳的性能。(换句话说，当许多线程都想访问共享资源时，JVM 可以花更少的时候来调度线程，把更多时间用在执行线程上。)
reentrant 锁意味着什么呢？简单来说，它有一个与锁相关的获取计数器，如果拥有锁的某个线程再次得到锁，那么获取计数器就加1，然后锁需要被释放两次才能获得真正释放。这模仿了 synchronized 的语义；如果线程进入由线程已经拥有的监控器保护的 synchronized 块，就允许线程继续进行，当线程退出第二个（或者后续） synchronized 块的时候，不释放锁，只有线程退出它进入的监控器保护的第一个 synchronized 块时，才释放锁。

Lock 和 synchronized 有一点明显的区别 —— lock 必须在 finally 块中释放。否则，如果受保护的代码将抛出异常，锁就有可能永远得不到释放！这一点区别看起来可能没什么，但是实际上，它极为重要。忘记在 finally 块中释放锁，可能会在程序中留下一个定时炸弹，当有一天炸弹爆炸时，您要花费很大力气才有找到源头在哪。而使用同步，JVM 将确保锁会获得自动释放。

ReentrantLock获取锁定与三种方式：

a) lock(), 如果获取了锁立即返回，如果别的线程持有锁，当前线程则一直处于休眠状态，直到获取锁

b) tryLock(), 如果获取了锁立即返回true，如果别的线程正持有锁，立即返回false；

c)tryLock(long timeout,TimeUnit unit)， 如果获取了锁定立即返回true，如果别的线程正持有锁，会等待参数给定的时间，在等待的过程中，如果获取了锁定，就返回true，如果等待超时，返回false；

d) lockInterruptibly:如果获取了锁定立即返回，如果没有获取锁定，当前线程处于休眠状态，直到或者锁定，或者当前线程被别的线程中断

同样的例子，使用lock 如何实现呢

public class Consumer implements Runnable {
 
     private Lock lock;
     public Consumer(Lock lock) {
            this. lock = lock;
     }
     @Override
     public void run() {
            int count = 10;
            while( count > 0 ) {
                 try {
                      lock.lock();
                     count --;
                     System. out.print( "B");
                } finally {
                      lock.unlock(); //主动释放锁
                      try {
                           Thread. sleep(91L);
                     } catch (InterruptedException e) {
                           e.printStackTrace();
                     }
                }
           }
 
     }
 
}
 
public class Producer implements Runnable{
 
     private Lock lock;
     public Producer(Lock lock) {
            this. lock = lock;
     }
     @Override
     public void run() {
            int count = 10;
            while (count > 0) {
                 try {
                      lock.lock();
                     count --;
                     System. out.print( "A");
                } finally {
                      lock.unlock();
                      try {
                           Thread. sleep(90L);
                     } catch (InterruptedException e) {
                           e.printStackTrace();
                     }
                }
           }
     }
}
 
调用代码：
 
public class Test {
 
     public static void main(String[] args) {

           Lock lock = new ReentrantLock();
           Consumer consumer = new Consumer(lock);
           Producer producer = new Producer(lock);
            new Thread(consumer).start();
            new Thread( producer).start();
           
     }
}

使用建议：
 
在并发量比较小的情况下，使用synchronized是个不错的选择，但是在并发量比较高的情况下，其性能下降很严重，此时ReentrantLock是个不错的方案。

三.总结 Lock与synchronized 的区别

1、ReentrantLock 拥有Synchronized相同的并发性和内存语义，此外还多了 锁投票，定时锁等候和中断锁等候

线程A和B都要获取对象O的锁定，假设A获取了对象O锁，B将等待A释放对O的锁定。

如果使用 synchronized ，如果A不释放，B将一直等下去，不能被中断。

如果 使用ReentrantLock，如果A不释放，可以使B在等待了足够长的时间以后，中断等待，而干别的事情。

2、synchronized是在JVM层面上实现的，不但可以通过一些监控工具监控synchronized的锁定，而且在代码执行时出现异常，JVM会自动释放锁定，但是使用Lock则不行，lock是通过代码实现的，要保证锁一定会被释放，就必须将unLock()放到finally{}中

3、在资源竞争不是很激烈的情况下，Synchronized的性能要优于ReetrantLock，但是在资源竞争很激烈的情况下，Synchronized的性能会下降几十倍，但是ReetrantLock的性能能维持常态；

5.0的多线程任务包对于同步的性能方面有了很大的改进，在原有synchronized关键字的基础上，又增加了ReentrantLock，以及各种Atomic类。了解其性能的优劣程度，有助与我们在特定的情形下做出正确的选择。

总体的结论先摆出来：

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

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