文章目录
Java基础(5)
特殊文件
IO流是用来读、写文件中的数据。但是我们接触到的文件都是普通的文本文件，普通的文本文件里面的数据是没有任何格式规范的，用户可以
随意编写像这种
普通的文本文件，没有任何规律可言，不方便程序对文件中的数据信息处理。
以后的Java开发过程中还会遇到一些
特殊的文本文件，这些文件是有一些格式要求的，方便程序对文件中的数据进行处理。两种特殊的文本文件，一种是
properties文件，还有一种是xml文件。
- 后缀为.properties的文件，称之为属性文件，它可以很方便的存储一些类似于键值对的数据。经常当做
软件的配置文件使用。- 而xml文件能够表示更加复杂的数据关系，比如要表示多个用户的用户名、密码、家乡、性别等。在后面，也经常当做
软件的配置文件使用。
Properties属性文件
格式：
- 属性文件后缀以
.properties结尾- 属性文件里面的每一行都是一个键值对，键和值中间用=隔开。比如:
admin=123456#表示这样是注释信息，是用来解释这一行配置是什么意思。- 每一行末尾不要习惯性加分号，以及空格等字符；不然会把分号，空格会当做值的一部分。
- 键不能重复，值可以重复
读写属性文件中的数据
Properties是什么？
Properties是Map接口下面的一个实现类，所以Properties也是一种双列集合，用来存储键值对。 但是一般不会把它当做集合来使用。Properties核心作用？
Properties类的对象，用来表示属性文件，可以用来读取属性文件中的键值对。
使用Properties读取属性文件中的键值对，需要用到的方法如下。
- Properties读取属性文件的步骤如下
- 1、创建一个Properties的对象出来（键值对集合，空容器）
- 2、调用load(字符输入流/字节输入流)方法，开始加载属性文件中的键值对数据到properties对象中去
- 3、调用getProperty(键)方法，根据键取值
/** * 目标：掌握使用Properties类读取属性文件中的键值对信息。 */ public class PropertiesTest1 { public static void main(String[] args) throws Exception { // 1、创建一个Properties的对象出来（键值对集合，空容器） Properties properties = new Properties(); System.out.println(properties); // 2、开始加载属性文件中的键值对数据到properties对象中去 properties.load(new FileReader("properties-xml-log-app\\src\\users.properties")); System.out.println(properties); // 3、根据键取值 System.out.println(properties.getProperty("赵敏")); System.out.println(properties.getProperty("张无忌")); // 4、遍历全部的键和值。 //获取键的集合 Set<String> keys = properties.stringPropertyNames(); for (String key : keys) { //再根据键获取值 String value = properties.getProperty(key); System.out.println(key + "---->" + value); } properties.forEach((k, v) -> { System.out.println(k + "---->" + v); }); } }
- Properties往属性文件中写键值对，需要用到的方法如下
往Properties属性文件中写键值对的步骤如下:
- 1、先准备一个.properties属性文件，按照格式写几个键值对
- 1、创建Properties对象出来，
- 2、调用setProperty存储一些键值对数据
- 3、调用store(字符输出流/字节输出流, 注释)，将Properties集合中的键和值写到文件中
注意：第二个参数是注释，必须得加；编写代码读取上面的属性文件
public class PropertiesTest2 { public static void main(String[] args) throws Exception { // 1、创建Properties对象出来，先用它存储一些键值对数据 Properties properties = new Properties(); properties.setProperty("张无忌", "minmin"); properties.setProperty("殷素素", "cuishan"); properties.setProperty("张翠山", "susu"); // 2、把properties对象中的键值对数据存入到属性文件中去 properties.store(new FileWriter("properties-xml-log-app/src/users2.properties") , "i saved many users!"); } }效果:
XML文件
什么是XML？
XML是可扩展的标记语言，意思是它是由一些标签组成 的，而这些标签是自己定义的。本质上一种数据格式，可以用来表示复杂的数据关系。
XML文件有如下的特点：
- XML中的
<标签名>称为一个标签或者一个元素，一般是成对出现的。- XML中的标签名可以自己定义（可扩展），但是必须要正确的嵌套
- XML中只能有一个根标签。
- XML标准中可以有属性
- XML必须第一行有一个文档声明，格式是固定的
<?xml version="1.0" encoding="UTF-8"?>- XML文件必须是以.xml为后缀结尾
最后，XML在实际开发中有什么作用？
XML解析
使用程序读取XML文件中的数据，称之为XML解析。
有很多开源的，好用的XML解析框架，最知名的是
DOM4J（第三方开发的）
由于
DOM4J是第三方提供的，所以需要把第三方提供的Jar包导入到自己的项目中来，才可以使用。具体步骤如下：
DOM4J解析XML文件的思想是：文档对象模型（意思是把整个XML文档、每一个标签、每一个属性都等都当做对象来看待）。Dowument对象表示真个XML文档、Element对象表示标签（元素）、Attribute对象表示属性、标签中的内容就是文本
-
DOM4J解析XML需要用到的方法如下图所示
-
XML解析的过程，是从根元素开始，从外层往里层解析。 我们先把Document对象，和根元素获取出来
public class Dom4JTest1 { public static void main(String[] args) throws Exception { // 1、创建一个Dom4J框架提供的解析器对象 SAXReader saxReader = new SAXReader(); // 2、使用saxReader对象把需要解析的XML文件读成一个Document对象。 Document document = saxReader.read("properties-xml-log-app\\src\\helloworld.xml"); // 3、从文档对象中解析XML文件的全部数据了 Element root = document.getRootElement(); System.out.println(root.getName()); } }
获取到XML文件的根元素之后，接下来，就可以用根元素在获取到它里面的子元素（包括子标签、表属性等）。需要用到的方法如下图所示
public class Dom4JTest1 { public static void main(String[] args) throws Exception { // 1、创建一个Dom4J框架提供的解析器对象 SAXReader saxReader = new SAXReader(); // 2、使用saxReader对象把需要解析的XML文件读成一个Document对象。 Document document = saxReader.read("properties-xml-log-app\\src\\helloworld.xml"); // 3、从文档对象中解析XML文件的全部数据了 Element root = document.getRootElement(); System.out.println(root.getName()); // 4、获取根元素下的全部一级子元素。 // List<Element> elements = root.elements(); List<Element> elements = root.elements("user"); for (Element element : elements) { System.out.println(element.getName()); } // 5、获取当前元素下的某个子元素。 Element people = root.element("people"); System.out.println(people.getText()); // 如果下面有很多子元素user，默认获取第一个。 Element user = root.element("user"); System.out.println(user.elementText("name")); // 6、获取元素的属性信息呢？ System.out.println(user.attributeValue("id")); Attribute id = user.attribute("id"); System.out.println(id.getName()); System.out.println(id.getValue()); List<Attribute> attributes = user.attributes(); for (Attribute attribute : attributes) { System.out.println(attribute.getName() + "=" + attribute.getValue()); } // 7、如何获取全部的文本内容:获取当前元素下的子元素文本值 System.out.println(user.elementText("name")); System.out.println(user.elementText("地址")); System.out.println(user.elementTextTrim("地址")); // 取出文本去除前后空格 System.out.println(user.elementText("password")); Element data = user.element("data"); System.out.println(data.getText()); System.out.println(data.getTextTrim()); // 取出文本去除前后空格 } }
-
xml写入
DOM4J也提供了往XML文件中写标签的方法，但是用起来比较麻烦。这里不建议使用我们自己使用StringBuilder按照标签的格式拼接，然后再使用BufferedWriter写到XML文件中去就可以了。
public class Dom4JTest2 { public static void main(String[] args) { // 1、使用一个StringBuilder对象来拼接XML格式的数据。 StringBuilder sb = new StringBuilder(); sb.append("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\r\n"); sb.append("<book>\r\n"); sb.append("\t<name>").append("从入门到跑路").append("</name>\r\n"); sb.append("\t<author>").append("dlei").append("</author>\r\n"); sb.append("\t<price>").append(999.99).append("</price>\r\n"); sb.append("</book>"); try ( BufferedWriter bw = new BufferedWriter(new FileWriter("properties-xml-log-app/src/book.xml")); ){ bw.write(sb.toString()); } catch (Exception e) { e.printStackTrace(); } } }
xml约束
首先，说一些什么是XML约束？
XML约束指的是限制XML文件中的标签或者属性，只能按照规定的格式写。
比如我在项目中，想约束一个XML文件中的标签只能写<书>、<书名>、<作者>、<售价>这几个标签，如果写其他标签就报错。
-
有两种约束技术，一种是
DTD约束、一种是Schame约束。 -
-
<!ELEMENT 书架(书+)> 表示根标签是<书架>，并且书架中有子标签<书> <!ELEMENT 书(书名、作者、售价)> 表示书是一个标签，且书中有子标签<书名>、<作者>、<售价> <!ELEMENT 书名(#PCDATA)> 表示<书名>是一个标签，且<书名>里面是普通文本 <!ELEMENT 作者(#PCDATA)> 表示<作者>是一个标签，且<作者>里面是普通文本 <!ELEMENT 售价(#PCDATA)> 表示<售价>是一个标签，且<售价>里面是普通文本
-
日志技术
- 系统系统能记住某些数据被谁操作，比如被谁删除了？
- 想分析用户浏览系统的具体情况，比如挖掘用户的具体喜好？
- 当系统在开发中或者上线后出现了Bug，崩溃了，该通过什么去分析，定位Bug?
而日志就可以帮我们解决以上的问题。所以日志就好比生活中的日记，日记可以记录生活中的点点滴滴；而程序中的日志，通常就是一个文件，里面记录了程序运行过程中产生的各种数据。
- 日志技术有如下好处
- 日志可以将系统执行的信息，方便的记录到指定位置，可以是控制台、可以是文件、可以是数据库中。
- 日志可以随时以开关的形式控制启停，无需侵入到源代码中去修改。
其实有很多日志框架给开发者使用。
比如有
JUL（java.util.logging）、Log4j、logback等。但是这些日志框架如果使用的API方法都不一样的话，使用者的学习成本就很高。为了降低程序员的学习压力，行内提供了一套日志接口，然后所有的日志框架都按照日志接口的API来实现就可以了。这样程序员只要会一套日志框架，那么其他的也就可以通过用，甚至可以在多套日志框架之间来回切换。比较常用的日志框架，和日志接口的关系如下图所示
-
Logback日志分为哪几个模块
-
Logback快速入门
使用一下Logback日志框架，使用Logback记录几条日志信息到文件中去和将日志信息打印在控制台上。
由于Logback是第三方提供的技术，所以首先需要啊将Jar包引入到项目中，具体步骤如下
在资料中找到
slftj-api.jar、logback-core.jar、logback-classes.jar这三个jar包，复制一下在当前模块下面新建一个lib文件夹，把刚刚复制的三个jar包都粘贴到此处
从资料中找到
logback.xml配置文件，将此文件复制粘贴到src目录下（必须是src目录）然后就可以开始写代码了，在代码中创建一个日志记录对象
public static final Logger LOGGER = LoggerFactory.getLogger("当前类名");public class LogBackTest { // 创建一个Logger日志对象 public static final Logger LOGGER = LoggerFactory.getLogger("LogBackTest"); public static void main(String[] args) { //while (true) { try { LOGGER.info("chu法方法开始执行~~~"); chu(10, 0); LOGGER.info("chu法方法执行成功~~~"); } catch (Exception e) { LOGGER.error("chu法方法执行失败了，出现了bug~~~"); } //} } public static void chu(int a, int b){ LOGGER.debug("参数a:" + a); LOGGER.debug("参数b:" + b); int c = a / b; LOGGER.info("结果是：" + c); } }当我们运行程序时，就可以看到控制台记录的日志
同时在文件中，也有一份这样的日志信息。文件在哪里内，从配置文件中去找
日志配置文件
Logback提供了一个核心配置文件logback.xml，日志框架在记录日志时会读取配置文件中的配置信息，从而记录日志的形式。具体可以做哪些配置呢？
- 可以配置日志输出的位置是文件、还是控制台
- 可以配置日志输出的格式
- 还可以配置日志关闭和开启、以及哪些日志输出哪些日志不输出。
-
如下图所示，控制日志往文件中输出，还是往控制台输出
-
-
如下图所示，控制打开和关闭日志
-
-
如下图所示，控制日志的输出的格式
-
日志级别
在哪里配置日志级别呢？
Logback只输出大于或者等于核心配置文件配置的日志级别信息。小于配置级别的日志信息，不被记录。
配置的是trace，则trace、debug、info、warn、error级别的日志都被输出
配置的是debug, 则debug、info、warn、error级别的日志被输出
配置的是info,则info、warn、error级别的日志被输出
…
多线程
方式 优点 缺点 继承Thread类 编程比较简单，可以直接使用Thread类中的方法 扩展性较差，不能再继承其他的类，不能返回线程执行的结果 实现Runnable接口 扩展性强，实现该接口的同时还可以继承其他的类。 编程相对复杂，不能返回线程执行的结果 实现Callable接口 扩展性强，实现该接口的同时还可以继承其他的类。可以得到线程执行的结果 编程相对复杂
线程其实是程序中的一条执行路径。
我们之前写过的程序，其实都是单线程程序，如下图代码，如果前面的for循环没有执行完，for循环下面的代码是不会执行的。
怎样的程序才是多线程程序呢？
12306网站就是支持多线程的，因为同时可以有很多人一起进入网站购票，而且每一个人互不影响。再比如百度网盘，可以同时下载或者上传多个文件。这些程序中其实就有多条执行路径，每一条执行执行路径就是一条线程，所以这样的程序就是多线程程序。
创建方式
线程创建方式1
Java为开发者提供了一个类叫做Thread，此类的对象用来表示线程。创建线程并执行线程的步骤如下
1.定义一个子类继承Thread类，并重写run方法
2.创建Thread的子类对象
3.调用start方法启动线程（启动线程后，会自动执行run方法中的代码）public class MyThread extends Thread{ // 2、必须重写Thread类的run方法 @Override public void run() { // 描述线程的执行任务。 for (int i = 1; i <= 5; i++) { System.out.println("子线程MyThread输出：" + i); } } }再定义一个测试类，在测试类中创建MyThread线程对象，并启动线程
public class ThreadTest1 { // main方法是由一条默认的主线程负责执行。 public static void main(String[] args) { // 3、创建MyThread线程类的对象代表一个线程 Thread t = new MyThread(); // 4、启动线程（自动执行run方法的） t.start(); for (int i = 1; i <= 5; i++) { System.out.println("主线程main输出：" + i); } } }打印结果如下图所示，我们会发现MyThread和main线程在相互抢夺CPU的执行权（注意：哪一个线程先执行，哪一个线程后执行，目前我们是无法控制的，每次输出结果都会不一样）
最后我们还需要注意一点：不能直接去调用run方法，如果直接调用run方法就不认为是一条线程启动了，而是把Thread当做一个普通对象，此时run方法中的执行的代码会成为主线程的一部分。
线程创建方式2
Java为开发者提供了一个Runnable接口，该接口中只有一个run方法，意思就是通过Runnable接口的实现类对象专门来表示线程要执行的任务。具体步骤如下
1.先写一个Runnable接口的实现类，重写run方法(这里面就是线程要执行的代码)
2.再创建一个Runnable实现类的对象
3.创建一个Thread对象，把Runnable实现类的对象传递给Thread
4.调用Thread对象的start()方法启动线程（启动后会自动执行Runnable里面的run方法）
代码如下：先准备一个Runnable接口的实现类
/** * 1、定义一个任务类，实现Runnable接口 */ public class MyRunnable implements Runnable{ // 2、重写runnable的run方法 @Override public void run() { // 线程要执行的任务。 for (int i = 1; i <= 5; i++) { System.out.println("子线程输出 ===》" + i); } } }再写一个测试类，在测试类中创建线程对象，并执行线程
public class ThreadTest2 { public static void main(String[] args) { // 3、创建任务对象。 Runnable target = new MyRunnable(); // 4、把任务对象交给一个线程对象处理。 // public Thread(Runnable target) new Thread(target).start(); for (int i = 1; i <= 5; i++) { System.out.println("主线程main输出 ===》" + i); } } }运行上面代码，结果如下图所示**（注意：没有出现下面交替执行的效果，也是正常的）**
主线程main输出 ===》1 主线程main输出 ===》2 主线程main输出 ===》3 子线程输出 ===》1 子线程输出 ===》2 子线程输出 ===》3 子线程输出 ===》4 子线程输出 ===》5 主线程main输出 ===》4 主线程main输出 ===》5线程创建方式2—匿名内部类
现在我不想写Runnable实现类，于是可以直接创建Runnable接口的匿名内部类对象，传递给Thread对象。
public class ThreadTest2_2 { public static void main(String[] args) { // 1、直接创建Runnable接口的匿名内部类形式（任务对象） Runnable target = new Runnable() { @Override public void run() { for (int i = 1; i <= 5; i++) { System.out.println("子线程1输出：" + i); } } }; new Thread(target).start(); // 简化形式1： new Thread(new Runnable() { @Override public void run() { for (int i = 1; i <= 5; i++) { System.out.println("子线程2输出：" + i); } } }).start(); // 简化形式2： new Thread(() -> { for (int i = 1; i <= 5; i++) { System.out.println("子线程3输出：" + i); } }).start(); for (int i = 1; i <= 5; i++) { System.out.println("主线程main输出：" + i); } } }
线程的创建方式3
假设线程执行完毕之后有一些数据需要返回，前面两种方式重写的run方法均没有返回结果。
public void run(){ ...线程执行的代码... }JDK5提供了
Callable接口和FutureTask类来创建线程，它最大的优点就是有返回值。在Callable接口中有一个call方法，重写call方法就是线程要执行的代码，它是有返回值的
public T call(){ ...线程执行的代码... return 结果; }步骤如下
1.先定义一个Callable接口的实现类，重写call方法
2.创建Callable实现类的对象
3.创建FutureTask类的对象，将Callable对象传递给FutureTask
4.创建Thread对象，将Future对象传递给Thread
5.调用Thread的start()方法启动线程(启动后会自动执行call方法)
等call()方法执行完之后，会自动将返回值结果封装到FutrueTask对象中6.调用FutrueTask对的get()方法获取返回结果
FutureTask提供的构造器 说明 public FutureTask<>(Callable call) 把Callable对象封装成FutureTask对象。
FutureTask提供的方法 说明 public V get() throws Exception 获取线程执行call方法返回的结果。
准备一个Callable接口的实现类
再如下：
public class ThreadTest3 { public static void main(String[] args) throws Exception { // 3、创建一个Callable的对象 Callable<String> call = new MyCallable(100); // 4、把Callable的对象封装成一个FutureTask对象（任务对象） // 未来任务对象的作用？ // 1、是一个任务对象，实现了Runnable对象. // 2、可以在线程执行完毕之后，用未来任务对象调用get方法获取线程执行完毕后的结果。 FutureTask<String> f1 = new FutureTask<>(call); // 5、把任务对象交给一个Thread对象 new Thread(f1).start(); Callable<String> call2 = new MyCallable(200); FutureTask<String> f2 = new FutureTask<>(call2); new Thread(f2).start(); // 6、获取线程执行完毕后返回的结果。 // 注意：如果执行到这儿，假如上面的线程还没有执行完毕 // 这里的代码会暂停，等待上面线程执行完毕后才会获取结果。 String rs = f1.get(); System.out.println(rs); String rs2 = f2.get(); System.out.println(rs2); } }
多线程常用方法
public class MyThread extends Thread{ public MyThread(String name){ super(name); //1.执行父类Thread(String name)构造器，为当前线程设置名字了 } @Override public void run() { //2.currentThread() 哪个线程执行它，它就会得到哪个线程对象。 Thread t = Thread.currentThread(); for (int i = 1; i <= 3; i++) { //3.getName() 获取线程名称 System.out.println(t.getName() + "输出：" + i); } } }测试类中，创建线程对象，并启动线程
public class ThreadTest1 { public static void main(String[] args) { Thread t1 = new MyThread(); t1.setName(String name) //设置线程名称; t1.start(); System.out.println(t1.getName()); //Thread-0 Thread t2 = new MyThread("2号线程"); // t2.setName("2号线程"); t2.start(); System.out.println(t2.getName()); // Thread-1 // 主线程对象的名字 // 哪个线程执行它，它就会得到哪个线程对象。 Thread m = Thread.currentThread(); m.setName("最牛的线程"); System.out.println(m.getName()); // main for (int i = 1; i <= 5; i++) { System.out.println(m.getName() + "线程输出：" + i); } } }
-
最后再演示一下join这个方法是什么效果。
-
public class ThreadTest2 { public static void main(String[] args) throws Exception { // join方法作用：让当前调用这个方法的线程先执行完。 Thread t1 = new MyThread("1号线程"); t1.start(); t1.join(); Thread t2 = new MyThread("2号线程"); t2.start(); t2.join(); Thread t3 = new MyThread("3号线程"); t3.start(); t3.join(); } }执行效果是1号线程先执行完，再执行2号线程；2号线程执行完，再执行3号线程；3号线程执行完就结束了。
-
线程安全问题
- 什么是线程安全问题呢？
线程安全问题指的是，多个线程同时操作同一个共享资源的时候，可能会出现业务安全问题。
场景：小明和小红是一对夫妻，他们有一个共享账户，余额是10万元，小红和小明同时来取钱，并且2人各自都在取钱10万元，可能出现什么问题呢？
如下图所示，小明和小红假设都是一个线程，本类每个线程都应该执行完三步操作，才算是完成的取钱的操作。但是真实执行过程可能是下面这样子的
① 小红线程只执行了判断余额是否足够（条件为true），然后CPU的执行权就被小红线程抢走了。
② 小红线程也执行了判断了余额是否足够（条件也是true）, 然后CPU执行权又被小明线程抢走了。
③ 小明线程由于刚才已经判断余额是否足够了，直接执行第2步，吐出了10万元钱，此时共享账户月为0。然后CPU执行权又被小红线程抢走。
④ 小红线程由于刚刚也已经判断余额是否足够了，直接执行第2步，吐出了10万元钱，此时共享账户月为-10万。
你会发现，在这个取钱案例中，两个人把共享账户的钱都取了10万，但问题是只有10万块钱啊！！！
以上取钱案例中的问题，就是线程安全问题的一种体现。
-
代码演示
-
先定义一个共享的账户类
public class Account { private String cardId; // 卡号 private double money; // 余额。 public Account() { } public Account(String cardId, double money) { this.cardId = cardId; this.money = money; } // 小明 小红同时过来的 public void drawMoney(double money) { // 先搞清楚是谁来取钱？ String name = Thread.currentThread().getName(); // 1、判断余额是否足够 if(this.money >= money){ System.out.println(name + "来取钱" + money + "成功！"); this.money -= money; System.out.println(name + "来取钱后，余额剩余：" + this.money); }else { System.out.println(name + "来取钱：余额不足~"); } } public String getCardId() { return cardId; } public void setCardId(String cardId) { this.cardId = cardId; } public double getMoney() { return money; } public void setMoney(double money) { this.money = money; } }在定义一个是取钱的线程类
public class DrawThread extends Thread{ private Account acc; public DrawThread(Account acc, String name){ super(name); this.acc = acc; } @Override public void run() { // 取钱(小明，小红) acc.drawMoney(100000); } }public class ThreadTest { public static void main(String[] args) { // 1、创建一个账户对象，代表两个人的共享账户。 Account acc = new Account("ICBC-110", 100000); // 2、创建两个线程，分别代表小明 小红，再去同一个账户对象中取钱10万。 new DrawThread(acc, "小明").start(); // 小明 new DrawThread(acc, "小红").start(); // 小红 } }
线程同步方案
同步最常见的方案就是加锁，意思是每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动释放锁，然后其他线程才能再加锁进来。
怎么加锁呢？Java提供了三种方案
1.同步代码块
2.同步方法
3.Lock锁
同步代码块
它的作用就是把访问共享数据的代码锁起来，以此保证线程安全。
//锁对象：必须是一个唯一的对象（同一个地址） synchronized(锁对象){ //...访问共享数据的代码... }使用同步代码块，来解决前面代码里面的线程安全问题。我们只需要修改DrawThread类中的代码即可。
// 小明 小红线程同时过来的 public void drawMoney(double money) { // 先搞清楚是谁来取钱？ String name = Thread.currentThread().getName(); // 1、判断余额是否足够 // this正好代表共享资源！ synchronized (this) { if(this.money >= money){ System.out.println(name + "来取钱" + money + "成功！"); this.money -= money; System.out.println(name + "来取钱后，余额剩余：" + this.money); }else { System.out.println(name + "来取钱：余额不足~"); } } }最后，再给同学们说一下锁对象如何选择的问题
1.建议把共享资源作为锁对象, 不要将随便无关的对象当做锁对象 2.对于实例方法，建议使用this作为锁对象 3.对于静态方法，建议把类的字节码(类名.class)当做锁对象
同步方法
同步方法，就是把整个方法给锁住，一个线程调用这个方法，另一个线程调用的时候就执行不了，只有等上一个线程调用结束，下一个线程调用才能继续执行。
// 同步方法 public synchronized void drawMoney(double money) { // 先搞清楚是谁来取钱？ String name = Thread.currentThread().getName(); // 1、判断余额是否足够 if(this.money >= money){ System.out.println(name + "来取钱" + money + "成功！"); this.money -= money; System.out.println(name + "来取钱后，余额剩余：" + this.money); }else { System.out.println(name + "来取钱：余额不足~"); } }接着，再问同学们一个问题，同步方法有没有锁对象？锁对象是谁？
同步方法也是有锁对象，只不过这个锁对象没有显示的写出来而已。
1.对于实例方法，锁对象其实是this（也就是方法的调用者）
2.对于静态方法，锁对象时类的字节码对象（类名.class）
-
总结一下同步代码块和同步方法有什么区别？
-
1.不存在哪个好与不好，只是一个锁住的
范围大，一个范围小
2.同步方法是将方法中所有的代码锁住
3.同步代码块是将方法中的部分代码锁住
Lock锁
构造器 说明 public ReentrantLock() 获得Lock锁的实现类对象
Lock锁是JDK5版本专门提供的一种锁对象，通过这个锁对象的方法来达到加锁，和释放锁的目的，使用起来更加灵活。格式如下
1.首先在成员变量位子，需要创建一个Lock接口的实现类对象（这个对象就是锁对象） private final Lock lk = new ReentrantLock(); 2.在需要上锁的地方加入下面的代码 lk.lock(); // 加锁 //...中间是被锁住的代码... lk.unlock(); // 解锁使用Lock锁改写前面DrawThread中取钱的方法，代码如下
// 创建了一个锁对象 private final Lock lk = new ReentrantLock(); public void drawMoney(double money) { // 先搞清楚是谁来取钱？ String name = Thread.currentThread().getName(); try { lk.lock(); // 加锁 // 1、判断余额是否足够 if(this.money >= money){ System.out.println(name + "来取钱" + money + "成功！"); this.money -= money; System.out.println(name + "来取钱后，余额剩余：" + this.money); }else { System.out.println(name + "来取钱：余额不足~"); } } catch (Exception e) { e.printStackTrace(); } finally { lk.unlock(); // 解锁 } } }
线程通信
方法名称 说明 void wait() 让当前线程等待并释放所占锁，直到另一个线程调用notify()方法或 notifyAll()方法 void notify() 唤醒正在等待的单个线程 void notifyAll() 唤醒正在等待的所有线程
什么是线程通信呢？
- 当多个线程共同操作共享资源时，线程间通过某种方式互相告知自己的状态，以相互协调，避免无效的资源挣抢。
线程通信的常见模式：是生产者与消费者模型
- 生产者线程负责生成数据
- 消费者线程负责消费生产者生成的数据
- 注意：生产者生产完数据后应该让自己等待，通知其他消费者消费；消费者消费完数据之后应该让自己等待，同时通知生产者生成。
比如下面案例中，有3个厨师（生产者线程），两个顾客（消费者线程）。
思路：
1.先确定在这个案例中，什么是共享数据？ 答：这里案例中桌子是共享数据，因为厨师和顾客都需要对桌子上的包子进行操作。 2.再确定有那几条线程？哪个是生产者，哪个是消费者？ 答：厨师是生产者线程，3条生产者线程； 顾客是消费者线程，2条消费者线程 3.什么时候将哪一个线程设置为什么状态 生产者线程(厨师)放包子： 1)先判断是否有包子 2)没有包子时，厨师开始做包子, 做完之后把别人唤醒，然后让自己等待 3)有包子时，不做包子了，直接唤醒别人、然后让自己等待 消费者线程(顾客)吃包子： 1)先判断是否有包子 2)有包子时，顾客开始吃包子, 吃完之后把别人唤醒，然后让自己等待 3)没有包子时，不吃包子了，直接唤醒别人、然后让自己等待先写桌子类，代码如下
public class Desk { private List<String> list = new ArrayList<>(); // 放1个包子的方法 // 厨师1 厨师2 厨师3 public synchronized void put() { try { String name = Thread.currentThread().getName(); // 判断是否有包子。 if(list.size() == 0){ list.add(name + "做的肉包子"); System.out.println(name + "做了一个肉包子~~"); Thread.sleep(2000); // 唤醒别人, 等待自己 this.notifyAll(); this.wait(); }else { // 有包子了，不做了。 // 唤醒别人, 等待自己 this.notifyAll(); this.wait(); } } catch (Exception e) { e.printStackTrace(); } } // 吃货1 吃货2 public synchronized void get() { try { String name = Thread.currentThread().getName(); if(list.size() == 1){ // 有包子，吃了 System.out.println(name + "吃了：" + list.get(0)); list.clear(); Thread.sleep(1000); this.notifyAll(); this.wait(); }else { // 没有包子 this.notifyAll(); this.wait(); } } catch (Exception e) { e.printStackTrace(); } } }再写测试类，在测试类中，创建3个厨师线程对象，再创建2个顾客对象，并启动所有线程
public class ThreadTest { public static void main(String[] args) { // 需求：3个生产者线程，负责生产包子，每个线程每次只能生产1个包子放在桌子上 // 2个消费者线程负责吃包子，每人每次只能从桌子上拿1个包子吃。 Desk desk = new Desk(); // 创建3个生产者线程（3个厨师） new Thread(() -> { while (true) { desk.put(); } }, "厨师1").start(); new Thread(() -> { while (true) { desk.put(); } }, "厨师2").start(); new Thread(() -> { while (true) { desk.put(); } }, "厨师3").start(); // 创建2个消费者线程（2个吃货） new Thread(() -> { while (true) { desk.get(); } }, "吃货1").start(); new Thread(() -> { while (true) { desk.get(); } }, "吃货2").start(); } }厨师1做了一个肉包子~~
吃货2吃了：厨师1做的肉包子
厨师3做了一个肉包子~~
吃货2吃了：厨师3做的肉包子
厨师1做了一个肉包子~~
吃货1吃了：厨师1做的肉包子
厨师2做了一个肉包子~~
吃货2吃了：厨师2做的肉包子
厨师3做了一个肉包子~~
吃货1吃了：厨师3做的肉包子
线程池
线程池就是一个可以复用线程的技术。
假设：用户每次发起一个请求给后台，后台就创建一个新的线程来处理，下次新的任务过来肯定也会创建新的线程，如果用户量非常大，创建的线程也讲越来越多。然而，创建线程是开销很大的，并且请求过多时，会严重影响系统性能。
而使用线程池，就可以解决上面的问题。如下图所示，线程池内部会有一个容器，存储几个核心线程，假设有3个核心线程，这3个核心线程可以处理3个任务。
但是任务总有被执行完的时候，假设第1个线程的任务执行完了，那么第1个线程就空闲下来了，有新的任务时，空闲下来的第1个线程可以去执行其他任务。依此内推，这3个线程可以不断的复用，也可以执行很多个任务。
所以，线程池就是一个线程复用技术，它可以提高线程的利用率。
创建线程池
在JDK5版本中提供了代表线程池的接口ExecutorService，而这个接口下有一个实现类叫ThreadPoolExecutor类，使用ThreadPoolExecutor类就可以用来创建线程池对象。
-
用这7个参数的构造器来创建线程池的对象。代码如下
-
ExecutorService pool = new ThreadPoolExecutor( 3, //核心线程数有3个 5, //最大线程数有5个。 临时线程数=最大线程数-核心线程数=5-3=2 8, //临时线程存活的时间8秒。 意思是临时线程8秒没有任务执行，就会被销毁掉。 TimeUnit.SECONDS,//时间单位（秒） new ArrayBlockingQueue<>(4), //任务阻塞队列，没有来得及执行的任务在，任务队列中等待 Executors.defaultThreadFactory(), //用于创建线程的工厂对象 new ThreadPoolExecutor.CallerRunsPolicy() //拒绝策略 );- 注意：
- 临时线程什么时候创建？
新任务提交时，发现核心线程都在忙、任务队列满了、并且还可以创建临时线程，此时会创建临时线程。
- 什么时候开始拒绝新的任务？
核心线程和临时线程都在忙、任务队列也满了、新任务过来时才会开始拒绝任务。
线程池执行Runnable任务
线程池执行的任务可以有两种，一种是Runnable任务；一种是callable任务。下面的execute方法可以用来执行Runnable任务。
先准备一个线程任务类
public class MyRunnable implements Runnable{ @Override public void run() { // 任务是干啥的？ System.out.println(Thread.currentThread().getName() + " ==> 输出666~~"); //为了模拟线程一直在执行，这里睡久一点 try { Thread.sleep(Integer.MAX_VALUE); } catch (InterruptedException e) { e.printStackTrace(); } } }下面是执行Runnable任务的代码，注意阅读注释，对照着前面的7个参数理解。
ExecutorService pool = new ThreadPoolExecutor( 3, //核心线程数有3个 5, //最大线程数有5个。 临时线程数=最大线程数-核心线程数=5-3=2 8, //临时线程存活的时间8秒。 意思是临时线程8秒没有任务执行，就会被销毁掉。 TimeUnit.SECONDS,//时间单位（秒） new ArrayBlockingQueue<>(4), //任务阻塞队列，没有来得及执行的任务在，任务队列中等待 Executors.defaultThreadFactory(), //用于创建线程的工厂对象 new ThreadPoolExecutor.CallerRunsPolicy() //拒绝策略 ); Runnable target = new MyRunnable(); pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！ pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！ pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！ //下面4个任务在任务队列里排队 pool.execute(target); pool.execute(target); pool.execute(target); pool.execute(target); //下面2个任务，会被临时线程的创建时机了 pool.execute(target); pool.execute(target); // 到了新任务的拒绝时机了！ pool.execute(target);
线程池执行Callable任务
callable任务相对于Runnable任务来说，就是多了一个返回值。
执行Callable任务需要用到下面的submit方法
先准备一个Callable线程任务
public class MyCallable implements Callable<String> { private int n; public MyCallable(int n) { this.n = n; } // 2、重写call方法 @Override public String call() throws Exception { // 描述线程的任务，返回线程执行返回后的结果。 // 需求：求1-n的和返回。 int sum = 0; for (int i = 1; i <= n; i++) { sum += i; } return Thread.currentThread().getName() + "求出了1-" + n + "的和是：" + sum; } }再准备一个测试类，在测试类中创建线程池，并执行callable任务。
public class ThreadPoolTest2 { public static void main(String[] args) throws Exception { // 1、通过ThreadPoolExecutor创建一个线程池对象。 ExecutorService pool = new ThreadPoolExecutor( 3, 5, 8, TimeUnit.SECONDS, new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(), new ThreadPoolExecutor.CallerRunsPolicy()); // 2、使用线程处理Callable任务。 Future<String> f1 = pool.submit(new MyCallable(100)); Future<String> f2 = pool.submit(new MyCallable(200)); Future<String> f3 = pool.submit(new MyCallable(300)); Future<String> f4 = pool.submit(new MyCallable(400)); // 3、执行完Callable任务后，需要获取返回结果。 System.out.println(f1.get()); System.out.println(f2.get()); System.out.println(f3.get()); System.out.println(f4.get()); } }
线程池工具类（Executors）
前面创建线程池的代码参数太多、记不住，有没有快捷的创建线程池的方法呢？有的。Java为开发者提供了一个创建线程池的工具类，叫做Executors，它提供了方法可以创建各种不能特点的线程池。如下图所示
我们演示一下创建固定线程数量的线程池。这几个方法用得不多，所以这里不做过多演示，同学们了解一下就行了。
核心线程数量到底配置多少呢？？？
计算密集型的任务：核心线程数量 = CPU的核数 + 1
IO密集型的任务：核心线程数量 = CPU核数 * 2public class ThreadPoolTest3 { public static void main(String[] args) throws Exception { // 1、通过Executors创建一个线程池对象。 ExecutorService pool = Executors.newFixedThreadPool(17); // 2、使用线程处理Callable任务。 Future<String> f1 = pool.submit(new MyCallable(100)); Future<String> f2 = pool.submit(new MyCallable(200)); Future<String> f3 = pool.submit(new MyCallable(300)); Future<String> f4 = pool.submit(new MyCallable(400)); System.out.println(f1.get()); System.out.println(f2.get()); System.out.println(f3.get()); System.out.println(f4.get()); } }Executors创建线程池这么好用，为什么不推荐同学们使用呢？原因在这里：看下图，这是《阿里巴巴Java开发手册》提供的强制规范要求。
线程的生命周期
在Thread类中有一个嵌套的枚举类叫Thread.Status，这里面定义了线程的6中状态。
NEW: 新建状态，线程还没有启动
RUNNABLE: 可以运行状态，线程调用了start()方法后处于这个状态
BLOCKED: 锁阻塞状态，没有获取到锁处于这个状态
WAITING: 无限等待状态，线程执行时被调用了wait方法处于这个状态
TIMED_WAITING: 计时等待状态，线程执行时被调用了sleep(毫秒)或者wait(毫秒)方法处于这个状态
TERMINATED: 终止状态, 线程执行完毕或者遇到异常时，处于这个状态。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
