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. 面向无连接，数据传递不算特别安全

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

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

TCP/IP
- 1. 面向连接，数据传递较为安全

因为面向连接，所有传递速度较慢
面向连接，数据传递有保障
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: 当前字节缓冲数组的容量

发送端
- 流程:

创建UDP服务器对应的发送端Socket
准备对应数据包，需要带有指定数据
发送数据 send
关闭UDP发送端

接收端
- 流程：

打开UDP服务，并且监听指定端口
创建新的空数据包
通过Socket接收数据
关闭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协议代码演示
- 服务器代码
  - 流程：

创建ServerSocket服务器，同时监听指定端口
通过accept方法获取Socket连接，得到客户端Socket对象
通过Socket对象，获取InputStream，读取客户端发送数据
通过Socket对象，获取OutputStream，发送数据给客户端
关闭服务
- 客户端代码
  - 流程:
创建Socket服务，同时明确连接服务器的IP地址和对应端口号
通过Socket对象，获取对应的OutputStream对象，发送数据给服务器
通过Socket对象，获取对应的InputStream对象，接收服务器发送数据
关闭服务
- 代码总结
  - 在这里只是一个小的演示，传递的只有一句话，比较小，所以用一个1024的字节数组就可以接收信息了。
    下边来传输比较大的文件，会用到之前的IO流操作。

文件上传操作
- 客户端程序
  - 流程：

创建对应文件的输入字节流操作，这里可以使用缓冲
启动Socket
获取Socket输出OutputStream对象，发送数据给服务器
边读边发
当文件读取结束，发送完毕，关闭客户端
- 服务端程序
  - 流程：
开启服务端服务，创建ServerSocket对象
明确保存文件的位置，创建对应文件夹的输出缓冲字节流
读取数据，写入文件
关闭服务器
- 目前服务端代码问题
  - 在上边的代码中，我们存在一些逻辑问题

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

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

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

		- 代码

XML

XML概述

Extensible Markup Language
可拓展标记语言

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

w3c万维网联盟指定的规范

基本语法

1. XML文件后缀名是.xml

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

XML文件组成部分

1. 文档声明:
  a. 格式:
  <?xml 属性列表 ?>
  <?xml version="1.0" encoding="utf-8" ?>
  version: 当前XML文件版本号
  encoding: 编码方式，这里建议XML文件的保存编码集和对应的解析编辑一致。
  standalone:是否依赖于其他文件 [了解]
  yes 不依赖， no 依赖

指令(了解)
这里可以导入一些CSS样式
<?xml-stylesheet type="text/css" href="test.css" ?>
标签内容自定义
规则:
a. 自定义标签允许使用英文字母，数字和其他标点符号(_ - .)
b. 不允许使用数组和标点符号开头，只能用英文字母
c. 不允许在自定义标签内使用xml标记，XML也不行
d. 名字不允许出现空格
属性
可以给标签一个属性，有时候要求ID属性是惟一的
文本(了解)
CDATA区，所见即所得，CDATA区内容是完整展示的
格式:
<![CDATA[ 数据 ]]>

XML文件数据约束

1. DTD
  一种简单的约束方式
  但是存在一定的约束问题

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两种解析方式，但是操作很繁琐，不便于程序员开发。

Dom4j: DOM For Java 一款非常优秀的解析器
Spring，SpringMVC… 框架中集成的XML解析器
Jsoup: 基于Java完成的对于HTML解析的工具，因为HTML和XML文件都是标记语言。
给Jsoup一个URL，页面地址. Java的小爬虫，API很多很方便
PULL:
Android手机上集成的XML解析工具，SAX方式解析

Dom4j使用入门
- 1. 导包
    目前使用的是第三方工具，不是原生的JDK
    导入第三方Jar包

设置IDEA
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方法

- **方式一:**
自定义线程类，继承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

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

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

	- 格式：

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

特征:

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

问题:

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

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

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

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

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

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

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

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

- Lock锁

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

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

- 三种加锁方式的总结


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

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

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

守护线程

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

守护线程一般用于:

自动下载
操作日志
操作监控

方法是通过线程对象
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);
让当前线程进入一个计时等待状态

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

Sleep方法

调用之后休眠指定时间
sleep方法必须执行在run方法内，才可以休眠线程
sleep不会打开当前线程占用的锁对象。
————————————————
版权声明：本文为CSDN博主「青柠小鱼码字猴」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_42581682/article/details/104818483

BLOCKED(锁阻塞)
- 线程中有锁存在，线程需要进入带有锁操作的同步代码，如果锁对象被别人持有，只能在锁外等待

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

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

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

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

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

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

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

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

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

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

线程通信

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

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

	- 子主题 1

线程池

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

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

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

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

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

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

- 线程池使用

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

Java第五周总结