JUC之Lock接口

synchronized:

一、synchronized介绍：

synchronized是Java语言的关键字，可用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这段代码。

当两个并发线程访问同一个对象object中的这个加锁同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。然而，当一个线程访问object的一个加锁代码块时，另一个线程仍可以访问该object中的非加锁代码块。

synchronized实现原理：
Java中每一个对象都可以作为锁，这是synchronized实现同步的基础：

普通同步方法，锁是当前实例对象
静态同步方法，锁是当前类的class对象
同步方法块，锁是括号里面的对象
当一个线程访问同步代码块时，它首先是需要得到锁，当退出或者抛出异常时必须要释放锁

二、synchronized代码：

synchronized卖票的代码：

package com.fan.sync;
//第一步，创建资源类，定义属性和操作方法
class Ticket{
    //属性：公共资源
    private int number = 30;
    //操作方法
     synchronized void sale(){
        //判断：是否有票
        if(number > 0){
            System.out.println(Thread.currentThread().getName()+
                    ":卖出："+(number--)+"剩下："+number );
        }
    }
}
//主启动类，主线程类
public class SaleTicket {
    //创建多个线程，调用资源类的操作方法
    public static void main(String[] args) {
        //创建Ticket对象
        Ticket ticket = new Ticket();
        //创建三个线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                //调用要线程干的事情：卖票
                for (int i = 0; i < 40; i++) {//循环调用
                    ticket.sale();
                }
            }
        }, "aa").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                //调用要线程干的事情：卖票
                for (int i = 0; i < 40; i++) {//循环调用
                    ticket.sale();
                }
            }
        }, "bb").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                //调用要线程干的事情：卖票
                for (int i = 0; i < 40; i++) {//循环调用
                    ticket.sale();
                }
            }
        }, "cc").start();
    }
}

说明:sync的上锁和解锁是自动完成的，而lock是可以手动上锁和解锁

Lock：

一、 Lock介绍：

二、lock和synchronized的区别:

区别如下：

1. 来源：
   lock是一个接口，而synchronized是java的一个关键字，synchronized是内置的语言实现；

2. 异常是否释放锁：
   synchronized在发生异常时候会自动释放占有的锁，因此不会出现死锁；而lock发生异常时候，不会主动释放占有的锁，必须手动unlock来释放锁，可能引起死锁的发生。（所以最好将同步代码块用try catch包起来，finally中写入unlock，避免死锁的发生。）

3. 是否响应中断
   lock等待锁过程中可以用interrupt来中断等待，而synchronized只能等待锁的释放，不能响应中断；

4. 是否知道获取锁
   Lock可以通过trylock来知道有没有获取锁，而synchronized不能；

5. Lock可以提高多个线程进行读操作的效率。（可以通过readwritelock实现读写分离）

6. 在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。所以说，在具体使用时要根据适当情况选择。

7. synchronized使用Object对象本身的wait 、notify、notifyAll调度机制，而Lock可以使用Condition进行线程之间的调度

Lock和synchronized的选择:

总结来说，Lock和synchronized有以下几点不同：

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

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

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

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

5）Lock可以提高多个线程进行读操作的效率。

在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。所以说，在具体使用时要根据适当情况选择。
　　
　　lock示例代码：

start方法源码解析：
start()之后的代码的核心就是其中调用的start0()方法，下面看看start0()的定义：
private native void start0();
很明显这是一个只声明而未实现的方法，native表示调用本机的原⽣操作系统函数，native 方法往往意味着这个方法无法使用平台无关的手段来实现。所以，还是那句话，实际上线程的实现与 Java 无关，由平台所决定，Java 所做的是将 Thread 对象映射到操作系统所提供的线程上面去，对外提供统一的操作接口，向程序员隐藏了底层的细节，使程序员感觉在哪个平台上编写的有关于线程的代码都是一样的。这也是 Java 这门语言诞生之初的核心思想，一处编译，到处运行，只面向虚拟机，实现所谓的平台无关性，而这个平台无关性就是由虚拟机为我们提供的。

总结一下：
   1、start()方法的具体流程：start（判断当前线程是不是首次创建，Java方法）->调用start0()方法（JVM）->通过JVM进行资源调度，系统分配->回调run()方法（Java方法）执行线程的具体操作任务。
   2、由于start()方法调用了JVM进行系统调度、系统分配等一系列操作，因此创建一个线程只能由start()来完成，而若直接调用run()方法，相当于是在调用一个普通方法。

使用可重（chong）入锁实现卖票：

可重入锁：

• 可重入就是说某个线程已经获得某个锁，可以再次获取锁而不会出现死锁。

• 广义上的可重入锁指的是可重复可递归调用的锁，在外层使用锁之后，在内层仍然可以使用，并且不发生死锁（前提得是同一个对象或者class），这样的锁就叫做可重入锁。ReentrantLock和synchronized都是可重入锁。

• 可重入锁示例(同一个线程可以重入上锁的代码段，不同的线程则需要进行阻塞)
  java的可重入锁有:ReentrantLock（显式的可重入锁）、synchronized（隐式的可重入锁）

可重入锁诞生的目的就是防止上面不可重入锁的那种情况，导致同一个线程不可重入上锁代码段。

目的就是让同一个线程可以重新进入上锁代码段。

三、Lock代码：

卖票代码：

package com.fan.lock;
import java.util.concurrent.locks.ReentrantLock;
//多线程编程第一步：资源类，定义属性和操作方法
class  LTicket{
    //票数量
    private int number = 30;
    //创建可重入锁对象，final定义的对象不能再重新指向其他对象了
    private final ReentrantLock lock =new ReentrantLock();
    //卖票的方法
    public void sale(){
        //上锁
        lock.lock();
        try {
            //判断是否有票
            if(number > 0){
                System.out.println(Thread.currentThread().getName()+
                        "-卖出:"+(number-- )+"剩余："+number);
            }
        }finally {
            lock.unlock();//解锁
        }
    }
}
public class LSaleTicket {
    //多线程第二步：创建多个线程，调用资源类的操作方法
    public static void main(String[] args) {
        //在主线程内，创建三个子线程
        LTicket lTicket = new LTicket();//创建同一个资源对象
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 40; i++) {
                    lTicket.sale();//调用资源类的卖票方法
                }
            }
        }, "aa").start();
        //
        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                lTicket.sale();//调用资源类的卖票方法
            }
        },"bb").start();
        //
        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                lTicket.sale();
            }
        },"cc").start();
    }
}