java synchronized加锁和释放流程

为什么需要加锁

在多线程环境中，多个线程同时运行同一个方法时，如果其中有对某一个资源就行修改处理时，可能会存在先后操作的问题，使得逻辑不一致，程序运行的结果不时我们想要的。

线程如何加锁

这里只讲synchronized进行加锁，并且只进行使用原理的阐述，其他加锁方式使用另外的篇幅。
加锁是为了避免多个线程同时进行逻辑处理时，可能会有数据不一致等情况从而影响程序的逻辑的准确性。 所以我们可以使用一个对象，给该对象设置一个锁状态标记，其他线程要进行逻辑处理时需要把该状态设置成功才能正常进行，不然就阻塞挂起。 这里问题来了，如果是我们直接在代码中添加一个状态标志，那么多线程的情况下设置这个状态下可能还是会有同时处理的情况。这里我们可以依赖java提供的synchronized关键字。

java内存布局和监视器锁

刚刚我们提到，可以给对象设置一个锁状态标记，其实vjm已经帮我们实现了，我们平常写的java对象经过编译字节码后，是会在内存中添加一个额外的信息的，这里就涉及到另一个概念，java对象的内存布局或者说java对象的数据结构。

当我们通过new关键字来新建一个对象时，jvm会在堆内存中开辟一块内存存储该对象实例，对象实例除了拥有我们自己定义的一些属性方法等，还会拥有额外的其他的信息。分为三块：

• 对象头
  对象头中会存储有hashcode,GC信息，锁标记等等。
• 实例数据
  实例数据就是我们自定义的各个字段和方法信息。
• 填充对齐
  简单理解为虚拟机中存储一个对象约定对象大小为8字节的整数倍，所以如果不够的话会额外占用一点空间凑数。

好了，简单说到这里就ok了，这里可以看到对象在实际运行过程中拥有锁标记的，这里称为监视器锁，实际上对象头的锁信息会更多，这里只是简单概括一下。在程序中通过synchronize关键字进行加锁的话，jvm会帮助我们标记该对象是由那个线程占有了，并且保证其他线程不会再拥有，只有当线程释放了改对象的锁后才可以重新进行锁竞争。
同时synchorize关键词能保证操作的对象是直接从内存中获取的(内存可见性)。
使用方式如下：

public class ThreadTest {

    public static void main(String[] args) {
        Task task = new Task();

        for (int i = 0; i< 50; i++) {
            new Thread(task).run();
        }

        System.out.println(task.getCount());
    }
}

class Task implements Runnable{
    private int count;

    private Object lock = new Object();

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    @Override
    public void run() {
        int total = 0;
        while (++total <= 10000) {
            synchronized (lock) {
                count++;
            }
        }
    }
}

synchronized究竟锁了谁

synchronized关键字的语法规则是定义在代码块中或者在定义方法时。

刚刚我们提到，java对象头中有锁标记，所以下面的逻辑就是对lock这个对象进行锁竞争

while (++total <= 10000) {
    synchronized (lock) {
        count++;
    }
}

而如果我们synchronized是在方法中定义的话，则是对当前类的实例进行锁竞争,这里就是C1
的实例对象，也即是C1 c1 = new C1()中的c1;而如果程序中还有C1 c11 = new C1()的定义，那么是分开竞争的。也即是同一个对象才进行锁竞争。

class C1{
    private int count;

    public synchronized void run() {
        int total = 0;
        while (++total <= 10000) {
           count++;
        }
    }
}

如果对象的方法是static的，那么进行锁竞争的是类对象，这个是jvm进行class字节码加载时生成的。

class C1{
    private int count;

    public static synchronized void run() {
        int total = 0;
        while (++total <= 10000) {
           count++;
        }
    }
}

至此，我们可以把监视器锁和synchronized关键字梳理了一遍。以上的重点信息是：java对象内存布局和监视器锁以及synchronized关键字的处理逻辑。如果需要深入可以对各个点进行往下研究。

线程的等待和唤醒

• wait()方法
  首先我们需要了解wait()方法的继承体系，他是在Object对象的基类方法，也就是说所有的对象都拥有wait()方法。一个线程调用了java的wait()方法后，当前线程会被阻塞挂起，这里的调用指的是线程里面调用了加锁对象的wait()方法。
  线程被阻塞挂起后是需要唤醒的，下面会讲到唤醒方法，但是也可以调用重载方法wait(long timeout)，让线程被阻塞后超过一定时间还没被唤醒而自动唤醒。

• notify()方法
  notify()方法也是继承于Object对象。当某个线程调用了加锁对象的notify方法后，会唤醒之前在该对象进行获取监视器锁时失败而被阻塞的线程，如果有多个线程同时被阻塞，notify()方法只会有一个线程被唤醒，如果需要唤醒全部，则可以调用notifyAll()方法。

所以面试中会被问到wait和notify的作用，可以侧重的知识点是：
1.调用wait之前一定是获取到锁的，所以要保证在synchronized块中。
2.调用wait后会释放该对象的锁。
3.调用notify()方法也要是获取锁, 也要保证在synchronized块中。
4.调用notify()方法唤醒一个线程，调用notifyAll()方法唤醒全部被阻塞线程。
5.调用notify()或者notifyAll()方法只是唤醒了其他被阻塞的线程，他们有了重新竞争锁的条件，但是当前线程还没有释放锁的，只有调用了wait()方法才会释放锁。

用一个生产者消费者模型来看看wait和notify的用法。生产者消费者模型可以简单理解为有一个容器，当里面没有数据时生产者会往里面添加数据，满了则暂停当前的工作等待消费者消费数据后通知他继续添加。消费者会往里面拿数据，没有了数据则暂停工作等待生产者生产了数据并通知他继续消费。

public static void main(String[] args) {
        Object lock = new Object();
        AtomicInteger counter = new AtomicInteger(0);
        Queue<Integer> queue = new LinkedList<>();

        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    while (true) {
                        //如果队列没有数据，调用wait()方法，阻塞自己
                        if (queue.isEmpty()) {
                            try {
                                System.out.println("消费者线程阻塞");
                                lock.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }

                        //如果队列不为空，消费数据；如果线程被生产者通过notifyAll()方法唤醒后，线程重新获取到锁时是从这里执行的
                        System.out.println("消费者线程消费数据： " + queue.poll());
                        //消费者消费后，唤醒可能由于之前队列满了而主动阻塞自己的生产者
                        lock.notifyAll();

                    }

                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    while (true) {
                        //如果队列数据满了，调用wait()方法，阻塞自己
                        if (queue.size() > 10) {
                            System.out.println("生产者线程阻塞");
                            try {
                                lock.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }

                        //如果队列没有满，生产数据; 如果被其他线程唤醒，在下次获取到锁的时候生产数据
                        System.out.println("生产者线程生产数据");
                        queue.add(counter.incrementAndGet());

                        //队列有数据了，唤醒之前可能没有数据而主动祖寺啊自己的消费者
                        lock.notifyAll();
                    }

                }
            }
        }).start();

    }