JUC中LOCK接口

使用LOCK前先回顾Synchronized(同步)关键字,这是一个重锁不建议使用.

#使用Synchronized修饰方法或者变量时只允许一个线程访问
package com.example.demo.thread;
/**
 * 高内聚低耦合
 * 线程  操作  资源类
 * 直接使用lamda表达式实习线程得创建口诀是
 * 复制小括号  写死右箭头  落地大括号
 */
class SaleTitcket{
    private int number = 30;
    public synchronized void sale(){
        if (number > 0){
            System.out.println(Thread.currentThread().getName()+"卖出第:"+(number--)+"剩余"+number);
        }
    }
}

public class TestDemo {
    public static void main(String[] args) {
        SaleTitcket saleTitcket = new SaleTitcket();
        new Thread(()->{for (int i = 0;i < 40;i++) saleTitcket.sale();},"A").start();
        new Thread(()->{for (int i = 0;i < 40;i++) saleTitcket.sale();},"B").start();
        new Thread(()->{for (int i = 0;i < 40;i++) saleTitcket.sale();},"C").start();
    }
}

运行结果:

image.png

从上面结果可以看出使用Synchronized修饰方法时只允许一个线程访问方法.
使用完Synchronized同步锁后我们再来使用LOCK接口看看两者区别
上代码

package com.example.demo.thread;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * 高内聚低耦合
 * 线程  操作  资源类
 * 直接使用lamda表达式实习线程得创建口诀是
 * 复制小括号  写死右箭头  落地大括号
 */
class SaleTitcket{
    private int number = 30;
    private Lock lock = new ReentrantLock();
    public  void sale(){
        lock.lock();
        try {
            if (number > 0){
                System.out.println(Thread.currentThread().getName()+"卖出第:"+(number--)+"剩余"+number);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

public class TestDemo {
    public static void main(String[] args) {
        SaleTitcket saleTitcket = new SaleTitcket();
        new Thread(()->{for (int i = 0;i < 40;i++) saleTitcket.sale();},"A").start();
        new Thread(()->{for (int i = 0;i < 40;i++) saleTitcket.sale();},"B").start();
        new Thread(()->{for (int i = 0;i < 40;i++) saleTitcket.sale();},"C").start();
    }
}
synchronized与Lock的区别 
 
两者区别：
1.首先synchronized是java内置关键字，在jvm层面，Lock是个java类；
2.synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁；

运行结果:

image.png

上述代码使用了lamda表达式就随便复习java8的lamda表达式
Lambda 是一个匿名函数，我们可以把 Lambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更
灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。

Lambda 表达式在Java 语言中引入了一个新的语法元素和操作符。这个操作符为 “->” ， 该操作符被称为 Lambda 操作符或剪头操作符。它将 Lambda 分为
两个部分：
左侧：指定了 Lambda 表达式需要的所有参数
右侧：指定了 Lambda 体，即 Lambda 表达式要执行的功能

lambda表达式，必须是函数式接口，必须只有一个方法如果接口只有一个方法java默认它为函数式接口。为了正确使用Lambda表达式，需要给接口加个注解@FunctionalInterface
如有两个方法，立刻报错
Runnable接口为什么可以用lambda表达式？

image.png

接口是否可以有实现类?

#从以下代码可以看出接口中可以有多个默认和静态方法实现.
package com.example.demo.thread;

@FunctionalInterface
interface Foo{
 
// public void sayHello() ;
// public void say886() ;
 
 public int add(int x,int y);
 
 default int div(int x,int y) {
   return x/y;
 }
 
 public static int sub(int x,int y) {
   return x-y;
 }
}
 
 
 
/**
 * 
 * @Description: Lambda Express-----> 函数式编程
 * 1 拷贝小括号(形参列表)，写死右箭头 ->，落地大括号 {方法实现}
 * 2 有且只有一个public方法@FunctionalInterface注解增强定义
 * 3 default方法默认实现
 * 4 静态方法实现
 */
public class LambdaDemo
{
 public static void main(String[] args)
 {
//  Foo foo = new Foo() {
//   @Override
//   public void sayHello() {
//     System.out.println("Hello!!");
//   }
//
//   @Override
//   public void say886() {
//     // TODO Auto-generated method stub
//     
//   }
//  };
//  foo.sayHello();
//  System.out.println("============");
//  foo = ()->{System.out.println("Hello!! lambda !!");};
//  foo.sayHello();
 
 Foo foo = (x,y)->{
   System.out.println("Hello!! lambda !!");
   return x+y;
   };
   
   int result = foo.add(3,5);
   System.out.println("******result="+result);
   System.out.println("******result div="+foo.div(10, 2));
   System.out.println("******result sub="+Foo.sub(10, 2));
   
 }
}