Java 多线程

已于 2024-07-21 10:58:45 修改
阅读量698 收藏 6
点赞数 8
文章标签： java python 开发语言 算法 windows jvm
于 2024-07-21 00:59:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62854966/article/details/140558350
版权

文章目录

一、概念

在 Java 中，多线程是指在一个程序中同时运行多个执行线程，例如，在一个服务器程序中，可以使用多线程同时处理多个客户端的请求。

二、实现方式

多线程的实现方式主要有两种。

  • 继承 Thread 类
  • 实现 Runnable 接口

2.1 Thread 类

public class MyThread extends Thread {

    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }


    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println(getName() + "：" + i);
        }
    }

    public static void main(String[] args) {
        MyThread t1 = new MyThread("线程一");
        MyThread t2 = new MyThread("线程二");

        // 开启线程一
        t1.start();
        // 开启线程二
        t2.start();
    }
}

2.2 Runnable 接口

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println(Thread.currentThread().getName() + "：" + i);
        }
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(new MyRunnable(), "线程一");
        Thread t2 = new Thread(new MyRunnable(), "线程二");

        // 开启线程一
        t1.start();
        // 开启线程二
        t2.start();
    }
}

三、常用方法

3.1 基本方法

方法名含义
public final String getName()获取当前线程的名称
void setName(String name)设置线程的名称
static Thread currentThread()获取当前线程的对象
static native void sleep(long millis)让当前线程休眠，时间单位是毫秒
public class MyThread extends Thread {
    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            // 获取线程名称
            System.out.println(getName() + "：" + i);

            // 获取线程名称
            // System.out.println(Thread.currentThread().getName() + "：" + i);

            // 休眠一秒在打印
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();

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

        // 开启线程一
        t1.start();
        // 开启线程二
        t2.start();
    }
}

运行结果：

线程二：1
线程一：1
线程二：2
线程一：2
线程二：3
线程一：3
线程二：4
线程一：4
线程二：5
线程一：5

3.2 线程优先级

在 Java 中，线程的抢夺方式是 抢占式调度 的，这就意味着线程执行的频率是随机，那如果想要某一线程的代码执行频率相较于其他线程要高的话，就可以设置线程的优先级，另外，每个线程如果不设置优先级的话，默认等级是5，最高是10，最低是1。

方法名含义
public final void setPriority(int newPriority)设置线程的优先级
public final int getPriority()获取当前线程的优先级
public class MyThread extends Thread {
    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            // 获取线程名称
            System.out.println(getName() + "：" + i);
        }
    }

    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();

        System.out.println("===== 默认线程的优先级 ======");
        // 获取线程的优先级
        System.out.println(t1.getName() + "：" + t1.getPriority());
        System.out.println(t2.getName() + "：" + t2.getPriority());


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

        // 设置线程的优先级
        t1.setPriority(1);
        t2.setPriority(10);

        // 开启线程一
        t1.start();
        // 开启线程二
        t2.start();
    }
}

运行结果：

===== 默认线程的优先级 ======
Thread-0：5
Thread-1：5
线程二：1
线程二：2
线程一：1
线程二：3
线程一：2
线程二：4
线程一：3
线程二：5
线程一：4
线程一：5

注：你会发现 线程二 比 线程一 先执行完的几率要高一些，因为线程二的的优先级较高。

3.3 守护线程

守护线程的应用场景是当其他线程执行完毕后，有的线程就没有必要存在了，这时候就是将这些进程设置为守护线程，简单理解，守护线程，守护的就是其他线程，当其他线程都执行完，那么自己就没必要存在了。

方法名含义
public final void setDaemon(boolean on)设置线程为守护线程

创建线程类，在后面设置为守护线程

// 守护线程
public class DaemonThread extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 50; i++) {
            System.out.println(getName() + "：" + i);
        }
    }
}

创建普通线程类，并测试守护线程

public class MyThread extends Thread {
    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            // 获取线程名称
            System.out.println(getName() + "：" + i);
        }
    }

    public static void main(String[] args) {
        // 创建普通线程
        MyThread Thread1 = new MyThread();
        // 创建普通线程
        DaemonThread daemonThread = new DaemonThread();

        // 设置线程为守护线程
        daemonThread.setDaemon(true);


        // 设置线程名字
        Thread1.setName("线程");
        daemonThread.setName("守护线程");

        // 开启线程一
        Thread1.start();
        // 开启线程二
        daemonThread.start();
    }
}

运行结果：

守护线程：1
线程：3
守护线程：2
线程：4
守护线程：3
守护线程：4
线程：5
守护线程：5
守护线程：6
守护线程：7
守护线程：8
守护线程：9
守护线程：10
守护线程：11
守护线程：12
守护线程：13
守护线程：14
守护线程：15
守护线程：16
守护线程：17

注：守护线程不是立刻就会停止，而是逐渐停止。

3.4 礼让线程

看前面的多线程代码中的运行结果，会发现 线程一 和 线程二 是交替执行的，也有 线程 一次执行多次代码的情况。而礼让线程就是让 线程 执行完后，重新去抢夺CPU执行权，可以让线程之间的执行频率对齐，但这不是一定的，有可能会出现当前 线程 再次抢到了执行权的情况。

方法名含义
public static native void yield()设置线程为礼让线程

创建礼让线程类

public class YieldThread extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            // 获取线程名称
            System.out.println(getName() + "：" + i);

            // 设置为礼让线程
            Thread.yield();
        }
    }
}

创建普通线程类，并测试礼让线程

public class MyThread extends Thread {
    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            // 获取线程名称
            System.out.println(getName() + "：" + i);
        }
    }

    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        YieldThread t2 = new YieldThread();

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

        // 开启线程一
        t1.start();
        // 开启线程二
        t2.start();
    }
}

运行结果：

线程一：1
礼让线程：1
线程一：2
礼让线程：2
线程一：3
线程一：4
线程一：5
礼让线程：3
礼让线程：4
礼让线程：5

3.5 插队线程

插队线程的作用就是，让插入线程先于其他线程先执行完代码。

public class JoinThread extends Thread{

    @Override
    public void run() {
        try {
            // 让当前线程休眠3秒
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(getName() + "线程执行完毕");
    }

    public static void main(String[] args) throws InterruptedException {

        // 创建对象
        JoinThread t1 = new JoinThread();

        // 设置线程名称
        t1.setName("线程一");

        // 开启线程一
        t1.start();

        // 设置t1线程为插队线程，会优先于其他线程先执行完毕
        t1.join();

        System.out.println("当线程一执行完毕后，Main线程才会去执行");
    }
}

运行结果：

线程一线程执行完毕
当线程一执行完毕后，Main线程才会去执行

四、线程安全问题

在多线程编程中，需要注意线程安全问题。当多个线程同时访问和修改共享资源时，可能会导致数据不一致等问题。可以使用同步机制，如 synchronized 关键字、锁 等来解决线程安全问题。

需求：某电影院目前正在上映电影，电影票共有50张，分别在3个窗口售卖，请你用程序模拟这个场景。

public class MyThread extends Thread {
    // 电影票
    static int ticket = 0;

    // 具体逻辑
    @Override
    public void run() {
        while (true) {
            // 票没卖完
            if (ticket < 50) {
                ticket++;
                System.out.println(getName() + "在售卖第" + ticket + "张票");
            } else {
                // 票卖完了
                break;
            }

        }
    }

    public static void main(String[] args) {
        // 创建线程对象
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();

        // 设置线程名
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");

        // 启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果：

窗口一在售卖第1张票
窗口二在售卖第2张票
窗口三在售卖第3张票
窗口二在售卖第5张票
窗口一在售卖第4张票
窗口二在售卖第7张票
窗口三在售卖第6张票
窗口二在售卖第9张票
窗口一在售卖第8张票
窗口二在售卖第11张票
窗口三在售卖第10张票
窗口二在售卖第13张票
窗口一在售卖第12张票
窗口二在售卖第15张票
窗口三在售卖第14张票
窗口二在售卖第17张票
窗口一在售卖第16张票
窗口二在售卖第19张票
窗口三在售卖第18张票
窗口二在售卖第21张票
窗口一在售卖第20张票
窗口二在售卖第23张票
窗口三在售卖第22张票
窗口二在售卖第25张票
窗口一在售卖第24张票
窗口二在售卖第27张票
窗口三在售卖第26张票
窗口一在售卖第28张票
窗口二在售卖第29张票
窗口三在售卖第30张票
窗口二在售卖第32张票
窗口一在售卖第31张票
窗口二在售卖第34张票
窗口三在售卖第33张票
窗口二在售卖第36张票
窗口一在售卖第35张票
窗口二在售卖第38张票
窗口一在售卖第39张票
窗口三在售卖第37张票
窗口一在售卖第41张票
窗口二在售卖第40张票
窗口一在售卖第43张票
窗口三在售卖第42张票
窗口一在售卖第45张票
窗口二在售卖第44张票
窗口一在售卖第47张票
窗口三在售卖第46张票
窗口一在售卖第49张票
窗口二在售卖第48张票
窗口三在售卖第50张票

注意点：

  • 你会发现电影票会出现票的顺序不一致、少票、重复票、多票的情况，这些都是因为线程在执行的时候是随机的，打比方，如上述代码，窗口一 在执行完电影票++操作的时候，还没打印，窗口二 和 窗口三就抢到了执行权，分别对车票进行++操作，然后所有窗口一起打印现在是多少张票，这就会造成重复票的安全问题，其他也是一样的逻辑。

4.1 同步代码块

上述问题，主要就是 窗口一 线程在执行方式时，窗口二 线程和 窗口三 线程也进来了，那么有没有一种方法可以让 窗口一 线程在执行方式时，其他线程不能进来，同步代码块就是来解决这个问题的，被同步代码块锁起来的代码，只用里面的代码全部执行完毕，锁才会释放，其他线程才能进来。

public class MyThread extends Thread {
    // 电影票
    static int ticket = 0;

    // 具体逻辑
    @Override
    public void run() {
        while (true) {
            synchronized (MyThread.class) {
                // 票没卖完
                if (ticket < 50) {
                    ticket++;
                    System.out.println(getName() + "在售卖第" + ticket + "张票");
                } else {
                    // 票卖完了
                    break;
                }
            }

        }
    }

    public static void main(String[] args) {
        // 创建线程对象
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();

        // 设置线程名
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");

        // 启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果：

窗口一在售卖第1张票
窗口一在售卖第2张票
窗口一在售卖第3张票
窗口一在售卖第4张票
窗口一在售卖第5张票
窗口一在售卖第6张票
窗口一在售卖第7张票
窗口一在售卖第8张票
窗口一在售卖第9张票
窗口一在售卖第10张票
窗口一在售卖第11张票
窗口一在售卖第12张票
窗口一在售卖第13张票
窗口一在售卖第14张票
窗口一在售卖第15张票
窗口一在售卖第16张票
窗口一在售卖第17张票
窗口一在售卖第18张票
窗口一在售卖第19张票
窗口一在售卖第20张票
窗口一在售卖第21张票
窗口一在售卖第22张票
窗口一在售卖第23张票
窗口一在售卖第24张票
窗口一在售卖第25张票
窗口一在售卖第26张票
窗口一在售卖第27张票
窗口一在售卖第28张票
窗口一在售卖第29张票
窗口一在售卖第30张票
窗口一在售卖第31张票
窗口一在售卖第32张票
窗口一在售卖第33张票
窗口一在售卖第34张票
窗口一在售卖第35张票
窗口一在售卖第36张票
窗口一在售卖第37张票
窗口一在售卖第38张票
窗口一在售卖第39张票
窗口一在售卖第40张票
窗口一在售卖第41张票
窗口一在售卖第42张票
窗口一在售卖第43张票
窗口一在售卖第44张票
窗口一在售卖第45张票
窗口一在售卖第46张票
窗口一在售卖第47张票
窗口一在售卖第48张票
窗口一在售卖第49张票
窗口一在售卖第50张票

注意点：

  • 第一：synchronized() 它小括号传入的是锁对象，且必须是唯一的，不然还是会发生安全问题，synchronized() 就没意义了。

    • 可以传入this，例如 synchronized(this)；
    • 可以创建自定义对象，专门表示唯一的锁对象，例如：Object lock = new Object();，然后 synchronized(lock)；
    • 可以类的字节码对象，synchronized(类名.class)。

  • 第二：注意 synchronized() 书写的位置，如果放在 while 循环的上面，那性质就变了。

4.2 同步方法

同步方法是用来保证方法内代码的安全问题的，锁对象不需要我们指定，如果方法是静态的它是用当前类的 字节码对象 当锁对象，如果是非静态的使用 this 来当锁对象的。

public class MyThread extends Thread {
    // 电影票
    static int ticket = 0;

    // 具体逻辑
    @Override
    public void run() {
        while (true) {
            if (extracted()) break;
        }
    }

    // 同步方法
    private static synchronized boolean extracted() {
        // 票没卖完
        if (ticket < 50) {
            ticket++;
            System.out.println(Thread.currentThread().getName() + "在售卖第" + ticket + "张票");
        } else {
            // 票卖完了
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        // 创建线程对象
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();

        // 设置线程名
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");

        // 启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果：

窗口一在售卖第1张票
窗口一在售卖第2张票
窗口一在售卖第3张票
窗口一在售卖第4张票
窗口一在售卖第5张票
窗口一在售卖第6张票
窗口一在售卖第7张票
窗口一在售卖第8张票
窗口一在售卖第9张票
窗口一在售卖第10张票
窗口一在售卖第11张票
窗口一在售卖第12张票
窗口一在售卖第13张票
窗口一在售卖第14张票
窗口一在售卖第15张票
窗口一在售卖第16张票
窗口一在售卖第17张票
窗口一在售卖第18张票
窗口一在售卖第19张票
窗口一在售卖第20张票
窗口一在售卖第21张票
窗口一在售卖第22张票
窗口一在售卖第23张票
窗口一在售卖第24张票
窗口一在售卖第25张票
窗口一在售卖第26张票
窗口一在售卖第27张票
窗口一在售卖第28张票
窗口一在售卖第29张票
窗口一在售卖第30张票
窗口一在售卖第31张票
窗口一在售卖第32张票
窗口一在售卖第33张票
窗口一在售卖第34张票
窗口一在售卖第35张票
窗口一在售卖第36张票
窗口一在售卖第37张票
窗口一在售卖第38张票
窗口一在售卖第39张票
窗口一在售卖第40张票
窗口一在售卖第41张票
窗口一在售卖第42张票
窗口一在售卖第43张票
窗口一在售卖第44张票
窗口一在售卖第45张票
窗口一在售卖第46张票
窗口一在售卖第47张票
窗口一在售卖第48张票
窗口一在售卖第49张票
窗口一在售卖第50张票

4.3 lock()

方法名含义
void lock()上锁
void unlock()解锁
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyThread extends Thread {
    // 电影票
    static int ticket = 0;

    // 创建锁对象
    static Lock lock = new ReentrantLock();

    // 具体逻辑
    @Override
    public void run() {
        while (true) {
            // 上锁
            lock.lock();
            try {
                // 票卖完了
                if (ticket >= 50) {
                    break;
                } else {
                    ticket++;
                    System.out.println(getName() + "在卖第" + ticket + "张票!!!");
                }
            } finally {
                // 解锁
                lock.unlock();
            }
            
        }
    }

    public static void main(String[] args) {
        // 创建线程对象
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();

        // 设置线程名
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");

        // 启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果：

窗口二在卖第1张票!!!
窗口二在卖第2张票!!!
窗口二在卖第3张票!!!
窗口二在卖第4张票!!!
窗口二在卖第5张票!!!
窗口二在卖第6张票!!!
窗口二在卖第7张票!!!
窗口二在卖第8张票!!!
窗口二在卖第9张票!!!
窗口二在卖第10张票!!!
窗口二在卖第11张票!!!
窗口一在卖第12张票!!!
窗口一在卖第13张票!!!
窗口一在卖第14张票!!!
窗口一在卖第15张票!!!
窗口一在卖第16张票!!!
窗口一在卖第17张票!!!
窗口一在卖第18张票!!!
窗口三在卖第19张票!!!
窗口三在卖第20张票!!!
窗口三在卖第21张票!!!
窗口三在卖第22张票!!!
窗口三在卖第23张票!!!
窗口三在卖第24张票!!!
窗口三在卖第25张票!!!
窗口三在卖第26张票!!!
窗口二在卖第27张票!!!
窗口二在卖第28张票!!!
窗口二在卖第29张票!!!
窗口二在卖第30张票!!!
窗口二在卖第31张票!!!
窗口二在卖第32张票!!!
窗口二在卖第33张票!!!
窗口二在卖第34张票!!!
窗口二在卖第35张票!!!
窗口一在卖第36张票!!!
窗口一在卖第37张票!!!
窗口一在卖第38张票!!!
窗口一在卖第39张票!!!
窗口一在卖第40张票!!!
窗口一在卖第41张票!!!
窗口一在卖第42张票!!!
窗口一在卖第43张票!!!
窗口一在卖第44张票!!!
窗口一在卖第45张票!!!
窗口一在卖第46张票!!!
窗口三在卖第47张票!!!
窗口三在卖第48张票!!!
窗口三在卖第49张票!!!
窗口三在卖第50张票!!!

注意点：

-Lock 它不像 synchronized ，它可以手动的上锁和解锁，比 synchronized 有更好的操作性；

  • Lock 是一个接口，可以通过 ReentrantLock 来创建对象调用方法。

五、线程生命周期

在这里插入图片描述

野生派蒙
关注
  • 8
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Java多线程详解及示例
07-20
Java多线程编程是提升程序性能和响应性的关键技术。理解多线程的概念，掌握线程的创建、同步、通信、死锁避免等核心知识点，以及合理使用线程池，对于编写高效、稳定的并发程序至关重要。通过实践，开发者可以更好地...
java 多线程
11-07
java 多线程 知识相关，主要是介绍 java 多线程相关的知识
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
qq_35716689的博客
03-10 15万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
Java多线程（超详细！）
一只小菜鸡
05-13 12万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
java多线程（超详细）
zdl66的博客
08-14 10万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 41万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
【Java系列】深入解析Java多线程
颜淡慕潇
05-09 2万+
Java多线程是提高程序并发性和响应能力的重要手段，需要掌握多线程的实现方式、同步机制、线程之间的通信机制等，以确保多线程程序的正确性和稳定性。
Java多线程并发编程技术详解
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
03-20 1万+
Java多线程并发编程是一项需要深入理解和熟练掌握的技术，只有合理地设计和使用多线程，才能真正发挥其在提升系统性能方面的巨大潜力。随着对Java并发机制及工具类库的深入学习和应用，开发者可以更好地构建高效、稳定的并发系统。
单核 CPU 支持 Java 多线程吗？我们来一起看看吧
吴名氏的博客
06-09 9万+
单核 CPU 支持 Java 多线程吗？我们来一起看看吧
Java 多线程编程基础(详细)
一夜星尘
11-03 3万+
Java多线程编程基础进程与线程多线程实现Thread类实现多线程Runnable接口实现多线程Callable接口实现多线程多线程运行状态多线程常用操作方法线程的命名和获取线程休眠线程中断线程强制执行线程让步线程优先级设定线程的同步和锁死线程同步处理线程死锁 进程与线程 进程与线程的基本认识 进程（Process）：进程是程序的一次动态执行过程，它经历了从代码加载、执行、到执行完毕的一个完整过程；同时也是并发执行的程序在执行过程中分配和管理资源的基本单位，竞争计算机系统资源的基本单位。 线程（Thread
java多线程使用教程
鹏鹏2077
04-25 5338
本教程介绍了Java多线程的基本知识和使用方法，包括创建线程、实现Runnable接口、继承Thread类、线程同步、线程间通信和线程池等。多线程技术可以提高程序的并发处理能力和响应速度，但同时也带来了线程安全和同步等问题，需要合理使用同步机制来保证线程安全。使用Java提供的Lock接口可以实现更加灵活和精细的线程同步。线程间通信可以使用wait()、notify()和notifyAll()方法来实现。线程池机制可以重用线程，提高了线程的利用率和效率。掌握了这些知识，可以使用Java实现高效、安全、可靠的
JAVA多线程是什么
qq_45022104的博客
08-31 4088
一、 什么是多线程： 我们现在所使用操作系统都是多任务操作系统(早期使用的DOS操作系统为单任务操作系统)，多任务操作指在同一时刻可以同时做多件事(可以同时执行多个程序)。 多进程:每个程序都是一个进程，在操作系统中可以同时执行多个程序,多进程的目的是为了有效的使用CPU资源，每开一个进程系统要为该进程分配相关的系统资源(内存资源) 多线程:线程是进程内部比进程更小的执行单元(执行流|程序片段),每个线程完成一个任务,每个进程内部包含了多个线程每个线程做自己的事情，在进程中的所有线程共享该进程的资源； 主
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
java多线程
05-02
Java多线程是Java编程中的核心概念，它允许程序同时执行多个任务，提高了程序的效率和响应速度。在Java中，实现多线程有两种主要方式：通过实现`Runnable`接口和继承`Thread`类。 1. 实现Runnable接口 当一个类...
Java多线程读取大文件
12-22
【Java多线程读取大文件】是一种优化的文件处理策略，特别适用于处理大型文本文件。在传统的单线程I/O操作中，读取大文件可能导致内存溢出（OOM），尤其是在尝试一次性加载整个文件到内存时。为了避免这个问题，我们...
Java内存模型
weixin_44267758的博客
07-19 557
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
最新发布
山重水复疑无路，柳暗花明又一村。
07-20 475
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 979
JVM-垃圾回收与内存分配
java算法day19
TOMOT77的博客
07-20 121
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

野生派蒙

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值