Java 多线程基础（五）线程同步
当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。 要解决上述多线程并发访问一个资源的安全性问题，Java中提供了同步机制(synchronized)来解决。
一、线程同步
当线程A进入操作的时候，线程B和线程C只能在外等着，线程A操作结束，线程B和线程C才有机会进入代码去执行。也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕，数据同步之后，才能去抢夺CPU资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象。
为了保证每个线程都能正常执行原子操作，Java引入了线程同步机制。 线程同步机制主要 synchronized 关键字，给对象加锁的机制来保证线程的同步。
二、synchronized
（一）、synchronized的原理
在java中，每一个对象有且仅有一个同步锁。这也意味着，同步锁是依赖于对象而存在。
当我们调用某对象的 synchronized 方法时，就获取了该对象的同步锁。例如，synchronized(obj) 就获取了“obj这个对象”的同步锁。
不同线程对同步锁的访问是互斥的。也就是说，某时间点，对象的同步锁只能被一个线程获取到！通过同步锁，我们就能在多线程中，实现对“对象/方法”的互斥访问。 例如，现在有两个线程A和线程B，它们都会访问“对象obj的同步锁”。假设，在某一时刻，线程A获取到“obj的同步锁”并在执行一些操作；而此时，线程B也企图获取“obj的同步锁” —— 线程B会获取失败，它必须等待，直到线程A释放了“该对象的同步锁”之后线程B才能获取到“obj的同步锁”从而才可以运行。
（二）、synchronized的基本规则
我们将 synchronized 的基本规则总结为下面3条，并通过实例对它们进行说明。
第一条: 当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时，其他线程对“该对象”的该“synchronized方法”或者“synchronized代码块”的访问将被阻塞。
第二条: 当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时，其他线程仍然可以访问“该对象”的非同步代码块。
第三条: 当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时，其他线程对“该对象”的其他的“synchronized方法”或者“synchronized代码块”的访问将被阻塞。
1、第一条规则
public class Demo01 {
public static void main(String[] args) {
MyRunnable run = new MyRunnable();
Thread t1 = new Thread(run);
Thread t2 = new Thread(run);
t1.start();
t2.start();
}
}
class MyRunnable implements Runnable{
@Override
public void run() {
synchronized (this) {
try {
for (int i = 0; i < 5; i++) {
Thread.sleep(1000);// 休眠1秒
System.out.println(Thread.currentThread().getName() + "---" + i);
}
}catch(Exception e) {
e.printStackTrace();
}
}
}
}
// 执行结果：
Thread-0---0
Thread-0---1
Thread-0---2
Thread-0---3
Thread-0---4
Thread-1---0
Thread-1---1
Thread-1---2
Thread-1---3
Thread-1---4
说明：run()方法中存在“synchronized(this)代码块”，而且t1和t2都是基于"run这个Runnable对象"创建的线程。这就意味着，我们可以将synchronized(this)中的this看作是“run这个Runnable对象”；因此，线程t1和t2共享“run对象的同步锁”。所以，当一个线程运行的时候，另外一个线程必须等待“运行线程”释放“run的同步锁”之后才能运行。
2、第二条规则
public class Demo01 {
public static void main(String[] args) {
Demo01 demo = new Demo01();
new Thread(() -> {
demo.synCount();
}).start();// Lambda方式启动线程
new Thread(() -> {
demo.notSynCount();
}).start();// Lambda方式启动线程
}
// 同步代码块的方法
public void synCount() {
synchronized (this) {
try {
for(int i = 0;i <5;i++) {
Thread.sleep(1000);// 休眠1秒
System.out.println(Thread.currentThread().getName() + " syn count method " + i);
}
}catch(Exception e) {
e.printStackTrace();
}
}
}
// 非同步的方法
public void notSynCount() {
try {
for(int i = 0;i <5;i++) {
Thread.sleep(1000);// 休眠1秒
System.out.println(Thread.currentThread().getName() + " not syn count method " + i);
}
}catch(Exception e) {
e.printStackTrace();
}
}
}
// 运行结果
Thread-0 syn count method 0
Thread-1 not syn count method 0
Thread-1 not syn count method 1
Thread-0 syn count method 1
Thread-0 syn count method 2
Thread-1 not syn count method 2
Thread-0 syn count method 3
Thread-1 not syn count method 3
Thread-0 syn count method 4
Thread-1 not syn count method 4
说明：主线程中通过Lambda方式新建了两个子线程Thread-0和Thread-1。Thread-0会调用demo对象的synCount()方法，该方法内含有同步块；而THread-1则会调用demo对象的notSynCount()方法，该方法不是同步方法。Thread-0运行时，虽然调用synchronized(this)获取“demo的同步锁”；但是并没有造成t2的阻塞，因为Thread-1没有用到“demo”同步锁。
3、第三条规则
public class Demo01 {
public static void main(String[] args) {
Demo01 demo = new Demo01();
new Thread(() -> {
demo.synCount();
}).start();// Lambda方式启动线程
new Thread(() -> {
demo.notSynCount();
}).start();// Lambda方式启动线程
}
// 同步代码块的方法
public void synCount() {
synchronized (this) {
try {
for(int i = 0;i <5;i++) {
Thread.sleep(1000);// 休眠1秒
System.out.println(Thread.currentThread().getName() + " syn count method " + i);
}
}catch(Exception e) {
e.printStackTrace();
}
}
}
// 同步代码块的方法
public void notSynCount() {
synchronized(this) {
try {
for(int i = 0;i <5;i++) {
Thread.sleep(1000);// 休眠1秒
System.out.println(Thread.currentThread().getName() + " not syn count method " + i);
}
}catch(Exception e) {
e.printStackTrace();
}
}
}
}
// 运行结果
Thread-0 syn count method 0
Thread-0 syn count method 1
Thread-0 syn count method 2
Thread-0 syn count method 3
Thread-0 syn count method 4
Thread-1 not syn count method 0
Thread-1 not syn count method 1
Thread-1 not syn count method 2
Thread-1 not syn count method 3
Thread-1 not syn count method 4
说明：主线程中新建了两个子线程Thread-0和Thread-1。两者运行时都调用synchronized(this)，这个this是demo对象，而两者共用demo对象。因此，在Thread-0运行时，Thread-1会被阻塞，等待Thread-0运行释放“demo对象的同步锁”，Thread-1才能运行。
三、线程同步的方式
（一）、同步代码块
同步代码块是通过 synchronized 关键字修饰程序的代码块，synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问 。格式示例如下：
public void count{
synchronized (this) {
for (int i = 0; i < 5; i++) {
System.out.println(i);
}
}
]
（二）、同步方法
同步方法是用 synchronized 关键字修饰方法，保证A线程执行该方法的时候,其他线程只能在方法外等候。格式示例如下：
public synchronized void count() {
for(int i = 0;i <5;i++) {
System.out.println(i);
}
}
四、全局锁和实例锁
（一）、全局锁：该锁针对的是类，无论实例多少个对象，那么线程都共享该锁。全局锁对应的就是 static synchronized（或者是锁在该类的class或者classloader对象上）。
（二）、示例锁：锁在某一个实例对象上。如果该类是单例，那么该锁也具有全局锁的概念。实例锁对应的就是 synchronized 关键字。
关于实例锁和全局锁有一个很形象的例子：
pulbic class Something {
public synchronized void isSyncA(){}
public synchronized void isSyncB(){}
public static synchronized void cSyncA(){}
public static synchronized void cSyncB(){}
}
假设，Something有两个实例x和y。分析下面4组表达式获取的锁的情况。
1、x.isSyncA() 与 x.isSyncB()
2、x.isSyncA() 与 y.isSyncA()
3、x.cSyncA() 与 y.cSyncB()
4、x.isSyncA() 与 Something.cSyncA()