Java Synchronized()

1、Synchronized使用的位置

同步的实现固然是采用锁了，java中使用锁的两个基本工具是 synchronized 和 Lock。

一直很喜欢synchronized，由于使用它很方便。好比，须要对一个方法进行同步，那么只需在方法的签名添加一个synchronized关键字。

// 未同步的方法

public void test() {}

1.1 放在方法的签名上面

// 同步的方法

pubilc synchronized void test() {}

1.2放在代码块上面

synchronized 也能够用在一个代码块上，看

public void test() {
     synchronized(obj) {
          System.out.println("===");
     }
}

1.3两种方式的区别

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()一块儿使用时，比较方便

1.4 对象的wait() 与notify()/notifyAll()

这三个方法都是Object的方法，并非线程的方法！

wait():释放占有的对象锁，线程进入等待池，释放cpu,而其余正在等待的线程便可抢占此锁，得到锁的线程便可运行程序。而sleep()不一样的是，线程调用此方法后，会休眠一段时间，休眠期间，会暂时释放cpu，但并不释放对象锁。也就是说，在休眠期间，其余线程依然没法进入此代码内部。休眠结束，线程从新得到cpu,执行代码。wait()和sleep()最大的不一样在于wait()会释放对象锁，而sleep()不会！

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

1.5 wait 与notify 使用实例

package com.yuan.test;
//生产者
public class Produce implements Runnable {

	@Override
	public void run() {
		// TODO Auto-generated method stub
		int count = 10;
		while (count > 0) {
			synchronized (Test.obj) {//Test.obj是一个静态变量

				// System.out.print("count = " + count);
				System.out.print("A");
				count--;
				try {
					Thread.sleep(5000);//让生产该线程sleep
				} catch (InterruptedException e1) {
					// TODO Auto-generated catch block
					e1.printStackTrace();
				}
				/*
				 * 另外，注意一点：若是要把notify和wait方法放在一块儿用的话，
				 * 必须先调用notify后调用wait，
				 * 由于若是调用完wait，该线程就已经不是currentthread了。
                                 */
				try {
					Test.obj.notify();
					Test.obj.wait();
					
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}

		}

	}
}

package com.yuan.test;
//消费者
public class Consumer implements Runnable {

	@Override
	public void run() {
		// TODO Auto-generated method stub
       int count=10;
       while(count>0){
    	    synchronized (Test. obj) {//Test.obj是一个静态变量
				System.out.println("B");
				count--;
				/*
				 * 另外，注意一点：若是要把notify和wait方法放在一块儿用的话，
				 * 必须先调用notify后调用wait，
				 * 由于若是调用完wait，该线程就已经不是currentthread了。
                                 */
				 try {
					 Test. obj.notify(); // 唤醒一个线程
                                         Test. obj.wait();
                    
                     
               } catch (InterruptedException e) {
                      // TODO Auto-generated catch block
                     e.printStackTrace();
               }
			}   
    	   
       }
	}

}

package com.yuan.test;
//测试类
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();
          
    }
}

1.6 Lock 来实现notify()和wait()一样的功能

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

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

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

package com.yuan.test;

import java.util.concurrent.locks.Lock;
//生产者
public class Produce implements Runnable {

	private Lock lock;
    public Produce(Lock lock) {
           this. lock = lock;
    }
    @Override
    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();//释放lock对象这个锁
                     try {
                          Thread. sleep(90L);
                    } catch (InterruptedException e) {
                           // TODO Auto-generated catch block
                          e.printStackTrace();
                    }
               }
          }
    }
}

package com.yuan.test;
//消费者
import java.util.concurrent.locks.Lock;

public class Consumer implements Runnable {
/*
 * 可是因为synchronized是在JVM层面实现的，
 * 所以系统能够监控锁的释放与否，而ReentrantLock使用代码实现的，
 * 系统没法自动释放锁，
 * 须要在代码中finally子句中显式释放锁lock.unlock();
 * 
 */
	private Lock lock;
    public Consumer(Lock lock) {
           this. lock = lock;
    }
    @Override
    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();
                    }
               }
          }

    }

}

package com.yuan.test;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
//测试
public class Test {
	private static final long serialVersionUID = 7373984872572414699L;
	
	public static void main(String[] args) {
		Lock lock = new ReentrantLock();//生成一个用于上锁的对象，查看源码发现有能够查看等待获取对象长度的方法

		Consumer consumer = new Consumer(lock);
		Produce producer = new Produce(lock);
		new Thread(consumer).start();
		new Thread(producer).start();
		
		
	}
}