线程同步。

线程同步

1、并发

要了解线程同步，就先要了解一下什么是并发。

并发就是多个线程同时操作一个对象或资源。而线程同步就是为了解决并发带来的一些问题。

2、线程同步

那什么是线程同步呢？

线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程才能使用。

为了实现线程同步的机制，就需要队列和锁。

当多个线程共享一个资源时，为了保证数据在被访问时候的正确性，需要线程在访问时加入锁机制（synchronized），当一个线程获得对象的排他锁，独占资源，其他线程必须等待，只有该线程使用完之后释放锁，其他线程才可以访问。

3、同步方法的实现

首先通过private关键字是数据只能被方法访问，那么我们只需要对方法提出一套机制，就可以实现同步。这个机制就是synchronized的关键字，它包括两种用法：

1、synchronized方法

使用synchronized方法时，必须要获取该对象的锁，当一个线程拿到该对象的锁，那么其他线程就无法访问该对象的synchronized方法，实现了同步。

代码示例：

模拟买票业务

public class BuyTicket implements Runnable{

    //票
    private int ticketNums = 100;

    boolean flag = true;//外部停止标志位

    @Override
    public void run() {
        //买票
        while (flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private synchronized void buy() throws InterruptedException {
        //判断是否有票
        if (ticketNums <= 0){
            flag = false;
            return;
        }
        //模拟延时
        Thread.sleep(100);
        //买票
        System.out.println(Thread.currentThread().getName() + "拿到第" + ticketNums-- + "张票~");
    }

}

在上例代码中，通过给buy()方法加上关键字synchronized，实现线程同步。

注意：synchronized锁的是this，也就是BuyTicket的对象。

2、synchronized块

同步块：synchronized (Obj){ }

Obj称为同步监视器

• Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
• 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是对象本身

模拟银行取款业务

//账户
class Account{
    private int money;//余额
    private String name;//卡名

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

//银行：模拟取款
class Drawing extends Thread{
    //账户
    private Account account;
    //取的金额
    private int drawingMoney;

    public Drawing(Account account,int drawingMoney,String name){
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    @Override
    public void run() {

        synchronized (account){
            //判断是否有钱
            if (account.getMoney() - drawingMoney < 0){
                System.out.println("账户余额不足~");
                return;
            }

            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            //卡内余额
            account.setMoney(account.getMoney() - drawingMoney);

            System.out.println(Thread.currentThread().getName() + "取了" + drawingMoney + "元" + account.getName() + "余额为： " + account.getMoney());
        }

    }
}

上述代码，由于取款的类与账户类是分开的，由于synchronized锁的是this，那么就不能直接通过给方法加上synchronized关键字来实现同步，这时就需要synchronized块并且传入account对象作为同步监视器来实现同步。

3、Lock块

在JDK5开始，Java提供了一个更强大的线程同步机制——通过显式定义同步锁对象来实现同步，同步锁由Lock对象充当。

ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁，释放锁。

代码示例：

public class Ticket implements Runnable{

    int ticketNum = 10;

    //定义lock锁
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        try {
            buy();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void buy() throws InterruptedException {

        lock.lock();
        try {
            while (true){
                if (ticketNum <= 0){
                    return;
                }

                Thread.sleep(100);

                System.out.println(ticketNum--);
            }
        }finally {
            lock.unlock();
        }

    }
}

synchronized和lock对比

• Lock是显式锁（手动开启和关闭锁），synchronized是隐式锁，出了作用域自动释放
• Lock只有代码块锁，synchronized有代码块锁和方法锁
• 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）

优先使用顺序：

Lock > 同步代码块 （已经进入了方法体，分配了相应资源）> 同步方法 （在方法体之外）

4、锁机制存在的问题

锁的机制虽然可以实现线程同步，但仍存在以下几个问题：

• 一个线程持有锁会导致其他所有需要此锁的线程挂起；
• 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题；
• 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题；