Synchronized和Lock

Synchronized

synchronized 是 Java 中的关键字，是一种同步锁。它修饰的对象有以下几种：

1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；

2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；

3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；

4. 修改一个类，其作用的范围是 synchronized 后面括号括起来的部分，作用主的对象是这个类的所有对象。

案例

//1.创建资源类
class Ticket{
    private int number = 10;
    public synchronized void sale(){
        if (number>0) System.out.println("当前票数为："+number+"----"+Thread.currentThread().getName()+"卖出一张票，剩余票数为："+(--number));
    }
}
public class SaleTicket {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        //创建两个个线程
        new Thread(()->{
            for (int i=0;i<=30;i++)
                ticket.sale();
        },"线程一").start();

        new Thread(()->{
            for (int i=0;i<=30;i++)
                ticket.sale();
        },"线程二").start();
    }
}

Lock锁

Lock 锁实现提供了比使用同步方法和语句可以获得的更广泛的锁操作。它们允许更灵活的结构，可能具有非常不同的属性，并且可能支持多个关联的条件对象。Lock 提供了比 synchronized 更多的功能

Lock 与的 Synchronized 区别

1. Lock 不是 Java 语言内置的，synchronized 是 Java 语言的关键字，因此是内置特性。Lock 是一个类，通过这个类可以实现同步访问；

2. Lock 和 synchronized 有一点非常大的不同，采用 synchronized 不需要用户去手动释放锁，当 synchronized 方法或者 synchronized 代码块执行完之后，系统会自动让线程释放对锁的占用；而 Lock 则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。

案例

//1.创建资源类，定义属性和操作方法
class LTicket{
    //票数
    private int number = 30;
    //创建可重入锁
    private final ReentrantLock lock = new ReentrantLock();
    //卖票方法
    public void sale(){
        //上锁
        lock.lock();
        try {
            if (number>0) System.out.println("现票总数为"+number+","+Thread.currentThread().getName()+"卖出一张票,剩余票数："+(--number));
        }finally {
            //解锁
            lock.unlock();
        }
    }
}
public class LSaleTicket {
    public static void main(String[] args) {
        LTicket lTicket = new LTicket();
        //2.创建两个个线程调用资源类的方法
        new Thread(()->{
            for (int i=0;i<40;i++)
                lTicket.sale();
        },"线程一：").start();

        new Thread(()->{
            for (int i=0;i<40;i++)
                lTicket.sale();
        },"线程二：").start();

    }
}

总结

Lock 和 synchronized 有以下几点不同：

1. Lock 是一个接口，而 synchronized 是 Java 中的关键字，synchronized 是内置的语言实现；

2. synchronized 在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而 Lock 在发生异常时，如果没有主动通过 unLock()去释放锁，则很可能造成死锁现象，因此使用 Lock 时需要在 finally 块中释放锁；

3. Lock 可以让等待锁的线程响应中断，而 synchronized 却不行，使用synchronized 时，等待的线程会一直等待下去，不能够响应中断；

4. 通过 Lock 可以知道有没有成功获取锁，而 synchronized 却无法办到。

5. Lock 可以提高多个线程进行读操作的效率。在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时 Lock 的性能要远远优于synchronized。