【Day10-配置文件&日志&多线程】

最新推荐文章于 2024-09-10 10:21:38 发布
最新推荐文章于 2024-09-10 10:21:38 发布
阅读量1.1k 收藏 28
点赞数 16
文章标签： java 开发语言 学习 学习方法 程序人生
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Doshaxin/article/details/142032120
版权

配置文件

        介绍 

        配置文件 

  • 在企业开发过程中，我们习惯把一些需要灵活配置的数据放在一些文本文件中，而不是在Java代码写死
  • 我们把这种存放程序配置信息的文件，统称为配置文件

 

          Properties

  • 是一个Map集合（键值对集合），但是我们一般不会当集合使用。
  • 核心作用：Properties是用来代表属性文件的，通过Properties可以读写属性文件里的内容。

使用Properties读取属性文件里的键值对数据 

 使用Properties把键值对数据写出到属性文件里去

/*
properties配置文件
特点:
    1、都只能是键值对
    2、键不能重复
    3、文件后缀一般是.properties结尾的

Properties
    这是一个Map集合（键值对集合），但是我们一般不会当集合使用
    主要用来代表属性文件，通过Properties可以读写属性文件里的内容

读取
    public Properties()  创建Properties集合对象

    public void load(InputStream is/Reader reader)  通过输入流读取文件中的键值对数据
    public String getProperty(String key) 	根据键获取值(其实就是get方法的效果)
    public Set<String> stringPropertyNames()	获取全部键的集合（其实就是ketSet方法的效果）

写出
    public Properties()  创建Properties集合对象

    public Object setProperty(String key, String value) 	保存键值对数据到Properties对象中去。
    public void store(OutputStream os/Writer writer, String comments)	把键值对数据，通过输出流写出到属性文件里去
*/
public class Demo1 {
    public static void main(String[] args) throws IOException {
        //1. 创建一个配置文件对象
        Properties prop = new Properties();
        prop.load(new FileReader("day10-code/user.properties"));
        //2. 读取
        String admin = prop.getProperty("admin");
        System.out.println(admin);
        Set<String> keys = prop.stringPropertyNames();
        for (String key : keys) {
            String value = prop.getProperty(key);
            System.out.println(key + "--" + value);
        }
        //3. 写出
        Properties prop2 = new Properties();
        prop2.setProperty("SSS", "888");
        prop2.setProperty("AAA", "999");
        prop2.store(new FileWriter("day10-code/user2.properties"),"abc");
    }
}

        1、Properties的作用？具体如何使用？

                可以加载属性文件中的数据到Properties对象中来

                void load​(Reader reader)

                public String getProperty(String key)   根据键获取值

                可以存储Properties属性集的键值对数据到属性文件中去

                void store​(Writer writer, String comments)  设置键值

                public Object setProperty(String key, String value)

        XML 

        认识XML

 

        XML
  • 全称Extensible Markup Language， 可扩展标记语言
  • 本质是一种数据的格式，可以用来存储复杂的数据结构，和数据关系。

        XML的特点
  • XML中的“<标签名>” 称为一个标签或一个元素，一般是成对出现的。
  • XML中的标签名可以自己定义（可扩展），但必须要正确的嵌套。
  • XML中只能有一个根标签。
  • XML中的标签可以有属性。
  • 如果一个文件中放置的是XML格式的数据，这个文件就是XML文件，后缀一般要写成.xml。
        XML的语法规则
  • XML文件的后缀名为：xml，文档声明必须是第一行

 

  • XML中可以定义注释信息：<!–- 注释内容 -->，快捷键是Ctrl+shift+/
  • XML中书写”<”、“&”等，可能会出现冲突，导致报错，此时可以用如下特殊字符替代。

  • XML中可以写一个叫CDATA的数据区: <![CDATA[   …内容…  ]]>，里面的内容可以随便写。直接输入CD，就会有提示 
<?xml version="1.0" encoding="UTF-8" ?>
<!--这是注释内容-->
<users>
    <user id="1">
        <name>张无忌</name>
        <password>minmin</password>
        <address>光明顶</address>
        <gender>男</gender>
    </user>
    <user id="2">
        <name>敏敏</name>
        <password><![CDATA[
            < > &
        ]]></password>
        <address>光明顶</address>
        <gender>女</gender>
    </user>
</users>
        XML的作用和应用场景
  • 本质是一种数据格式，可以存储复杂的数据结构，和数据关系。
  • 应用场景：经常用来做为系统的配置文件；或者作为一种特殊的数据结构，在网络中进行传输。

        1、XML是什么?  有啥作用？

                XML的是一种可扩展的标记语言。

                作用：1）作为软件的配置文件   2）用于进行存储数据和传输数据

        2、XML的组成格式要求是什么样的？

                文件后缀一般是是xml，文档声明必须是第一行

                必须存在一个根标签，有且只能有一个

                XML文件中可以定义注释信息：<!–- 注释内容 -->

                标签必须成对出现，有开始，有结束标签: <name></name>

                必须能够正确的嵌套

         读取XML

         解析XML文件
  • 使用程序读取XML文件中的数据
         DOM4J解析XML文件的思想：文档对象模型
         Dom4j解析XML-得到Document对象

SAXReader：Dom4j提供的解析器，可以认为是代表整个Dom4j框架 

构造器/方法

说明

public SAXReader()

构建Dom4J的解析器对象

public Document read(String path)

把XML文件读成Document对象

 Document

方法名

说明

Element getRootElement()

获得根元素对象

Element提供的方法 

方法名

说明

public String getName()

得到元素名字

public List<Element> elements()

得到当前元素下所有子元素

public List<Element> elements(String name)

得到当前元素下指定名字的子元素返回集合

public Element element(String name)

得到当前元素下指定名字的子元素,如果有很多名字相同的返回第一个

public String  attributeValue(String name)

通过属性名直接得到属性值

public String elementText(子元素名)

得到指定名称的子元素的文本

public String getText()

得到文本

         案例：

/*
需求: 解析b-2.xml,将内容封装到一个List<User对象的集合>

XML解析
    DOM解析思想
        DOM (document Object Model)文档对象模型
        将文档的各个组成部分看做是对应的对象
        首先会将xml文件全部加载到内存，在内存中形成一个树状结构，在获取对应的值
        DOM解析思想就是一层一层的进入，一层一层的解析

    对象分类
        Document:整个xml文档对象
        Element: 标签对象
        Attribute:属性对象
        Text标签体:文本对象

    DOM4J解析XML准备工作
        1、将dom4j的jar包加入到项目中
        2、创建DOM4]解析器对象SAXReader，获取Document文档对象，获取根标签对象
        3、从根标签对象开始往下层层解析


    详细API
        SAXReader：Dom4j提供的解析器，可以认为是代表整个Dom4j框架
            public SAXReader() 	构建Dom4J的解析器对象
            public Document read(String path)	把XML文件读成Document对象
        Element getRootElement() 	获得根元素对象
            public String getName()	得到元素名字
            public List<Element> elements()	得到当前元素下所有子元素
            public List<Element> elements(String name)	得到当前元素下指定名字的子元素返回集合
            public Element element(String name)	得到当前元素下指定名字的子元素,如果有很多名字相同的返回第一个
            public String  attributeValue(String name)	通过属性名直接得到属性值
            public String elementText(子元素名)	得到指定名称的子元素的文本
            public String getText()	得到文本

 */
public class Demo2 {
    public static void main(String[] args) throws Exception {
        ArrayList<User> users = new ArrayList<>();
//        1、将dom4j的jar包加入到项目中
//        2、创建DOM4]解析器对象SAXReader，获取Document文档对象，获取根标签对象
        SAXReader saxReader = new SAXReader();
        //读取xml文件
        Document document = saxReader.read(new FileReader("day10-code/b-2.xml"));
//        3、从根标签对象开始往下层层解析
        Element rootElement = document.getRootElement();
        //获取根标签的名字
        String rootName = rootElement.getName();
        System.out.println("name=" + rootName);
        //获取根标签下的所有子标签
        List<Element> elements = rootElement.elements();
        System.out.println(elements.size());
        //遍历标签的集合
        for (Element element : elements) {
            String name = element.getName();
            String id = element.attributeValue("id");
            System.out.println("子标签名字：" + name + id);
            List<Element> elements1 = element.elements();
            System.out.println(elements1.size());
            String userName = element.element("name").getText();
            System.out.println("name" + userName);
            String password = element.element("password").getText();
            System.out.println("password" + password);
            String address = element.element("address").getText();
            System.out.println("address" + address);
            String gender = element.element("gender").getText();
            System.out.println("gender" + gender);
            User user = new User(userName, password, address, gender);
            users.add(user);
        }
        for (User user : users) {
            System.out.println(user);
        }
    }
}
class User{
    private String name;
    private String password;
    private String address;
    private String gender;

    public User() {
    }

    public User(String name, String password, String address, String gender) {
        this.name = name;
        this.password = password;
        this.address = address;
        this.gender = gender;
    }


    public String getName() {
        return name;
    }


    public void setName(String name) {
        this.name = name;
    }


    public String getPassword() {
        return password;
    }


    public void setPassword(String password) {
        this.password = password;
    }


    public String getAddress() {
        return address;
    }


    public void setAddress(String address) {
        this.address = address;
    }


    public String getGender() {
        return gender;
    }


    public void setGender(String gender) {
        this.gender = gender;
    }

    public String toString() {
        return "User{name = " + name + ", password = " + password + ", address = " + address + ", gender = " + gender + "}";
    }
}

<?xml version="1.0" encoding="UTF-8" ?>
<users>
    <user id="1">
        <name>张无忌</name>
        <password>minmin</password>
        <address>光明顶</address>
        <gender>男</gender>
    </user>
    <user id="2">
        <name>敏敏</name>
        <password>wuji</password>
        <address>光明顶</address>
        <gender>女</gender>
    </user>
</users>

         XML约束

         什么是约束XML文件的书写？
  • 就是限制XML文件只能按照某种格式进行书写。 

         约束文档

  • 专门用来限制xml书写格式的文档，比如：限制标签、属性应该怎么写。 

        约束文档的分类

  • DTD文档
  • Schema文档

        XML文档约束-DTD的使用（了解） 

需求：利用DTD约束文档，约束一个XML文件的编写。

①：编写DTD约束文档，后缀必须是.dtd

②：在需要编写的XML文件中导入该DTD约束文档

③：然后XML文件，就必须按照DTD约束文档指定的格式进行编写，否则报错！

        XML文档约束-schema的使用（了解） 

需求：利用schema文档约束，约束一个XML文件的编写。

①：编写schema约束文档，后缀必须是.xsd，具体的形式到代码中观看。

②：在需要编写的XML文件中导入该schema约束文档

③：按照约束内容编写XML文件的标签。

/*
案例需求: 将如下数据写入到b-3.xml中
    <?xml version="1.0"encoding="UTF-8"?>
    <book>
        <name>Java从入门到放弃</name>
        <author>黑马-小明老师</author>
        <price>89.5</price>
    </book>

如何从程序中写数据到xml文件中
    不建议用DOM4J将数据写入到xml文件中
    推荐在java代码中，将数拼接成xml格式，用IO流写出去
*/
public class Demo3 {
    public static void main(String[] args) throws Exception {
        //1.拼接xml内容的字符串
        //使用可变字符串对象去拼接
        StringBuilder sb = new StringBuilder();
        sb.append("<?xml version=\"1.0\"encoding=\"UTF-8\"?>\r\n");
        sb.append("<book>\r\n");
        sb.append("<name>Java从入门到放弃</name>\r\n");
        sb.append("<author>黑马-小明老师</author>\r\n");
        sb.append("<price>89.5</price>\r\n");
        sb.append("</book>\r\n");
        //拼接完成后返回字符串
        String xmlStr = sb.toString();
        //2.IO流写到文件
        try (
                FileWriter writer = new FileWriter("day10-code/b-3.xml")
        ){
            //使用Writer, FileWriter
            //把拼接好的字符串写到文件中
            writer.write(xmlStr);
            //关闭流
//            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

 日志文件

         概述

 

        日志技术 

  • 可以将系统执行的信息，方便的记录到指定的位置（控制台、文件中、数据库中）。
  • 可以随时以开关的形式控制日志的启停，无需侵入到源代码中去进行修改。

         日志技术的体系结构

  • 日志接口：设计日志框架的一套标准，日志框架需要实现这些接口。
  • 日志框架：牛人或者第三方公司已经做好的实现代码，后来者直接可以拿去使用。
  • 注意1：因为对Commons Logging接口不满意，有人就搞了SLF4J；因为对Log4j的性能不满意，有人就搞了Logback。
  • 注意2：Logback是基于slf4j的日志规范实现的框架。

        1、什么是日志？

                用来记录程序运行过程中的信息，并可以进行永久存储。

        2、常见的日志实现框架有哪些？

                Log4J、Logback(我们重点学习的，其他的都大同小异)

                Logback是基于slf4j日志接口实现的日志框架

        3、使用Logback至少需要使用哪几个模块？

                slf4j-api：日志接口

                logback-core：基础模块

                logback-classic：功能模块，它完整实现了slf4j API 

        Logback快速入门 

需求

使用 Logback 日志框架，纪录系统的运行信息。

实现步骤

①：导入Logback框架到项目中去。

②：将Logback框架的核心配置文件logback.xml直接拷贝到src目录下（必须是src下）。

③：创建Logback框架提供的Logger对象，然后用Logger对象调用其提供的方法就可以记录系统的日志信息 。

/*
需求
    使用Logback日志框架，纪录系统的运行信息。
实现步骤
    1. 导入Logback框架到项目中去。
    2. 将Logback框架的核心配置文件logback.xml直接拷贝到src目录下（必须是src下）。
    4. 创建Logback框架提供的Logger对象，然后用Logger对象调用其提供的方法就可以记录系统的日志信息。
        public static final Logger LOGGER = LoggerFactory.getLogger("当前类类名");
    5. 打印日志
        LOGGER.info("日志信息")
        LOGGER.debug("日志信息")
        LOGGER.error("日志信息")
*/
public class Demo1 {
    public static final Logger LOGGER = LoggerFactory.getLogger("Demo1");
    public static void main(String[] args) {
        LOGGER.info("你喜欢跳舞吗？");
        div(5,2);
        div(5,0);
    }

    public static int div(int a, int b) {
        int c = 0;
        try {
            LOGGER.debug("方法执行了，a={},b={}", a,b);
             c = a / b;

        } catch (Exception e) {
            LOGGER.error("{}/{}出错了", a, b);
            e.printStackTrace();
        }
        return c;
    }
}

        核心配置文件logback.xml

对Logback日志框架进行控制的。 

        日志的输出位置、输出格式的设置 

通常可以设置2个输出日志的位置：一个是控制台、一个是系统文件中 

         Logback设置日志级别

        什么是日志级别？ 

日志级别指的是日志信息的类型，日志都会分级别，常见的日志级别如下（优先级依次升高）： 

日志级别

说明

trace

追踪，指明程序运行轨迹

debug

调试，实际应用中一般将其作为最低级别，而 trace 则很少使用

info

输出重要的运行信息，数据连接、网络连接、IO操作等等，使用较多

warn

警告信息，可能会发生问题，使用较多

error

错误信息,  使用较多

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!--
        CONSOLE ：表示当前的日志信息是可以输出到控制台的。
    -->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <!--输出流对象 默认 System.out 改为 System.err-->
        <target>System.out</target>
        <encoder>
            <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度
                %msg：日志消息，%n是换行符-->
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%-5level]  %c [%thread] : %msg%n</pattern>
        </encoder>
    </appender>

    <!-- File是输出的方向通向文件的 -->
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
            <charset>utf-8</charset>
        </encoder>
        <!--日志输出路径-->
        <file>C:/log/itheima-data.log</file>
        <!--指定日志文件拆分和压缩规则-->
        <rollingPolicy
                class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <!--通过指定压缩文件名称，来确定分割文件方式-->
            <fileNamePattern>C:/log/itheima-data-%i-%d{yyyy-MM-dd}-.log.gz</fileNamePattern>
            <!--文件拆分大小-->
            <maxFileSize>1MB</maxFileSize>
        </rollingPolicy>
    </appender>

    <!--
        1、控制日志的输出情况：如，开启日志，取消日志
    -->
    <root level="ALL">
        <appender-ref ref="CONSOLE"/>
        <appender-ref ref="FILE" />
    </root>
</configuration>

         为什么要学习日志级别？ 

 

只有日志的级别是大于或等于核心配置文件配置的日志级别，才会被记录，否则不记录。 

        1、设置日志输出级别的作用是什么？

                用于控制系统中哪些日志级别是可以输出的

        2、Logback的日志级别是什么样的？ 

                ALL  和 OFF分别是打开全部日志和关闭全部日志

                级别程度依次是：TRACE< DEBUG< INFO<WARN<ERROR

                默认级别是debug（忽略大小写），只输出当前级别及高于该级别的日志

 多线程

        什么是线程？ 

  • 线程：简单的说，就是计算机在做一件事
  • 单线程：在计算机中同一时间只能做一件事
  • 多线程：在计算机中同一时间可以做多件事

         多线程在程序中的应用

         线程的创建方式

         继承Thread类

         多线程的创建方式一：继承Thread类

  1. 定义一个子类继承线程类java.lang.Thread，重写run()方法
  2. 创建子类的对象
  3. 调用子类对象的start()方法启动线程（底层会自动去执行run方法 

        方式一优缺点 

  • 优点：编码简单
  • 缺点：线程类已经继承Thread，无法继承其他类，不利于功能的扩展。

        多线程的注意事项

1、启动线程必须是调用start方法，不是调用run方法。

  • 直接调用run方法会当成普通方法执行，此时相当于还是单线程执行。
  • 只有调用start方法才是启动一个新的线程执行。

2、不要把主线程任务放在启动子线程之前。 

  • 这样主线程一直是先跑完的，相当于是一个单线程的效果了。 
/*
多线程
    让程序同时做多件事

多线程的创建方式一：继承Thread类
    1. 定义一个子类继承线程类java.lang.Thread，重写run()方法
    2. 创建子类的对象
    3. 调用子类对象的start()方法启动线程（底层会自动去执行run方法）

优缺点
    优点：编码简单
    缺点：线程类已经继承Thread，无法继承其他类，不利于功能的扩展。

注意事项
    1、启动线程必须是调用start方法,不是调用run方法。
    2、直接调用run方法会当成普通方法执行，只有调用start方法才是启动一个新的线程执行。
    3、不要将主线任务放在start方法之前，这样主线程一直是先跑完的，相当于是一个单线程的效果了。

扩展
    对于单核cpu来讲, 多线程是一种假象
*/
public class Demo1 {
    public static final Logger LOGGER = LoggerFactory.getLogger("Demo1");
    public static void main(String[] args) {
        //需求：创建两个线程，分别用于打印10个A和10个B，最后观察下输出顺序
        AThread aThread = new AThread();
        BThread bThread = new BThread();
        aThread.start();
        bThread.start();

        for (int i = 0; i <20; i++) {
            LOGGER.debug("main-" + i);
        }
    }
}
class AThread extends Thread {
    public static final Logger LOGGER = LoggerFactory.getLogger("AThread");
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            LOGGER.info("A-" + i);
        }
    }
}
class BThread extends Thread {
    public static final Logger LOGGER = LoggerFactory.getLogger("BThread");
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            LOGGER.info("B-" + i);
        }
    }
}

        1、什么是多线程？

                同时做多件事

        2、线程创建方式一的具体步骤是？

  • 继承Thread类，重写run方法
  • 创建线程对象
  • 调用start()方法启动

        3、线程的第一种创建方式有啥优缺点？

  • 优点：编码简单
  • 缺点：存在单继承的局限性，线程类继承Thread后，不能继承其他类，不便于扩展

          实现Runnable接口

        多线程的创建方式二：实现Runnable接口 

① 定义一个线程任务类实现 Runnable 接口，重写 run() 方法
② 创建任务类对象
③ 把任务类对象交给 Thread 处理
④ 调用线程对象的 start() 方法启动线程

Thread类提供的构造器

说明

public Thread(Runnable target)

封装Runnable对象成为线程对象

         方式二的优缺点

  • 优点：任务类只是实现接口，可以继续继承其他类、实现其他接口，扩展性强。
  • 缺点：需要多一个Runnable对象。
/*
多线程的创建方式二：实现Runnable接口
    1. 定义一个线程任务类实现Runnable接口，重写run()方法
    2. 创建任务类对象
    3. 把任务类对象交给Thread处理
        public Thread(Runnable target)
    4. 调用线程对象的start()方法启动线程

优缺点
    优点：任务类只是实现接口，可以继续继承其他类、实现其他接口，扩展性强。
    缺点：需要多一个Runnable对象。
*/
public class Demo1 {

    public static void main(String[] args) {
        //需求：创建两个线程，分别用于打印10个A和10个B，最后观察下输出顺序
        AThread aThread = new AThread();
        BThread bThread = new BThread();

        Thread t1 = new Thread(aThread);
        Thread t2 = new Thread(bThread);
        t1.setName("t1-a");
        t2.setName("t2-b");
        t1.start();
        t2.start();

    }
}

class AThread implements Runnable{
    public static final Logger LOGGER = LoggerFactory.getLogger("AThread");
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            LOGGER.debug("A-" + i);
        }
    }
}
class BThread implements Runnable{
    public static final Logger LOGGER = LoggerFactory.getLogger("BThread");
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            LOGGER.debug("B-" + i);
        }
    }
}

        1、线程创建方式二是如何创建线程的？

                定义一个线程任务类实现Runnable接口，重写run()方法

                创建任务类对象

                把任务对象交给Thread线程对象处理

                调用线程对象的start()方法启动线程

        2、方式二的优缺点是啥？

                优点：线程任务类只是实现了Runnale接口，可以继续继承和实现

                缺点：如果线程有执行结果是不能直接返回的

          实现Callable接口 

         多线程的第三种创建方式：利用Callable接口、FutureTask类来实现。

① 创建任务对象
  • 定义一个类实现Callable接口，重写call方法，封装要做的事情，和要返回的数据。
  • 把Callable类型的对象封装成FutureTask（线程任务对象）。
② 把线程任务对象交给 Thread 对象。
③ 调用 Thread 对象的 start 方法启动线程。
④ 线程执行完毕后、通过 FutureTask 对象的的 get 方法去获取线程任务执行的结果。

         FutureTask的API

FutureTask提供的构造器

说明

public FutureTask<>(Callable call)

把Callable对象封装成FutureTask对象。

FutureTask提供的方法

说明

public V get() throws Exception

获取线程执行call方法返回的结果。

        线程创建方式三的优缺点 

  • 优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强；可以在线程执行完毕后去获取线程执行的结果。
  • 缺点：编码复杂一点。
/*
多线程的创建方式三：实现Callable接口
    1. 创建任务对象
        定义一个类实现Callable接口，重写call方法，封装要做的事情，和要返回的数据
        把Callable类型的对象封装成FutureTask（线程任务对象）
            public FutureTask<>(Callable call)	把Callable对象封装成FutureTask对象
            public V get() throws Exception	获取线程执行call方法返回的结果
    2. 把线程任务对象交给Thread对象。
    3. 调用Thread对象的start方法启动线程。
    4. 线程执行完毕后、通过FutureTask对象的的get方法去获取线程任务执行的结果

优缺点
    优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强；可以在线程执行完毕后去获取线程执行的结果
    缺点：编码复杂一点。
*/
public class Demo1 {

    public static void main(String[] args) throws Exception {
        //需求：启动两个子线程，分别计算100之内的奇数的和和偶数的和，然后在主线程中再做个汇总，得到总和
        //创建callable的对象
        OddThread oddThread = new OddThread();
        EvenThread evenThread = new EvenThread();
        //创建FutureTask对象
        FutureTask<Integer> oddFutureTask = new FutureTask<>(oddThread);
        FutureTask<Integer> evenFutureTask = new FutureTask<>(evenThread);
        //创建线程对象
        Thread oddT = new Thread(oddFutureTask, "奇数线程");
        Thread evenT = new Thread(evenFutureTask, "偶数线程");
        //调用线程的对象
        oddT.start();
        evenT.start();
        //获取线程的结果
        Integer oddSum = oddFutureTask.get();
        Integer evenSum = evenFutureTask.get();

        int sum = oddSum + evenSum;
        System.out.println(sum);
    }
}

//计算100以内的奇数和，并返回
class OddThread implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i+=2) {
            sum += i;
        }
        return sum;
    }
}
//计算100以内的偶数和，并返回
class EvenThread implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= 100; i+=2) {
            sum += i;
        }
        return sum;
    }
}

请对对比说一下三种线程的创建方式，和不同点？

方式

优点

缺点

继承Thread类

编程比较简单，可以直接使用Thread类中的方法

扩展性较差，不能再继承其他的类，不能返回线程执行的结果

实现Runnable接口

扩展性强，实现该接口的同时还可以继承其他的类。

编程相对复杂，不能返回线程执行的结果

实现Callable接口

扩展性强，实现该接口的同时还可以继承其他的类。可以得到线程执行的结果

编程相对复杂

          Thread类的方法

        Thread线程操作相关的方法 

        Thread线程获取线程、设置线程、拿到当前线程对象

         Thread线程休眠、线程join

          Thread其他方法说明

 

完球了
关注
  • 16
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
day10-配置文件&日志&多线程
qq_58478983的博客
09-10 1148
配置文件：properties配置文件、xml配置文件、Dom4j解析XML得到Document对象 日志：Logback、日志级别 多线程：继承Thread类、实现Runnable接口、实现Callable接口
每日分享之-配置文件&日志&多线程
jayzhang_的博客
09-08 1313
在企业开发过程中，我们习惯把一些需要灵活配置的数据放在一些文本文件中，而不是在Java代码写死 我们把这种存放程序配置信息的文件，统称为配置文件配置文件一般要求有明确的格式，以方便读写操作。
每日筑基之配置文件&日志&多线程
abcdewn的博客
09-08 1215
简单来说就是电脑在做一件事,单线程,在做一件事;多线程,在做多件事。
【Java学习】配置文件&日志&多线程
weixin_69134024的博客
09-08 1480
程序中的日志，通常就是一个文件，里面记录的是程序运行过程中的各种信息。日志会展示在控制台不能更方便的将日志记录到其他的位置（文件，数据库）想取消日志，需要修改源代码才可以完成在实际项目开发中就会使用日志技术，可以将系统执行的信息，方便的记录到指定的位置（控制台、文件中、数据库中）。也可以随时以开关的形式控制日志的启停，无需侵入到源代码中去进行修改。日志接口：设计日志框架的一套标准，日志框架需要实现这些接口。日志框架：大佬或者第三方公司已经做好的实现代码，后来者直接可以拿去使用。
day20--特殊文件、日志技术、多线程
ZHUSHANGLIN的博客
05-29 697
首先，我们来认识一下，什么是XML？XML是可扩展的标记语言，意思是它是由一些标签组成 的，而这些标签是自己定义的。本质上一种数据格式，可以用来表示复杂的数据关系。XML中的称为一个标签或者一个元素，一般是成对出现的。XML中的标签名可以自己定义（可扩展），但是必须要正确的嵌套XML中只能有一个根标签。XML标准中可以有属性XML必须第一行有一个文档声明，格式是固定的XML文件必须是以.xml为后缀结尾如下图所示接下，同学们可以跟着步骤新建一个XML文件，试试！>
黑马头条-day04&day05
hmmmgo的博客
02-12 1491
点击这里进行学习。1、定义feign接口2、定义跟feign接口对应的controller接口3、调用feign接口。
kafka 2.13-2.8.0 单机 & 集群配置（zookeeper）
疯飙的蜗牛
11-10 2198
1、配置预安装环境，下载kafka yum -y install java-1.8.0-openjdk.x86_64 wget https://archive.apache.org/dist/kafka/2.8.0/kafka_2.13-2.8.0.tgz tar -xvf kafka_2.13-2.8.0.tgz mv kafka_2.13-2.8.0 kafka cd kafka/ 2、配置并启动zookeeper mkdir zklogs vim config/zookeeper.prop
mysql的日志文件
左直拳的马桶_日用桶
03-24 3222
上回说到数据库的备份与恢复，日志文件在其中占有很重要的位置。 但是，我查了下资料，发现想搞懂这个数据库日志其实并不容易。包括网上许多文章，说了许多，但我越看越糊涂。只有一些mysql的日志文件原理介绍，相对好一些。mysql因为应用广泛，使用者众，作为数据库的学习对象，也算有代表性。 一、MySQL的日志文件 MySQL中有七种日志文件，分别是： 重做日志（redo log） 回滚日志（undo log） 二进制日志（binlog） 错误日志（errorlog） 慢查询日志（slow query log）
SpringBoot-21-异步&定时任务
paiidds的博客
04-12 2591
异步任务&定时任务   异步任务   异步任务知识介绍 在多线程时，后台执行多个任务，我们需要同步等待。此时前台不会给出任何响应，可以采用多线程 的方式解决这个问题。 SpringBoot采用异步注解的方式来解决这个问题，让我们在同步等待的时候，响应前台页面，无需 等待，后台代码执行依旧 实现异步任务        在SpringBoot实现异步任务很简单，在同步等待的任务中添加@Async注解，然后在SpringBoot添加@EnableAsync 代码实现 在com.liang.se
day020-继承加强和设计模式代码和笔记.rar
03-15
传统方式获取流是new创建的，而在web开发中有可能获取不到配置文件，为了避免这种情况，用以下方式获取流： 1. 通过当前类字节码文件的方式，一般是用当前类的字节码文件 当前类.class....
JavaWeb-day02&day03
夕月希的博客
08-23 1334
思考：如何在登录成功后显示一个网页而不是一段文本1.转发不会改变地址栏，重定向会2.转发只发送一个请求，重定向是两次请求3.转发操作请求，重定向操作重定向4.转发可以获取request作用域数据，重定向不能5.转发只能转发服务器已有的资源，重定向可以重定向到外部资源​ 作用在整个应用范围内，多个session Http协议响应状态码 什么是Http？Http是一种无状态协议。请求行：存储请求的url请求头：浏览器信息、系统信息、cookie、请求类型…请求体：例如：上传文件的文件数据、P
tomcat服务器日志文件配置
iOS逆向与安全
08-21 105
这个配置项通常在MyBatis的配置文件（比如mybatis-config.xml）或者Spring Boot的application.properties或application.yml文件中进行设置。来记录从接收到请求到发送响应的总时间，单位毫秒，对应的日志文件是 localhost_access_log.xxx.txt。修改server.xml 文件，日志格式包含。
framework学习笔记day05---Spring基础
Wynb1020的博客
12-24 256
Spring Spring简介 spring是分层的JavaSE及JavaEE应用于全栈的轻量级开源框架，以IoC（Inverse Of Control：控制反转/反转控制）和AOP（Aspact Oriented Programming：面向切面编程）为核心，提供了表现层SpringMVC和持久层Spring JDBC以及业务层事务管理等众多模块的企业级应用技术，还能整合开源世界中众多著名的第三方框架和类库，逐渐成为使用最多的JavaEE企业应用开源框架。 SSH(struts2 spring hiber
spring事务详细讲解-深入浅出
小电玩
09-08 466
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1452
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
Java集合：Stack详解
最新发布
yang_brother的博客
09-10 523
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 539
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
自定义Stater
m0_63624484的博客
09-07 716
我们平时在导入依赖的时候，大部分导入的都是xxx-spring-boot-stater。那是因为它们都基于spring的规则将写好的框架定义成一个stater，这样方便springboot引用它们写好的功能。那我们为什么也要自定义stater呢？
cd "d:\code\day1\" && gcc test.c -o test && "d:\code\day1\"test
07-28
你可以使用以下命令在 Windows 上编译和运行 C 代码： ``` cd "d:\code\day1\" && gcc test.c -o test && "d:\code\day1\test" ``` 这个命令将首先切换到 `d:\code\day1\` 目录，然后使用 `gcc` 编译 `test.c` 文件，并将可执行文件命名为 `test.exe`。最后，它会运行生成的可执行文件。 请确保你已经在 `d:\code\day1\` 目录下，并且已经安装并配置好了 GCC 编译器。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值