复习多线程

已于 2022-03-06 18:34:50 修改
阅读量177 收藏
点赞数 1
分类专栏： java基础 文章标签： java 开发语言 后端
于 2022-03-03 20:24:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jxiao_linbei/article/details/123260063
版权

目录

线程简介:

线程创建(三种):

方法一: Thread类 

方法二: 创建Runnable类:

线程并发：　

龟兔赛跑：

方法三：实现Callable接口

线程简介:

任务, 进程, 线程, 多线程: 程序是静态的, 程序跑起来变成了进程, 进程里分为了若干个线程.

注意: 很多多线程是模拟出来的, 真正的多线程是指有多个cpu, 即多核, 如服务器. 如果是模拟出来的多线程, 即在一个cpu的情况下, 在同一个时间点, cpu只能执行一个代码, 因为切换的很快, 所以就有同时执行的错觉.

  • 线程就是独立的执行路径;
  • 在程序运行时, 即使没有自己创建的线程, 后台也会有多个线程, 如主线程, gc线程;
  • main()称之为主线程, 为系统的入口, 用于执行整个程序
  • 在一个进程中, 如果开辟了多个线程, 线程的运行由调度器(cpu)安排调度, 调度器是与操作系统紧密相关的, 先后顺序是不能认为的干预的
  • 对同一份资源操作时, 会存在资源抢夺的问题, 需要加入并发控制
  • 线程会带来额外的开销, 如cpu调度时间, 并发控制开销
  • 每个线程在自己的工作内存交互, 内存控制不当会造成数据不一致.

线程创建(三种):

  • Thread class : 继承Thread类 ( 重点 ), 实现了Runnable接口
  • Runnable接口 : 实现Runnable接口 ( 重点 )
  • Callable接口 : 实现Callable接口 ( 了解 )

方法一: Thread类 

  • 自定义线程类继承Thread类
  • 重写run()方法, 编写线程执行体
  • 创建线程对象, 调用start()方法启动线程
//创建线程方式一: 继承Thread类, 重写run()方法, 调用start开启线程
public class TestThread1 extends Thread{

    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我再看代码---" + i);
        }
    }

    public static void main(String[] args) {
        //main线程, 主线程

        //创建一个线程对象
        TestThread1 testThread1 = new TestThread1();
        //调用start()方法开启线程
        testThread1.start();
        //调用run方法会先执行完run, 再执行main方法.
        /*testThread1.run();*/

        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习多线程---" + i);
        }
    }
}
输出结果:

我再看代码---0
我在学习多线程---0
我在学习多线程---1
我在学习多线程---2
我在学习多线程---3
我在学习多线程---4
我在学习多线程---5
我在学习多线程---6
我再看代码---1
我在学习多线程---7
我再看代码---2
我在学习多线程---8
我再看代码---3
我在学习多线程---9
我在学习多线程---10
我在学习多线程---11
我在学习多线程---12
我在学习多线程---13
我在学习多线程---14
我在学习多线程---15
我再看代码---4
我在学习多线程---16
我再看代码---5
我在学习多线程---17
我再看代码---6
我再看代码---7
我再看代码---8
我再看代码---9
我再看代码---10
我再看代码---11
我再看代码---12
我在学习多线程---18
我在学习多线程---19
我再看代码---13
我再看代码---14
我再看代码---15
我再看代码---16
我再看代码---17
我再看代码---18
我再看代码---19

 练习(lib导入commons-io-2.11.0.jar):  下载网络图片

//练习Thread, 实现多线程同步下载图片
public class TestThread2 extends Thread{

    private String url;//网络图片地址
    private String name;//保存的文件名

    public TestThread2(String url, String name){
        this.url = url;
        this.name = name;
    }

    @Override
    public void run() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载了文件名为" + name);
    }

    public static void main(String[] args) {
        TestThread2 t1 = new TestThread2("https://t12.baidu.com/it/u=949912871,2851013736&amp;fm=58", "1.jpg");
        TestThread2 t2 = new TestThread2("https://p.ssl.qhimg.com/dmsmty/148_148_100/t0155a138b0754de130.webp", "2.jpg");
        TestThread2 t3 = new TestThread2("https://p.ssl.qhimg.com/dmsmty/148_148_100/t01241afac55d126121.webp", "3.jpg");

        t1.start();
        t2.start();
        t3.start();
    }
}

//下载器
class WebDownloader{
    //下载方法
    public void downloader(String url, String name){
        try {
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常downloader方法出现问题");
        }
    }
}

输出 : (说明为同时进行)

下载了文件名为3.jpg
下载了文件名为2.jpg
下载了文件名为1.jpg

方法二: 创建Runnable类:

  • 定义MyRunnable类实现Runnable接口
  • 实现run()方法, 编写线程执行体
  • 创建线程对象, 调用start()方法启动线程
//创建线程方式2 : 实现runnable接口, 重写run方法,
//执行线程需要丢入runnable接口实现类,调用start方法.
public class TestThread03 implements Runnable {
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我再看代码---" + i);
        }
    }

    public static void main(String[] args) {
//        // 创建一个Runnable接口实现类对象
        TestThread03 testThread03 = new TestThread03();
//        //创建线程对象, 通过线程对象来开启我们的线程 : 代理
//        Thread thread = new Thread();
//        thread.start();
        //简写
        new Thread(testThread03).start();

        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习多线程---" + i);
        }
    }
}

结果:

我在学习多线程---0
我再看代码---0
我在学习多线程---1
我再看代码---1
我在学习多线程---2
我再看代码---2
我在学习多线程---3
我再看代码---3
我在学习多线程---4
我再看代码---4
我在学习多线程---5
我再看代码---5
我在学习多线程---6
我再看代码---6
我在学习多线程---7
我再看代码---7
我在学习多线程---8
我再看代码---8
我再看代码---9
我再看代码---10
我再看代码---11
我再看代码---12
我再看代码---13
我再看代码---14
我再看代码---15
我再看代码---16
我再看代码---17
我再看代码---18
我在学习多线程---9
我在学习多线程---10
我再看代码---19
我在学习多线程---11
我在学习多线程---12
我在学习多线程---13
我在学习多线程---14
我在学习多线程---15
我在学习多线程---16
我在学习多线程---17
我在学习多线程---18
我在学习多线程---19

练习.plus : 下载网络图片

//改为Runnable, 实现多线程同步下载图片
public class TestThread2 /*extends Thread*/implements Runnable{

    private String url;//网络图片地址
    private String name;//保存的文件名

    public TestThread2(String url, String name){
        this.url = url;
        this.name = name;
    }

    @Override
    public void run() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载了文件名为" + name);
    }

    public static void main(String[] args) {
        TestThread2 t1 = new TestThread2("https://t12.baidu.com/it/u=949912871,2851013736&amp;fm=58", "1.jpg");
        TestThread2 t2 = new TestThread2("https://p.ssl.qhimg.com/dmsmty/148_148_100/t0155a138b0754de130.webp", "2.jpg");
        TestThread2 t3 = new TestThread2("https://p.ssl.qhimg.com/dmsmty/148_148_100/t01241afac55d126121.webp", "3.jpg");
//        t1.start();
//        t2.start();
//        t3.start();
        new Thread(t1).start();
        new Thread(t2).start();
        new Thread(t3).start();
    }
}

//下载器
class WebDownloader{
    //下载方法
    public void downloader(String url, String name){
        try {
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常downloader方法出现问题");
        }
    }
}

小结 :

  • 继承Thread类
    • 子类继承Thread类具备多线程能力
    • 启动线程: 子类对象.start()
    • 不建议使用: 避免OOP单继承局限性
  • 实现Runnable接口
    • 实现接口Runnable具有多线程能力
    • 启动线程: 传入目标对象+Thread对象.start()
    • 推荐使用: 避免单继承局限性, 灵活方便, 方便同一个对象被多个线程使用

线程并发：　

//多个线程同时操作同一个对象
//买火车票的例子

//发现问题: 多个线程操作同一个资源的情况下, 线程不安全, 数据紊乱
public class TestThread4 implements Runnable {

    //票数
    private int ticketNums = 10;

    @Override
    public void run() {
        while (true){
            if (ticketNums<=0){
                break;
            }
            System.out.println(Thread.currentThread().getName() + "-->拿到了第" + ticketNums-- + "票");
        }
    }

    public static void main(String[] args) {
        TestThread4 ticket = new TestThread4();

        new Thread(ticket, "小明").start();
        new Thread(ticket, "黄牛").start();
        new Thread(ticket, "工人").start();
    }
}

结果：

工人-->拿到了第10票
黄牛-->拿到了第9票
小明-->拿到了第10票
工人-->拿到了第8票
小明-->拿到了第7票
黄牛-->拿到了第7票
工人-->拿到了第6票
黄牛-->拿到了第5票
小明-->拿到了第4票
工人-->拿到了第3票
小明-->拿到了第2票
黄牛-->拿到了第2票
工人-->拿到了第1票
小明-->拿到了第0票
黄牛-->拿到了第-1票

龟兔赛跑：

  1. 首先来个赛道距离，然后要离重点越来越近
  2. 判断比赛是否结束
  3. 打印出胜利者
  4. 龟兔赛跑开始
  5. 故事中是乌龟赢，兔子需要睡觉，所以我们来模拟兔子睡觉
  6. 终于，乌龟赢得比赛
//模拟龟兔赛跑
public class Race implements Runnable {

    //胜利者
    private static String winner;

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            //模拟兔子休息
            if (Thread.currentThread().getName().equals("兔子")&& i%20==0){
                try {
                    Thread.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            //判断比赛是否结束
            boolean flag = gameover(i);
            //如果比赛结束了, 我们就停止程序
            if (flag){
                break;
            }

            System.out.println(Thread.currentThread().getName()+"--->跑了" + i+ "步");
        }
    }

    //判断是否完成比赛
    private boolean gameover(int steps/*步数*/){
        //判断是否为胜利者
        if (winner!=null){//已经存在胜利者
            return true;
        }else if (steps>=100){
            winner = Thread.currentThread().getName();
            System.out.println("winner is " + winner);
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        Race race = new Race();
        new Thread(race, "兔子").start();
        new Thread(race, "乌龟").start();
    }
}

结果：

乌龟--->跑了0步
乌龟--->跑了1步
乌龟--->跑了2步
乌龟--->跑了3步
乌龟--->跑了4步
乌龟--->跑了5步
乌龟--->跑了6步
乌龟--->跑了7步
乌龟--->跑了8步
乌龟--->跑了9步
乌龟--->跑了10步
乌龟--->跑了11步
乌龟--->跑了12步
乌龟--->跑了13步
乌龟--->跑了14步
乌龟--->跑了15步
乌龟--->跑了16步
乌龟--->跑了17步
乌龟--->跑了18步
乌龟--->跑了19步
乌龟--->跑了20步
兔子--->跑了0步
兔子--->跑了1步
兔子--->跑了2步
兔子--->跑了3步
兔子--->跑了4步
兔子--->跑了5步
兔子--->跑了6步
兔子--->跑了7步
兔子--->跑了8步
兔子--->跑了9步
兔子--->跑了10步
兔子--->跑了11步
兔子--->跑了12步
兔子--->跑了13步
乌龟--->跑了21步
乌龟--->跑了22步
乌龟--->跑了23步
乌龟--->跑了24步
乌龟--->跑了25步
乌龟--->跑了26步
乌龟--->跑了27步
乌龟--->跑了28步
兔子--->跑了14步
兔子--->跑了15步
兔子--->跑了16步
兔子--->跑了17步
兔子--->跑了18步
兔子--->跑了19步
乌龟--->跑了29步
乌龟--->跑了30步
乌龟--->跑了31步
乌龟--->跑了32步
乌龟--->跑了33步
乌龟--->跑了34步
乌龟--->跑了35步
乌龟--->跑了36步
乌龟--->跑了37步
乌龟--->跑了38步
乌龟--->跑了39步
乌龟--->跑了40步
乌龟--->跑了41步
乌龟--->跑了42步
乌龟--->跑了43步
乌龟--->跑了44步
乌龟--->跑了45步
乌龟--->跑了46步
乌龟--->跑了47步
乌龟--->跑了48步
乌龟--->跑了49步
乌龟--->跑了50步
乌龟--->跑了51步
乌龟--->跑了52步
乌龟--->跑了53步
乌龟--->跑了54步
乌龟--->跑了55步
乌龟--->跑了56步
乌龟--->跑了57步
乌龟--->跑了58步
乌龟--->跑了59步
乌龟--->跑了60步
乌龟--->跑了61步
乌龟--->跑了62步
乌龟--->跑了63步
乌龟--->跑了64步
乌龟--->跑了65步
乌龟--->跑了66步
乌龟--->跑了67步
乌龟--->跑了68步
兔子--->跑了20步
兔子--->跑了21步
兔子--->跑了22步
兔子--->跑了23步
乌龟--->跑了69步
兔子--->跑了24步
兔子--->跑了25步
乌龟--->跑了70步
兔子--->跑了26步
乌龟--->跑了71步
兔子--->跑了27步
乌龟--->跑了72步
乌龟--->跑了73步
乌龟--->跑了74步
乌龟--->跑了75步
乌龟--->跑了76步
兔子--->跑了28步
乌龟--->跑了77步
兔子--->跑了29步
乌龟--->跑了78步
兔子--->跑了30步
乌龟--->跑了79步
兔子--->跑了31步
乌龟--->跑了80步
兔子--->跑了32步
兔子--->跑了33步
兔子--->跑了34步
乌龟--->跑了81步
兔子--->跑了35步
乌龟--->跑了82步
兔子--->跑了36步
乌龟--->跑了83步
兔子--->跑了37步
乌龟--->跑了84步
兔子--->跑了38步
乌龟--->跑了85步
乌龟--->跑了86步
乌龟--->跑了87步
乌龟--->跑了88步
乌龟--->跑了89步
乌龟--->跑了90步
乌龟--->跑了91步
乌龟--->跑了92步
乌龟--->跑了93步
兔子--->跑了39步
乌龟--->跑了94步
乌龟--->跑了95步
乌龟--->跑了96步
乌龟--->跑了97步
乌龟--->跑了98步
乌龟--->跑了99步
winner is 乌龟

方法三：实现Callable接口

  • 实现Callable接口, 需要返回值类型
  • 重写call方法, 需要抛出异常
  • 创建目标对象
  • 创建执行服务: ExecutorService ser = Executors.newFixedThreadPool(1);
  • 提交执行: Future<Boolean> result1 = ser.submit(t1);
  • 获取结果: boolean r1 = result1.get()
  • 关闭服务: ser.shutdownNow();

练习.plus++: 下载网络图片

//线程创建方式三: 实现callable接口
public class TestCallable implements Callable<Boolean> {

    private String url;//网络图片地址
    private String name;//保存的文件名

    public TestCallable(String url, String name){
        this.url = url;
        this.name = name;
    }

    @Override
    public Boolean call() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载了文件名为" + name);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable t1 = new TestCallable("https://t12.baidu.com/it/u=949912871,2851013736&amp;fm=58", "1.jpg");
        TestCallable t2 = new TestCallable("https://p.ssl.qhimg.com/dmsmty/148_148_100/t0155a138b0754de130.webp", "2.jpg");
        TestCallable t3 = new TestCallable("https://p.ssl.qhimg.com/dmsmty/148_148_100/t01241afac55d126121.webp", "3.jpg");
        //创建执行服务: ExecutorService ser = Executors.newFixedThreadPool(1);
        ExecutorService ser = Executors.newFixedThreadPool(3);
        //提交执行: Future<Boolean> result1 = ser.submit(t1);
        Future<Boolean> r1 = ser.submit(t1);
        Future<Boolean> r2 = ser.submit(t2);
        Future<Boolean> r3 = ser.submit(t3);
        //获取结果: boolean r1 = result1.get()
        boolean rs1 = r1.get();
        boolean rs2 = r2.get();
        boolean rs3 = r3.get();
        //打印返回值
        System.out.println(rs1);
        System.out.println(rs2);
        System.out.println(rs3);
        //关闭服务: ser.shutdownNow();
        ser.shutdownNow();
    }
}

//下载器
class WebDownloader{
    //下载方法
    public void downloader(String url, String name){
        try {
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常downloader方法出现问题");
        }
    }
}
结果:
下载了文件名为1.jpg
下载了文件名为3.jpg
下载了文件名为2.jpg
true
true
true

总结: Callable的好处:

  1. 可以定义返回值
  2. 可以抛出异常
1128bei
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程复习笔记
pwn2017211808的博客
03-22 3436
Java多线程复习笔记 1、基础概要 ​ Java线程的创建方法有三种，第一种是通过实现Runnable接口，第二种是通过继承Thread类本身，第三种是通过 Callable 和 Future 来创建线程。第一种和第二种，都是通过重写run方法，来实现线程的执行实例。并通过start方法启动线程。第三种方法后文再做详细描述。 2、线程死锁 ​ Java是通过synchronized关键字实...
E05_多线程复习.pdf
11-02
在计算机科学中，多线程是并发编程的重要概念，它允许多个任务在同一时间执行，提高了系统的效率和响应性。本文将深入探讨多线程的相关知识点。 1. **进程与线程** - **进程**：是操作系统分配资源的基本单位，每...
多线程个人笔记
AKS_D的博客
09-05 84
1、定义 程序：编写的代码，静态 进程：执行代码的过程，动态 线程：进程至少含有一个线程 注意：很多多线程都是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所有就有同时执行的错觉 2、核心 线程就是独立的执行路径 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程（垃圾回收） main()称之为主线程，为系统的入口，用于执行整个程序
每个线程在自己的工作内存交互，内存控制不当会造成数据不一致
m0_56013912的博客
03-11 606
　　很多多线程是模拟出来的，真整的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，在一个cpu的情况下，同一个时间点，cpu只能执行一个代码，因为切换的快，所以就有同时执行的错觉。 　　? @线程是独立的执行路径 　　? @在程序运行时，即使自己没有创建线程，后台也会有多个线程，如主线程，gc线程 　　? @在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序不能人为干预 　　? @线程会带来额外的开销，如cpu调度时间，并发控制开销 　　?
java牛马之路-15-复习多线程
SaysGoodbye的博客
07-19 774
什么是线程？线程是进程里面的一条执行路径，每个线程同享进程里面的内存空间和系统资源一个进程 可以有 多个线程：各个线程都有不同的分工理解线程和进程的关系进程 与 进程 之间的关系：进程之间的内存空间和系统资源是独立的同一个进程里的多条线程 ：线程之间的内存空间和系统资源是共享的进程里：可以有一条或一条以上的线程进程里只有一条线程的情况下，这条线程就叫做主线程进程里有多条线程的情况下，只有一条线程叫做主线程Ps：线程是在进程里的，他们是包含关系。
多线程基础
Eliaukqwe的博客
07-04 1101
多线程基础
多线程 快速复习篇。
李岳锋的专栏
11-04 164
对象锁，即指，同一个对象，当有多个线程【1对象 + 多线程】，都要执行被synchronized 修饰的方法或是包裹的代码块时。同一时间，只有一个线程可以进入。但如果对于多个线程，所个线程都有自己的对象【多对象 + 多线程】，则同一时间，所有线程都可以进入。 类锁，不管是【1对象 + 多线程】的情况，还是，【多对象 + 多线程】的情况，同一时间，也只能有一个线程对其中的一个对象进行操作。 对象锁（方法锁）。 public synchronized void test(); // 方法锁，也即时对象锁。
Java多线程复习
技术蜗牛
03-07 166
#Runnable与Callable有何区别？ Runnable是在JDK1.0的时候提出的多线程的实现接口，而Callable是在JDK1.5之后提出的 Runnable接口中只提供有一个run（）方法，并且没有返回值 java.util.concurrent.Callable接口提供有call方法，可以有返回值（get()方法） ...
JavaSE总复习之多线程
zt的博客
03-28 1023
文章目录多线程概念实现线程的三种方式线程的生命周期线程控制问题 多线程概念 线程指进程中的一个执行场景 每个进程是一个应用程序,都有独立的内存空间 同一个进程中的线程共享其进程中的内存和资源 共享的内存是堆内存和方法区内存,栈内存不共享 实现线程的三种方式 Java 虚拟机的主线程入口是 main 方法,用户可以自己创建线程,创建方式有三种： 继承 Thread 类 实现 Runnable 接口（推荐使用 Runnable 接口） 实现 Callable 接口 继承 Thread 类 编写一个类,直
多线程复习 七 线程的生命周期状态
零零JA
08-31 110
多线程同步异步-复习
罗兰娇的博客
06-05 721
一个线程对象，被启动一次就创建了一个新线程。 每个线程的共有资源是此线程对象持有的对象，如下图的thread-a/thread-b/thread-c调用single对象的方法，即持有single对象资源，这是共有的。 每个线程有自己的方法栈，各自执行，就是异步，需要协同执行就是同步。 对对象加锁 在被持有对象（共享对象）中定义同步语句，如single对象，而不是在线程对象中定义。除非线程对象中有...
C#多线程复习题目80道+答案
10-10
此资源有利于初学者巩固C#多线程的基础知识，内有80道练习题及答案。
Java期末复习||应用程序设计-多线程和泛型
08-02
Java中的多线程和泛型是程序设计中的关键概念，它们极大地增强了代码的并发性和可复用性。在Java中，实现多线程有两种主要方式：一是通过继承`Thread`类，二是通过实现`Runnable`接口。通常推荐使用实现`Runnable`...
多线程、JVM复习&面试&强化训练100题
03-27
多线程、JVM复习&面试&强化训练100题，面试更有信心，面试不再发愁。多线程、JVM复习&面试&强化训练100题，面试更有信心，面试不再发愁。
QT多线程.xmind
11-08
针对Qt中如何创建线程，线程同步以及一些注意事项的总结
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1190
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java-Lambda
lizhiwei21的博客
07-21 482
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
最新发布
weixin_43561432的博客
07-24 240
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
淘客返利系统中的服务发现与注册机制详解
技术研究中心
07-22 1947
通过服务注册中心，服务提供者可以将自己注册到注册中心，服务消费者可以从注册中心获取服务提供者的地址，以实现服务调用。本文详细介绍了淘客返利系统中服务发现与注册机制的实现，包括Eureka的配置与代码示例。通过Eureka，我们可以轻松实现服务的注册与发现，确保分布式系统中各个服务之间的通信。在本文中，我们将深入探讨淘客返利系统中的服务发现与注册机制，并结合Java代码进行详细讲解。在我们的淘客返利系统中，我们采用Eureka作为服务发现与注册的工具。在我们的淘客返利系统中，首先需要配置Eureka服务器。
高级网络编程：Java多线程与电商法期末复习
本篇资料着重讲解了Java编程语言中的关键概念，特别是与多线程、网络通信以及Web开发技术相关的部分。 首先，Java线程（Thread）和进程（Process）是程序并发执行的基本单位。一个进程是独立运行且与其他进程隔离的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值