什么是线程安全？

当多个线程去访问同一个类（对象或方法）的时候，该类都能表现出正常的行为（与自己预想的结果一致），那我们就可以说这个类是线程安全的。
看一段代码：
package com.itsoku.chat04;

/
微信公众号：程序员路人，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
/
public class Demo1 {
static int** num = 0;

  1. **public** **static** **void** **m1**() {<br />        **for** (**int** i = 0; i < 10000; i++) {<br />            num++;<br />        }<br />    }
  3. **public** **static** **class** **T1** **extends** **Thread** {<br />        @Override<br />        **public** **void** **run**() {<br />            Demo1.m1();<br />        }<br />    }
  5. **public** **static** **void** **main**(String[] args) **throws** InterruptedException {<br />        T1 t1 = **new** T1();<br />        T1 t2 = **new** T1();<br />        T1 t3 = **new** T1();<br />        t1.start();<br />        t2.start();<br />        t3.start();
  7.     //等待3个线程结束打印num<br />        t1.join();<br />        t2.join();<br />        t3.join();
  9.     System.out.println(Demo1.num);<br />        /**<br />         * 打印结果：<br />         * 25572<br />         */<br />    }<br />}

Demo1 中有个静态变量 num，默认值是 0，m1()方法中对 num++执行 10000 次，main 方法中创建了 3 个线程用来调用 m1()方法，然后调用 3 个线程的 join()方法，用来等待 3 个线程执行完毕之后，打印 num 的值。我们期望的结果是 30000，运行一下，但真实的结果却不是 30000。上面的程序在多线程中表现出来的结果和预想的结果不一致，说明上面的程序不是线程安全的。
线程安全是并发编程中的重要关注点，应该注意到的是，造成线程安全问题的主要诱因有两点：

  1. 一是存在共享数据(也称临界资源)
  2. 二是存在多条线程共同操作共享数据

因此为了解决这个问题，我们可能需要这样一个方案，当存在多个线程操作共享数据时，需要保证同一时刻有且只有一个线程在操作共享数据，其他线程必须等到该线程处理完数据后再进行，这种方式有个高尚的名称叫互斥锁，即能达到互斥访问目的的锁，也就是说当一个共享数据被当前正在访问的线程加上互斥锁后，在同一个时刻，其他线程只能处于等待的状态，直到当前线程处理完毕释放该锁。在 Java 中，关键字 synchronized 可以保证在同一个时刻，只有一个线程可以执行某个方法或者某个代码块(主要是对方法或者代码块中存在共享数据的操作)，同时我们还应该注意到 synchronized 另外一个重要的作用，synchronized 可保证一个线程的变化(主要是共享数据的变化)被其他线程所看到（保证可见性，完全可以替代 volatile 功能），这点确实也是很重要的。
那么我们把上面的程序做一下调整，在 m1()方法上面使用关键字 synchronized，如下：
public static synchronized void m1() {
for (int i = 0; i < 10000; i++) {
num++;
}
}

然后执行代码，输出 30000，和期望结果一致。

synchronized 主要有 3 种使用方式

  1. 修饰实例方法，作用于当前实例，进入同步代码前需要先获取实例的锁
  2. 修饰静态方法，作用于类的 Class 对象，进入修饰的静态方法前需要先获取类的 Class 对象的锁
  3. 修饰代码块，需要指定加锁对象(记做 lockobj)，在进入同步代码块前需要先获取 lockobj 的锁

    synchronized 作用于实例对象

    所谓实例对象锁就是用 synchronized 修饰实例对象的实例方法，注意是实例方法，不是静态方法，如：
    package com.itsoku.chat04;

/
微信公众号：程序员路人，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
/
public class Demo2 {
int** num = 0;

  1. **public** **synchronized** **void** **add**() {<br />        num++;<br />    }
  3. **public** **static** **class** **T** **extends** **Thread** {<br />        **private** Demo2 demo2;
  5.     **public** **T**(Demo2 demo2) {<br />            **this**.demo2 = demo2;<br />        }
  7.     @Override<br />        **public** **void** **run**() {<br />            **for** (**int** i = 0; i < 10000; i++) {<br />                **this**.demo2.add();<br />            }<br />        }<br />    }
  9. **public** **static** **void** **main**(String[] args) **throws** InterruptedException {<br />        Demo2 demo2 = **new** Demo2();<br />        T t1 = **new** T(demo2);<br />        T t2 = **new** T(demo2);<br />        t1.start();<br />        t2.start();
  11.     t1.join();<br />        t2.join();
  13.     System.out.println(demo2.num);<br />    }<br />}

main()方法中创建了一个对象 demo2 和 2 个线程 t1、t2，t1、t2 中调用 demo2 的 add()方法 10000 次，add()方法中执行了 num++，num++实际上是分 3 步，获取 num，然后将 num+1，然后将结果赋值给 num，如果 t2 在 t1 读取 num 和 num+1 之间获取了 num 的值，那么 t1 和 t2 会读取到同样的值，然后执行 num++，两次操作之后 num 是相同的值，最终和期望的结果不一致，造成了线程安全失败，因此我们对 add 方法加了 synchronized 来保证线程安全。
注意：m1()方法是实例方法，两个线程操作 m1()时，需要先获取 demo2 的锁，没有获取到锁的，将等待，直到其他线程释放锁为止。
synchronize 作用于实例方法需要注意：

  1. 实例方法上加 synchronized，线程安全的前提是，多个线程操作的是同一个实例，如果多个线程作用于不同的实例，那么线程安全是无法保证的
  2. 同一个实例的多个实例方法上有 synchronized，这些方法都是互斥的，同一时间只允许一个线程操作同一个实例的其中的一个 synchronized 方法

    synchronized 作用于静态方法

    当 synchronized 作用于静态方法时，锁的对象就是当前类的 Class 对象。如：
    package com.itsoku.chat04;

/
微信公众号：程序员路人，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
/
public class Demo3 {
static int** num = 0;

  1. **public** **static** **synchronized** **void** **m1**() {<br />        **for** (**int** i = 0; i < 10000; i++) {<br />            num++;<br />        }<br />    }
  3. **public** **static** **class** **T1** **extends** **Thread** {<br />        @Override<br />        **public** **void** **run**() {<br />            Demo3.m1();<br />        }<br />    }
  5. **public** **static** **void** **main**(String[] args) **throws** InterruptedException {<br />        T1 t1 = **new** T1();<br />        T1 t2 = **new** T1();<br />        T1 t3 = **new** T1();<br />        t1.start();<br />        t2.start();<br />        t3.start();
  7.     //等待3个线程结束打印num<br />        t1.join();<br />        t2.join();<br />        t3.join();
  9.     System.out.println(Demo3.num);<br />        /**<br />         * 打印结果：<br />         * 30000<br />         */<br />    }<br />}

上面代码打印 30000，和期望结果一致。m1()方法是静态方法，有 synchronized 修饰，锁用于与 Demo3.class 对象，和下面的写法类似：
public static void m1() {
synchronized (Demo4.class) {
for (int i = 0; i < 10000; i++) {
num++;
}
}
}

synchronized 同步代码块

除了使用关键字修饰实例方法和静态方法外，还可以使用同步代码块，在某些情况下，我们编写的方法体可能比较大，同时存在一些比较耗时的操作，而需要同步的代码又只有一小部分，如果直接对整个方法进行同步操作，可能会得不偿失，此时我们可以使用同步代码块的方式对需要同步的代码进行包裹，这样就无需对整个方法进行同步操作了，同步代码块的使用示例如下：
package com.itsoku.chat04;

/
微信公众号：程序员路人，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
/
public class Demo5 implements Runnable {
static Demo5 instance = new Demo5();
static int** i = 0;

  1. @Override<br />    **public** **void** **run**() {<br />        //省略其他耗时操作....<br />        //使用同步代码块对变量i进行同步操作,锁对象为instance<br />        **synchronized** (instance) {<br />            **for** (**int** j = 0; j < 10000; j++) {<br />                i++;<br />            }<br />        }<br />    }
  3. **public** **static** **void** **main**(String[] args) **throws** InterruptedException {<br />        Thread t1 = **new** Thread(instance);<br />        Thread t2 = **new** Thread(instance);<br />        t1.start();<br />        t2.start();
  5.     t1.join();<br />        t2.join();
  7.     System.out.println(i);<br />    }<br />}

从代码看出，将 synchronized 作用于一个给定的实例对象 instance，即当前实例对象就是锁对象，每次当线程进入 synchronized 包裹的代码块时就会要求当前线程持有 instance 实例对象锁，如果当前有其他线程正持有该对象锁，那么新到的线程就必须等待，这样也就保证了每次只有一个线程执行 i++;操作。当然除了 instance 作为对象外，我们还可以使用 this 对象(代表当前实例)或者当前类的 class 对象作为锁，如下代码：
//this,当前实例对象锁
synchronized(this){
for(int j=0;j<1000000;j++){
i++;
}
}

//class对象锁
synchronized(Demo5.class){
for(int j=0;j<1000000;j++){
i++;
}
}

分析代码是否互斥的方法，先找出 synchronized 作用的对象是谁，如果多个线程操作的方法中 synchronized 作用的锁对象一样，那么这些线程同时异步执行这些方法就是互斥的。如下代码:
package com.itsoku.chat04;

/
微信公众号：程序员路人，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
/
public class Demo6 {
//作用于当前类的实例对象
public synchronized void m1**() {
}

  1. //作用于当前类的实例对象<br />    **public** **synchronized** **void** **m2**() {<br />    }
  3. //作用于当前类的实例对象<br />    **public** **void** **m3**() {<br />        **synchronized** (**this**) {<br />        }<br />    }
  5. //作用于当前类Class对象<br />    **public** **static** **synchronized** **void** **m4**() {<br />    }
  7. //作用于当前类Class对象<br />    **public** **static** **void** **m5**() {<br />        **synchronized** (Demo6.**class**) {<br />        }<br />    }
  9. **public** **static** **class** **T** **extends** **Thread**{<br />        Demo6 demo6;
  11.     **public** **T**(Demo6 demo6) {<br />            **this**.demo6 = demo6;<br />        }
  13.     @Override<br />        **public** **void** **run**() {<br />            **super**.run();<br />        }<br />    }
  15. **public** **static** **void** **main**(String[] args) {<br />        Demo6 d1 = **new** Demo6();<br />        Thread t1 = **new** Thread(() -> {<br />            d1.m1();<br />        });<br />        t1.start();<br />        Thread t2 = **new** Thread(() -> {<br />            d1.m2();<br />        });<br />        t2.start();
  17.     Thread t3 = **new** Thread(() -> {<br />            d1.m2();<br />        });<br />        t3.start();
  19.     Demo6 d2 = **new** Demo6();<br />        Thread t4 = **new** Thread(() -> {<br />            d2.m2();<br />        });<br />        t4.start();
  21.     Thread t5 = **new** Thread(() -> {<br />            Demo6.m4();<br />        });<br />        t5.start();
  23.     Thread t6 = **new** Thread(() -> {<br />            Demo6.m5();<br />        });<br />        t6.start();<br />    }

}

分析上面代码：

  1. 线程 t1、t2、t3 中调用的方法都需要获取 d1 的锁，所以他们是互斥的
  2. t1/t2/t3 这 3 个线程和 t4 不互斥，他们可以同时运行，因为前面三个线程依赖于 d1 的锁，t4 依赖于 d2 的锁
  3. t5、t6 都作用于当前类的 Class 对象锁，所以这两个线程是互斥的，和其他几个线程不互斥