Java第五周总结

2020-03-24 17:41:08 浏览数 (1)

Java第五周

lambda表达式

思想 “说重点”

lambda表达式的核心即在于说重点 以线程代码为例，他需要的是什么？最核心的东西是什么？ 就是run方法！！！ runnable接口中重写实现的就一个run方法！！！接口只是run方法的载体，装黄桃的罐头盒子！！！核心只要run方法。 我们为什么要写runnable接口的实现类？就是为了重写run方法，并且让线程去执行run方法。 所以，现在我们不要盒子了，直接用手抓着吃！！！

Lambda表达式格式

  • service.submit(() -> System.out.println(Thread.currentThread().getName()));

() -> System.out.println(Thread.currentThread().getName()) Lambda表达式

() 参数列表 -> 做什么事情，就是对应方法体 箭头之后的代码就是正常语句

(参数列表) -> {代码语句}

Lambda表达式使用，无参数无返回值

Lambda表达式使用，有参数有返回值

Lambda表达式使用前提

  • 有且只有一个缺省属性为public abstract方法的接口，例如 Comparator接口，Runnable接口

使用lambda表达式是有一个前后要求约束的方法的参数为接口类型，或者说局部变量使用调用方法，可以使用lambda也OK

有且只有一个抽象方法的接口，称之为【函数式接口】Comparator接口，Runnable接口

反射

Java文件和.class文件的关系

  • Java文件 Java文件中包含代码的所有内容，类，接口，成员变量，成员方法…

.class字节码文件 .java文件 通过 javac编译工具生成对应的.class字节码文件 使用JDK中提供的反编译工具，可以看到.class文件中包含 Class 完整的包名.类名 Field 成员变量，成员变量的名字和成员变量的数据类型[如果是引用数据类型，也是 完整的包名.类名] Method 成员方法，方法权限修饰符，返回值类型，方法名，形式参数列表数据类型

总结： .class字节码文件中，包含了Java文件的所有内容

程序加载过程和.class文件的关系

  • 在Java文件运行过程中，当前程序需要哪一个类参与代码执行，那么就需要加载这个类的.class字节码文件，该.class字节码文件在程序的加载阶段，存在于内存的【代码区】

.class字节码文件既然加载到内存的【代码区】 .class文件中包含对应Java程序的所有内容 代码区存在一块空间 ==> .class ==> Java程序的所有内容

Java中的万物皆对象

  • 在Java代码中，把在内存代码区保存的.class字节码内存空间，看做是一个对象。而该对象中包含了对应Java文件的所有内容。

我的理解：是否和方法名，引用数据类型，数组名之类的类似？都是空间地址。不过他们都是堆区空间地址，而这个对象是代码区空间地址。

  • 我的理解：java文件反编译形成的.class文件，会在代码区占据一片空间，保存java文件所有内容，也就是构造方法，成员变量，成员方法，注解。而把这片空间看做是一个对象，这个对象是Class类型的。

反射必会方法【重点】

  • Class涉及到的方法（获取Class类对象）
    • Class Class.forName(String packageNameAndClassName); Class类的静态成员方法，通过完整的包名.类名 获取对应.class文件的Class对象 同时也可以作为.class文件加载的方式。

Class 类名.class; 通过类名.class方法，获取对应的Class类对象，通常用于方法的参数类型。

Class 类对象.getClass(); 通过类对象获取对应的.class的Class类对象，方法参数，或者说数据类型判断。

  • Constructor 构造方法类涉及到的方法（通过Class类对象获取对应类对象的构造方法）
    • 这里有四种方法

1.public Constructor[] getConstructors(); 2.public Constructor[] getDeclaredConstructors(); 3.public Constructor getConstructor(Class… initArgumentTypes); 4.public Constructor getDeclaredConstructor(Class… initArgumentTypes);

具体如下：

public Constructor[] getConstructors(); 获取当前Class类对象对应Java文件中，所有【public修饰构造方法的类对象数组】 public：方法权限修饰符 Constructor[]：返回值类型，数组 getConstructors()：方法名，并且无参数 下边的方法就不一一赘述。

public Constructor[] getDeclaredConstructors(); 【暴力反射】 获取当前Class类对象对应Java文件中，所有【构造方法的类对象数组】，包括私有化构造方法。回顾】 new Person(); new Person(1); 因为这里利用了重载的知识点，会根据实际【参数类型】，来选择对应的构造方法。 【推理】 通过Class类对象，获取指定构造方法，需要根据构造方法的所需的参数数据类型来完成。

public Constructor getConstructor(Class… initArgumentTypes); 根据指定的数据类型，来选择对应的构造方法，这里可能会抛出异常。 这里有且只能获取获取类内的指定数据类型public修饰构造方法类对象 Class: 约束数据类型，当前方法所需的参数类型 例如: 这里需要int类型 int.class 这里需要String类型 String.class 之类需要Perosn类型 Person.class 异常: NoSuchMethodException … : 不定长参数 构造方法需要的参数类型是很多的，有可能无参数，有可能有参数。… 不定长参数 类约束使用，增强代码的普适性 例如: 这里无参数 () or (null) 参数类型int类型 (int.class) 参数类型int, String类型 (int.class, String.class) initArgumentTypes: 参数类型 初始化参数类型复数

public Constructor getDeclaredConstructor(Class… initArgumentTypes); 【暴力反射】 根据指定的数据类型，来选择对应的构造方法，这里可能会抛出异常。 这里可以获取指定参数类型私有化构造方法和非私有化构造方法 Class: 约束数据类型，当前方法所需的参数类型 例如: 这里需要int类型 int.class 这里需要String类型 String.class 之类需要Perosn类型 Person.class 异常: NoSuchMethodException … : 不定长参数 构造方法需要的参数类型是很多的，有可能无参数，有可能有参数。… 不定长参数 类约束使用，增强代码的普适性 例如: 这里无参数 () or (null) 参数类型int类型 (int.class) 参数类型int, String类型 (int.class, String.class) initArgumentTypes: 参数名 初始化参数类型复数

  • 通过Class对象创建Class对象对应的类对象
    • Object newInstance(Object… initArguments); 通过Constructor对象来调用，传入当前构造方法所需创建对象的初始化参数，创建对象。 Object: Object类是Java中所有类的基类，这里可以传入任意类型的参数 … : 不定长参数，因为Constructor类对象在获取的过程中，约束的参数个数都不确定， 这里使用不定长参数来传入数据
  • Method成员方法涉及到的方法
    • Method[] getMethods(); 获取类内所有public修饰的成员方法，包括从父类继承而来的public修饰方法。

Method[] getDeclaredMethods(); 暴力反射 获取类内所有成员方法，但是不包括从父类继承而来的方法。Method getMethod(String methodName, Class… parameterTypes); 根据指定的方法名和对应的参数类型，获取对应的public修饰的成员方法 methodName: 方法名，指定获取的是哪一个方法 parameterTypes: Class用于约束当前使用你的参数数据类型 … 不定长参数，方法参数个数，顺序，有参无参问题 例如： cls是Class类对象 cls.getMethod(“setName”, String.class); cls.getMethod(“getName”);

Method getDeclaredMethod(String methodName, Class… parameterTypes); 根据指定的方法名和对应的参数类型，获取对应的成员方法，包括私有化成员方法，但是不 包括从父类继承而来的方法 methodName: 方法名，指定获取的是哪一个方法 parameterTypes: Class用于约束当前使用你的参数数据类型 … 不定长参数，方法参数个数，顺序，有参无参问题 例如： cls是Class类对象 cls.getMethod(“setName”, String.class); cls.getMethod(“getName”); - Object invoke(Object obj, Object… arguments); 通过Method类对象调用，执行对应的方法，需要的参数 obj : 执行当前方法的执行者 arguments: Object… 不定长参数，当前方法执行所需的实际参数，

  • Field成员变量涉及到方法
    • Field[] getFields(); 获取类内所有public修饰的成员变量 Field[] getDeclaredFields(); 获取类内所有成员变量，包括私有化成员方法

Field getField(String fieldName); 获取指定变量名的成员变量对象，要求是public修饰的成员变量

Field getDeclaredField(String fieldName); 获取指定变量名的成员变量对象，包括private私有化修饰的成员变量

void set(Object obj, Object value); 设置指定调用者中对应成员变量的数据 obj : 调用者 value: 对应当前成员变量需要赋值的内容 Object get(Object obj); 获取指定调用者中指定成员变量的数据 obj: 调用者

  • 给予暴力反射私有化内容的权限操作
    • setAccessible(boolean flag); 给予Constructor，Method, Field对象，私有化内容，操作权限设置 true表示可以操作

网络编程

C/S和B/S

  • C/S
    • 客户端 服务器软件结构

服务提供商给予用户服务需要准备的内容 1. 各大平台的客户端 Android iOS PC Windows Linux macOS QQ 微信 淘宝 JD 剑与远征 2. 服务器提供服务 软件更新: LOL服务器版本更新，同时本地软件也要进行更新操作。这个操作非常耗时。 热更新

  • B/S
    • 浏览器 服务器软件结构

服务提供商只要提供数据服务就OK，以及前端数据展示方式 1. 浏览器提供商非常非常多 谷歌，火狐，欧朋，Safari，Edge 2. 服务器提供服务 软件更新: 服务器更新数据，浏览器刷新就ok了

网络通信协议

  • 协议
    • protocol协议

网络通信协议是要求双方传递数据的计算机必须遵守的，按照对应的网络传输协议，才可以进入数据的交互和传递。

目前网络段数据传输比较常见的协议: UDP TCP/IP

UDP和TCP/IP区别

  • UDP
      1. 面向无连接，数据传递不算特别安全
  1. 因为面向无连接，传输速度快
  2. 因为面向无连接，数据传递存在丢包问题
  3. UDP没有客户端和服务器区别，都可以作为发送端和接收端，相互的

UDP协议使用场景 直播，网络游戏 实时的大部分都是UDP

  • TCP/IP
      1. 面向连接，数据传递较为安全
  1. 因为面向连接，所有传递速度较慢
  2. 面向连接，数据传递有保障
  3. TCP/IP协议是有明确的服务器和客户端概念

TCP/IP协议使用场景 客户端登陆，数据下载，文件传输

一个软件肯定是混合协议的，不是单独的。

网络编程的三要素

  • 协议
    • 两个在于网络情况下的计算机数据传递，都需要对应的协议来完成。
  • IP地址
    • Internet Protocol Address 当前计算机在网络中的一个地址编号，类似于手机号号码 IP地址有IPv4协议和IPv6协议 IPv4是一个32位的二进制数，通常展示效果是a.b.c.d 例如 192.168.1.1 a.b.c.d 各代表0 ~ 255的数字，目前已经消耗殆尽 42亿个 IPv6 IPv6是能够保证地球上的每一粒沙子都有一个IP地址。 128位地址长度，16字节一组 8组 0x0 ~ 0xFFFF
  • 端口号
    • 端口号是当前应用程序在计算机中的一个编号。可以让计算机明确知道，当前的数据是给予哪一个程序使用，或者数据从哪一个程序出现的。 端口号是一个short类型 0 ~ 65535 0~1024不能用于自定义端口号使用，特定的系统端口号

IP类

  • SUN公司提供给开发使用的IP地址类 InetAddress

常用方法: InetAddress getLocalhost(); 获取本机IP地址类对象 InetAddress getByName(String str); 根据指定的主机名获取对应的IP地址对象 InetAddress[] getAllByName(String str); 获取指定主机名，或者域名对应的所有IP地址类对象

UDP协议数据传输

  • UDP数据传输方式
    • User Datagram Protocol 数据传递采用数据包方式传递，所有的数据要进行打包操作，并且没有对应的客户端服务器概念，有且只有发送端和接收端

Socket 套接字 数据需要进行传递操作，在数据传递的两台计算机当中必须有对应的Socket。这里采用UDP协议，那么必须有一个UDP协议的Socket

DatagramSocket(); 创建一个发送端UDP协议Socket对象 DatagramSocket(int port); 创建一个接收端UDP协议的Socket对象，这里需要【监听】指定端口 发送端数据包的打包方法： DatagramPacket DatagramPacket(byte[] buf, int length, InetAddress address, int port); buf: 需要传递数据的字节数组 length：是当前字节数组中数据容量字节数 address：接收端IP地址对象 port: 接收端对应的端口号

接收端数据包接收方式 这里需要准备一个空的数据包 DatagramPacket DatagramPacket(byte[] buf, int length); buf: 字节缓冲数组，通常是1024整数倍 length: 当前字节缓冲数组的容量

  • 发送端
    • 流程:
  1. 创建UDP服务器对应的发送端Socket
  2. 准备对应数据包，需要带有指定数据
  3. 发送数据 send
  4. 关闭UDP发送端
  • 接收端
    • 流程：
  1. 打开UDP服务，并且监听指定端口
  2. 创建新的空数据包
  3. 通过Socket接收数据
  4. 关闭UDP服务接收端
  • UDP数据传递丢失问题
    • 这是udp的缺点之一，因为面向无连接，所以可能会丢数据，类似于玩电脑游戏丢包，瞬移，卡顿。

网络不够好，稳定性不行，带宽不够 电脑性能不好

TCP

  • TCP概述
    • TCP相对于UDP比较稳定的传输协议，这里存在三次握手，保证连接状态，同时有明确的客户端和服务端之分

TCP服务中需要服务器端先启动，需要监听指定端口，等待客户端连接。

客户端主动连接服务器，和服务器连接之后，才可以进行数据交互，服务器不能主动连接客户端的。

TCP操作而言，Java中提供了两个Socket

服务端Socket java.net.ServerSocket; 创建对应的ServerScoket开启服务器，等待客户端连接

客户端Socket(这个比较重要) java.net.Socket 创建客户端Scoket，并且连接服务器，同时将Socket发送给服务器绑定注册。

  • Socket 客户端Socket
    • 给客户端提供数据传输的符合TCP/IP要求的Socket对象

构造方法 Constructor Socket(String host, int port); host是服务器IP地址，port对应服务器程序的端口号 通过指定的服务器IP地址和端口号，获取TCP连接对象

成员方法 Method InputStream getInputStream(); 获取Socket对象输入字节流，可以从服务器获取对应的数据 InputStream是一个资源，需要在程序退出是关闭 Read

OutputStream getOutputStream(); 获取Sokcet对象输出字节流，可以发送数据到服务器 OutputStream是一个资源，需要在程序退出是关闭 Write

void close(); 关闭客户端Socket

void shutdownOutput(); 禁止当前Socket发送数据

TCP/IP协议对应的Socket是给予IO流实现的。

  • ServerSocket服务端Socket
    • 在服务端开启Socket服务器

构造方法 Constructor： ServerSocket(int port); 开启ServerSocket服务器，并且明确当前服务端口是谁

成员方法 Method： Socket accept(); 监听并且连接，得到一个Socket对象，同时该方法是一个阻塞方法，会处于一个始终的监听状态 返回的是Socket，也就是客户端Socket对象，获取到当前Socket对象，相对于获取到客户端连接，同时使用的Socket和客户端一致。

  • TCP协议代码演示
    • 服务器代码
      • 流程：
  1. 创建ServerSocket服务器，同时监听指定端口
  2. 通过accept方法获取Socket连接，得到客户端Socket对象
  3. 通过Socket对象，获取InputStream，读取客户端发送数据
  4. 通过Socket对象，获取OutputStream，发送数据给客户端
  5. 关闭服务
    • 客户端代码
      • 流程:
  6. 创建Socket服务，同时明确连接服务器的IP地址和对应端口号
  7. 通过Socket对象，获取对应的OutputStream对象，发送数据给服务器
  8. 通过Socket对象，获取对应的InputStream对象，接收服务器发送数据
  9. 关闭服务
    • 代码总结
      • 在这里只是一个小的演示，传递的只有一句话，比较小，所以用一个1024的字节数组就可以接收信息了。 下边来传输比较大的文件，会用到之前的IO流操作。
  • 文件上传操作
    • 客户端程序
      • 流程：
  1. 创建对应文件的输入字节流操作，这里可以使用缓冲
  2. 启动Socket
  3. 获取Socket输出OutputStream对象，发送数据给服务器
  4. 边读边发
  5. 当文件读取结束，发送完毕，关闭客户端
    • 服务端程序
      • 流程：
  6. 开启服务端服务，创建ServerSocket对象
  7. 明确保存文件的位置，创建对应文件夹的输出缓冲字节流
  8. 读取数据，写入文件
  9. 关闭服务器
    • 目前服务端代码问题
      • 在上边的代码中，我们存在一些逻辑问题

保存的文件名都是一致的，无法保存多个文件。 这里可以考虑使用UUID作为文件名

服务端没有这么low，代码肯定不能执行完一个上传功能就结束

同理，服务端代码不可能只有一个上传文件功能 - 服务端代码优化

代码语言：javascript复制
		- 代码

XML

XML概述

  • Extensible Markup Language 可拓展标记语言

用途: 1. 数据存储，小型数据库，存在一定的CRUD操作可行性 2. 网络端数据的传输 3. JavaWEB框架项目配置文件 Spring Druid …

w3c万维网联盟指定的规范

基本语法

    1. XML文件后缀名是.xml
  1. XML第一行是对于当前文件的定义声明
  2. XML文件中有且只有一个根标签
  3. 属性值必须使用引号包含，这里推荐使用双引号
  4. 标签必须正确匹配，正确开始和关闭
  5. XML标签内严格区分大小写

XML文件组成部分

    1. 文档声明: a. 格式: <?xml 属性列表 ?> <?xml version="1.0" encoding="utf-8" ?> version: 当前XML文件版本号 encoding: 编码方式，这里建议XML文件的保存编码集和对应的解析编辑一致。 standalone:是否依赖于其他文件 [了解] yes 不依赖， no 依赖
  1. 指令(了解) 这里可以导入一些CSS样式 <?xml-stylesheet type="text/css" href="test.css" ?>
  2. 标签内容自定义 规则: a. 自定义标签允许使用英文字母，数字和其他标点符号(_ - .) b. 不允许使用数组和标点符号开头，只能用英文字母 c. 不允许在自定义标签内使用xml标记，XML也不行 d. 名字不允许出现空格
  3. 属性 可以给标签一个属性，有时候要求ID属性是惟一的
  4. 文本(了解) CDATA区，所见即所得，CDATA区内容是完整展示的 格式: <![CDATA[ 数据 ]]>

XML文件数据约束

    1. DTD 一种简单的约束方式 但是存在一定的约束问题
  1. Schema 一种复杂XML文件约束方式 非常严谨
  • DTD约束
  • Schema约束

XML解析

  • XML解析思路
    • DOM解析 Document Object Model 文件对象模型 把XML整个文件看做一个Document对象，每一个节点看做一个Element，节点中有Attribute，或者当前节点中存在Text文本内容。 DOM是将整个XML文件读取到计算机内存中，可以进行CRUD操作。 缺点: 占用了大量内存空间 适用的环境： 服务器对于XML文件的解析过程。

SAX解析 逐行读取，给予一定的事件操作。 读取一行内容，释放上一行内容，可以有效的节约内存空间 缺点: 不能对XML文件，进行增删改 适用的环境: 手机读取解析XML文件时采用的方式。

  • XML文件解析工具
      1. JAXP: SUN提供的一个基本的解析器，支持DOM和SAX两种解析方式，但是操作很繁琐，不便于程序员开发。
  1. Dom4j: DOM For Java 一款非常优秀的解析器 Spring，SpringMVC… 框架中集成的XML解析器
  2. Jsoup: 基于Java完成的对于HTML解析的工具，因为HTML和XML文件都是标记语言。 给Jsoup一个URL，页面地址. Java的小爬虫，API很多很方便
  3. PULL: Android手机上集成的XML解析工具，SAX方式解析
  • Dom4j使用入门
      1. 导包 目前使用的是第三方工具，不是原生的JDK 导入第三方Jar包
  1. 设置IDEA
  2. Dom4j涉及到的方法 SAXReader(); 解析XML文件使用的核心类 read() --> XML文件Document对象 Document document = new SAXReader().read(new File("./xml/User.xml")); Document对象中可以使用方法 Element getRootElement(); 获取当前XML文件的根节点对象 Element对象中可以使用方法 List elements(); 当前节点下的所有子节点 List elements(String name); 当前节点下所有指定名字的子节点 Element element(); 获取当前节点下的第一个子节点 Element element(String name); 获取当前节点下指定名字的第一个子节点 Attribute getAttribute(String name); 根据属性名获取对应的属性对象Attribute Attribute节点中可以使用String getValue()来获取对应的节点数据 String getName(); 获取当前节点的名字 String getText(); 获取当前节点对应的文本数据
  • XML文件保存
    • 流程：
    1. 创建Document对象
    2. 通过Document对象来添加元素 addElment(); addAttribute();

Java线程初识

进程是什么

  • windows电脑中，打开任务管理器，可以看到电脑中执行的每一个程序，每一个程序就是一个进程。

Windows系统是一个多任务系统。 电脑可以同时执行多个程序。

线程是什么

  • 电脑管家是一个软件，也是程序 ==> 进程 电脑可以同时开启 病毒查杀，垃圾清理，一键加速…等功能

每一个功能就可以看做是线程！

一个应用程序 ==> 进程 应用程序的某一个功能 ==> 线程 应用程序中可以同时执行多个功能 ==> 多线程

线程使用的是系统资源，该系统资源你是操作系统分配给当前进程使用的。 多个线程的情况下，同时【抢占执行】会导致资源紧缺。 线程抢占过程就类似于进程抢占过程。

一个Java程序，最少有几个线程？ 2个线程 　main线程 　JVM的GC机制，守护线程。

并发和并行

  • 并发: 两个或者两个以上的事务在同一个时间段发生

并行: 两个或者两个以上的事务在同一个时刻发生 宏观并行，微观串行

高并发 双十一 JD 618 12306 中午下课的餐厅 同时在一个时间段以内，很多事情都发生了，这就是高并发。

多线程

  • 多线程的优缺点
    • 优点
    1. 提升资源利用率
    2. 提高用户体验

缺点: 1. 降低了其他线程的执行概率 2. 用户会感受到软件的卡顿问题 3. 增加的系统，资源压力 4. 多线程情况下的共享资源问题，线程冲突，线程安全问题

  • 创建自定义线程类的两种方式
    • class Thread类 Java中的一个线程类 Thread类是Runnable接口的实现类，同时提供了很多线程的操作使用的方法。

interface Runnable接口 这里规定了what will be run? 里面只有一个方法 run方法

代码语言：javascript复制
- **方式一:**
自定义线程类，继承Thread类，重写run方法
创建自定义线程对象，直接调用start方法，开启线程


- **方式二：**
自定义线程类，遵从Runnable接口
使用自定义遵从接口Runnable实现类对象，作为Thread构造方法参数
借助于Thread类对象和start方法，开启线程

【推荐】 以上两种方式，推荐使用方法二，遵从Runnable接口来完成自定义线程，不影响正常的继承逻辑，并且可以使用匿名内部类来完成线程代码块的书写。

Thread类需要了解的方法

  • 构造方法 Constructor Thread(); 分配一个新的线程对象，无目标，无指定名字 Thread(Runnable target); 创建一个新的线程对象，并且在创建线程对象的过程中，使用Runnable接口的实现类 对象作为执行的线程代码块目标 Thread(String name); 创建一个新的线程，无指定目标，但是指定当前线程的名字是什么 Thread(Runnable target, String name); 创建一个线程的线程对象，使用Runnable接口实现类对象，作为执行目标，并且指定name作为线程名

成员方法: void setName(String name); String getName(); 以上两个是name属性setter和getter方法 void setPriority(int Priority); 设置线程的优先级，非一定执行要求，只是增加执行的概率 优先级数值范围 [1 - 10] 10最高 1最低 5默认 int getPriority(); 获取线程优先级 void start(); 启动线程对象

public static void sleep(int ms); 当前方法是静态方法，通过Thread类调用，要求是当前所在线程代码块对应的线程， 进行休眠操作，休眠指定的毫秒数 public static Thread currentThread(); 当前方法是静态方法，通过Thread类调用，获取当前所处代码块对应的线程对象。

这些方法必须牢牢记住！

线程安全问题–共享资源能使用问题

  • 例如： <<湄公河行动>> 100张票

淘票票CGV 美团 猫眼 三个销售渠道，100张票是一个共享资源！！！ 三个销售渠道，可以认为是三个销售线程！！！

问题一： 100张票共享资源问题，选什么来保存？ 局部变量： 在方法内，如果run方法执行，存在，run方法当前执行完毕，销毁。 每一个线程对象中都有run方法，无法满足共享问题 成员变量： 每一个线程对象中，都有一个对应的成员变量，非共享资源。 静态成员变量： 属于类变量，所有的当前类对象，使用的静态成员变量都是一个，而且一处修改，处处 受影响。【共享资源】

问题二: 资源冲突问题

线程之间会相互抢占，而且抢占频率很快，有可能会导致一张票卖了三次，也就是资源冲突问题 ———————————————— 版权声明：本文为CSDN博主「青柠小鱼码字猴」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/qq_42581682/article/details/104815540

  • 锁
    • 所以为了解决这个问题，我们用锁来解决

以下锁的是方法，无论谁调用，怎么调用都会锁住 - 同步代码块

代码语言：javascript复制
	- 格式：

synchronized (/* 锁对象 */) { }

特征:

  1. synchronized 小括号里面的对象是锁对象，并且要求如果是多线程的情况下，锁对象必须是同一个对象。也就是runnable接口实现类对象。
  2. synchronized 大括号中的代码块就是需要进行同步的代码，或者说是加锁的代码，大括号里面的内容，有且只允许一个线程进入。
  3. 同步代码块越短越好，在保证安全的情况下，提高性能

问题:

  1. 目前锁对象感觉很随意，存在一定的隐患
  2. 代码层级关系很复杂，看着有点麻烦 这个方法比较随意，一把锁会锁了多个线程，有隐患
    • 同步方法
      • 定义在线程类内

synchronized 作为关键字来修饰方法，修饰的方法就是对应的同步方法

有且只允许一个线程进入，到底是谁来完成的加锁操作?

静态成员方法 锁对象，是当前类对应的字节码文件.class 就是类名.class

非静态成员方法 锁对象就是当前类对象 this

选择同步方法是否使用static修饰问题

如果非static修饰，要保证执行的线程对象有且只有一个，因为锁对象就是当前线程对象

如果是static修饰，锁对象具有唯一性，多个线程使用的锁是同一个锁。类似于同步代码块。

代码语言：javascript复制
- Lock锁

	- Java提供了一个对于线程安全问题，加锁操作相对于同步代码块和同步方法更加广泛的一种操作方式。

对象化操作。 创建Lock构造方法 Lock lock = new ReentrantLock(); 多态思想，不理解就先记着这么用。 方法化操作。 开锁: unlock(); 加锁: lock();

代码语言：javascript复制
- 三种加锁方式的总结


	- 一锁一线程，一锁多线程问题。

使用对应的锁操作对应的线程，考虑静态和非静态问题。 同步方法和Lock锁使用。 静态是一锁多目标，非静态是一锁一目标

涉及到同步问题时，要考虑好锁对象的选择问题 同步代码块，同步方法，Lock对象

守护线程

  • 守护线程，也称之为后台线程，如果当前主线程GG思密达，守护线程也就GG思密达。

守护线程一般用于:

  1. 自动下载
  2. 操作日志
  3. 操作监控

方法是通过线程对象 setDeamon(boolean flag); true为守护线程 false缺省属性，正常线程

线程的状态简说

  • NEW(新建) 线程刚刚被创建，没有启动，没有调用start方法 RUNNABLE(可运行) 线程已经可以在JVM中运行，但是是否运行不确定，看当前线程是否拥有CPU执行权 BLOCKED(锁阻塞) 当前线程进入一个同步代码需要获取对应的锁对象，但是发现当前锁对象被其他线程持有，当前线程会进入一个BLOCKED。如果占用锁对象的线程打开锁对象，当前线程持有对应锁对象，进入Runnable状态 WAITING(无限等待) 通过一个wait方法线程进入一个无限等待状态，这里需要另外一个线程进行唤醒操作。进入无限等待状态的线程是无法自己回到Runnable状态，需要其他线程通过notify或者notifyAll方法进行唤醒操作 TIMED_WAITING(计时等待) 当前线程的确是等待状态，但是会在一定时间之后自动回到Runnable状态，例如 Thread.sleep() 或者是Object类内的wait(int ms); TERMINATED(被终止) 因为Run方法运行结束正常退出线程，或者说在运行的过程中因为出现异常导致当前线程GG思密达
  • TIMED_WAITING(计时等待)
    • Thread.sleep(int ms); 在对应线程代码块中，当前线程休眠指定的时间。

Object类内 wait(int ms); 让当前线程进入一个计时等待状态

  1. 规定的时间及时完毕，线程回到可运行状态
  2. 在等待时间内，通过其他线程被notify或者notifyAll唤醒

Sleep方法

  1. 调用之后休眠指定时间
  2. sleep方法必须执行在run方法内，才可以休眠线程
  3. sleep不会打开当前线程占用的锁对象。 ———————————————— 版权声明：本文为CSDN博主「青柠小鱼码字猴」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/qq_42581682/article/details/104818483
  • BLOCKED(锁阻塞)
    • 线程中有锁存在，线程需要进入带有锁操作的同步代码，如果锁对象被别人持有，只能在锁外等待

锁阻塞状态的线程是否能够抢到锁对象有很多因素

  1. 优先级问题，非决定因素
  2. CPU执行概率问题。

后期高并发一定会存在多线程操作锁对象问题，秒杀，抢购… 队列方式来处理

  • 线程状态 WAITING(无限等待)
    • 当某一个线程被执行wait()方法，需要等待另外的一个线程进行唤醒操作。

以下三个方法都是Object类内的方法: public void wait(); 在哪一个线程中执行，就会让当前线程进入一个无限等待状态。

  1. 所在线程进入无限等待状态
  2. 开启【锁对象】

public void notify(); 唤醒和当前锁对象有关的无限等待线程中的一个，随机选择。

  1. 唤醒一个无限等待状态线程
  2. 开启【锁对象】

public void notifyAll(); 唤醒所有和当前锁对象有关的无限等待线程

  1. 唤醒所有线程
  2. 开启【锁对象】
  3. 线程进入锁对象抢占过程，就有可能进入一个锁阻塞状态。 ———————————————— 版权声明：本文为CSDN博主「青柠小鱼码字猴」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/qq_42581682/article/details/104818483

线程通信

  • 共享资源处理问题
    • 现在存在两个完全无关的线程：生产者和消费者，但是商品会作为他们两者之间的共享资源。 生产者和消费者中都有一个成员变量 商品类型

【解决方案】 创建生产者或者消费者线程对象时，使用同一个商品类对象，作为构造方法参数进行初始化操作 - 代码

代码语言：javascript复制
	- 子主题 1

线程池

我们在之前的线程学习中，都是之间创建新的线程，显性线程，用的时候开启，用完销毁，效率低且不安全 而且我们看到在阿里巴巴代码规范规约中也是不建议显式创建线程，建议使用线程池。

代码语言：javascript复制
- 不管是继承Thread还是遵从Runnable接口，都需要重写Run方法，而且每一个线程对象有且只能执行一次，之后就会被销毁。

利用Runnable接口来提供执行目标，而且借助于Thread执行线程。 - 用生活中的例子来理解：

一个餐厅 服务人员 餐厅会按照餐桌比例安排服务员人数。 每一个服务员我们都可以看做是一个线程对象 需要告知服务器做什么事情就可以了，相对于告知线程对象执行目标是什么 当你来餐厅之前，服务员在这里，你走之后，服务员依然在这类。

线程池 ==> 可以容纳多个线程的容器

程序可以从线程池获取线程来完成目标代码 同时也可以将线程归还给线程池。 省去了创建线程和销毁线程这样非常繁琐的操作。节省时间。

代码语言：javascript复制
- 线程池使用

public static ExecutorService newFixedThreadPool(int nThreads); 得到一个线程池对象，初始化参数是要求的当前线程池中的线程数

在这行代码中， newFixedThreadPool是ExecutorService类中的方法 返回值是ExecutorService，参数是int类型的线程数量。 创建代码示例为：

ExecutorService service = Executors.newFixedThreadPool(5);

public Future submit(Runnable target);

从线程池中获取一个线程对象，并且执行给定的Runnable接口实现类对象作为执行目标

XMind: ZEN - Trial Version

socket编程 编程算法 xml ipv6 java

0 人点赞