线程的同步——Synchronized和ReentrantLock

多线程访问产生的临界资源问题

有多个线程在同时访问一个资源，如果一个线程在取值的过程中，时间片又被其他线程抢走了，临界资源问题就产生了。

比如在《多线程——基础使用》中的存钱和取钱的案例，当存钱加和操作执行完毕，还没有执行打印操作的时候，取钱线程进入，并将钱取走，先一步打印，这样的输出结果就会有问题：余额为0，但是取走了1000。

解决方案：一个线程在访问临界资源的时候，给这个资源“上一把锁”，这个时候如果其他线程也要访问这个资源，就得在“锁”外面等待，直到该线程执行完毕，释放锁。

同步代码块

同步：Synchronized：有等待
异步：Asynchronized：没有等待，各执行各的

/**
* 注意事项：
* 1.程序走到代码段中，就用锁来锁住了临界资源，这个时候，其他线程不能执行代码段中的代码，只能在锁外边等待
* 2.执行完代码段中的这段代码，会自动解锁。然后剩下的其他线程开始争抢cpu时间片
* 3.一定要保证不同的线程看到的是同一把锁，否则同步代码块没有意义，也就是说mutex的值必须是唯一的，不能new对象，一般使用字符串或者 对象.Class()方法
* 4.使用同步代码块，必须是真正意义上存在的线程直接抢占系统共享资源，而且同步的代码越少越好，提高效率
* 5.避免死锁情况发生
*  
* 死锁发生的条件：
* 1.有两个以上线程抢占资源
* 2.至少有两个锁
* 3.锁同步中嵌套锁同步
*/
synchronized(mutex) {
	//需要加锁的代码块，不要将循环放入，否则会出现一个线程一直循环占用资源而不释放锁
}

//案例
class Tickets implements Runnable {
    private static int tickets = 100;
    private int flag = 0;

    @Override
    public void run() {
        while (true) {
            synchronized ("lock") {
                if (tickets > 0) {
                    System.out.println(Thread.currentThread().getName() +
                            "已经卖出了" + ++flag + "张票, " + "还剩余" + (tickets - 1) + "张票");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    tickets--;

                } else {
                    System.out.println("售罄");
                    break;
                }
            }
        }
    }
}

同步方法

将一个方法使用synchronized修饰，然后由线程直接调用该方法，一般分为非静态同步方法和静态同步方法。

非静态同步方法，由于是new的对象调用的，意味着不同的对象调用的锁不一样，所以使用线程调用的时候，注意对象地址的统一。

静态同步方法可以避免“不同锁”的情况。

public class Demo2 {
    private static int tickets = 100;
    //静态同步方法
    public static synchronized void saleTickets() throws InterruptedException {
        if (tickets == 0) {
            System.out.println("售罄");
        } else {
            System.out.println(Thread.currentThread().getName() +
             "售出后,剩余" + (tickets - 1) + "张票");
            tickets--;
            Thread.sleep(100);
        }
    }
	
	//主方法，使用了匿名内部类调用静态方法
    public static void main(String[] args) {
        new Thread(() -> {
            while (tickets > 0) {
                try {
                	//调用同步方法
                    saleTickets();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "糯米").start();
        new Thread(() -> {
            while (tickets > 0) {
                try {
                    saleTickets();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "美团").start();
    }
}

ReentrantLock类(可重入锁)

从jdk1.5之后加入新的接口 Lock，ReentrantLock是Lock接口的实现类。

通过显式定义同步锁对象来实现同步,同步锁提供了比synchronized代码块更广泛的锁定操作，使用ReentrantLock可以显式地加锁、释放锁。

注意：锁后使用try-finally结构，unlock的操作放到finally中，注意对象地址的一致性

//主方法
public class Demo1 {
    public static void main(String[] args) {
    	//不建议使用匿名内部类，每次都是新建Tickets对象，如果锁没有static final修饰，会出现不同锁问题
        new Thread(new Tickets(), "猫眼").start();
        new Thread(new Tickets(), "淘票票").start();
        new Thread(new Tickets(), "糯米").start();
        new Thread(new Tickets(), "百度").start();
    }
}

//继承Runnable的票类
class Tickets implements Runnable {
    private static int tickets = 100;
    private int flag = 0;

    //定义锁的对象,由于对象地址的不确定性，可能导致new不同对象，锁不同，所以这里使用static final修饰
    private static final Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            //上锁
            lock.lock();

            try {
                if (tickets > 0) {
                    System.out.println(Thread.currentThread().getName() +
                            "已经卖出了" + ++flag + "张票, " + "还剩余" 
                            + (tickets - 1) + "张票");
                    tickets--;
                } else {
                    System.out.println("售罄");
                    break;
                }
            } finally {

                //手动解锁
                lock.unlock();
            }
        }
    }
}