Java多线程（四）使用synchronized锁实现线程同步

本篇本章主要介绍以synchronized关键字的方式实现线程同步，以及线程间的通信。

为什么要用线程同步####

我们先来看下这段代码的运行结果：

package com.Dan;

public class TestRunnable {
    public static void main(String[] args) {

        MyThread myThread = new MyThread();
        Thread t1 = new Thread( myThread, "1 号售票窗口");
        Thread t2 = new Thread( myThread, "2 号售票窗口");
        Thread t3 = new Thread( myThread, "3 号售票窗口");
        t1.start();
        t2.start();
        t3.start();
    }
}
class MyThread implements Runnable{
    private int ticket = 90; // 90张票
    private String ticketWindowName; // 售票窗口

    @Override
    public void run(){
        for(int i = 0;i < 100; i++){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(this.ticket>0){
                System.out.println(Thread.currentThread().getName() + "卖票---->" + (this.ticket--));
            }
        }
    }
}
// 1 号售票窗口卖票---->90
// 3 号售票窗口卖票---->88
// 2 号售票窗口卖票---->89
// 2 号售票窗口卖票---->87
// 1 号售票窗口卖票---->87
// 3 号售票窗口卖票---->87
// 2 号售票窗口卖票---->86

// 87 那张票被三个窗口各卖了一次，想下那个画面，火车上一个位子三个人坐。

在多线程上篇博客已经介绍过了，JVM采用的是抢占式调度模型，当一个线程sleep的时候，其它线程会抢占CPU资源。如果发生在数据库中，就是“脏读”。synchronized锁就是用来解决这个问题的，多线程的线程同步机制实际上是靠锁的概念来控制的。

第一种方式：synchronized关键字修饰函数方法####

    // 修改run方法
    @Override
    public synchronized void run(){
        for(int i = 0;i < 100; i++){
            if(this.ticket>0){
                System.out.println(Thread.currentThread().getName() + "卖票---->" + (this.ticket--));
                notifyAll();
            }
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    // 1 号售票窗口卖票---->90
    // 3 号售票窗口卖票---->89
    // 2 号售票窗口卖票---->88
    // 3 号售票窗口卖票---->87
    // 1 号售票窗口卖票---->86
    // 2 号售票窗口卖票---->85
    // 3 号售票窗口卖票---->84
    // 1 号售票窗口卖票---->83

    // 关于notify和wait的用法参考多线程（三）

第二种方式：synchronized关键字修饰代码块####

    public void run() {
        for (int i = 0; i < 100; i++) {
            synchronized (this) {
                if (this.ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "卖票---->" + (this.ticket--));
                    notifyAll();
                }
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    // 1 号售票窗口卖票---->90
    // 2 号售票窗口卖票---->89
    // 1 号售票窗口卖票---->88
    // 3 号售票窗口卖票---->87
    // 1 号售票窗口卖票---->86
    // 2 号售票窗口卖票---->85
    // 3 号售票窗口卖票---->84
    // 1 号售票窗口卖票---->83

多个对象多个锁的情况####

三个线程同时进行，每个线程只打印一个字母，交替打印ABCABC...

package com.Dan;

class MyThread2 implements Runnable {

    private Object prev;
    private Object self;

    public MyThread2(Object prev, Object self) {
        this.prev = prev;
        this.self = self;
    }

    @Override
    public void run() {
        int ticket = 8; // 打印8次
        while (ticket > 0) {
            synchronized (prev) {
                synchronized (self) {
                    System.out.print(Thread.currentThread().getName());
                    ticket--;
                    self.notify();
                }
                try {
                    prev.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {

        Object a = new Object();
        Object b = new Object();
        Object c = new Object();

        MyThread2 myThread1 = new MyThread2(c, a);
        MyThread2 myThread2 = new MyThread2(a, b);
        MyThread2 myThread3 = new MyThread2(b, c);

        new Thread(myThread1, "A").start();
        Thread.sleep(100);
        new Thread(myThread2, "B").start();
        Thread.sleep(100);
        new Thread(myThread3, "C").start();
        Thread.sleep(100);
    }
}
// ABCABCABCABCABCABCABCABC

prev代表前一个对象，self代表自身。线程先持有前一个对象的锁和本次要打印的对象的锁，执行打印，然后唤醒一个正在等待当前对象锁的线程（剩下的那个线程），并让它拿到对象锁。prev.wait()方法让本线程进入等待状态，让本线程休眠，线程自动释放其占有的对象锁，并等待notify。如此循环反复打印8次ABC。

总结一下####

1. 当多个线程访问同一对象的时候，只能有一个线程取得对象的锁，多个对象需要多个对象的锁。
2. 这里锁住的是当前对象，并不是方法。哪个线程执行了带synchronized关键字的方法，哪个线程就持有该方法所属对象的锁，其他的线程要访问这个对象锁内的内容，都只能等待这个锁被释放后，再去抢占资源获得对象的锁。
3. synchronized修饰非static的方法时，锁的就是对象本身，也就是this。
4. synchronized修饰static的方法时，方法中无法使用this，所以它锁的不是this，而是这个类。所以，static synchronized方法也相当于全局锁。
5. 使用synchronized关键字，应尽量缩小代码块的范围，最好能在代码块上加同步，而不是在整个方法上加同步。因为你锁的范围大的话，时间又长，别的线程就不会获得相应的资源。
6. A线程持有对象的锁，B线程可以以异步方式调用对象中的非synchronized同步的方法。

写完喽！ㄟ(▔,▔)ㄏㄟ(▔,▔)ㄏㄟ(▔,▔)ㄏ
纸上得来终觉浅，绝知此事要躬行。——陆游
问渠那得清如许，为有源头活水来。——朱嘉

---

欢迎转载，转载请注明出处！
如果有错误的地方，或者有您的见解，还请不啬赐教！
喜欢的话，麻烦点个赞！