java 代码锁和数据库锁 java锁的区别

转载

level 2024-02-02 20:24:20

文章标签 java 代码锁和数据库锁 System java 数据 文章分类 Java 后端开发

Day 26开篇：

"今天java基础主要学习了线程通信，Lambda表达式，Stream等"

知识点反馈：

今天的知识点总结的思维导图

java 代码锁和数据库锁 java锁的区别_System

一．线程通信

1. Lock锁、synchronized的对比

（1）Lock是一个显示锁(锁开跟锁关都需要手动进行操作，别忘记了释放锁资源)

（2）synchronized是一个隐式锁，完全靠作用域操作，不需要手动管理

（3）Lock只有代码块锁，synchronized既有代码块也有方法锁

（4）Lock的性能比较好，Jvm只需要花比较少的时间来调用代码，而且扩展性也比较强(Lock是一个接口，接口可以多实现)

如果是简单的同步代码块，可以优先考虑Lock，如果是同步方法只能使用synchronized但是在实际的开发当中，synchronized的使用场景还是比Lock高，因为Lock是一个新特性。

2.一个类似的案例(你们熟悉的学生对象)

资源:学生对象Student

获取线程:GetStudent

设置线程:SetStudent

案例产生问题:

（1）每次获取的数据都是null---0---/u00000

原因:是因为获取和设置两个线程分别使用了不同的Student对象

解决:创建一个Student的栈空间，不进行赋值，交给构造器要求调用者进行赋值堆空间

（2）数据获取的不完整，甚至造成了数据错乱

原因:因为有可能设置线程并没有抢到执行权，所有获取线程就拿不到数据，也有可能设置或者获取线程执行过程当中，相互抢夺了，所以造成数据错乱

解决:给两个线程，都加上synchronize同步锁，至少可以保证两个线程在执行过程当中不会被打断，从而造成数据错乱的问题

为了保证数据的真实准确，我们加入死循环不断生产和消费数据(事实证明，数据错乱的问题，已经解决好了)

（3）读到的数据仍然可能是null---0---/u0000

原因:设置线程并没有从第一次就抢到执行权，所有获取线程拿到的就是空数据

3.何谓线程通信?

（1）其实就是两个线程之间，产生一个互相连接通知的过程。

（2）void wait():使当前线程挂起并放弃CPU的执行权，同步资源并等待，使其他线程可以访问并修改共享资源，wait一旦被执行必须调用

（3）notify或者notifyAll进行唤醒，唤醒后在就绪位置重新进行CPU的抢夺。

（4）notify():唤醒正在排队(阻塞状态)等待同步资源线程中优先级别最高的线程进行操作。

（5）notifyAll():唤醒所有正在排队(阻塞状态)等待同步线程的资源

（6）为什么wait/notify不是在Thread里面,反而跑到Object里面?

wait/notify进行操作的前提一定是基于一个同步监视器(对象锁)来完成。而对象锁又可以是任何的锁对象(任意类都没问题),所有的类都是Object的子类，所以放到Object里面避免类型接收和转换的问题。

（7）notify:是唤醒线程，只不过是把线程从一个阻塞状态调整为就绪状态，所以不保证一定执行，只能有抢夺执行权的机会。

这个案例的整个编码的过程，其实就是一个非常经典的生产者和消费者设计模式。

例子：

public class Demo {
    public static void main(String[] args) {
        //保证get和set两个线程获取的是同一个资源
        Student s = new Student();
        GetStundet gs = new GetStundet(s);
        SetStudent ss = new SetStudent(s);
        //创建设置Thread
        Thread t1 = new Thread(ss);
        //创建获取Thread
        Thread t2 = new Thread(gs);
        t2.start();
        t1.start();
    }
}

二.Lambda表达式

1.JDK8的介绍:

（1） java 8,是java语言再1.5版本之后更新最大的一个版本。是2014年3年发布可以看做是能够和java5并肩的一个重量级版本

（2）特性:

速度更快

代码更少(新增的新的语法:Lambda表达式)

非常的强大的StreamAPI

最大的减少了空指针异常的操作:Optional(谷歌写着玩)

Nashorm引擎，运行JVM当中操作JavaScrpit代码

2. 为什么要去使用Lambda表达式?

Lambda其实本质上就是一个匿名函数，可以将Lambda表达式理解成一个一段可以进行执行传递的代码，他可以写出更加简洁，更加灵活的代码，是一个非常紧凑型的代码分割。

3.Lambda的格式解释:

() -> {
            System.out.println("我是一个Lambda");
         };

（1） ->:lambda的操作符号(箭头操作符)

（2）左边数据:lambda的形参列表(其实就你重新接口那个抽象方法的形参列表)

（3）右边数据:lambda的方法体(其实就是你重写那个接口具体方法体)

4. lambda只能用于接口?

是的，而且只能用于函数式接口(整个接口当中只存一个抽象方法)

5.lambda是怎么找到这方法?

因为只能用于存在一个抽象方法的接口，所以完全采用了自动推断机制进行推断

6.lambda的具体使用（看下面例子代码）

7.关于省略的问题:

（1）左边:所有的形参的数据类型可以直接省略，实行自动推断。如果形参列表只有一个的时候，甚至连括号都可以直接省略掉

（2）右边:当语句体里面值存在一句代码的时候，可以省略大括号，甚至可以连return省略掉

8.啥时候用它呢?

凡是可以使用内部类实现的，都可以使用lambda表达式(这个接口有且只有一个抽象)

例子：

package lambda;
import java.util.Comparator;
import java.util.function.Consumer;
 
public class LambdaTest02 {
    public static void main(String[] args) {
        //test01();
        //test02();
        //test03();
        //test04();
        //当你的lambda表达式，语句体里面只存在一句代码的时候，可以将大括号、return都直接省略
        Comparator<Integer> com = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1+o2;
            }
        };
        System.out.println(com.compare(2,1));
        System.out.println("--------------");
        Comparator<Integer> com2 = (o1,o2) -> o1+o2;
        System.out.println(com2.compare(2,1));
    }
 
    public static void test04() {
        Comparator<Integer> com = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1+o2;
            }
        };
        System.out.println(com.compare(2,1));
        System.out.println("--------------");
        Comparator<Integer> com2 = (o1,o2) -> {
            System.out.println(o1);
            System.out.println(o2);
          return o1+o2;
        };
        System.out.println(com2.compare(2,1));
    }
 
    public static void test03() {
        //语法格式三:使用Lambda的时候，所有的参数列表的数据类型可以省略，因为完全实现自动推断
        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("这个世界上最美的女人");
        System.out.println("---------------");
        //Consumer con1 = (s) -> System.out.println(s);
        //当你的形参只有一个的时候，连形参括号都可以直接省略
        Consumer con1 = s -> System.out.println(s);
        con1.accept("小花");
    }
 
    public static void test02() {
        //语法格式二:一个形式参数，没有返回值
        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("这个世界上最美的女人");
        System.out.println("---------------");
        Consumer<String> con1 = (String s) -> {
            System.out.println(s);
        };
        con1.accept("小花");
    }
 
    public static void test01() {
        //语法格式一:方法无参也无返回值
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("我是一个内部类");
            }
        };
        r1.run();
        System.out.println("---------------");
        Runnable r2 = () -> {
            System.out.println("我是一个Lambda");
        };
        r2.run();
    }
}

9. 方法引用:

（1）使用场景:当要传递给Lambda体的操作，已经有实现的方法，就可以使用方法引用。

（2）具体介绍:本质上就是Lambda表达式，而Lambda表达式作为函数式接口的实例，所以方法引用就是函数数接口实例。一样。

（3）格式:

类(具体对象) :: 方法名(必须是成立的)

例子：

import java.io.PrintStream;
import java.util.function.Consumer;
import java.util.function.Supplier;
 
public class MethodRef {
    public static void main(String[] args) {
        //test01();
        Student s = new Student("toobug", 19);
        Supplier<String> sup = () -> s.getName();
        System.out.println(sup.get());
        System.out.println("-------------");
        Supplier<String> sup1 = s::getName;
        System.out.println(sup1.get());
    }
 
    public static void test01() {
        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("TOOBUG");
        System.out.println("-----------------");
        Consumer<String> con1 = (String str) -> System.out.println(str);
        con1.accept("TOOBUG");
        System.out.println("-----------------");
 
        PrintStream ps = System.out;
        Consumer<String> con2 = ps::println;//自动推断
        con2.accept("toobug");
    }
}

三.Stream

1.Java8有两大重点特性:Lambda和StreamAPI

2.StreamAPI:是真正将一个函数式编程的风格引入到Java当中的一种技术，可以让程序员写出更加高效、干净简洁的代码

3.Stream是Java8当中处理集合的关键抽象概念，可以对你指定的集合进程非常负载的操作,比如集合的查找、过滤、映射数据等操作，使用Stream可以对复杂数据进行操作，就有点类似于SQL执行数据操作一样。

4.Stream和Collection集合的区别是什么?

(1)Collection是一种静态的内存数据结构。

(2) Stream是一个面向CPU的计算结构。

5.Stream特点:

(1)Stream本身不会存储数据(数据从集合过来，和迭代器一样)

Stream本身并不会改变源数据，但是他会返回一个持有将结果的新的Stream对象

(3)Stream是延时的,只有在你关闭的时候才会同一返回数据(类似缓冲流)

6.Stream创建的四个步骤:

(1)准备一个数据源(可以是集合,也可以是数组)

(2)获取一个流

(3)自己进行中间操作链(其实就是对集合进行处理的一大堆步骤)

(4)终止操作

7.问题:获取流

java8当中，其实对Collection的接口进行一个扩展，这个扩展提供了两个流的获取方法:(1)顺序流:default Stream<E> stream;

(2)并行流:default Stream<E> parallelStream;

例子：

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.stream.Stream;
 
public class StreamAPIDemo {
    public static void main(String[] args) {
        //准备好数据源
        List<String> list = Arrays.asList("小马","小明","小军","小东");
        //获取集合的顺序流
       Stream<String> stream =  list.stream();
        System.out.println(stream);
        //获取一个并行流
        Stream<String> stream1 = list.parallelStream();
        System.out.println(stream1);
        //获取所有偶数，并且输出
        //无限流(无止境生产数据)
        Stream.iterate(0,t -> t + 2).forEach(System.out::println);
    }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。