多线程(二)、内置锁 synchronized

前言

在上一篇 多线程(一)、基础概念及notify()和wait()的使用 文章中我们讲了多线程的一些基础概念还有等待通知机制，在讲线程之间共享资源的时候，提到会出现数据不同步问题，我们先通过一个示例来演示这个问题。

/**
 * @author : EvanZch
 *         description:
 **/
public class SynchronizedTest {

    // 赋count初始值为0
    public static int count = 0;
    // 进行累加操作
    public void add() {
        count++;
    }

    public static class TestThread extends Thread {
        private SynchronizedTest synchronizedTest;

        public TestThread(SynchronizedTest synchronizedTest) {
            this.synchronizedTest = synchronizedTest;
        }
        @Override
        public void run() {
            super.run();
            // 执行10000次累加
            for (int x = 0; x < 10000; x++) {
                synchronizedTest.add();
            }
        }
    }
    public int getCount() {
        return count;
    }
    public static void main(String[] args) throws InterruptedException {
        SynchronizedTest synchronizedTest = new SynchronizedTest();
        // 开启两个线程
        new TestThread(synchronizedTest).start();
        new TestThread(synchronizedTest).start();
        int count = synchronizedTest.getCount();
        System.out.println("count=" + count);
    }
}

可以看到，我程序中我们启动了两个线程，同时对 Count 变量进行累加操作，每个线程循环累加10000次，我们预想的结果，获取的count值应该会是20000，执行程序可以发现。

0？为什么结果会是0？因为我们在main里面开启线程执行，方法是顺序执行，当执行到 输出语句的时候，线程run方法还没有启动，所以这里打印的是count的初始值 0；

怎么获取到正确结果？

1、等待一会在获取结果

public static void main(String[] args) throws InterruptedException {
        SynchronizedTest synchronizedTest = new SynchronizedTest();
        new TestThread(synchronizedTest).start();
        new TestThread(synchronizedTest).start();
        // 等待一秒再回去结果
        Thread.sleep(1000);
        int count = synchronizedTest.getCount();
        System.out.println("count=" + count);
    }

我们在获取结果之前，先等待一秒，结果如下：

结果不再为 0 ，但是结果也不是我们预想的 20000啊，难道是等待时间不够？我们增加等待时间，在运行，发现结果也不是20000，这么看，使用等待时间不严谨，因为没办法判断线程执行结束时间（其实线程执行很快的，远不需要几秒），那我们可以使用 join方法。

2、thread.join()

我们先看一下 thread 的 join方法

/**
     * Waits for this thread to die.
     *
     * <p> An invocation of this method behaves in exactly the same
     * way as the invocation
     *
     * <blockquote>
     * {@linkplain #join(long) join}{@code (0)}
     * </blockquote>
     *
     * @throws  InterruptedException
     *          if any thread has interrupted the current thread. The
     *          <i>interrupted status</i> of the current thread is
     *          cleared when this exception is thrown.
     */
    public final void join() throws InterruptedException {
        join(0);
    }

注释大概意思是：当调用join方法后，会进行阻塞，直到该线程任务执行结束。

可以让线程顺序执行。

那我们可以简单修改代码，让两个线程执行结束后再打印结果

这里需要注意，我们是在 main 这个线程里面调用 join 方法， 则两个线程会在main 线程阻塞，但是两个子线程还是在并行处理，都执行结束后才会唤醒 main 线程执行后续操作。

public static void main(String[] args) throws InterruptedException {
        SynchronizedTest synchronizedTest = new SynchronizedTest();
        TestThread testThread = new TestThread(synchronizedTest);
        TestThread testThread1 = new TestThread(synchronizedTest);
        testThread.start();
        testThread1.start();
        // 让程序顺序执行
        testThread.join();
        testThread1.join();
        // 当两个线程任务结束后再获取结果
        int count = synchronizedTest.getCount();
        System.out.println("count=" + count);
    }

结果：

发现结果也不是我们预想的 20000，我们使用了 join() 方法，它会在调用线程进行阻塞（main），当testThread 和 testThread1 都执行结束后再唤醒调用线程 , 能确保两个线程肯定是执行结束了的，可是结果跟预期不一致，多次打印，发现结果一直在 10000 ~ 20000 这个区间波动。

为什么会出现这种情况？

上一篇文章讲过，同一个进程的多个线程共享该进程的所有资源，当多个线程同时访问一个对象或者一个对象的成员变量，可能会导致数据不同步问题，比如 线程A 对数据a进行操作，需要从内存中进行读取然后进行相应的操作，操作完成后再写入内存中，但是如果数据还没有写入内存中的时候，线程B 也来对这个数据进行操作，取到的就是还未写入内存的数据，导致前后数据同步问题，我们也叫线程不安全操作。

比如 线程 A 取到 count 的时候，其值为 100，加 1 后再放入内存中，如果在放入内存之前 线程B 也来拿 count 并对其进行累加操作，这个时候 **线程B **取到的 count 值 还是100，加 1 后放入内存，这个时候值为101， 这样 线程 A 进行累加的那步操作就没有被算上，这就是为啥，最后两个线程算出来的结果肯定是小于 20000。

怎么避免这种情况？

我们知道出现这种情况的原因是操作的时候，因为多个线程同时访问一个对象或者对象的成员变量，要处理这个问题，我们就引入了关键字 synchronized

正文

一、内置锁 synchronized

关键字 synchronized 可以修饰方法或者以同步块的形式来进行使用，它主要确保多个线程在同一个时刻，只能有一个线程处于方法或者同步块中，它保证了线程对变量访问的可见性和排他性，又称为内置锁机制。

锁又分为对象锁和类锁：

对象锁： 对一个对象实例进行锁操作，实例对象可以有多个，不同对象实例的对象锁互不干扰。

类锁：用于类的静态方法或者类的Class对象进行锁操作。我们知道每个类只有一个Class对象，也就只有一个类锁。

注意点：

类锁只是一个概念上的东西，它锁的也是对象，只不过这个对象是类的Class对象，其唯一存在。

类锁和对象锁之间互不干扰。

通过上面的案例，我们简单改改，我们在执行累加方法上加上 synchronized 关键字，然后再运行。

/**
 * @author : EvanZch
 *         description:
 **/
public class SynchronizedTest {

    public static int count = 0;

    // 我们对add方法添加关键字 synchronized
    public synchronized void add() {
        count++;
    }

    public static class TestThread extends Thread {
        private SynchronizedTest synchronizedTest;

        public TestThread(SynchronizedTest synchronizedTest) {
            this.synchronizedTest = synchronizedTest;
        }

        @Override
        public void run() {
            super.run();
            for (int x = 0; x < 10000; x++) {
                synchronizedTest.add();
            }
        }
    }

    public int getCount() {
        return count;
    }

    public static void main(String[] args) throws InterruptedException {
        SynchronizedTest synchronizedTest = new SynchronizedTest();
        TestThread testThread = new TestThread(synchronizedTest);
        TestThread testThread1 = new TestThread(synchronizedTest);
        testThread.start();
        testThread1.start();

        // 让程序顺序执行
        testThread.join();
        testThread1.join();

        int count = synchronizedTest.getCount();
        System.out.println("count=" + count);
    }
}

结果：

可以看到我们只加了一个关键字 synchronized ，结果就跟我们预期的 20000 一致，我们将 synchronized

添加到方法上，就确保了多个线程同一时刻只有一个线程对此方法进行操作，这样就确保了线程安全问题。

前面说了内置锁存在对象锁和类锁 ，我们来看一下具体怎么实现和区别。

1.1、对象锁

对一个对象实例进行锁操作，实例对象可以有多个，不同对象实例的对象锁互不干扰。

我们在前面的示例上进行更改。

方法锁：

// 非静态方法
    public synchronized void add() {
        count++;
    }

同步代码块锁：

public void add(){
        synchronized (this){
            count ++;
        }
    }

或者：

// 非静态变量
    public Object object = new Object();
    public void add(){
        synchronized (object){
            count ++;
        }
    }

我们可以看到对象锁都是对非静态方法和非静态变量进行加锁，以上三种从本质上来说没有区别，我们这个时候再改一下我们的示例代码，来验证一下 不同对象实例的对象锁互不干扰。

public static void main(String[] args) throws InterruptedException {

        SynchronizedTest synchronizedTest = new SynchronizedTest();
        // 我们再创建一个 SynchronizedTest 对象
        SynchronizedTest synchronizedTest1 = new SynchronizedTest();
        // 传入 synchronizedTest 
        TestThread testThread = new TestThread(synchronizedTest);
        // 传入 synchronizedTest1
        TestThread testThread1 = new TestThread(synchronizedTest1);

        testThread.start();
        testThread1.start();
        // 让程序顺序执行
        testThread.join();
        testThread1.join();

        int count = synchronizedTest.getCount();
        System.out.println("count=" + count);
    }

我们开启两个线程，分别传入了不同的实例对象，这个时候再多次运行，查看运行结果。

结果:

我们多次运行获取结果，发现都获取不到我们期望的20000，可以我们明明也在add() 方法上添加了 synchronized 啊，唯一不同的就是，两个线程传入了不同的对象，所以通过结果，我们可以得出，不同对象的对象锁之间，是互不影响，各种运行。

1.2、类锁

用于类的静态方法或者类的Class对象进行锁操作。我们知道每个类只有一个Class对象，也就只有一个类锁。

类锁其实也是对象锁，只不过锁的对象比较特殊。

静态方法锁：

// 静态方法
    public static synchronized void add() {
        count++;
    }

同步代码块锁：

public void add(){
        // 传入Class对象
        synchronized (SynchronizedTest.class){
            count ++;
        }
    }

或者：

// 静态成员变量
    public static Object object = new Object();
    public void add(){
        synchronized (object){
            count ++;
        }
    }

我们知道静态变量和类的Class对象在内存中只存在一个，所以我们对add方法通过类锁方式进行加锁，不管外界这个时候传的对象有多少个，它也是唯一的，我们再执行上面的main方法，打印结果：

可以看到结果和期望一致。

知识拓展 ：static 关键字和 new 一个对象，做了什么操作？

static 关键字：

• 静态变量是随着类加载时被完成初始化的，它在内存中仅有一个，且 JVM 也只会为它分配一次内存，同时类所有的实例都共享静态变量，即一处变、处处变，可以直接通过类名来访问它。
• 但是实例变量则不同，它是伴随着new实例化的，每创建一个实例就会产生一个实例变量，它与该实例同生共死。

new 一个对象，底层做了啥？
1、Jvm加载未加载的字节码,开辟空间
2、静态初始化(1静态代码块和2静态变量)
3、成员变量初始化(1普通代码块和2普通成员变量)
4、构造器初始化(构造函数)