synchronized基本用法

概述

　　synchronized  关键字 ，代表这个方法加锁,相当于不管哪一个线程（例如线程A），运行到这个方法时,都要检查有没有其它线程B（或者C、 D等）正在用这个方法，有的话要等正在使用synchronized方法的线程B（或者C 、D）运行完这个方法后再运行此线程A,没有的话,直接运行。它包括两种用法：synchronized 方法和 synchronized 块。

1. synchronized 方法：

　　声明是为了定义 变量 的作用范围和 作用域

　　通过在方法声明中加入 synchronized 关键字 来声明 synchronized 方法。如：

　　public synchronized void accessVal(int newVal);

　　synchronized 方法控制对类 成员变量 的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行，否则所属 线程阻塞 ，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可 执行状态 。这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态（因为至多只有一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为 synchronized）。

　　在 Java 中，不光是类实例，每一个类也对应一把锁，这样我们也可将类的 静态成员 函数声明为 synchronized ，以控制其对类的 静态成员变量 的访问。

　　synchronized 方法的缺陷：若将一个大的方法声明为synchronized 将会大大影响效率，典型地，若将 线程 类的方法 run() 声明为 synchronized ，由于在线程的整个 生命期 内它一直在运行，因此将导致它对本类任何 synchronized 方法的调用都永远不会成功。当然我们可以通过将访问类成员变量的代码放到专门的方法中，将其声明为 synchronized ，并在主方法中调用来解决这一问题，但是 Java 为我们提供了更好的解决办法，那就是 synchronized 块。

2. synchronized 块：

　　通过 synchronized 关键字 来声明synchronized 块。语法如下：

　　synchronized(syncObject) {

　　//允许访问控制的代码

　　}

　　synchronized 块是这样一个代码块，其中的代码必须获得对象 syncObject （如前所述，可以是类实例或类）的锁方能执行，具体机制同前所述。由于可以针对任意代码块，且可任意指定上锁的对象，故灵活性较高。

synchronized(this)原理

在java虚拟机中，每个对象和类在逻辑上都是和一个监视器相关联的。 
对于对象来说，相关联的监视器保护对象的实例变量。 

对于类来说，监视器保护类的类变量。 

（如果一个对象没有实例变量，或者一个类没有变量，相关联的监视器就什么也不监视。） 
为了实现监视器的排他性监视能力，java虚拟机为每一个对象和类都关联一个锁。代表任何时候只允许一个线程拥有的特权。线程访问实例变量或者类变量不需锁。 

但是如果线程获取了锁，那么在它释放这个锁之前，就没有其他线程可以获取同样数据的锁了。（锁住一个对象就是获取对象相关联的监视器） 

类锁实际上用对象锁来实现。当虚拟机装载一个class文件的时候，它就会创建一个java.lang.Class类的实例。当锁住一个对象的时候，实际上锁住的是那个类的Class对象。 

一个线程可以多次对同一个对象上锁。对于每一个对象，java虚拟机维护一个加锁计数器，线程每获得一次该对象，计数器就加1，每释放一次，计数器就减 1，当计数器值为0时，锁就被完全释放了。

在Java中，设计可同步的变量时至少要考虑两点： 

1.需要有一个锁对象与之关联，在synchronized快或方法中的代码，JVM调用的时候，会尝试去获取被Synchronized 的对象或Class的lock。这样才能达到同步。 
2.在执行wait 或notify的时候，需要有一个与之关联的集合来保存这个对象的锁被lock了几次，unlock了几次，满足如可重入锁的需求。这也就和唤醒有关了 

编辑本段对synchronized(this)的一些理解

　　一、当两个并发线程访问同一个对象object中的这个synchronized(this) 同步代码块 时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

　　二、当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

　　三、然而，当一个 线程 访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的除synchronized(this)同步代码块以外的部分。

　　四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的 对象锁 。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

　　五、以上规则对其它对象锁同样适用

编辑本段synchronized的4种用法

　　

1.方法声明时使用，放在范围操作符(public等)之后，返回类型声明(void等)之前。即一次只能有一个线程进入该方法，其他线程要想在此时调用该方法，只能排队等候，当前线程（就是在synchronized方法内部的线程）执行完该方法后，别的线程才能进入。  例如：  public synchronized void synMethod() {  //方法体  }  2.对某一代码块使用，synchronized后跟括号，括号里是变量，这样，一次只有一个线程进入该代码块。例如：  public int synMethod(int a1){  synchronized(a1) {  //一次只能有一个线程进入  }  }  3.synchronized后面括号里是一对象，此时，线程获得的是对象锁。例如：  public class MyThread implements Runnable {  public static void main(String args[]) {  MyThread mt = new MyThread();  Thread t1 = new Thread(mt, "t1");  Thread t2 = new Thread(mt, "t2");  Thread t3 = new Thread(mt, "t3");  Thread t4 = new Thread(mt, "t4");  Thread t5 = new Thread(mt, "t5");  Thread t6 = new Thread(mt, "t6");  t1.start();  t2.start();  t3.start();  t4.start();  t5.start();  t6.start();  }  public void run() {  synchronized (this) {  System.out.println(Thread.currentThread().getName());  }  }  }  对于3,如果线程进入，则得到对象锁，那么别的线程在该类所有对象上的任何操作都不能进行。在对象级使用锁通常是一种比较粗糙的方法。为什么要将整个对象都上锁，而不允许其他线程短暂地使用对象中其他同步方法来访问共享资源？如果一个对象拥有多个资源，就不需要只为了让一个线程使用其中一部分资源，就将所有线程都锁在外面。由于每个对象都有锁，可以如下所示使用虚拟对象来上锁：  class FineGrainLock {  MyMemberClass x, y;  Object xlock = new Object(), ylock = new Object();  public void foo() {  synchronized(xlock) {  //access x here  }  //do something here - but don‘t use shared resources  synchronized(ylock) {  //access y here  }  }  public void bar() {  synchronized(this) {  //access both x and y here  }  //do something here - but don‘t use shared resources  }  }  4.synchronized后面括号里是类。例如：  class ArrayWithLockOrder{  private static long num_locks = 0;  private long lock_order;  private int[] arr;  public ArrayWithLockOrder(int[] a)  {  arr = a;  synchronized(ArrayWithLockOrder.class) {//-----------------------------------------这里  num_locks++; // 锁数加 1。  lock_order = num_locks; // 为此对象实例设置唯一的 lock_order。  }  }  public long lockOrder()  {  return lock_order;  }  public int[] array()  {  return arr;  }  }  class SomeClass implements Runnable  {  public int sumArrays(ArrayWithLockOrder a1,  ArrayWithLockOrder a2)  {  int value = 0;  ArrayWithLockOrder first = a1; // 保留数组引用的一个  ArrayWithLockOrder last = a2; // 本地副本。  int size = a1.array().length;  if (size == a2.array().length)  {  if (a1.lockOrder() > a2.lockOrder()) // 确定并设置对象的锁定  { // 顺序。  first = a2;  last = a1;  }  synchronized(first) { // 按正确的顺序锁定对象。  synchronized(last) {  int[] arr1 = a1.array();  int[] arr2 = a2.array();  for (int i=0; i value += arr1[i] + arr2[i];  }  }  }  return value;  }  public void run() {  //...  }  }  对于4,如果线程进入，则线程在该类中所有操作不能进行，包括静态变量和静态方法，实际上，对于含有静态方法和静态变量的代码块的同步，我们通常用4来加锁。  以上4种之间的关系：  锁是和对象相关联的，每个对象有一把锁，为了执行synchronized语句，线程必须能够获得synchronized语句中表达式指定的对象的锁，一个对象只有一把锁，被一个线程获得之后它就不再拥有这把锁，线程在执行完synchronized语句后，将获得锁交还给对象。  在方法前面加上synchronized修饰符即可以将一个方法声明为同步化方法。同步化方法在执行之前获得一个锁。如果这是一个类方法，那么获得的锁是和声明方法的类相关的Class类对象的锁。如果这是一个实例方法，那么此锁是this对象的锁。synchronzied块后面跟类的具体详细例子、public class DB2_JDBCFactory {private static DB2_JDBCFactory instance = null; public static final ThreadLocal threadLocal = new ThreadLocal(); private DB2_JDBCFactory() {  } public static DB2_JDBCFactory getInstance() {  if(instance == null) {  synchronized(DB2_JDBCFactory.class) { //synchronized后面跟一个类  instance = new DB2_JDBCFactory();  }  }  return instance;  } public Connection getConnection_JNDI_localhost(){  Connection c = (Connection) threadLocal.get();  try {  if (c == null || c.isClosed()) {  InitialContext ctx = new InitialContext();  DataSource ds = (DataSource)ctx.lookup("java:comp/env/jdbc/localhost");  c = ds.getConnection();  threadLocal.set(c);  }  } catch (Exception ex) {  System.err.println("getConnection_JNDI Initial failed. " + ex);  return null;  }  return c;  }}外面的对象访问这个类的 需要通过调用它的getInstance()

 

 假设某个Object lock = new Object();
线程1（比如消费者线程）调用lock.wait()方法后，线程1就停下，直到其他某个线程（比如生产者线程）调用了lock.notify()或者lock.notifyAll();唤醒一个或者多个等待lock被唤醒的线程（此例中的线程1）。
调用wait之前，需要对lock同步synchronized (lock) {...}

如果只是想让当前线程停下一段时间
Thread.sleep(毫秒数）