Synchronized关键字

同步处理

所谓的同步指的是所有的线程不是一起进入到方法中执行，而是按照顺序一个一个进来。

解决同步问题

使用synchronized关键字处理有两种模式：同步代码块、同步方法

• 使用同步代码块 : 如果要使用同步代码块必须设置一个要锁定的对象，所以一般可以锁定当前对象:this

class MyThread implements Runnable { 
    private int ticket = 1000 ; // 一共十张票 
    @Override 
    public void run() { 
      for (int i = 0; i < 1000; i++) {  
      // 在同一时刻，只允许一个线程进入代码块处理 
          synchronized(this) { 
          // 表示为程序逻辑上锁 
          if(this.ticket>0) { 
          // 还有票 
            try {Thread.sleep(20); 
           } 
           catch (InterruptedException e) { 
           // TODO Auto-generated catch block 
              e.printStackTrace(); 
            } 
            // 模拟网络延迟 
                     System.out.println(Thread.currentThread().getName()+",还有" +this.ticket -- +" 张票"); 
          } 
       } 
   } 
}
public class TestDemo { 
    public static void main(String[] args) { 
      MyThread mt = new MyThread() ;
      Thread t1 = new Thread(mt,"黄牛A"); 
      Thread t2 = new Thread(mt,"黄牛B"); 
      Thread t3 = new Thread(mt,"黄牛C");  
      t1.setPriority(Thread.MIN_PRIORITY);   
      t2.setPriority(Thread.MAX_PRIORITY); 
      t3.setPriority(Thread.MAX_PRIORITY); 
      t1.start(); 
      t2.start(); 
      t3.start(); 
  } 
}

• 同步方法

class MyThread implements Runnable { 
  private int ticket = 1000; // 一共十张票 
  @Override 
  public void run() { 
    for (int i = 0; i < 1000; i++) { 
      this.sale(); 
    }
  }
  public synchronized void sale() {
     if (this.ticket > 0) { // 还有票 
       try {Thread.sleep(20); 
     } catch (InterruptedException e) { 
     // TODO Auto-generated catch block 
       e.printStackTrace(); 
     } 
     // 模拟网络延迟 
     System.out.println(Thread.currentThread().getName() + ",还有" + this.ticket-- + " 张票"); 
    } 
  } 
}
public class TestDemo { 
   public static void main(String[] args) { 
      MyThread mt = new MyThread(); 
      Thread t1 = new Thread(mt, "黄牛A"); 
      Thread t2 = new Thread(mt, "黄牛B"); 
      Thread t3 = new Thread(mt, "黄牛C"); 
      t1.setPriority(Thread.MIN_PRIORITY); 
      t2.setPriority(Thread.MAX_PRIORITY); 
      t3.setPriority(Thread.MAX_PRIORITY); 
      t1.start(); 
      t2.start(); 
      t3.start(); 
   } 
}

实际上，synchronized(this)以及非static的synchronized方法，只能防止多个线程同时执行同一个对象的同步代码段。即synchronized锁住的是括号里的对象，而不是代码。对于非static的synchronized方法，锁的就是对象本身也就是this。
当synchronized锁住一个对象后，别的线程如果也想拿到这个对象的锁，就必须等待这个线程执行完成释放锁，才能再次给对象加锁，这样才达到线程同步的目的。即使两个不同的代码段，都要锁同一个对象，那么这两个代码段也不能在多线程环境下同时运行。

如果要想锁的是代码段，锁住多个对象的同一方法，使用这种全局锁，锁的是类而不是this。

static synchronized方法，static方法可以直接类名加方法名调用，方法中无法使用this，所以它锁的不 是this，而是类的Class对象，所以，static synchronized方法也相当于全局锁，相当于锁住了代码段。

Synchronized底层原理

在java代码中使用synchronized可使用在代码块和方法中，根据Synchronized用的位置可以有这些使用场景：

JVM 将 synchronized 锁分为 无锁、偏向锁、轻量级锁、重量级锁状态。会根据情况，进行依次升级。
无锁： 没有对资源进行锁定，所有的线程都能访问并修改同一个资源，但同时只有一个线程能修改成功，其他修改失败的线程会不断重试直到修改成功。
偏向锁： 对象的代码一直被同一线程执行，不存在多个线程竞争，该线程在后续的执行中自动获取锁，降低获取锁带来的性能开销。偏向锁，指的就是偏向第一个加锁线程，该线程是不会主动释放偏向锁的，只有当其他线程尝试竞争偏向锁才会被释放。偏向锁的撤销，需要在某个时间点上没有字节码正在执行时，先暂停拥有偏向锁的线程，然后判断锁对象是否处于被锁定状态。如果线程不处于活动状态，则将对象头设置成无锁状态，并撤销偏向锁；如果线程处于活动状态，升级为轻量级锁的状态。
轻量级锁： 轻量级锁是指当锁是偏向锁的时候，被第二个线程 B 所访问，此时偏向锁就会升级为轻量级锁，线程 B会通过自旋的形式尝试获取锁，线程不会阻塞，从而提高性能。当前只有一个等待线程，则该线程将通过自旋进行等待。但是当自旋超过一定的次数时，轻量级锁便会升级为重量
级锁；当一个线程已持有锁，另一个线程在自旋，而此时又有第三个线程来访时，轻量级锁也会升级为重量级锁。
重量级锁： 指当有一个线程获取锁之后，其余所有等待获取该锁的线程都会处于阻塞状态。
重量级锁通过对象内部的监视器（monitor）实现，而其中 monitor 的本质是依赖于底层操作系统的 Mutex Lock实现，操作系统实现线程之间的切换需要从用户态切换到内核态，切换成本非常高。

对象锁(monitor)机制

执行同步代码块后首先要先执行monitorenter指令，退出的时候monitorexit指令.使用Synchronized进行同步，其关键就是必须要对对象的监视器monitor进行获取，当线程获取monitor后才能继续往下执行，否则就只能等待。而这个获取的过程是互斥的，即同一时刻只有一个线程能够获取到monitor。

当用 synchronized 标记方法时，你会看到字节码中方法的访问标记包括 ACC_SYNCHRONIZED。该标记表示在进入该方法时，Java 虚拟机需要进行 monitorenter 操作。而在退出该方法时，不管是正常返回，还是向调用者抛异常，Java 虚拟机均需要进行 monitorexit 操作。这里 monitorenter 和 monitorexit 操作所对应的锁对象是隐式的。对于实例方法来说，这两个操作对应的锁对象是 this；对于静态方法来说，这两个操作对应的锁对象则是所在类的 Class 实例。
关于 monitorenter 和 monitorexit 的作用，我们可以抽象地理解为每个锁对象拥有一个锁计数器和一个指向持有该锁的线程的指针。
当执行 monitorenter 时，如果目标锁对象的计数器为 0，那么说明它没有被其他线程所持有。在这个情况下，Java 虚拟机会将该锁对象的持有线程设置为当前线程，并且将其计数器加 1。
在目标锁对象的计数器不为 0 的情况下，如果锁对象的持有线程是当前线程，那么 Java 虚拟机可以将其计数器加 1，否则需要等待，直至持有线程释放该锁。
当执行 monitorexit 时，Java 虚拟机则需将锁对象的计数器减 1。当计数器减为 0 时，那便代表该锁已经被释放掉了。

Synchronized优化

CAS操作

什么是CAS

使用锁时，线程获取锁是一种悲观锁策略，即假设每一次执行临界区代码都会产生冲突，所以当前线程获取到锁的时候同时也会阻塞其他线程获取该锁。而CAS操作（又称为无锁操作）是一种乐观锁策略，它假设所有线程访问共享资源的时候不会出现冲突，既然不会出现冲突自然而然就不会阻塞其他线程的操作。因此，线程就不会出现阻塞停顿的状态。那么，如果出现冲突了怎么办？无锁操作是使用CAS(compare and swap)又叫做比较交换来鉴别线程是否出现冲突，出现冲突就重试当前操作直到没有冲突为止。

CAS的操作过程

CAS比较交换的过程可以通俗的理解为CAS(V,O,N)，包含三个值分别为：V 内存地址存放的实际值；O预期的值（旧值）；N 更新的新值。当V和O相同时，也就是说旧值和内存中实际的值相同表明该值没有被其他线程更改过，即该旧值O就是目前来说最新的值了，自然而然可以将新值N赋值给V。反之，V 和O不相同，表明该值已经被其他线程改过了则该旧值O不是最新版本的值了，所以不能将新值N赋给V，返回V即可。当多个线程使用CAS操作一个变量时，只有一个线程会成功，并成功更新，其余会失败。失败的线程会重新尝试，当然也可以选择挂起线程。

CAS问题

• ABA问题 因为CAS会检查旧值有没有变化，这里存在这样一个有意思的问题。比如一个旧值A变为了成B，然后再变成A，刚好在做CAS时检查发现旧值并没有变化依然为A，但是实际上的确发生了变化。解决方案可以沿袭数据库中常用的乐观锁方式，添加一个版本号可以解决。在JDK1.5后的atomic包中提供了AtomicStampedReference来解决ABA问题，解决思路就是这样的。
• 自旋会浪费大量的处理器资源，与线程阻塞相比，自旋会浪费大量的处理器资源。这是因为当前线程仍处于运行状况，只不过跑的是无用指令。它期望在运行无用指令的过程中，锁能够被释放出来。
• 公平性
  自旋状态还带来另外一个副作用，不公平的锁机制。处于阻塞状态的线程，无法立刻竞争被释放的锁。然而，处于自旋状态的线程，则很有可能优先获得这把锁。

总结

Java虚拟机中synchronized关键字的实现，按照代价由高到低可以分为重量级锁、轻量锁和偏向锁三种。

1. 重量级锁会阻塞、唤醒请求加锁的线程。它针对的是多个线程同时竞争同一把锁的情况。 JVM采用了自适应自旋，来避免线程在面对非常小的synchronized代码块时，仍会被阻塞、 唤醒的情况。
2. 轻量级锁采用CAS操作，将锁对象的标记字段替换为一个指针，指向当前线程栈上的一块空 间，存储着锁对象原本的标记字段。它针对的是多个线程在不同时间段申请同一把锁的情 况。
3. 偏向锁只会在第一次请求时采用CAS操作，在锁对象的标记字段中记录下当前线程的地址。 在之后的运行过程中，持有该偏向锁的线程的加锁操作将直接返回。它针对的是锁仅会被同 一线程持有的情况。