多线程synchronized同步与锁的认识

推荐阅读：深入浅出Java多线程

1. 锁与同步

• 由于同一进程的多个线程共享同一块存储空间, 在带来方便的同时，也带来了访问冲突问题,为了保证数据在方法中被访问时的正确性,在访问时加入锁机制synchronized ,当一个线程获得对象的排它锁,独占资源,其他线程必须等待，使用后释放锁即可存在以下问题:

1. 一个线程持有锁会导致其他所有需要此锁的线程挂起;
2. 在多线程竞争下,加锁,释放锁会导致比较多的上下文切换和调度延时，引起性能问题;
3. 如果一个优先级高的线程等待一 个优先级低的线程释放锁会导致优先级倒置，引起性能问题.

synchronized

• 首先需要明确的一点是：Java多线程的锁都是基于对象的，Java中的每一个对象都可以作为一个锁。

• 还有一点需要注意的是，我们常听到的类锁其实也是对象锁。

• Java类只有一个Class对象（可以有多个实例对象，多个实例共享这个Class对象），而Class对象也是特殊的Java对象。所以我们常说的类锁，其实就是Class对象的锁。

说到锁，我们通常会谈到synchronized这个关键字。它翻译成中文就是“同步”的意思。
我们通常使用synchronized关键字来给一段代码或一个方法上锁。它通常有以下三种形式：

// 关键字在实例方法上，锁为当前实例
public synchronized void instanceLock() {
    // code
}

// 关键字在静态方法上，锁为当前Class对象
public static synchronized void classLock() {
    // code
}

// 关键字在代码块上，锁为括号里面的对象
public void blockLock() {
    Object o = new Object();
    synchronized (o) {
        // code
    }
}

我们这里介绍一下“临界区”的概念。所谓“临界区”，指的是某一块代码区域，它同一时刻只能由一个线程执行。在上面的例子中，如果synchronized关键字在方法上，那临界区就是整个方法内部。而如果是使用synchronized代码块，那临界区就指的是代码块内部的区域。

通过上面的例子我们可以看到，下面这两个写法其实是等价的作用：

// 关键字在实例方法上，锁为当前实例
public synchronized void instanceLock() {
    // code
}

// 关键字在代码块上，锁为括号里面的对象
public void blockLock() {
    synchronized (this) {
        // code
    }
}

Lock锁机制
Java 6 为了减少获得锁和释放锁带来的性能消耗，引入了“偏向锁”和“轻量级锁“。在Java 6 以前，所有的锁都是”重量级“锁。所以在Java 6 及其以后，一个对象其实有四种锁状态，它们级别由低到高依次是：

无锁状态
偏向锁状态
轻量级锁状态
重量级锁状态

• 推荐阅读——>http://concurrent.redspider.group/article/02/9.html

JUC

java.util.concurrent包下的类是线程安全的
常用的类包括：

• CopyOnWriteArrayList
• ConcurrentHashMap

Lock锁

转载：http://concurrent.redspider.group/article/03/14.html

Java原生的锁——基于对象的锁，它一般是配合synchronized关键字来使用的。实际上，Java在java.util.concurrent.locks包下，还为我们提供了几个关于锁的类和接口。它们有更强大的功能或更高的性能。

synchronized的不足之处

• 如果临界区是只读操作，其实可以多线程一起执行，但使用synchronized的话，同一时间只能有一个线程执行。
• synchronized无法知道线程有没有成功获取到锁
• 使用synchronized，如果临界区因为IO或者sleep方法等原因阻塞了，而当前线程又没有释放锁，就会导致所有线程等待。

而这些都是locks包下的锁可以解决的。
锁的类型

• 可重入锁和非可重入锁

所谓重入锁，顾名思义。就是支持重新进入的锁，也就是说这个锁支持一个线程对资源重复加锁。

synchronized关键字就是使用的重入锁。比如说，你在一个synchronized实例方法里面调用另一个本实例的synchronized实例方法，它可以重新进入这个锁，不会出现任何异常。

如果我们自己在继承AQS实现同步器的时候，没有考虑到占有锁的线程再次获取锁的场景，可能就会导致线程阻塞，那这个就是一个“非可重入锁”。

ReentrantLock的中文意思就是可重入锁

class BuyTicket implements Runnable {

    private int ticket = 10;//定义票数
    //定义可重入锁
    private final ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true){
            try {
                lock.lock();//加锁
                if (ticket > 0) {
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "获得了第" + ticket-- + "票");
                } else {
                    break;
                }
            }finally {
                lock.unlock();//释放锁
            }
        }
    }
}

synchronized与Lock的对比

• Lock是显式锁(手动开启和关闭锁，别忘记关闭锁) synchronized是隐式锁， 出了
  作用域自动释放
• Lock只有代码块锁，synchronized有代码块锁和方法锁
• 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展
  性(提供更多的子类)ReentrantLock
• 优先使用顺序:
  Lock >同步代码块(已经进入了方法体，分配了相应资源) >同步方法(在方
  法体之外)