synchronized和Lock

通常首先想到的同步synchronized

// 未同步的方法
public void test() {}
// 同步的方法
pubilc synchronized void test() {}
 
synchronized 也能够用在一个代码块上，看
 
public void test() {
     synchronized(obj) {
          System.out.println("===");
     }
}

synchronized 用在方法和代码块上有什么区别呢？

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

（可是若是该方法为类方法，即其修饰符为static，那么synchronized 意味着某个调用此方法的线程当前会拥有该类的锁，只要该线程持续在当前方法内运行，其余线程依然没法得到方法的使用权！）

synchronized 用在代码块的使用方式：synchronized(obj){//todo code here}

当线程运行到该代码块内，就会拥有obj对象的对象锁，若是多个线程共享同一个Object对象，那么此时就会造成互斥！特别的，当obj == this时，表示当前调用该方法的实例对象。即

public void test() { ... synchronized(this) { // todo your code } ... }

此时，其效果等同于 public synchronized void test() { // todo your code }

使用synchronized代码块，能够只对须要同步的代码进行同步，这样能够大大的提升效率。

小结： 使用synchronized 代码块相比方法有两点优点： 一、能够只对须要同步的使用 二、与wait()/notify()/nitifyAll()一块儿使用时，比较方便

---

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](https://my.oschina.net/u/1162528)
 public synchronized void run() {
        // TODO Auto-generated method stub
        int count = 10;
        while(count > 0) {
             synchronized (Test. obj) {
                 
                 System. out.print( "B");
                 count --;
                 Test. obj.notify(); // 主动释放对象锁
                 
                  try {
                       Test. obj.wait();
                       
                 } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                       e.printStackTrace();
                 }
            }
            
       }
 }

}

public class Produce implements Runnable {

[@Override](https://my.oschina.net/u/1162528)
 public void run() {
        // TODO Auto-generated method stub
        int count = 10;
        while(count > 0) {
             synchronized (Test. obj) {
                 
                  //System.out.print("count = " + count);
                 System. out.print( "A");
                 count --;
                 Test. obj.notify();
                 
                  try {
                       Test. obj.wait();
                 } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                       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()就能够达到线程同步的目的。

---

除了wait()和notify()协做完成线程同步以外，使用Lock也能够完成一样的目的。

ReentrantLock 与synchronized有相同的并发性和内存语义，还包含了中断锁等候和定时锁等候，意味着线程A若是先得到了对象obj的锁，那么线程B能够在等待指定时间内依然没法获取锁，那么就会自动放弃该锁。

可是因为synchronized是在JVM层面实现的，所以系统能够监控锁的释放与否，而ReentrantLock使用代码实现的，系统没法自动释放锁，须要在代码中finally子句中显式释放锁lock.unlock();

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

public class Consumer implements Runnable {

private Lock lock;
 public Consumer(Lock lock) {
        this. lock = lock;
 }
 [@Override](https://my.oschina.net/u/1162528)
 public void run() {
        // TODO Auto-generated method stub
        int count = 10;
        while( count > 0 ) {
             try {
                  lock.lock();
                 count --;
                 System. out.print( "B");
            } finally {
                  lock.unlock(); //主动释放锁
                  try {
                       Thread. sleep(91L);
                 } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                       e.printStackTrace();
                 }
            }
       }

 }

}

public class Producer implements Runnable{

private Lock lock;
 public Producer(Lock lock) {
        this. lock = lock;
 }
 [@Override](https://my.oschina.net/u/1162528)
 public void run() {
        // TODO Auto-generated method stub
        int count = 10;
        while (count > 0) {
             try {
                  lock.lock();
                 count --;
                 System. out.print( "A");
            } finally {
                  lock.unlock();
                  try {
                       Thread. sleep(90L);
                 } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                       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是个不错的方案。