多线程和线程池相关概念和线程方法的使用

最新推荐文章于 2024-10-15 11:12:27 发布
最新推荐文章于 2024-10-15 11:12:27 发布
阅读量59 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_58591155/article/details/132673015
版权

1. 什么是线程（线程的概念）

线程的概念：线程其实是程序中的一条执行路径。

2. 多线程的创建

2.1. 多线程的创建方式一：继承Thread类

  • 步骤：1、定义一个子类MyThread继承线程类java.lang.Thread，重写run()方法

2、创建MyThread类的对象

3、调用线程对象的start()方法启动线程（启动后还是执行run方法的）

  • 注意事项：1、启动线程必须是调用start方法，不是调用run方法。

2、不要把主线程任务放在启动子线程之前。

直接调用run方法会当成普通方法执行，此时相当于还是单线程执行。

只有调用start方法才是启动一个新的线程执行。

这样主线程一直是先跑完的，相当于是一个单线程的效果了。

  • 优缺点：
    • 优点：编码简单
    • 缺点：存在单继承的局限性，线程类继承Thread后，不能继承其他类，不便于扩展。

public class MyThread extends Thread{
    // 2、必须重写Thread类的run方法
    @Override
    public void run() {
        // 描述线程的执行任务。
        for (int i = 1; i <= 5; i++) {
            System.out.println("子线程MyThread输出：" + i);
        }
    }
}

//测试类
public class ThreadTest1 {
    // main方法是由一条默认的主线程负责执行。
    public static void main(String[] args) {
        // 3、创建MyThread线程类的对象代表一个线程
        Thread t = new MyThread();
        // 4、启动线程（自动执行run方法的）
        t.start(); 

        for (int i = 1; i <= 5; i++) {
            System.out.println("主线程main输出：" + i);
        }
    }
}

2.2. 多线程的创建方式二：实现Runnable接口

  • 步骤
    • 定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法
    • 创建MyRunnable任务对象
    • 把MyRunnable任务对象交给Thread处理。
  • Thread类提供的构造器
  • 说明
  • public Thread(Runnable target)
  • 封装Runnable对象成为线程对象
    • 调用线程对象的start()方法启动线程

  • 优缺点
    • 优点：任务类只是实现接口，可以继续继承其他类、实现其他接口，扩展性强。
    • 缺点：需要多一个Runnable对象。

/**
 * 1、定义一个任务类，实现Runnable接口
 */
public class MyRunnable implements Runnable{
    // 2、重写runnable的run方法
    @Override
    public void run() {
        // 线程要执行的任务。
        for (int i = 1; i <= 5; i++) {
            System.out.println("子线程输出 ===》" + i);
        }
    }
}

public class ThreadTest2 {
    public static void main(String[] args) {
        // 3、创建任务对象。
        Runnable target = new MyRunnable();
        // 4、把任务对象交给一个线程对象处理。
        //  public Thread(Runnable target)
        new Thread(target).start();

        for (int i = 1; i <= 5; i++) {
            System.out.println("主线程main输出 ===》" + i);
        }
    }
}

  • 匿名内部类创建线程
public class ThreadTest2_2 {
    public static void main(String[] args) {
        // 1、直接创建Runnable接口的匿名内部类形式（任务对象）
        Runnable target = new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.println("子线程1输出：" + i);
                }
            }
        };
        new Thread(target).start();

        // 简化形式1：
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.println("子线程2输出：" + i);
                }
            }
        }).start();

        // 简化形式2：
        new Thread(() -> {
                for (int i = 1; i <= 5; i++) {
                    System.out.println("子线程3输出：" + i);
                }
        }).start();

        for (int i = 1; i <= 5; i++) {
            System.out.println("主线程main输出：" + i);
        }
    }
}

2.3. 多线程的第三种创建方式：利用Callable接口、FutureTask类来实现。

  1. 步骤
  • 创建任务对象
    • 定义一个类实现Callable接口，重写call方法，封装要做的事情，和要返回的数据。
    • 把Callable类型的对象封装成FutureTask（线程任务对象）。
  • 把线程任务对象交给Thread对象。
  • 调用Thread对象的start方法启动线程。
  • 线程执行完毕后、通过FutureTask对象的的get方法去获取线程任务执行的结果。

  1. 优缺点
  • 优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强；可以在线程执行完毕后去获取线程执行的结果。
  • 缺点：编码复杂一点。

/**
 * 1、让子类继承Thread线程类。
 */
public class MyThread extends Thread{
    // 2、必须重写Thread类的run方法
    @Override
    public void run() {
        // 描述线程的执行任务。
        for (int i = 1; i <= 5; i++) {
            System.out.println("子线程MyThread输出：" + i);
        }
    }
}

public class ThreadTest3 {
    public static void main(String[] args) throws Exception {
        // 3、创建一个Callable的对象
        Callable<String> call = new MyCallable(100);
        // 4、把Callable的对象封装成一个FutureTask对象（任务对象）
        // 未来任务对象的作用？
        // 1、是一个任务对象，实现了Runnable对象.
        // 2、可以在线程执行完毕之后，用未来任务对象调用get方法获取线程执行完毕后的结果。
        FutureTask<String> f1  = new FutureTask<>(call);
        // 5、把任务对象交给一个Thread对象
        new Thread(f1).start();


        Callable<String> call2 = new MyCallable(200);
        FutureTask<String> f2  = new FutureTask<>(call2);
        new Thread(f2).start();


        // 6、获取线程执行完毕后返回的结果。
        // 注意：如果执行到这儿，假如上面的线程还没有执行完毕
        // 这里的代码会暂停，等待上面线程执行完毕后才会获取结果。
        String rs = f1.get();
        System.out.println(rs);

        String rs2 = f2.get();
        System.out.println(rs2);
    }
}

3. Thread的常用方法

  • 演示
public class MyThread extends Thread{
    public MyThread(String name){
        super(name); //1.执行父类Thread(String name)构造器，为当前线程设置名字了
    }
    @Override
    public void run() {
        //2.currentThread() 哪个线程执行它，它就会得到哪个线程对象。
        Thread t = Thread.currentThread();
        for (int i = 1; i <= 3; i++) {
            //3.getName() 获取线程名称
            System.out.println(t.getName() + "输出：" + i);
        }
    }
}

//测试类
public class ThreadTest1 {
    public static void main(String[] args) {
        Thread t1 = new MyThread();
        t1.setName(String name) //设置线程名称;
        t1.start();
        System.out.println(t1.getName());  //Thread-0

        Thread t2 = new MyThread("2号线程");
        // t2.setName("2号线程");
        t2.start();
        System.out.println(t2.getName()); // Thread-1

        // 主线程对象的名字
        // 哪个线程执行它，它就会得到哪个线程对象。
        Thread m = Thread.currentThread();
        m.setName("最牛的线程");
        System.out.println(m.getName()); // main

        for (int i = 1; i <= 5; i++) {
            System.out.println(m.getName() + "线程输出：" + i);
        }
    }
}


//join方法演示
public class ThreadTest2 {
    public static void main(String[] args) throws Exception {
        // join方法作用：让当前调用这个方法的线程先执行完。
        Thread t1 = new MyThread("1号线程");
        t1.start();
        t1.join();

        Thread t2 = new MyThread("2号线程");
        t2.start();
        t2.join();

        Thread t3 = new MyThread("3号线程");
        t3.start();
        t3.join();
    }
}

4. 线程安全

  1. 什么是线程安全问题

多个线程，同时操作同一个共享资源的时候，可能会出现业务安全问题。

  1. 下面通过一个取钱的案例给同学们演示一下。案例需求如下

场景：小明和小红是一对夫妻，他们有一个共享账户，余额是10万元，小红和小明同时来取钱，并且2人各自都在取钱10万元，可能出现什么问题呢？

如下图所示，小明和小红假设都是一个线程，本类每个线程都应该执行完三步操作，才算是完成的取钱的操作。但是真实执行过程可能是下面这样子的

① 小红线程只执行了判断余额是否足够（条件为true），然后CPU的执行权就被小红线程抢走了。

② 小红线程也执行了判断了余额是否足够（条件也是true）, 然后CPU执行权又被小明线程抢走了。

③ 小明线程由于刚才已经判断余额是否足够了，直接执行第2步，吐出了10万元钱，此时共享账户月为0。然后CPU执行权又被小红线程抢走。

④ 小红线程由于刚刚也已经判断余额是否足够了，直接执行第2步，吐出了10万元钱，此时共享账户月为-10万。

线程安全代码演示：

1.先创建一个共享账户类

public class Account {
    private String cardId; // 卡号
    private double money; // 余额。

    public Account() {
    }

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

    // 小明 小红同时过来的
    public void drawMoney(double money) {
        // 先搞清楚是谁来取钱？
        String name = Thread.currentThread().getName();
        // 1、判断余额是否足够
        if(this.money >= money){
            System.out.println(name + "来取钱" + money + "成功！");
            this.money -= money;
            System.out.println(name + "来取钱后，余额剩余：" + this.money);
        }else {
            System.out.println(name + "来取钱：余额不足~");
        }
    }

    public String getCardId() {
        return cardId;
    }

    public void setCardId(String cardId) {
        this.cardId = cardId;
    }

    public double getMoney() {
        return money;
    }

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

2.在定义一个是取钱的线程类

public class DrawThread extends Thread{
    private Account acc;
    public DrawThread(Account acc, String name){
        super(name);
        this.acc = acc;
    }
    @Override
    public void run() {
        // 取钱(小明，小红)
        acc.drawMoney(100000);
    }
}

3.最后，再写一个测试类，在测试类中创建两个线程对象

public class ThreadTest {
    public static void main(String[] args) {
         // 1、创建一个账户对象，代表两个人的共享账户。
        Account acc = new Account("ICBC-110", 100000);
        // 2、创建两个线程，分别代表小明 小红，再去同一个账户对象中取钱10万。
        new DrawThread(acc, "小明").start(); // 小明
        new DrawThread(acc, "小红").start(); // 小红
    }
}

结果如图所示：

总结：线程出现安全问题的的原因是

1.存在多个线程在同时执行

2.同时访问一个共享资源

3.存在修改该共享资源

5. 线程同步

5.1. 认识线程同步

  • 线程同步就是解决线程安全问题的方案
  • 线程同步的思想
    • 让多个线程实现先后依次访问共享资源，这样就解决了安全问题。

线程同步常见方案

  • 加锁：每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动解锁，然后其他线程才能再加锁进来。

5.2. 方式一，同步代码块

  • 同步代码块
  • 作用：把访问共享资源的核心代码给上锁，以此保证线程安全。
synchronized(同步锁) {
    访问共享资源的核心代码
}
  • 原理：每次只允许一个线程加锁后进入，执行完毕后自动解锁，其他线程才可以进来执行。
  • 同步锁的注意事项：对于当前同时执行的线程来说，同步锁必须是同一把（同一个对象），否则会出bug。

// 小明 小红线程同时过来的
public void drawMoney(double money) {
    // 先搞清楚是谁来取钱？
    String name = Thread.currentThread().getName();
    // 1、判断余额是否足够
    // this正好代表共享资源！
    synchronized (this) {
        if(this.money >= money){
            System.out.println(name + "来取钱" + money + "成功！");
            this.money -= money;
            System.out.println(name + "来取钱后，余额剩余：" + this.money);
        }else {
            System.out.println(name + "来取钱：余额不足~");
        }
    }
}

锁对象的使用规范

  • 建议使用共享资源作为锁对象，对于实例方法建议使用this作为锁对象。
  • 对于静态方法建议使用字节码（类名.class）对象作为锁对象。

5.3. 方式二，同步方法

其实同步方法，就是把整个方法给锁住，一个线程调用这个方法，另一个线程调用的时候就执行不了，只有等上一个线程调用结束，下一个线程调用才能继续执行。

  • 同步方法底层原理：

1.同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。

2.如果方法是实例方法：同步方法默认用this作为的锁对象。

3.如果方法是静态方法：同步方法默认用类名.class作为的锁对象。

// 同步方法
public synchronized void drawMoney(double money) {
    // 先搞清楚是谁来取钱？
    String name = Thread.currentThread().getName();
    // 1、判断余额是否足够
    if(this.money >= money){
        System.out.println(name + "来取钱" + money + "成功！");
        this.money -= money;
        System.out.println(name + "来取钱后，余额剩余：" + this.money);
    }else {
        System.out.println(name + "来取钱：余额不足~");
    }
}

问题：是同步代码块好还是同步方法好一点？

  • 范围上：同步代码块锁的范围更小，同步方法锁的范围更大。
  • 可读性：同步方法更好。

5.4. 方式三，Lock锁

Lock锁

  • Lock锁是JDK5开始提供的一个新的锁定操作，通过它可以创建出锁对象进行加锁和解锁，更灵活、更方便、更强大。
  • Lock是接口，不能直接实例化，可以采用它的实现类ReentrantLock来构建Lock锁对象。

1.首先在成员变量位子，需要创建一个Lock接口的实现类对象（这个对象就是锁对象）

private final Lock lk = new ReentrantLock();

2.在需要上锁的地方加入下面的代码

lk.lock(); // 加锁

//...中间是被锁住的代码...

lk.unlock(); // 解锁

// 创建了一个锁对象
private final Lock lk = new ReentrantLock();

public void drawMoney(double money) {
        // 先搞清楚是谁来取钱？
        String name = Thread.currentThread().getName();
        try {
            lk.lock(); // 加锁
            // 1、判断余额是否足够
            if(this.money >= money){
                System.out.println(name + "来取钱" + money + "成功！");
                this.money -= money;
                System.out.println(name + "来取钱后，余额剩余：" + this.money);
            }else {
                System.out.println(name + "来取钱：余额不足~");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lk.unlock(); // 解锁
        }
    }
}

6. 线程通信

  • 线程通信：当多个线程共同操作共享的资源时，线程间通过某种方式互相告知自己的状态，以相互协调，并避免无效的资源争夺。

线程通信的常见模型（生产者与消费者模型）

  • 生产者线程负责生产数据
  • 消费者线程负责消费生产者生产的数据。
  • 注意：生产者生产完数据应该等待自己，通知消费者消费；消费者消费完数据也应该等待自己，再通知生产者生产！

线程通信常用的三个方法：

案例：有3个厨师（生产者线程），两个顾客（消费者线程）

案例思路分析：

1.先确定在这个案例中，什么是共享数据？

答：这里案例中桌子是共享数据，因为厨师和顾客都需要对桌子上的包子进行操作。

2.再确定有那几条线程？哪个是生产者，哪个是消费者？

答：厨师是生产者线程，3条生产者线程；

顾客是消费者线程，2条消费者线程

3.什么时候将哪一个线程设置为什么状态

生产者线程(厨师)放包子：

(1)先判断是否有包子

(2)没有包子时，厨师开始做包子, 做完之后把别人唤醒，然后让自己等待

(3)有包子时，不做包子了，直接唤醒别人、然后让自己等待

消费者线程(顾客)吃包子：

(1)先判断是否有包子

(2)有包子时，顾客开始吃包子, 吃完之后把别人唤醒，然后让自己等待

(3)没有包子时，不吃包子了，直接唤醒别人、然后让自己等待

创建一个桌子类：

public class Desk {
    private List<String> list = new ArrayList<>();

    // 放1个包子的方法
    // 厨师1 厨师2 厨师3
    public synchronized void put() {
        try {
            String name = Thread.currentThread().getName();
            // 判断是否有包子。
            if(list.size() == 0){
                list.add(name + "做的肉包子");
                System.out.println(name + "做了一个肉包子~~");
                Thread.sleep(2000);

                // 唤醒别人, 等待自己
                this.notifyAll();
                this.wait();
            }else {
                // 有包子了，不做了。
                // 唤醒别人, 等待自己
                this.notifyAll();
                this.wait();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 吃货1 吃货2
    public synchronized void get() {
        try {
            String name = Thread.currentThread().getName();
            if(list.size() == 1){
                // 有包子，吃了
                System.out.println(name  + "吃了：" + list.get(0));
                list.clear();
                Thread.sleep(1000);
                this.notifyAll();
                this.wait();
            }else {
                // 没有包子
                this.notifyAll();
                this.wait();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

再写测试类，在测试类中，创建3个厨师线程对象，再创建2个顾客对象，并启动所有线程：

public class ThreadTest {
    public static void main(String[] args) {
        //   需求：3个生产者线程，负责生产包子，每个线程每次只能生产1个包子放在桌子上
        //      2个消费者线程负责吃包子，每人每次只能从桌子上拿1个包子吃。
        Desk desk  = new Desk();

        // 创建3个生产者线程（3个厨师）
        new Thread(() -> {
            while (true) {
                desk.put();
            }
        }, "厨师1").start();

        new Thread(() -> {
            while (true) {
                desk.put();
            }
        }, "厨师2").start();

        new Thread(() -> {
            while (true) {
                desk.put();
            }
        }, "厨师3").start();

        // 创建2个消费者线程（2个吃货）
        new Thread(() -> {
            while (true) {
                desk.get();
            }
        }, "吃货1").start();

        new Thread(() -> {
            while (true) {
                desk.get();
            }
        }, "吃货2").start();
    }
}

结果：你会发现多个线程相互协调执行，避免无效的资源挣抢。

7. 线程池

线程池是一个容器，可以保存一些长久存活的线程对象，负责创建、复用、管理线程

线程池的优势

1.降低资源消耗，重复利用线程池中线程，不需要每次都创建、销毁 。

2.便于线程管理，线程池可以集中管理并发线程的数量。

7.1. 线程池的使用方式1-提交Runnable任务

  • Executors工具类创建线程池
  • JDK 1.5起提供了线程池，Executors类是线程池的工具类，通过Executors工具类可以创建线程池。

  • ExecutorService：真正的代表线程池的接口。常见实现类ThreadPoolExecutor
ExecutorService pool = new ThreadPoolExecutor(  //7个参数
    3,	//核心线程数有3个
    5,  //最大线程数有5个。   临时线程数=最大线程数-核心线程数=5-3=2
    8,	//临时线程存活的时间8秒。 意思是临时线程8秒没有任务执行，就会被销毁掉。
    TimeUnit.SECONDS,//时间单位（秒）
    new ArrayBlockingQueue<>(4), //任务阻塞队列，没有来得及执行的任务在，任务队列中等待
    Executors.defaultThreadFactory(), //用于创建线程的工厂对象
    new ThreadPoolExecutor.CallerRunsPolicy() //拒绝策略
);

关于线程池，我们需要注意下面的两个问题：

  • 临时线程什么时候创建？
    • 新任务提交时，发现核心线程都在忙、任务队列满了、并且还可以创建临时线程，此时会创建临时线程。
  • 什么时候开始拒绝新的任务？
    • 核心线程和临时线程都在忙、任务队列也满了、新任务过来时才会开始拒绝任务。
       
  • ExecutorService线程池中的常用方法

创建一个线程任务类

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        // 任务是干啥的？
        System.out.println(Thread.currentThread().getName() + " ==> 输出666~~");
        //为了模拟线程一直在执行，这里睡久一点
        try {
            Thread.sleep(Integer.MAX_VALUE);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

执行Runnable任务的代码

ExecutorService pool = new ThreadPoolExecutor(
    3,	//核心线程数有3个
    5,  //最大线程数有5个。   临时线程数=最大线程数-核心线程数=5-3=2
    8,	//临时线程存活的时间8秒。 意思是临时线程8秒没有任务执行，就会被销毁掉。
    TimeUnit.SECONDS,//时间单位（秒）
    new ArrayBlockingQueue<>(4), //任务阻塞队列，没有来得及执行的任务在，任务队列中等待
    Executors.defaultThreadFactory(), //用于创建线程的工厂对象
    new ThreadPoolExecutor.CallerRunsPolicy() //拒绝策略
);

Runnable target = new MyRunnable();
pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
//下面4个任务在任务队列里排队
pool.execute(target);
pool.execute(target);
pool.execute(target);
pool.execute(target);

//下面2个任务，会被临时线程的创建时机了
pool.execute(target);
pool.execute(target);
// 到了新任务的拒绝时机了！
pool.execute(target);

7.2. 线程池的使用方式2-提交Callable任务

Callable方式好处

  • 有返回值
  • 可以抛异常

线程池的使用步骤

  • 创建线程池
  • 创建Callable任务
  • 提交任务

案例：使用线程池方式完成求和计算

准备一个Callable线程任务

public class MyCallable implements Callable<String> {
    private int n;
    public MyCallable(int n) {
        this.n = n;
    }

    // 2、重写call方法
    @Override
    public String call() throws Exception {
        // 描述线程的任务，返回线程执行返回后的结果。
        // 需求：求1-n的和返回。
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return Thread.currentThread().getName() + "求出了1-" + n + "的和是：" + sum;
    }
}

在测试类中创建线程池，并执行callable任务

public class ThreadPoolTest2 {
    public static void main(String[] args) throws Exception {
        // 1、通过ThreadPoolExecutor创建一个线程池对象。
        ExecutorService pool = new ThreadPoolExecutor(
            3,
            5,
            8,
            TimeUnit.SECONDS, 
            new ArrayBlockingQueue<>(4),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.CallerRunsPolicy());

        // 2、使用线程处理Callable任务。
        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));

        // 3、执行完Callable任务后，需要获取返回结果。
        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());
    }
}

补充：

了解ThreadPoolExecutor创建线程池(面试专用)

Executors使用可能存在的弊端

  • 高并发系统环境中使用Executors如果不注意可能会出现资源耗尽的风险。

创建线程池的七个参数

拒绝策略

8. 线程的生命周期

线程从创建到结束共有6个状态

Aurora丶EX
关注
基于C语言实现多线程和线程池【100012227】
05-18
在IT领域，多线程和线程池是提高系统性能和效率的重要技术，尤其是在处理高并发场景时。本文将深入探讨基于C语言实现这些概念及其相关的知识点。 首先，我们要了解多线程。在单线程程序中，任务是顺序执行的，而多...
java多线程之线程池
程序三两行
06-30 4450
在执行一个异步任务或并发任务时，往往是通过直接new Thread()方法来创建新的线程，这样做弊端较多，更好的解决方案是合理地利用线程池，线程池的优势很明显，如下： 降低系统资源消耗，通过重用已存在的线程，降低线程创建和销毁造成的消耗...
java线程学习(八)：多线程高级使用之线程池的使用（非常推荐，涉及：ThreadPoolExecutor，Executors，ThreadPoolExecutor，ScheduledThreadP）
shenhaiyushitiaoyu的博客
12-24 1243
前言： 通过前面几篇文章的学习，对多线程的知识了解了很多，同时也明白，其实学习不仅仅要看书，看文章，还要自己动手去敲demo，顺便写点文章收获更多。当然多线程如果仅仅是用前面几篇的知识的话，那未免也太肤浅了，毕竟，线程如果频繁开启和关闭的话，对系统资源的消耗那是相当大的。所以，从本篇文章起，我们开启对线程的更高一级的学习，那就是使用线程池去管理线程的使用。 线程池的学习，主要还是学习JDK提供...
多线程-线程池的运用
qq_54414566的博客
04-23 189
我们日常工作中常见的有数据库连接池、线程池、对象池等，它们的特点都是将 “昂贵的”、“费时的” 的资源维护在一个特定的 “池子” 中，规定其最小连接数、最大连接数、阻塞队列等配置，方便进行统一管理和复用，通常还会附带一些探活机制、强制回收、监控一类的配套功能。先启动若干数量的线程，并让这些线程都处于睡眠状态，当需要一个开辟一个线程去做具体的工作时，就会唤醒线程池中的某一个睡眠线程，让它去做具体工作，当工作完成后，线程又处于睡眠状态，而不是将线程销毁。所以我们最好自己手动创建线程池。
java多线程，对多线程，线程池进行封装，方便使用
05-16
总之，通过合理地封装和使用线程池，开发者可以更好地控制多线程环境，提高系统的稳定性和性能。在实际项目中，我们应该根据具体的需求选择合适的线程池配置，并对其进行监控和调优，确保系统的高效运行。
多线程与线程池技术详解（图书配套）
07-01
多线程与线程池是Java编程中至关重要的概念，特别是在处理高并发场景时，它们的作用尤为突出。本文将深入探讨这两个主题，并结合标签中的"排它锁"、"重入锁"、"共享锁"等概念进行讲解。 首先，线程是操作系统分配...
完全解析Android多线程中线程池ThreadPool的原理和使用
01-20
线程池是多线程编程中的一个重要概念，它允许开发者管理多个并发线程，提高系统资源的利用率，同时提供更好的任务调度。在Android开发中，理解线程池的工作原理和使用方式至关重要，因为它能帮助优化应用程序性能，...
多线程与线程池技术详解
06-12
在Java编程领域，多线程和线程池技术是核心且关键的概念，它们在现代的高性能、高并发应用中扮演着重要角色。多线程允许应用程序同时执行多个任务，而线程池则是一种管理和控制线程的有效手段，有助于提高系统的效率...
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
杨荧的CSDN博客
10-10 1465
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
Java分布式锁
juanmiao的专栏
10-12 657
每种方法都有其优点和适应的场景，数据库通常简单，但可能存在性能问题，redis非常快，但需要第三方库，并且可能引入网诺问题，Zookeeper提供了更复杂的同步原语，但需要额外学习曲线。分布式锁的实现比线程锁和进程锁要复杂得多，因为它需要在网诺中的多个节点之间进行协调，以保证锁的唯一性和一致性。在实现分布式锁时，通常会有一个中心节点（或者称为锁服务），所有需要获取锁的节点都需要向这个中心节点申请。这个中心节点负责协调和管理所有节点的锁请求，确保锁的唯一性和一致性。创建临时节点，执行业务逻辑，释放锁。
2024.10月12日--- SpringMVC异常处理
whisper_Java 的博客
10-12 876
*** 用户【】 IP[]* 在【时间】* 操作【Controller.find】 发生如下异常*/@OverrideSystem.out.println("---------执行了自定义异常处理器------------");// 根据不同的异常类型，设置不同的响应状态码// 可以添加更多的自定义处理逻辑//}else {// 记录日志或其他处理逻辑// 可以将异常信息放入模型中供视图展示。
Netty 相比原生IO模型的优势
lssffy的博客
10-09 676
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
Backend - Java 基础
是萝卜干呀的博客
10-11 832
知识量决定了未来能走多远
JavaSE——认识异常
wx2023_10_15的博客
10-12 955
本文主要是正在学习异常的总结，主要讲了异常的概念、体系结构、分类、处理以及捕获，还有自定义异常类
java工具类判断一个点是否在多边形内
最新发布
weixin_47315082的博客
10-15 147
最近在做的项目，需要画一个多边形范围，并且判断当前定位是否在这个范围内，进出需要提醒，因此写了一个工具类判断一个点是否在多边形内，记录一下。
springboot 用request.setAttribute 传值到控制层
qq56477643的博客
10-09 617
【代码】springboot 用request.setAttribute 传值到控制层。
【网络编程】掌握Java网络编程：深入理解Socket通信与实战技巧
Dylaniou的博客
10-11 1046
Java的网络Socket编程为开发者提供了强大的工具来构建网络通信应用，从简单的客户端-服务器模型到复杂的分布式系统。Java的网络Socket编程为开发者提供了强大的工具来构建网络通信应用，从简单的客户端-服务器模型到复杂的分布式系统。希望本文能帮助您掌握Java网络编程的核心技术，并在实际项目中灵活运用。如果您有任何疑问或想要分享经验，请在评论区留下您宝贵的意见！🚀🌐🔌。
Unsafe 详解
qq_73210658的博客
10-10 2480
学习JUC的过程中发现有一个类很神奇，今天我们就来一起学习一下Unsafe类。
JavaScript前端开发技术
Chujun123528的博客
10-12 1005
JavaScript前端开发是一个充满挑战和机遇的领域。随着技术的不断进步和用户需求的变化，前端开发者需要不断学习新知识、掌握新技能，以应对日益复杂和多样化的开发需求。同时，注重性能优化和安全实践也是前端开发不可或缺的一部分。通过不断探索和创新，我们可以为用户创造更加优质、高效和安全的Web体验。在JavaScript前端开发的学习过程中，建议从基础语法入手，逐步掌握DOM操作、事件处理、Ajax通信等核心技能。同时，关注最新的前端框架和库的发展动态，尝试将它们应用到实际项目中。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值