Java 多线程基础（五）线程同步

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()

1、不能被同时访问：因为 isSyncA() 和 isSyncB() 都是访问同一个对象(对象x)的同步锁！

2、可以被同时访问：因为访问的不是同一个对象的同步锁，x.isSyncA() 访问的是 x 的同步锁，而 y.isSyncA() 访问的是 y 的同步锁。

3、不能被同时访问：因为 cSyncA() 和 cSyncB() 都是 static 类型，x.cSyncA() 相当于 Something.isSyncA()，y.cSyncB() 相当于Something.isSyncB()，因此它们共用一个同步锁，不能被同时访问。

4、可以被同时访问：因为 isSyncA() 是实例方法，x.isSyncA() 使用的是对象x的锁；而 cSyncA() 是静态方法，Something.cSyncA() 可以理解对使用的是“类的锁”。因此，它们是可以被同时访问的。