1.synchronized关键词

a.synchronized关键字修饰方法

由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。

  public synchronized void demo(){
    ......
  }

b.synchronized关键字修饰静态方法

此时如果调用该静态方法，将会锁住整个类

c.synchronized关键字修饰语句块

被修饰的语句块会自动被加上内置锁实现同步

  synchronized(object){
    ......
  }

  lock.lock();
    try {
      System.out.println("已锁住");
      for (int i = 0; i < 10; i++) { // 放大代码块执行完成的时间，便于观察
      System.out.println(i);
      try {
        System.out.println(Thread.currentThread().getName() + "休眠5秒!");
        Thread.sleep(5000);// 放大代码块执行完成的时间，便于观察
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  } finally {
    lock.unlock();
    System.out.println("解锁");
  }

当公共资源被占用时，其它线程必须等待资源被释放后才能执行，这种场景适用于对数据库的操作，保证其数据的原子性。

2.Semaphore并发包

Semaphore是基于计数的信号量，它可以设定一个资源的总数量，基于这个总数量，多线程竞争获取许可信号，做自己的申请后归还，超过总数量后，线程申请许可，信号将会被阻塞。等到有资源时，继续执行。

下面在springboot中实现：

 @Contorller
 public class Controller(){
 Semaphore semaphore=new Semaphore(1);  //定义资源的总数量
    @GetMapping("/userInfo/request")
    @ResponseBody
    public String Resquest(){
        int availablePermits=semaphore.availablePermits();//可用资源数
        if(availablePermits>0){
            System.out.println("抢到资源");
        }else{
            System.out.println("资源已被占用，稍后再试");
            return "Resource is busy！";
        }
        try {
            semaphore.acquire(1);  //请求占用一个资源
            System.out.println("资源正在被使用");
            Thread.sleep(30000);//放大资源占用时间，便于观察
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally{
            semaphore.release(1);//释放一个资源
        }
        return "Success";
    }
 }

当有多个线程同时请求资源时，效果如下：
先获得资源的线程会在30秒之后显示success，后面请求的线程会直接返回