008.多线程-synchronized锁

为了解决线程安全问题，
我们的做法是：不要让多个线程同时对一个全局变量作写的操作。

常用的做法就是加锁，来实现线程的同步。
自动锁synchronized和手动锁lock。
由于synchronized不需要手动释放锁，抛出异常也可自动释放锁。
后面将会介绍lock锁。

一个线程拿到锁后，其他线程则只能排队，等待锁的释放。
代码执行完毕或者程序抛出异常，锁均会被释放。

---

synchronized 代码块

    /**
     * 相当于同步函数
     */
    public void test1_() {
        synchronized (this) {
            for (int i = 1; i < 500; i++) {
                System.out.println("test1_..." + i);
            }
        }
    }

    /**
     * 相当于静态同步函数
     */
    public void test1s_() {
        synchronized (Test.class) {
            for (int i = 1; i < 500; i++) {
                System.out.println("test1s_..." + i);
            }
        }
    }

---

	synchronized(lock-object){
	}

括号后面要跟一个对象，
这个对象充当锁的作用。
Java中，全部都是对象，不相同的常量字符串也是不同的对象。

---

同步函数： (实例对象锁)

在方法上修饰synchronized

    public synchronized void test1() {
        for (int i = 1; i < 500; i++) {
            System.out.println("test1..." + i);
        }
    }

---

静态同步函数： (类对象锁)
方法上加上static关键字，使用synchronized 关键字修饰
或者使用 类.class 文件。

    public static synchronized void test1s() {
        for (int i = 1; i < 500; i++) {
            System.out.println("test1..." + i);
        }
    }

    public void test1s_() {
        synchronized (Test.class) {
            for (int i = 1; i < 500; i++) {
                System.out.println("test1s_..." + i);
            }
        }
    }

---

若类对象被锁，则类对象的所有同步方法全部被锁。
若实例对象被锁，则该实例对象的所有同步方法全部被锁。
不是同一个对象，实例对象锁没有约束。

---

synchronized代码块的优势：

1. 只对需要同步的代码进行同步
2. 与wait() 、notify() 、notifyAll() 一起使用时，比较方便

package cn.qbz.thread;

public class WaitNotifyTest {


    public static void main(String[] args) {
        new Thread(new Produce()).start();
        new Thread(new Consumer()).start();
    }
}

class Produce implements Runnable {

    public void run() {
        int count = 5;
        while (count > 0) {
            synchronized ("lock-object") { //此处可以锁定任何对象，只要锁定Produce和Consumer中的对象一样
                System.out.println("A");
                count--;
                "lock-object".notify();// 唤醒因为调用对象的wait()而等待的线程

                if (count > 0) {
                    try {
                        "lock-object".wait();//释放本线程的对象锁，释放CPU
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

    }

}

class Consumer implements Runnable {

    public void run() {
        int count = 5;
        while (count > 0) {
            synchronized ("lock-object") {

                System.out.println("B");
                count--;
                "lock-object".notify(); // 唤醒因为调用对象的wait()而等待的线程

                if (count > 0) {
                    try {
                        "lock-object".wait(); //释放本线程的对象锁，释放CPU
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

---

wait():
释放占有的对象锁，线程进入等待池，释放cpu。
其他正在等待的线程即可抢占此锁，获得锁的线程即可运行程序。
sleep():
线程休眠，休眠期间，释放cpu，但不释放占有的对象锁。
即：休眠期间，其他线程依然无法进入此同步代码块内。
notify():
唤醒因为调用对象的wait()而等待的线程。
调用notify()后，并不会立即释放锁，
而是直到synchronized代码块中全部执行完毕，才释放锁。
JVM会在等待的线程中调度一个线程去获得此锁，执行代码。
notifyAll()
唤醒所有等待的线程。

---

notify与notifyAll
锁池：
假设线程A已经拥有了某个对象锁（非类锁），
此时想获取此对象锁的其他线程，将进入此对象的锁池中，
参与下次锁的竞争。
等待池：
假设线程A调用了对象锁的wait()方法，
线程A会释放该对象锁，并进入此对象的等待池中。
等待池中的线程不会参与对象锁的竞争。
notify调用后，只会将等待池中的一个随机线程移到锁池中。
notifyAll调用后，会将全部线程移到锁池中。

notify有一定几率造成死锁。