javaSE基础进阶知识笔记5-多线程

最新推荐文章于 2025-10-25 20:54:30 发布
原创 最新推荐文章于 2025-10-25 20:54:30 发布 · 93 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

本文详细介绍了Java中多线程的创建，包括继承Thread类、实现Runnable接口以及使用Callable接口。还探讨了线程的常用方法，如线程安全问题和解决策略，包括同步代码块、同步方法和Lock锁。此外，文章还讨论了线程通信示例以及线程池的使用，如ThreadPoolExecutor和Executors工具类。最后提到了定时器Timer在并发编程中的应用。

多线程

线程概述

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

线程创建方式

方式一：继承Thread类

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

package org.example.d1_create;

/**
        目标：多线程的创建方式一，继承Thread类实现
 */
public class Demo1 {
    public static void main(String[] args) {
        //3.new一个新线程对象
        Thread t=new MyThread();
        //4.调用start方法启动线程（执行的还是run方法）
        t.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程启动"+i);
        }
    }
}

/**
        1.定义一个线程类继承Thread类
 */
class MyThread extends Thread{
    /**
            2.重写run方法，里面定义线程以后干啥
     */
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程启动"+i);
        }
    }
}

方式二：实现Runnable接口

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

package org.example.d1_create;

/**
        目标：学会线程的创建方式二，理解它的优缺点
 */
public class ThreadDemo2 {
    public static void main(String[] args) {
        //3.创建一个任务对象
        Runnable target=new MyRunnable();
        //4.把任务对象交给Thread类处理
        Thread t=new Thread(target);
        //5.启动线程
        t.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("主线程执行输出；"+i);
        }
    }
}

/**
        1.定义线程任务类，实现Runnable接口
 */
class MyRunnable implements Runnable{
    //2.重写run方法，定义线程的执行任务

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("子线程执行输出；"+i);
        }
    }
}

在这里插入图片描述

package org.example.d1_create;

/**
 目标：学会线程的创建方式二，使用匿名内部类方式
 */
public class Demo2 {
    public static void main(String[] args) {
        //3.创建一个任务对象
        Runnable target=new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("子线程1执行输出；"+i);
                }
            }
        };
        //4.把任务对象交给Thread类处理
        Thread t=new Thread(target);
        //5.启动线程
        t.start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("子线程2执行输出；"+i);
                }
            }
        }).start();

        new Thread(() ->{
                for (int i = 0; i < 10; i++) {
                    System.out.println("子线程3执行输出；"+i);
                }
            }
        ).start();


        for (int i = 0; i < 10; i++) {
            System.out.println("主线程执行输出；"+i);
        }
    }
}

方式三：实现Callable接口

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

在这里插入图片描述

package org.example.d1_create;

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

/**
        目标：学会线程的创建方式三：实现Callable接口，结合FutureTask完成
 */
public class Demo3 {
    public static void main(String[] args) {
        //3.创建Callable任务对象
        Callable<String> call=new MyCallable(100);
        //4.把Callable任务对象交给FutureTask对象
        //FutureTask对象的作用1：是Runnable的对象（实现了Runnable接口）可以交给Thread了
        //FutureTask对象的作用2：可以在线程完毕之后通过调用get方法得到线程执行的结果
        FutureTask<String> f1=new FutureTask<>(call);
        //5.交给线程处理
        Thread t=new Thread(f1);
        //6.启动线程
        t.start();

        Callable<String> call2=new MyCallable(200);
        FutureTask<String> f2=new FutureTask<>(call);
        //5.交给线程处理
        Thread t2=new Thread(f2);
        //6.启动线程
        t2.start();


        try {
            //如果f1任务没有执行完毕，这里的代码会等待，直到线程1跑完才提取结果
            String rs1=f1.get();
            System.out.println("第一个线程结果："+rs1);
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            String rs2=f2.get();
            System.out.println("第一个线程结果："+rs2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

/**
        1.定义一个任务类，实现Callable接口  应该申明线程任务执行完毕后的结果的数据类型
 */
class MyCallable implements Callable<String>{
    private int n;

    public MyCallable(int n) {
        this.n = n;
    }

    /**
        2.重写call方法
     */
    @Override
    public String call() throws Exception {
        int sum=0;
        for (int i = 0; i <= n; i++) {
            sum+=n;
        }
        return ("子线程执行的结果是："+sum);
    }
}

在这里插入图片描述

线程常用方法

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

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

package org.example.d2_api;

/**
        目标：线程的API
 */
public class Demo1 {
    public static void main(String[] args) {
        Thread t1=new Thread(()-> {
                for (int i = 0; i < 10; i++) {
                    System.out.println("子线程"+Thread.currentThread().getName()+i); }});
        t1.setName("1号");
        t1.start();
        System.out.println(t1.getName());

        Thread t2=new Thread(()-> {
            for (int i = 0; i < 10; i++) {
                System.out.println("子线程"+Thread.currentThread().getName()+i); }});
        t2.setName("2号");
        t2.start();
        System.out.println(t2.getName());

        //哪个线程执行它，它就得到哪个线程对象（当前线程）
        Thread m=Thread.currentThread();
        m.setName("最牛的线程");
        System.out.println(m.getName());
        for (int i = 0; i < 5; i++) {
            System.out.println(m.getName()+"输出："+i);
        }
    }
}

在这里插入图片描述

package org.example.d2_api;

public class Demo2 {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.println("输出"+ i);
            if (i==3){
                //让线程进入休眠状态
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

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

线程安全

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

package org.example.d3_thread_safe;


/**
        目标：模拟取钱案例
 */
public class ThreadDemo {
    public static void main(String[] args) {
        //1.定义线程类，创建一个共享账户对象
        Account acc=new Account("ICBC-111",100000.00);
        //2.创建2个线程对象，代表小明和小红同时进来了

        new DrawThread(acc,"小明").start();
        new DrawThread(acc,"小红").start();

    }
}


package org.example.d3_thread_safe;

public class DrawThread extends Thread{
    private Account account;

    public DrawThread(Account acc,String name){
        super(name);
        this.account=acc;
    }

    @Override
    public void run() {
        account.drawMoney(100000.00);
    }
}


package org.example.d3_thread_safe;

public class Account {
    private String card;
    private double money;

    public Account() {
    }

    public Account(String card, double money) {
        this.card = card;
        this.money = money;
    }

    public String getCard() {
        return card;
    }

    public void setCard(String card) {
        this.card = card;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    public void drawMoney(double money) {
        //1.判断是谁来取钱
        String name=Thread.currentThread().getName();

        if (this.money>=money){
            //2.取钱
            System.out.println(name+"取钱成功，吐出"+money);
            //3.更新余额
            this.money =this.money-money;
            System.out.println(name+"取钱后剩余："+this.money);
        }else {
            System.out.println(name+"取钱失败，余额不足");
        }
    }
}

线程同步

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

加锁方式一：同步代码块

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

package org.example.d4_thread_synchronized_code;

public class Account {
    private String card;
    private double money;

    public Account() {
    }

    public Account(String card, double money) {
        this.card = card;
        this.money = money;
    }

    public String getCard() {
        return card;
    }

    public void setCard(String card) {
        this.card = card;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    public void drawMoney(double money) {
        //1.判断是谁来取钱
        String name=Thread.currentThread().getName();

        //加锁
        synchronized (this) {
            if (this.money >= money){
                //2.取钱
                System.out.println(name+"取钱成功，吐出"+money);
                //3.更新余额
                this.money =this.money-money;
                System.out.println(name+"取钱后剩余："+this.money);
            }else {
                System.out.println(name+"取钱失败，余额不足");
            }
        }
    }
}


package org.example.d4_thread_synchronized_code;


public class DrawThread extends Thread{
    private Account account;

    public DrawThread(Account acc, String name){
        super(name);
        this.account=acc;
    }

    @Override
    public void run() {
        account.drawMoney(100000.00);
    }
}


package org.example.d4_thread_synchronized_code;


/**
        目标：模拟取钱案例
 */
public class ThreadDemo {
    public static void main(String[] args) {
        //1.定义线程类，创建一个共享账户对象
        Account acc=new Account("ICBC-111",100000.00);
        //2.创建2个线程对象，代表小明和小红同时进来了

        new DrawThread(acc,"小明").start();
        new DrawThread(acc,"小红").start();

    }
}

加锁方式二：同步方法

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

package org.example.d5_thread_synchronized_method;

public class Account {
    private String card;
    private double money;

    public Account() {
    }

    public Account(String card, double money) {
        this.card = card;
        this.money = money;
    }

    public String getCard() {
        return card;
    }

    public void setCard(String card) {
        this.card = card;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    public synchronized void drawMoney(double money) {
        //1.判断是谁来取钱
        String name=Thread.currentThread().getName();

        if (this.money>=money){
            //2.取钱
            System.out.println(name+"取钱成功，吐出"+money);
            //3.更新余额
            this.money =this.money-money;
            System.out.println(name+"取钱后剩余："+this.money);
        }else {
            System.out.println(name+"取钱失败，余额不足");
        }
    }
}

加锁方式三：lock锁

在这里插入图片描述

package org.example.d6_thread_lock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Account {
    private String card;
    private double money;
    //final修饰：锁对象唯一
    private final Lock lock=new ReentrantLock();

    public Account() {
    }

    public Account(String card, double money) {
        this.card = card;
        this.money = money;
    }

    public String getCard() {
        return card;
    }

    public void setCard(String card) {
        this.card = card;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    public void drawMoney(double money) {
        //1.判断是谁来取钱
        String name=Thread.currentThread().getName();

        lock.lock();
        try {
            if (this.money>=money){
                //2.取钱
                System.out.println(name+"取钱成功，吐出"+money);
                //3.更新余额
                this.money =this.money-money;
                System.out.println(name+"取钱后剩余："+this.money);
            }else {
                System.out.println(name+"取钱失败，余额不足");
            }
        } finally {
            lock.unlock();
        }
    }
}

线程通信

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

package org.example.d7_thread_conmminute;

public class Account {
    private String card;
    private double money;

    public Account() {
    }

    public Account(String card, double money) {
        this.card = card;
        this.money = money;
    }

    public String getCard() {
        return card;
    }

    public void setCard(String card) {
        this.card = card;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    /**
        亲爹，干爹，岳父存钱
     * @param money
     */
    public synchronized void deposit(double money){
        try {
            String name=Thread.currentThread().getName();
            if (this.money==0){
                this.money +=money;
                System.out.println(name+ "存钱"+money+"成功，余额为："+this.money);
                //有钱了，唤醒别人，等待自己
                this.notify();
                this.wait();
            }else {
                //有钱不存
                this.notify();
                this.wait();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 取钱
     * @param money
     */
    public synchronized void drawMoney(double money) {
        try {
            //1.判断是谁来取钱
            String name=Thread.currentThread().getName();

            if (this.money>=money){
                //2.取钱
                System.out.println(name+"取钱成功，吐出"+money);
                //3.更新余额
                this.money =this.money-money;
                System.out.println(name+"取钱后剩余："+this.money);
                //没钱了
                this.notify();
                this.wait();
            }else {
                System.out.println(name+"取钱失败，余额不足");
                //钱不够，不能取
                //唤醒别人，等待自己
                this.notify();
                this.wait();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


package org.example.d7_thread_conmminute;

public class DrawThread extends Thread{
    private Account account;

    public DrawThread(Account acc, String name){
        super(name);
        this.account=acc;
    }

    @Override
    public void run() {
        while (true) {
            account.drawMoney(100000.00);
            try {
                Thread.sleep(3000);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}


package org.example.d7_thread_conmminute;

public class DepositThread extends Thread{
    private Account acc;
    public DepositThread(Account acc,String name){
        super(name);
        this.acc=acc;
    }
    @Override
    public void run() {
        while (true) {
            acc.deposit(100000.00);
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


package org.example.d7_thread_conmminute;


/**
        目标：了解线程通信的流程
 */
public class ThreadDemo {
    public static void main(String[] args) {
        //使用三个爸爸存钱（生产者），俩个孩子取钱（消费者），模拟线程通信思想
        //创建账户对象，代表五个人共同操作的对象
        Account acc=new Account("ICCBC",0);
        //创建2个线程对象代表小明和小红
        new DrawThread(acc,"小明").start();
        new DrawThread(acc,"小红").start();
        //创建3个线程对象代表三个爸爸
        new DepositThread(acc,"亲爹").start();
        new DepositThread(acc,"干爹").start();
        new DepositThread(acc,"岳父").start();

    }
}

线程池

线程池概述和创建线程

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

线程池处理Runnable、Callable任务

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

package org.example.d8_threadpool;

import java.lang.reflect.Executable;
import java.util.concurrent.*;

/**
        目标：自定义一个线程池对象，并测试其特性
 */
public class ThreadPoolDemo1 {
    public static void main(String[] args) {
        //1.创建线程池对象
        /*
        public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)*/
        ExecutorService pool=new ThreadPoolExecutor(3,5,8,
                TimeUnit.SECONDS,new ArrayBlockingQueue<>(5),
                Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
        //2.给任务线程池处理
        Runnable target=new MyRunnable();
        //核心线程处理
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        //放进任务队列
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        //若核心线程在忙，任务对列已满，则创建临时线程
        pool.execute(target);
        pool.execute(target);
        //若最大线程数在忙，任务队列已满，则抛出异常
        //pool.execute(target);

        //关闭线程池，开发中一般不会使用
        //pool.shutdownNow();//立即关闭，即使任务没有完成，会丢失数据
        pool.shutdown();//会等待任务执行完毕后在进行关闭
    }
}

在这里插入图片描述

package org.example.d8_threadpool;

import java.util.concurrent.Callable;

/**
        1.定义一个任务类，实现Callable接口  应该申明线程任务执行完毕后的结果的数据类型
 */
class MyCallable implements Callable<String>{
    private int n;

    public MyCallable(int n) {
        this.n = n;
    }

    /**
        2.重写call方法
     */
    @Override
    public String call() throws Exception {
        int sum=0;
        for (int i = 0; i <= n; i++) {
            sum+=n;
        }
        return (Thread.currentThread().getName()+"线程执行1--->"+n+"的和是："+sum);
    }
}


package org.example.d8_threadpool;

import java.util.concurrent.*;

/**
        目标：自定义一个线程池对象，并测试其特性
 */
public class ThreadPoolDemo2 {
    public static void main(String[] args) throws Exception {
        //1.创建线程池对象
        /*
        public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)*/
        ExecutorService pool=new ThreadPoolExecutor(3,5,8,
                TimeUnit.SECONDS,new ArrayBlockingQueue<>(5),
                Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
        //2.给任务线程池处理
        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));
        Future<String> f5 = pool.submit(new MyCallable(500));

        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());
        System.out.println(f5.get());
    }
}

Executors的工具类构建线程池对象

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

package org.example.d8_threadpool;


import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
        目标：使用Executors的工具方法直接接得到一个线程池对象
 */
public class ThreadPoolDemo3 {
    public static void main(String[] args) {
        //1、创建固定线程数据的线程池
        ExecutorService pool = Executors.newFixedThreadPool(3);
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
    }
}

补充知识

定时器

在这里插入图片描述

在这里插入图片描述

Timer定时器的特点和存在的问题

  1. Timer是单线程，处理多个任务按照顺序执行，存在延时与设置定时器的时间有出入。
  2. 可能因为其中的某个任务的异常使Timer线程死掉，从而影响后续任务执行。

在这里插入图片描述

package org.example.d9_timer;


import com.sun.jmx.snmp.tasks.Task;

import java.util.Date;
import java.util.TimerTask;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 目标：Timer定时器的使用和了解
 */

public class TimerDemo2 {
    public static void main(String[] args) {
        //创建一个ScheduledExecutorService对象，做定时器
        ScheduledExecutorService pool= Executors.newScheduledThreadPool(3);

        //开启定时任务
        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行了AAA\t"+ new Date());
                try {
                    Thread.sleep(10000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },0,2, TimeUnit.SECONDS);


        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行了BBB\t"+new Date());
                System.out.println(10/0);
            }
        },0,2, TimeUnit.SECONDS);


        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行了CCC\t"+new Date());
            }
        },0,2, TimeUnit.SECONDS);
    }
}

并发并行

在这里插入图片描述

在这里插入图片描述

线程的生命周期

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

在这里插入图片描述

参考视频

Java进阶笔记----翁恺YYDS
xiaofuvip的博客
08-04 593
翁恺老师Java进阶课程的学习笔记
[Java学习笔记doc]-javase基本知识
08-11
这份"Java学习笔记doc-javase基本知识"涵盖了Java SE的核心概念，对于初学者和有经验的开发者来说都是宝贵的参考资料。 1. **Java语法基础** - **关键字和标识符**：Java的关键字包括`public`, `private`, `...
JavaSE-进阶-学习笔记-JUC
qq_52668773的博客
04-03 2318
​ 管程 (英语：Monitors，也称为监视器) 是一种程序结构，结构内的多个子程序（对象或模块）形成的多个工作线程互斥访问共享资源。​ 这些共享资源一般是硬件设备或一群变量。对共享变量能够进行的所有操作集中在一个模块中。（把信号量及其操作原语“封装”在一个对象内部）管程实现了在一个时间点，最多只有一个线程在执行管程的某个子程序。管程提供了一种机制，管程可以看做一个软件模块，它是将共享的变量和对于这些共享变量的操作封装起来，形成一个具有一定接口的功能模块，进程可以调用管程来实现进程级别的并发控制。
JavaSE-进阶-学习笔记-多线程
qq_52668773的博客
10-17 163
当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，有几种状态呢？在API中这个枚举中给出了六种线程状态：这里先列出各个线程状态发生的条件，下面将会对每种状态进行详细解析线程状态导致状态发生条件NEW(新建)线程刚被创建，但是并未启动。还没调用start方法。MyThread t = new MyThread只有线程对象，没有线程特征。Runnable(可运行)
JavaSE进阶笔记-多线程02
SUIT THUG!的博客
07-24 376
今日目标 能够知道java中线程的相关状态以及各个状态之间的转换过程 能够理解什么是线程池 能够了解volatile关键字的语义 能够知道什么是原子性 能够掌握jdk中提供的线程并发工具类的使用 1.线程池 1.1 线程状态介绍 当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。线程对象在不同的时期有不同的状态。那么Java中的线程存在哪几种状态呢？ Java中的线程状态被定义在了java.lang.Thread.State枚举类中，State枚举类的源
JavaSE进阶笔记-多线程01
SUIT THUG!的博客
07-21 289
1.实现多线程 1.1简单了解多线程【理解】 是指从软件或者硬件上实现多个线程并发执行的技术。 具有多线程能力的计算机因有硬件支持而能够在同一时间执行多个线程，提升性能。 1.2并发和并行【理解】 并行：在同一时刻，有多个指令在多个CPU上同时执行。 并发：在同一时刻，有多个指令在单个CPU上交替执行。 1.3进程和线程【理解】 进程：是正在运行的程序 独立性：进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位 动态性：进程的实质是程序的一次执行过程，进程是动态产生，动态
JavaSE-进阶-学习笔记-Socket编程
qq_52668773的博客
04-07 1931
一个该类的对象就代表一个IP地址对象UDP是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。简单来说，当一台计算机向另外一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向发送端反馈是否收到数据。​由于使用UDP协议消耗资源小，通信效率高，所以通常都会用于音频、视频和普通数据的传输例如视频会议都使用UDP协议，因为这种情况即使偶尔丢失一两个数据包，也不会对接收结果产生太大影响。
JavaSE-进阶-学习笔记-IO模型
qq_52668773的博客
04-07 855
​ 非阻塞IO是在应用调用recvfrom读取数据时，如果该缓冲区没有数据的话，就会直接返回一个EWOULDBLOCK错误，不会让应用一直等待中。在没有数据的时候会即刻返回错误标识，那也意味着如果应用要读取数据就需要不断的调用recvfrom请求，直到读取到它数据要的数据为止。
[JavaSE进阶笔记]day09 多线程
asd532157097的博客
09-08 256
目录 并行和并发 进程 线程 线程概述 继承Thread多线程实现 线程调度 多线程原理 线程的生命周期 实现Runnable接口实现多线程 线程同步 同步代码块 同步方法 Lock锁 死锁 sleep和wait的区别 wait和notify在哪个类中定义，为什么 并行和并发 并行：同一时刻，多个指令（多个软件或命令）在CPU上同时执行。 并发：同一时间段，多个指令在CPU上交替执行（纳秒级别，无法感知）。多核CPU都是并发执行 ...
JavaSE从入门到进阶---------文章总目录
DempseyLee的博客
03-07 317
尚硅谷JavaSE视频笔记 目录 1 编程入门硬件部分_DempseyLee的博客-CSDN博客_硬件编程 2 一 [Java基础]Java语言概述_DempseyLee的博客-CSDN博客 3 二 Java基础语法 变量和数据类型_DempseyLee的博客-CSDN博客 4 三【 java基础语法 】进制和运算符_DempseyLee的博客-CSDN博客 5 四 【java基础】 程序流程控制- 分支结构_DempseyLee的博客-CSDN博客 ..
JavaSE进阶学习笔记：知识点详解与实践应用
- **复习基础语法和OOP原则**：帮助程序员检查自己是否掌握了Java的基础知识和面向对象编程的基本原则。 - **更新对Java新特性的理解**：通过学习Java 8及以上版本的新特性，有经验的程序员可以了解最新的编程范式...
JavaSE进阶每日复习与笔记.zip
11-03
**JavaSE进阶知识点概述** JavaSE（Java Standard Edition）是Java编程语言的基础部分，它提供了用于开发桌面应用程序和服务器端应用的核心库。本压缩包包含的笔记涵盖了JavaSE的一些重要进阶主题，包括抽象类与...
javaSE基础系统学习笔记
04-17
这份"javaSE基础系统学习笔记"涵盖了Java编程语言的基本概念、语法和常用库的使用，是初学者深入理解Java技术体系的良好参考资料。下面将详细阐述其中可能包含的知识点。 1. **Java编程基础**： - **环境配置**：...
JavaSE精华笔记.zip
01-06
这个"JavaSE精华笔记.zip"压缩包包含了关于Java基础的多个主题，对于初学者和想要巩固基础知识的开发者来说是非常有价值的资源。下面我们将逐个探讨这些主题。 1. **Java基础知识点查漏补缺.pdf**： 这部分可能...
Java事故排查
最新发布
sinat_28694519的博客
10-25 911
作为一名软件开发人员，经常会遇到各种各样的事故，一般凭借日志就可以定位到异常问题，然后修复测试，即可验证是否解决，这种较为简单的问题。复杂一点的是，长时间运行出现的问题，比如运行几天之后，程序发生异常，这种不是部署上线后立即发现的，很难排查，但是一般也可以归结为并发性能异常、内存漏洞之类异常。这种情况，日志比较少，需要dump程序的信息，进行分析，以内存泄露为例来说，需要定位到程序中的大对象，然后查看相关代码定位。
SpringBoot+Shiro+mybatis教务管理系统源码
10-21 416
本系统包含完善的权限管理体系，设有管理员、教务人员、教师和学生四种角色。管理员拥有系统全部权限（15项核心功能），教务人员、教师和学生则根据职责分配相应权限。系统支持灵活的角色权限配置，可根据实际需求进行扩展调整。
面试鸭Java八股之后端场景面试题（下）
小小博客
10-24 1423
这个设计方案的核心是“一个队列保顺序，一个令牌桶控流速”。分布式：通过Redis实现中心化的协调，通过无状态Worker集群实现水平扩展。FIFO：通过单一消息队列（或Kafka单分区）和正确的重试逻辑（失败消息回退到队头）来严格保证。限流与用满：通过Redis实现的令牌桶算法，将第三方调用速率精确控制在100 TPS。只要队列不空，Worker会持续尝试，确保每秒100个额度被充分利用。这是一个在理论和实践中都非常可靠的设计，被广泛应用于需要严格限流和顺序处理的金融、交易等场景。
记录一次线上oom问题排查
北冥的博客
10-21 1645
截图显示的内存使用情况表明，存在大量的。
3.Docker日志分析
清菡的博客
10-25 205
1）开发或运维直接把项目环境所需要部署的基础软件+项目代码+数据库脚本等，直接构建成镜像(上传到docker hub私有仓库--如果是测试环境，不做上传仓库)，打包成压缩包xx.tar 提交给测试。测试中，出现bug了，特别是页面无任何响应/无数据/服务器异常，先用定位工具：先抓包工具(前后端bug定位)。运行镜像为容器，如果运行失败，也会占用容器资源-(容器名已存在/端口地址被使用)，可以通过"--name 容器名称、 -d后台运行、-p映射端口(外部访问端口-自定义:容器内部端口)、
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值