java进阶day34多线程、反射机制、类加载机制

最新推荐文章于 2023-12-23 13:26:54 发布
最新推荐文章于 2023-12-23 13:26:54 发布
阅读量214 收藏
点赞数
分类专栏： 笔记 java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mzj15101229871/article/details/115399066
版权
笔记 同时被 2 个专栏收录
46 篇文章 5 订阅
订阅专栏
java
28 篇文章 0 订阅
订阅专栏

p800 守护线程概述

在这里插入图片描述

p801 实现守护线程

package com.bjpowernode.java.thread;

public class ThreadTest14 {
    public static void main(String[] args) {

        BackDataThread bdt = new BackDataThread();
        bdt.setName("备份数据的线程");
        bdt.setDaemon(true);
        bdt.start();



        //主线程是用户线程
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"----->"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

        //现在备份线程还不是守护线程。如果想要把备份线程设置为守护线程，很简单
        //只需要在启动之前加一句
        //        bdt.setDaemon(true);即可
        //设置之后，用户线程结束之后，守护线程自动结束。
        //设置之后，用户线程结束之后，守护线程自动结束。

    }
}
class BackDataThread extends Thread{

    @Override
    public void run() {
        int i= 0;
        //即使是死循环，但是作为守护线程，等到用户线程结束时，他也会自动结束
        while(true){
            System.out.println(Thread.currentThread().getName()+"------------>"+(++i));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

p802 定时器概述

在这里插入图片描述

p803 实现定时器

在这里插入图片描述
在这里插入图片描述

自定义类实现接口

package com.bjpowernode.java.thread;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.format.DateTimeFormatter;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class TimerTest {

    public static void main(String[] args) throws ParseException {
        //创建定时器对象
        //Timer timer = new Timer(true);参数true表示以守护线程运行
        Timer timer = new Timer();

        //创建定时任务
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //设置第一次时间为2020年4月2日九点半
        Date firstTime = sdf.parse("2021-04-02 09:30:00");

        timer.schedule(new LogTimerTask(),firstTime,1000*10);

    }
}
class LogTimerTask extends TimerTask{

    /**
     * The action to be performed by this timer task.
     */
    @Override
    public void run() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String strTime = sdf.format(new Date());
        System.out.println(strTime+":成功完成了一次数据备份！");
    }
}

匿名内部类

import java.util.TimerTask;

public class TimerTest02 {

    public static void main(String[] args) throws ParseException {
        //创建定时器对象
        //Timer timer = new Timer(true);参数true表示以守护线程运行
        Timer timer = new Timer();

        //创建定时任务
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //设置第一次时间为2020年4月2日九点半
        Date firstTime = sdf.parse("2021-04-02 09:30:00");

        timer.schedule(new TimerTask(){

            /**
             * The action to be performed by this timer task.
             */
            @Override
            public void run() {
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                String strTime = sdf.format(new Date());
                System.out.println(strTime+":成功完成了一次数据备份！");
            }
        },firstTime,1000*10);

    }
}

p804 实现线程的第三种方式

在这里插入图片描述
在这里插入图片描述

package com.bjpowernode.java.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/*
实现线程的第三种方式：callable（）,可以得到线程的返回值。
 */
public class ThreadTest15 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        //第一步：创建一个"未来任务类"对象
        //参数很重要，需要实现一个Callable接口的实现类对象
        FutureTask futureTask = new FutureTask(new Callable() {
            @Override
            public Object call() throws Exception {//call()方法相当于run（）方法
                //线程执行任务。可能会有一个执行结果。
                //模拟执行
                System.out.println("call method begin");
                Thread.sleep(1000*10);
                System.out.println("call method end");
                int a = 100;
                int b = 200;
                return a+b;//return自动装箱后返回Integer类型
            }
        });

        //创建线程对象
        Thread t = new Thread(futureTask);//新建线程对象的时候将上面的未来任务传进来
        t.setName("ttt");
        t.start();

        //在主线程如何获取t线程的返回结果
        //get()方法的执行会导致当前线程阻塞，效率较低。但是他可以拿到返回结果。
        Object obj = futureTask.get();



        //但是现在有一个问题，main()方法想要执行必须等待get方法结束
        //而get方法又要等待另一个线程执行结束。
        //另一个线程执行需要时间
        System.out.println("hello main");

    }
}

p805 wait和notify方法（生产者和消费者）

在这里插入图片描述

p806 生产者和消费者模式

在这里插入图片描述
在这里插入图片描述

p807 生产者和消费者模式代码实现【生产1个，消费1个】

package com.bjpowernode.java.thread;

import java.util.ArrayList;
import java.util.List;

public class ThreadTest16 {
    public static void main(String[] args) {

        //创建一个仓库对象，共享的
        List list = new ArrayList();

        //创建两个线程对象
        Thread t1 = new Thread(new Producer(list));
        Thread t2 = new Thread(new Consumer(list));

        //设置线程名字
        t1.setName("t1");
        t2.setName("t2");

        //启动
        t1.start();
        t2.start();


    }
}
class Producer implements Runnable{
    private List list;

    public Producer(List list) {
        this.list = list;
    }

    @Override
    public void run() {
        while(true){
            //给仓库对象list加锁
            synchronized (list){
                //如果list集合大于0，那么就等待，不需要生产了。
                if (list.size() > 0){
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //如果if条件不成立，那就说明list集合为空，开始生产
                Object obj = new Object();
                list.add(obj);
                System.out.println(Thread.currentThread().getName()+"---->"+obj);

                //唤醒消费者进行消费
                list.notifyAll();

            }
        }
    }
}
class Consumer implements Runnable{

    private List list;

    public Consumer(List list) {
        this.list = list;
    }
    @Override
    public void run() {
        while(true){
            synchronized (list){
                //如果list集合等关于0，那么就等待，不能继续消费。
                if (list.size() == 0){
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //如果if条件不成立，那就说明list集合不为空，开始消费
                Object obj = list.remove(0);//参数为数组中的元素下标。
                System.out.println(Thread.currentThread().getName()+"---->"+obj);

                //唤醒生产者开始生产
                list.notifyAll();
           }
        }
    }
}

p808 生产者和消费者模式代码理解【平衡】在这里插入图片描述

p809 布置线程作业

package com.bjpowernode.java.homework;

/*
运行不成功，下次找答案再试试
 */
import java.util.ArrayList;
import java.util.List;

public class ThreadNumber {
    public static void main(String[] args) {

        //创建一个仓库对象，共享的
        Integer num = 0;

        //创建两个线程对象
        Thread t1 = new Thread(new Number(num));
        Thread t2 = new Thread(new Number(num));

        //设置线程名字
        t1.setName("t1");
        t2.setName("t2");

        //启动
        t1.start();
        t2.start();

    }
}
class Number implements Runnable{
    private Integer num;

    public Number(int num) {
        this.num = num;
    }

    @Override
    public void run() {
        while(true){
            synchronized (num){

                //如果是偶数，那就等待
                if (num % 2 == 0){
                    try {
                        num.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //如果是奇数，那就输出
                System.out.println(Thread.currentThread().getName()+"--->"+num);
                num++;
                num.notifyAll();
            }
            synchronized (num){

                //如果是奇数，那就等待
                if (num % 2 != 0){
                    try {
                        num.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //如果是偶数，那就输出
                System.out.println(Thread.currentThread().getName()+"--->"+num);
                num++;
                num.notifyAll();

            }
        }
    }
}

p810 反射机制

在这里插入图片描述
在这里插入图片描述

p811 反射机制可以草操作字节码文件【获取字节码的第一种方式】

package com.bjpowernode.java.reflect;

/*
反射机制可以操作字节码文件，但是怎么拿到字节码文件？
如何拿到字节码文件？
 */
public class ReflectTest01 {
    public static void main(String[] args) {


        try {
            Class c1 = Class.forName("java.lang.String");
            Class c2 = Class.forName("java.util.Dtae");
            Class c3 = Class.forName("java.lang.Integer");
            Class c4 = Class.forName("java.lang.System");
            
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

在这里插入图片描述

p812 获取字节码的第二种方式

在这里插入图片描述
在这里插入图片描述

p813 获取字节码的第三种方式

package com.bjpowernode.java.reflect;

import java.util.Date;

/*
反射机制可以操作字节码文件，但是怎么拿到字节码文件？
如何拿到字节码文件？
 */
public class ReflectTest01 {
    public static void main(String[] args) {

        Class c1 = null;
        Class c2 = null;
        try {
            c1 = Class.forName("java.lang.String");
            c2 = Class.forName("java.util.Date");
            Class c3 = Class.forName("java.lang.Integer");
            Class c4 = Class.forName("java.lang.System");

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }


        //java中任何一个对象都有一个方法：：getClass()
        String s = "abc";
        Class x = s.getClass();
        System.out.println(x);//class java.lang.String.x表示String类型。x表示String.class字节码文件
        System.out.println(c1 == x);//双等号判断内存地址，c1和x都表示String.class字节码文件


        Date time = new Date();
        Class y = time.getClass();
        System.out.println(y);
        System.out.println(c2 == y);//true.c2和y在方法区都指向Date.class字节码文件。


        //java中任何一种类型，包括基本数据类型给，都有.class属性
        Class z = String.class;
        Class k = Date.class;
        Class f = int.class;
        Class e = double.class;

        System.out.println(x == z);
    }
}

在这里插入图片描述

p814 通过反射机制实例化对象

package com.bjpowernode.java.reflect;

import com.bjpowernode.java.bean.User;

public class ReflectTest02 {
    public static void main(String[] args) {

        //第一种方法创建对象，实例化对象。
        User user = new User();
        System.out.println(user);

        //第二种方法创建对象
        try {
            Class c = Class.forName("com.bjpowernode.java.bean.User");
            Object o = c.newInstance();
            System.out.println(o);


        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
    }
}

在这里插入图片描述

p815 通过读属性文件实例化对象

在这里插入图片描述
在这里插入图片描述

测试文件

package com.bjpowernode.java.reflect;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.Properties;

/*
验证反射机制创建对象的灵活性
 */
public class ReflectTest03 {
    public static void main(String[] args) throws Exception {

        //通过I/O流读取配置文件
        FileReader reader = new FileReader("Chapter25_Reflect/classinfo.properties");

        //创建属性类对象pro
        Properties pro = new Properties();

        //加载
        pro.load(reader);

        //关闭流
        reader.close();

        //通过key获取value
        String className = pro.getProperty("className");

        //拿到类名
        //System.out.println(className);

        //通过反射机制创建对象
        Class c = Class.forName(className);
        Object obj = c.newInstance();
        System.out.println(obj);



    }
}

配置文件

#className=com.bjpowernode.java.bean.User
className=java.util.Timer

p816 只让静态代码块执行可以使用forName

在这里插入图片描述

package com.bjpowernode.java.reflect;
/*如果只希望一个类的静态代码块执行，其他代码一律不执行，那么就使用：
    Class.forName("完整类名")

   这个方法的执行会导致类加载，类加载时，静态代码块执行。
 */
public class ReflectTest04 {
    public static void main(String[] args) {
//        Myclass mc = new Myclass();
        try {
            Class.forName("com.bjpowernode.java.reflect.Myclass");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

在这里插入图片描述

p817 获取类路径下文件的绝对路径

在这里插入图片描述
在这里插入图片描述

package com.bjpowernode.java.reflect;

import java.io.FileNotFoundException;
import java.io.FileReader;

public class AbsolutePath {
    public static void main(String[] args) throws Exception {
        //这种方式的路径缺点是：移植性差，在IDEA中默认的当前路径是project的根
        //这个代码离开IDEA之后，换到其他位置，这个路径就无效了
//        FileReader reader = new FileReader("Chapter25_Reflect");


        //通用路径，这样编写，即使代码换位置之后，也能找到。
        //前提是必须在类路径下
        //什么是类路径？凡是在src下的都是类路径【记住】
        //src是类路径的根路径

        //当前线程对象【Thread.currentThread()】的类加载器对象【getContextClassLoader】的资源【getResource()】的路径
        String path = Thread.currentThread().getContextClassLoader()
                .getResource("classinfo2.properties").getPath();

        //获取一个文件的绝对路径
        System.out.println(path);

        String path2 = Thread.currentThread().getContextClassLoader()
                .getResource("com/bjpowernode/java/bean/db.properties").getPath();

        //获取一个文件的绝对路径
        System.out.println(path2);
    }
}

p818 以流的形式直接返回

在这里插入图片描述

package com.bjpowernode.java.reflect;

import java.io.FileReader;
import java.nio.file.Path;
import java.util.Properties;

public class IoPropertiesTest {
    public static void main(String[] args) throws Exception {
        //获取绝对路径【通用方式】

        String path = Thread.currentThread().getContextClassLoader()
                .getResource("classinfo2.properties").getPath();


        //System.out.println(path);
        FileReader reader = new FileReader(path);
        Properties pro = new Properties();
        pro.load(reader);
        reader.close();

        //通过Key获取value
        String className = pro.getProperty("className");
        System.out.println(className);

    }
}

在这里插入图片描述

package com.bjpowernode.java.reflect;

import java.io.FileReader;
import java.io.InputStream;
import java.nio.file.Path;
import java.util.Properties;

public class IoPropertiesTest {
    public static void main(String[] args) throws Exception {
        //获取绝对路径【通用方式】
//
//        String path = Thread.currentThread().getContextClassLoader()
//                .getResource("classinfo2.properties").getPath();
//
//
//        //System.out.println(path);
//        FileReader reader = new FileReader(path);

        //直接以流的形式返回

        InputStream reader = Thread.currentThread().getContextClassLoader()
                .getResourceAsStream("classinfo2,properties");

        Properties pro = new Properties();
        pro.load(reader);
        reader.close();

        //通过Key获取value
        String className = pro.getProperty("className");
        System.out.println(className);

    }
}

p819 资源绑定器

java.util包下提供了一个资源绑定器，便于获取属性配置文件下中的内容
资源绑定器只能绑定xxx.properties配置文件，并且这个文件必须在类路径下，文件扩展名也必须是properties
并且在写路径的时候，路径后面的扩展名不能写。

package com.bjpowernode.java.reflect;

import java.util.ResourceBundle;

public class ResourceBundleTest {
    public static void main(String[] args) {
        //注意都是以src作为起点。
        ResourceBundle bundle = ResourceBundle.getBundle("classinfo2");

        String className = bundle.getString("className");
        System.out.println(className);

        //都是以src下作为起点
        ResourceBundle bundle2 = ResourceBundle.getBundle("com/bjpowernode/java/bean/db");
        String className2 = bundle2.getString("className");
        System.out.println(className2);



    }
}

p820 类加载器概述【扩展】

在这里插入图片描述

p821 双亲委派机制【扩展】

在这里插入图片描述
在这里插入图片描述

只会写bug的菜鸡
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java进阶 —— 注解与反射
荔枝当大佬的博客
07-24 123
在了解完Java中的集合和IO流之后，荔枝继续梳理有关Java反射的知识，这个基础知识点也是在面试中可能会考到滴哦~~~在这篇文章中，荔枝主要梳理了有关Java反射、动态代理类的实现和注解的相关知识。其中Java反射中通过反射来获取指定方法、属性、父类和接口等内容需要掌握，还有一个重点就是如何实现动态代理类。
Java进阶作业
XXXZhy丶Blog
04-04 3525
系列文章目录 day01：Java概述和基础语法 文章目录系列文章目录面向对象高级(1) 面向对象高级(1)
java进阶
IAMARRAY的博客
06-25 109
java；进阶；详细笔记
java进阶学习笔记
weixin_41158378的博客
12-23 1054
学习java源码及高级特性，提升编程思维
JAVA进阶
scu_cs_yhh的博客
04-15 581
JAVA DAY01 单例多态 DAY02 正则泛型集合 DAY03 Map异常线程死锁 DAY04 文件流Socket DAY05 反射
06-多线程进阶 synchronized 锁
qq_54781283的博客
05-31 107
流程图[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CEn2g5Yz-1654005335265)(image-20210430152730779.png)] 服务端代码改造: 线程API 获取线程相关信息的方法 线程优先级 线程start后会纳入到线程调度器中统一管理,线程只能被动的被分配时间片并发运行,而无法主动索取时间片.线程调度器尽可能均匀的将时间片分配给每个线程.线程有10个优先级,使用整数1-10表示 sleep阻塞 线程提供了一个静态方法: 线程API sle
JAVA进阶——尚学堂
LAndyQR的博客
11-26 529
java基础，关于面向对象，JVM，一些类
SE进阶笔记（IO流、线程、多线程、数据库、JDBC、类的反射和元注解）
Skity666的博客
05-18 604
知识点第一章IO流编程字符和字节数据源头File类File类常用方法InputStreamFileInputStreamOutputStreamFileOutputStream流的套接DataInputStream/DataOutputStreamBufferedInputStream/BufferedOutputStreamBufferedOutputStream第二章IO流编程2配置文件读取配置文件修改并保存配置到文件ReaderFileReaderBufferedReaderWriterFileWri
JVM 原理与实战【java进阶笔记十三】
yuyu的博客
06-08 480
JVM原理与实战
java_diary_18.rar_JFC_swing_反射机制_国际化 java
09-19
Day07：反射机制与内部类 Day08：异常与Swing图形界面 Day09：swing图形界面与AWT事件模型 Day10：JFC基础类库(具体类查看API) Day11：多线程-进程与线程及方法 Day12：线程机制与I/O流的方法 Day13：I/O流的类与...
day11-多线程 java
06-10
day11-多线程 java
java进阶13天资料.zip
08-08
Java进阶13天资料 day01-复习回顾、静态、继承、引用类型使用 day02-抽象类、接口、代码块，final、单例、枚举 day03-多态、包、权限修饰符、内部类，Object类，Date类 day04-常用API、正则表达式，泛型、Collection...
day15-类加载器&反射
06-10
day15-类加载器&反射
Day43 Java反射（二）
最新发布
05-04
Day43 Java反射（二）
特征融合方法
不要回答的博客
03-05 8841
概述 基本概念 在很多工作中，融合不同尺度的特征是提高分割性能的一个重要手段。低层特征分辨率更高，包含更多位置、细节信息，但是由于经过的卷积更少，其语义性更低，噪声更多。高层特征具有更强的语义信息，但是分辨率很低，对细节的感知能力较差。如何将两者高效融合，取其长处，弃之糟泊，是改善分割模型的关键。 很多工作通过融合多层来提升检测和分割的性能，按照融合与预测的先后顺序，分类为早融合(Early fusion)和晚融合(Late fusion)。 早融合(Early fusion): 先融合多层的特征，然后在
计算机网络【java面试题】
不要回答的博客
09-11 3354
1、计算机网络中的七层模型以及每一层的作用？ OSI七层模型 功能 对应的网络协议 应用层 应用层是网络体系中最高的一层，也是唯一面向用户的一层，也可视为为用户提供常用的应用程序，每个网络应用都对应着不同的协议 HTTP、TFTP, FTP, NFS, WAIS、SMTP 表示层 主要负责数据格式的转换，确保一个系统的应用层发送的消息可以被另一个系统的应用层读取，编码转换，数据解析，管理数据的解密和加密，同时也对应用层的协议进行翻译 Telnet, Rlogin, SNMP, Goph
2020最新Spring框架教程【IDEA版】-Spring框架从入门到精通
不要回答的博客
06-21 2922
第一章：认识Spring 01p/102p Spring认识框架 02p/102p Spring官网浏览以及资源介绍 03p/102p 框架内部模块 第二章 IoC控制反转 04p/102p IoC概念 05p/102p 创建对象的方式 06p/102p IoC的实现技术 07p/102p 第一个例子创建对象 08p/102p 创建spring配置文件 09p/102p 创建容器对象ApplicaitonContext【拿到spring创建的对象】 @Test publi
深度学习中参数和超参数的区别
不要回答的博客
03-05 2708
参数：就是模型可以根据数据可以自动学习出的变量，应该就是参数。比如，深度学习的权重，偏差等。 超参数：就是用来确定模型的一些参数，超参数不同，模型是不同的(比如说：假设都是CNN模型，如果层数不同，模型不一样，虽然都是CNN模型。)，超参数一般就是根据经验确定的变量。在深度学习中，超参数有：学习速率，迭代次数，层数，每层神经元的个数等等。 ...
Java基础知识-day06 【线程、同步】.pdf
10-26
"Java基础知识-day06 【线程、同步】.pdf，涵盖了Java多线程的原理、创建方式、同步机制以及线程状态等内容，适用于Java学习者参考" Java多线程是程序设计中的重要概念，特别是在并发处理时。在Java中，线程允许...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值