Java基础之多线程

最新推荐文章于 2024-03-10 23:38:03 发布
最新推荐文章于 2024-03-10 23:38:03 发布
阅读量471 收藏
点赞数
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51833408/article/details/119011194
版权

在这里插入图片描述

文章目录

前言

随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。

一、线程简介

多任务：边吃饭边玩手机，同时做多件事
多线程：多车道，多条线路同时执行任务

二、线程实现

1.继承Thread类

不建议使用：为了避免OOP单继承局限性

Thread类本身实现了Runnable接口

实现步骤：

① 自定义线程类继承Thread类

② 重写run方法，编写程序执行体

③ 创建线程对象，调用start()方法启动线程

代码如下（示例）：

/**
 * 描述：继承Thread类创建线程
 */
public class Thread1 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("子线程： " + i);
        }
    }

    public static void main(String[] args) {
        Thread1 thread1 = new Thread1();
        // thread1.run();//先执行run方法，再执行接下来的代码（没起到多线程的作用）
        thread1.start();//主线程和子线程交替执行，且不可控，每次执行结果都不一样
        for (int i = 0; i < 20; i++) {
            System.out.println("主线程： " + i);
        }
    }
}

总结： 线程开启不一定立即执行，由CPU调度执行，直接调用run方法相当于调用普通方法，不会创建新的线程。

2.实现Runnable接口

Java 是单继承，推荐使用Runnable接口，方便同一个独享被多个线程使用

避免了单继承的局限性：即在Java中一个类只能使用extends继承一个父类.，如果继承多个父类，而父类有同名方法时就不知道调用哪一个方法了，另外会是两个类的耦合性增加，如果父类有改动时会直接影响子类。

实现步骤：

① 定义MyRunnable类实现Runnabke接口

② 实现Run()方法，编写程序执行体

③ 创建线程对象，调用start()方法启动线程

代码如下（示例）：

/**
 * 描述：实现Runnable接口
 */
public class Thread2 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("子线程： " + i);
        }
    }

    public static void main(String[] args) {
        //创建Runnable接口实现类的对象
        Thread2 thread2 = new Thread2();
        //创建线程类对象,通过线程对象开启我们的线程（代理）
        new Thread(thread2).start();
        for (int i = 0; i < 20; i++) {
            System.out.println("主线程： " + i);
        }
    }
}

3.实现Callable接口

了解即可

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

三、线程状态

1.五种状态

创建、就绪、运行、阻塞、死亡
在这里插入图片描述

2.线程停止（标志位）

不推荐使用jdk提供的stop()，destory()方法，建议使用一个标志位进行终止变量，当 flag = false，则线程终止运行。

死亡之后的线程不能再次启动

代码如下（示例）：

/**
 * 描述：停止线程
 */
public class ThreadStop implements Runnable {
    //1.线程中定义线程体使用的标识
    private boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        //2.线程体使用该标识
        while (flag){
            System.out.println("run.....Thread"+(i++));
        }
    }

    //3.对外提供方法改变标识
    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        ThreadStop threadStop = new ThreadStop();
        new Thread(threadStop).start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("主线程： "+i);
            if ( i == 900){ // 900时就停止子线程
                threadStop.stop();
                System.out.println("run线程停止了！");
            }
        }
    }
}

3.线程休眠（sleep）

  • sleep(时间) 指定当前线程阻塞的毫秒数
  • sleep时间达到后线程进入就绪状态
  • 每一个对象都有一个锁，sleep不会释放锁
  • sleep可以模拟网络延时(放大问题的发生性，比如多线程卖票，一票多卖)，倒计时等

代码如下（示例）：

/**
 * 描述：线程休眠
 */
public class ThreadSleep implements Runnable {
    @Override
    public void run() {

    }

    //模拟打印当前时间
    public static void main(String[] args) throws InterruptedException {
		testDown();
        //当前系统时间
        Date date = new Date(System.currentTimeMillis());
        while (true){
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(date)); // 格式化输出
            date = new Date(System.currentTimeMillis()); // 更新当前系统时间
            Thread.sleep(1000);
        }
    }

    //模拟倒计时
    public static void testDown() throws InterruptedException {
        int num = 10;
        while (true){
            Thread.sleep(1000); // 1秒，毫秒单位
            System.out.println(num--);
            if (num <= 0){
                break;
            }
        }
    }
}

4.线程礼让（yield）

  • 礼让线程，让当前正在执行的线程暂停，但不阻塞
  • 将线程从运行状态转为就绪状态
  • 让CPU重新调度，礼让不一定成功

代码如下（示例）：

/**
 * 描述：线程礼让
 */
public class ThreadYield implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程结束执行");
    }

    public static void main(String[] args) {
        ThreadYield threadYield = new ThreadYield();
        new Thread(threadYield,"a").start(); // 线程a
        new Thread(threadYield,"b").start(); // 线程b
    }
}

总结： 即使不进行礼让，也会出现礼让成功，因为是多线程，cpu调度来决定。

5.线程强制执行（join）

join合并线程，待此线程执行完毕之后，在执行其他线程，其他线程阻塞，可以想象成插队。

注意：join是通过 new Thread 对象来调用的，而sleep和yield是通过 Thread 直接调用。

代码如下（示例）：

/**
 * 描述：线程强制执行
 */
public class ThreadJoin implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("join线程：" + i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ThreadJoin threadJoin = new ThreadJoin();
        Thread thread=  new Thread( threadJoin);
        thread.start();

        for (int i = 0; i < 50; i++) {
            if( i == 25 ) {
                thread.join(); // 插队，让join线程先执行完后到主线程
            }
            System.out.println("主线程"+i);
        }
    }
}

四、线程优先级

线程优先级高不一定优先执行，大多数时候，线程优先级高的线程会优先执行，先设置优先级，再start线程！

java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。

线程的优先级用数字表示，范围从1~10。

  • Thread.MIN_PRIORITY = 1;
  • Thread.MAX_PRIORITY = 10;
  • Thread.NORM_PRIORITY = 5;

代码如下（示例）：

/**
 * 描述：线程优先级
 */
public class ThreadPriority {
    public static void main(String[] args) {
        //主线程设置默认优先级
        System.out.println(Thread.currentThread().getName() + "-->" + Thread.currentThread().getPriority());

        MyPriority myPriority = new MyPriority();
        Thread t1 = new Thread(myPriority,"t1");
        Thread t2 = new Thread(myPriority,"t2");
        Thread t3 = new Thread(myPriority,"t3");
        Thread t4 = new Thread(myPriority,"t4");
        Thread t5 = new Thread(myPriority,"t5");

        //先设置线程优先级，再启动
        t1.setPriority(1);
        t1.start();
        t2.setPriority(3);
        t2.start();
        t3.setPriority(6);
        t3.start();
        t4.setPriority(Thread.MAX_PRIORITY);    // 优先级=10
        t4.start();
        t5.setPriority(Thread.MIN_PRIORITY);    // 优先级=1
        t5.start();
    }
}

class MyPriority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "---线程被执行了！---" + Thread.currentThread().getPriority());
    }
}

五、守护线程（daemon）

线程分为用户线程和守护线程

守护线程在用户线程执行完毕之后也会执行完毕，不过JVM需要一点时间

应用场景：后台记录操作日志，监控内存，垃圾回收等

首先：守护线程先执行，然后用户线程执行与守护线程一起执行，用户线程执行完毕后，守护线程执行完毕。

代码如下（示例）：

/**
 * 描述：守护线程
 */
public class ThreadDaemon {
    public static void main(String[] args) {
        God god = new God();
        You you = new You();
        Thread thread = new Thread(god);
        thread.setDaemon(true); // 默认为false用户线程，true守护线程
        thread.start();
        new Thread(you).start();
    }
}

class God implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("上帝守护你");
        }
    }
}

class You implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("开心着活着每一天------");
        }
        System.out.println("----goodbye!Beautiful World!!!------");
    }
}

六、线程同步

解决多个线程操作同一个对象的安全问题。

线程同步其实就是一种等待机制。多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。

为了保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可。

线程同步形成条件：队列+锁

锁的对象就是多个线程共享的对象，锁谁取决于共同操作的对象是谁（且这个对象是要改变的）

只读代码是不需要加锁的，只有需要进行修改的代码才需要加锁（所以产生了同步方法和同步代码块）

  • 同步方法： public synchronized void method(int args)f
  • 同步块： synchronized(Obj) {} 注意：监视的对象是需要增删改查的对象

线程同步案例

1.线程安全买票

如果没有同步，剩一张票的时候，3个人都可以买到，会出现负数，线程不安全。

代码如下（示例）：

/**
 * 描述：线程安全买票
 */
public class BuyTicket implements Runnable {

    // 标志位
    private boolean flag = true;

    // 票数
    private int ticketNums = 10;

    @Override
    public void run() {
        while (true){
            buy();
        }
    }

    // 买票
    // synchronized同步方法，锁的是this
    private synchronized void buy(){
        if (ticketNums <= 0){
            flag = false;
            return;
        }
        // 模拟延时
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 买票
        System.out.println(Thread.currentThread().getName() + "拿到"+ ticketNums--);
    }

    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();
        new Thread(buyTicket,"a").start();
        new Thread(buyTicket,"b").start();
        new Thread(buyTicket,"c").start();
    }

}

2.银行取钱

因为synchronized默认所得独享是this，那么这里就是锁的银行，但是我们操作是对account进行操作的，银行是没有变的，所以我们需要synchronized同步块，锁account。

代码如下（示例）：

/**
 * 描述：银行取钱
 */
public class BankDraw {
    public static void main(String[] args) {
        //取钱首先得有账户
        Account account = new Account(100,"结婚基金");
        DrawMoney you = new DrawMoney(account,50,"张三");
        DrawMoney girl = new DrawMoney(account,100,"李四");
        you.start();
        girl.start();
    }
}

class Account{
    int money;   // 账户余额
    String name; // 卡名

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

class DrawMoney extends Thread{
    Account account;    // 账户
    int drawingMoney;   // 取多少钱
    int nowMoney;       // 现在有多少钱

    public DrawMoney(Account account, int drawingMoney, String name) {
        super(name);    // 调用父类的方法
        this.account = account;
        this.drawingMoney = drawingMoney;
//        this.nowMoney = nowMoney;
    }

    @Override
    public void run() {
        synchronized (account){ // 锁账户
            // 判断账户有没有钱
            if (account.money - drawingMoney < 0){
                System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
                return;
            }
            // 模拟延时
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 卡内余额
            account.money = account.money - drawingMoney;
            // 现在手里的钱
            nowMoney = nowMoney + drawingMoney;
            System.out.println(account.name+"余额为："+account.money);
            // this就是调用当前方法的对象，Drawing继承了Thread,所以this也是一个线程对象，可以调用Thread的getName方法来获取线程的名字
            // Thread.currentThread().getName()=this.getName()
            System.out.println(this.getName()+"手里的钱"+nowMoney);
        }
    }
}

3.线程安全集合

如果没有锁住集合两个线程同一瞬间操作了同一个位置，导致覆盖，元素变少。

代码如下（示例）：

/**
 * 描述：线程集合
 */
public class Gather {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(() ->{ // lamda 表达式
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        // 让主线程休眠一会再打印，电脑运行速度太快了。线程里add还没执行完就执行主线程的打印语句。会导致打印结果偏小。
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

4.JUCC集合

JUCC是JAVA提供的线程安全集合。

代码如下（示例）：

/**
 * 描述：线程安全的集合
 */
public class SafeGather {
    public static void main(String[] args) {
        CopyOnWriteArrayList list = new CopyOnWriteArrayList();
        for (int i = 0; i < 1000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

七、死锁

死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。

应用场景： 相当于两台并行前进的车，左边的车想变道右边，右边的车想变道左边，谁也不让谁。

产生死锁的四个必要条件：

  1. 互斥条件：一个资源每次只能被一个进程使用
  2. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放
  3. 不剥夺条件：进程已获得的资源，在末使用完之前，不能强行剥夺
  4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系

代码如下（示例）：

/**
 * 描述：死锁
 */
public class DeadLock {
    public static String obj1 = "A对象";
    public static String obj2 = "B对象";

    public static void main(String[] args) {
        Thread a = new Thread(new Thread1());
        Thread b = new Thread(new Thread2());
        a.start();
        b.start();
    }
}

class Thread1 implements Runnable{
    @Override
    public void run() {
        try {
            System.out.println("线程1 Running");
            while (true){
                synchronized (DeadLock.obj1){
                    System.out.println("线程1 锁定 A对象");
                    Thread.sleep(3000); // 获取obj1后先等一会儿，让Lock2有足够的时间锁住obj2
                    synchronized (DeadLock.obj2){
                        System.out.println("线程1 锁定 B对象");
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class Thread2 implements Runnable{
    @Override
    public void run() {
        try {
            System.out.println("线程2 Running");
            while (true){
                synchronized (DeadLock.obj2){
                    System.out.println("线程2 锁定 B对象");
                    Thread.sleep(3000); // 获取obj2后先等一会儿，让Lock1有足够的时间锁住obj1
                    synchronized (DeadLock.obj1){
                        System.out.println("线程2 锁定 A对象");
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

简单来说：

  1. 线程1和线程2的执行逻辑中都需要锁定对象A和对象B。
  2. 线程1在执行中先锁定了A对象。
  3. 线程2在执行中锁定了B对象。
  4. 线程1需要锁定B对象时发现B对象已经被其他线程锁住，所以线程1需要等待B对象锁释放后继续执行。
  5. 线程2需要锁定A对象时发现A对象已经被其他线程锁住，所以线程2需要等待A对象锁释放后继续执行。

总结： 线程1和线程2都在相互等待，它们都将无法推进下去。

八、Lock锁

ReentrantLock(可重入锁)类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。

ReentrantLock 与 Synchronized 对比：

  • Lock是显式锁（手动开启和关闭，别忘记关闭锁）Synchronized是隐式锁，出了作用域自动释放
  • Lock只有代码块锁，Synchronized有代码块锁和方法锁

代码如下（示例）：

/**
 * 描述：ReentrantLock可重入锁
 */
public class TestLock implements Runnable {

    int ticketNums = 10;

    //定义lock锁
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true){
            try {
                // 上锁
                lock.lock();
                if (ticketNums > 0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"获得了第"+(ticketNums--)+"票");
                }else {
                    break;
                }
            } finally {
                // 释放解锁
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        TestLock testLock = new TestLock();
        new Thread(testLock,"a").start();
        new Thread(testLock,"b").start();
        new Thread(testLock,"c").start();
    }
}

九、线程通信

方法：管程法 和 信号灯法

十、线程池

背景： 经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

思路： 提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。

好处： 提高响应速度（减少了创建新线程的时间)、降低资源消耗、便于线程管理

  • ExecutorService：真正的线程池接口
  • Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

代码如下（示例）：

/**
 * 描述：线程池
 */
public class ThreadPool {
    public static void main(String[] args) {
        //1、创建服务，创建线程池
        ExecutorService service = Executors.newFixedThreadPool(10); //newFixedThreadPool 参数为：线程池大小
        //2、执行
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        //3、关闭连接
        service.shutdown();
    }
}

class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"天天向上");
    }
}

总结

好了Java多线程基础先到这里了，记得点个赞哦！
在这里插入图片描述

林深时见鹿v
关注
专栏目录
Java面试之多线程篇
qq_24095055的博客
03-14 3338
Java面试之多线程篇 篇章 个人博客链接 多线程基础
java基础之多线程解析
qq_50313418的博客
11-23 1193
java基础之多线程解析 下面我们通过一张图来了解一下多线程我们需要学习什么内容 程序、进程、线程 程序： 是为完成特定任务，用某种语言编写的一段代码的集合，即一段静态的代码 进程： 程序的一次执行过程或是正在运行的程序 进程作为资源分配的基本单位，系统在运行时会为每个进程分配一定的内存区域 线程： 进程可进一步细化为线程，是程序运行过程中的一条执行路径 线程作为调度和运行的最小基本单位，每个线程拥有自己独立的pc(程序计数器)和运行栈，线程切换的开销小， 可以理解为独立运行的子任
java基础之多线程的引入
weixin_50691399的博客
11-03 2635
本文主要是引入多线程
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
qq_35716689的博客
03-10 25万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
Java多线程（超详细！）
一只小菜鸡
05-13 13万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
Java基础——多线程详解！！！！
qq_52519008的博客
10-04 4899
就是进程中的一个独立控制单元，线程在控制着进程的执行。一个进程中至少有一个进程。多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。多线程能满足程序员编写高效率的程序来达到充分利用 CPU 的目的。注意：很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一个时间点，CPU只执行一个代码，因为切换得很快，所以就有同时执行的错觉。程序、进程和线程的大家可以通过百度搜索得知，在这里我就不多阐述。
Java 多线程编程基础(详细)
一夜星尘
11-03 3万+
Java多线程编程基础进程与线程多线程实现Thread类实现多线程Runnable接口实现多线程Callable接口实现多线程多线程运行状态多线程常用操作方法线程的命名和获取线程休眠线程中断线程强制执行线程让步线程优先级设定线程的同步和锁死线程同步处理线程死锁 进程与线程 进程与线程的基本认识 进程（Process）：进程是程序的一次动态执行过程，它经历了从代码加载、执行、到执行完毕的一个完整过程；同时也是并发执行的程序在执行过程中分配和管理资源的基本单位，竞争计算机系统资源的基本单位。 线程（Thread
java多线程（超详细）
zdl66的博客
08-14 10万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 42万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
JAVA面试八股文之多线程基础知识
m0_59230408的博客
12-16 2万+
操作系统中有一个组件叫做任务调度器，将cpu的时间片（windows下时间片最小约为 15 毫秒）分给不同的程序使用，只是由于cpu在线程间（时间片很短）的切换非常快，人类感觉是同时运行的。进程就是用来加载指令、管理内存、管理 IO 的。家庭主妇雇了个保姆，她们一起这些事，这时既有并发，也有并行（这时会产生竞争，例如锅只有一口，一个人用锅时，另一个人就得等待）雇了3个保姆，一个专做饭、一个专打扫卫生、一个专喂奶，互不干扰，这时是并行。()方法在一个线程中启动另一个线程，另外一个线程完成该线程继续执行。
Java基础之多线程.md
11-10
Java多线程，Java基础，并发
JAVA零基础到高级进阶特训营 JAVA多线程并发设计+Spring高级+数据库开发+JAVA基础等
08-04
这套课程既可以作为从零基础开始...课程的主要内容涉及有JAVA基础课程、JAVA多线程与并发编程、数据库开发基础和进阶、Spring Framework、Spring进阶、Spring MVC框架、Spring boot、Java常用类库、Java异常处理等等
Java基础多线程.xmind
09-20
个人关于java基础多线程的思维导图总结。0积分下载。如果认为有帮助，请关注点赞，日后还有更多免费资源。
java基础：多线程学习笔记
最新发布
11-14
java基础：多线程学习笔记
Java开发遇见的异常错误
weixin_51833408的博客
07-22 1451
文章目录前言一、MySQL二、IDEA三、Mybatis四、Spring框架总结 前言 记录开发过程中常见的异常。 一、MySQL 1、MySQL 插入emoji表情错误的解决方案，Incorrect string value: '\xF0\x9F\x98\x84’ 原因： mysql的UTF-8只支持三个字节的存储，而一般字符是三个字节，但是emoji表情是4个字节，所以存储不了。 解决方案： 第一步：在有表情的字段上就应该这样做,将该字段设置为utf8mb4 ALTER TABLE table_na
Java8新特性——Optional 类
weixin_51833408的博客
09-01 1017
文章目录一、Optional 类概述API介绍ofofNullableemptyisPresentgetifPresentorElseorElseGetorElseThrowmapflatMapfilterOptional应用 一、Optional 类 概述  Optional不是函数式接口，而是用于防止 NullPointerException 的漂亮工具。这是下一节的一个重要概念，让我们快速了解一下Optional的工作原理。  Optional 是一个简单的容器，其值可能是null或者不是null。
Java8新特性——Date Time API
weixin_51833408的博客
09-01 749
文章目录一、Date Time API1.Java 8以前日期时间API存在的问题2.LocalDate/LocalTime/LocalDateTime3.获取对象的方法4.获取相关的方法5.转换的方法6.判断的方法7.增减年月日时分秒的方法8.指定年月日的方法9.日期格式化为字符串10.解析字符串为日期时间的方法11.两个日期之间的间隔 一、Date Time API 1.Java 8以前日期时间API存在的问题 Java 8以前， java.util.Date 、java.util.Calendar
Java基础之网络编程
weixin_51833408的博客
07-23 539
文章目录前言一、网络编程概述二、网络通信协议与接口1.网络通信协议2.网络通信接口3.网络分层模型三、网络协议1.IP地址2.端口（port）四、网络通信协议1.TCP协议Socket实现TCPTCP文件上传客户端：服务端：2.UDP协议Socket实现UDPUDP实现聊天室发送端：接收端：学生老师五、Socket套接字1.Socket实现TCP协议服务端：客户端：2.Socket实现UDP协议服务端客户端六、HTTP协议1.http和https2.URL下载网络资源3.HTTP方法4.HTTP状态码5.G
Java基础：多线程原理与创建方法详解
Java基础之多线程是计算机编程中的核心概念，尤其是在并发编程领域，它允许程序同时执行多个任务或操作，从而提高系统的效率和响应能力。本文将深入探讨Java中的多线程实现以及其重要性。 **1. 线程简介** 多线程是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值