备案控制台
开发者社区 云原生 文章 正文

线程安全问题、同步代码块、同步方法、线程池详解

2024-05-24 27
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 线程安全问题、同步代码块、同步方法、线程池详解

前言

通过本文我们将会了解到基本的多线程的知识。

一、线程安全的问题

在了解线程的安全问题前，我们先来看一个需求：

某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟电影院卖票。

分析：

有三个窗口，窗口各自都是独立的，可以将这3个窗口当作3个线程，在线程中执行的是卖票的代码。

1.创建一个类，继承Thread类

2.定义变量int ticked，表示票数

3.在run()方法中执行循环，当票数小于100时，票数自减，继续循环，直到票数卖完，循环结束。

若是根据上述分析，最后的结果是三个线程，每个线程都卖了100张票，总共卖了300张票，并不是正确的需求

那么把变量ticked类型改为static int就可以让三个线程共享一个数据

但此时运行代码会发现，三个线程在执行的时候会有重复出现，甚至还有超出100范围的，这不是我们想要的，还是存在问题。

package com.practice.threaddemo1;
/**
 * @Author YJ
 * @Date 2023/7/21 19:07
 * Description:卖票线程代码
 */
public class MyThread extends Thread {
  //通过静态变量实现三个线程共享
    static int ticked = 0;
    @Override
    public void run() {
        while (true) {
            if (ticked < 100) {
                //每次卖票前睡一会
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                ticked++;
                System.out.println(getName() + "正在卖第" + ticked + "张票！");
            } else {
                break;
            }
        }
    }
}
package com.practice.threaddemo1;
/**
 * @Author YJ
 * @Date 2023/7/21 19:02
 * Description:模拟电影院卖票
 */
public class MyThreadDemo {
    public static void main(String[] args) {
        //1.创建线程对象
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();
        //2.设置线程名字
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        //3.开启线程
        t1.start();
        t2.start();
        t3.start();
    }
}

通过上面的买票需求，我们发现线程存在的安全问题，会出现重复和超出范围的情况，为什么会出现这种情况呢，我们可以通过线程的执行结合代码分析：

原因分析：

1.票数重复：

在线程开启的时候，三个线程都在抢夺CPU的资源，假设线程一在开始抢到了CPU的执行权，线程一就会继续往下执行，进入线程后，满足判断条件，接着会立马睡10毫秒（自定义的），此时线程一不会抢夺CPU的执行权，线程二和线程三一定会有一个抢到CPU的执行权，，假设是线程二抢到了，它也会继续往下执行，通过判断条件，也同样会睡10毫秒，此时CPU的执行权一定会被其他线程抢到，所以线程三也会睡10毫秒，于是当线程各自醒来后，继续抢夺CPU执行权，假设是线程一抢到了，ticked会自增变成1，此时线程一还没来得及打印，线程二就抢到了CPU的执行权，ticked又自增变成了2，同样的线程三也会抢到CPU执行权，ticked自增到3，接下来无论是哪个线程继续往下打印，ticked结果都是3，这样就出现了重复的情况。

2.票数超出范围：

当票数到达99张时，三个线程还是在抢夺CPU执行权，线程一抢到后进入循环睡10毫秒，线程二抢到同样睡10毫秒，线程三同样进来睡10毫秒，睡完后陆续醒来继续执行下面的代码，线程一醒来后ticked自增变为100，还没来得及打印，线程二醒来执行代码ticked子增变为101，还没来得及打印，线程三醒来执行代码ticked子增变为了102，接下来无论哪个线程打印，结果都是102，票数超出了范围。

上述根本原因是：线程执行时有随机性

解决方案：

将要执行的循环语句锁起来，这样当第一个线程抢到了CPU执行权，若是线程一的循环还没有执行完，线程二抢到了CPU执行权，由于循环是被锁住的，线程二就必须等待线程一执行完后才能进入循环。

二、同步代码块

2.1同步代码块实现方式

格式：

synchronized(锁对象){操作共享数据的代码}

特点1：锁默认打开，有一个线程进去了，锁自动关闭

特点2：里面的代码全部执行完毕，线程出来，锁自动打开

锁对象一定要是唯一的

通过锁来解决线程安全问题被叫做同步代码块

package com.practice.threaddemo1;
/**
 * @Author YJ
 * @Date 2023/7/21 19:07
 * Description:同步代码块
 */
public class MyThread extends Thread {
    static int ticked = 0;
    //锁对象要唯一
    static Object obj = new Object();
    @Override
    public void run() {
        synchronized (obj) {
        while (true) {
            if (ticked < 100) {
                //每次卖票前睡一会
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                ticked++;
                System.out.println(getName() + "正在卖第" + ticked + "张票！");
            } else {
                break;
            }
        }
        }
    }
}

2.1同步代码块实现细节

分析上述同步代码块实现卖票的方式，结果只有一个线程卖完了所有的票，也就是说，一个线程抢到CPU执行权后进入循环，直到这个线程执行完所有的代码后循环结束，票数也增加到了100，后面的线程再进入循环时已经不符合循环条件，所以循环直接结束。

所以要注意的是，synchronized 锁应该放在循环里面。

既然锁对象是唯一的，我们可以直接将当前类的字节码对象作为唯一的锁对象，字节码对象一定是唯一的。

package com.practice.threaddemo1;
/**
 * @Author YJ
 * @Date 2023/7/21 19:07
 * Description:同步代码块
 */
public class MyThread extends Thread {
    static int ticked = 0;
    @Override
    public void run() {
        while (true) {
            synchronized (MyThread.class) {
                if (ticked < 100) {
                    //每次卖票前睡一会
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    ticked++;
                    System.out.println(getName() + "正在卖第" + ticked + "张票！");
                } else {
                    break;
                }
            }
        }
    }
}

结果：

二、同步方法

同步方法：就是将synchronized 直接加在方法上

格式：

修饰符 synchronized 返回值类型 方法名（方法参数）{...}

**特点1：**同步方法是锁住方法里面所有的代码

**特点2：**锁对象不能自己指定（非静态的：this静态的：当前的字节码对象）

我们可以通过同步方法实现上述卖票需求：

package com.practice.threaddemo2;
/**
 * @Author YJ
 * @Date 2023/7/21 21:00
 * Description:同步方法
 */
public class MyRunnable implements Runnable {
    //只创建一次，不需要static修饰
    int ticket = 0;
    @Override
    public void run() {
        //1.循环
        //2.同步代码块
        //3.判断共享数据是否到了末尾，如果到了末尾
        //4.判断共享数据是否到了末尾，如果没有到末尾
        while (true) {
            //同步方法
            if (method()) break;
        }
    }
    private synchronized boolean method() {
        if(ticket==100) {
            return true;
        } else {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            ticket++;
            System.out.println(Thread.currentThread().getName() + "在卖第" + ticket + "张票！！！");
        }
        return false;
    }
}

StringBuffer线程安全的原因是它的所有方法都有synchronized 修饰而StringBuilder 没有synchronized 修饰，这就是同步方法保证线程安全的原因。

三、Lock锁

虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5之后提供了一个新的锁对象Lock锁

Lock实现提供比使用synchronized 方法和语句获得更广阔的锁定操作

Lock中提供了获得锁和释放锁的方法

void lock()：获得锁

void unlock()：释放锁

手动上锁，手动释放锁

Lock是接口，不能实例化，这里采用它的实现类ReentrantLock来实例化

ReentrantLock的构造方法

ReentrantLock()：创建一个ReentrantLock的实例

package com.practice.threaddemo3;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * @Author YJ
 * @Date 2023/7/21 19:07
 * Description:Lock锁
 */
public class MyThread extends Thread {
    static int ticked = 0;
    static Lock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true) {
           // synchronized (MyThread.class) {
            lock.lock();
            try {
                if (ticked == 100) {
                    break;
                } else {
                    //每次卖票前睡一会
                    Thread.sleep(10);
                    ticked++;
                    System.out.println(getName() + "正在卖第" + ticked + "张票！");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
            //}
        }
    }
}

注意：在多线程使用锁的时候，不能让两个锁嵌套起来，两个锁嵌套有可能导致死锁的产生。

四、生产者和消费者（等待唤醒机制）

生产者消费者模式是一个十分经典的多线程协作的模式。

  • void wait()：当前线程等待，直到被其他线程唤醒
  • void notify()：随机唤醒单个线程
  • void notifyAll()：唤醒所有线程

4.1生产者和消费者的思路分析

  • 假设有一个吃货线程表示消费者，厨师线程表示生产者，有一个桌子，桌子上有面条，吃货线程执行吃，厨师线程负责等，桌子上没有面条，吃货就负责等，厨师生产面条。
  • 生产者和消费者的理想情况：
  • 厨师线程生产了一碗面条，放到桌子上，吃货线程吃一碗面条，相当于厨师做一碗面条，吃货吃一碗面条。
    但是线程执行具有随机性，并不一定会是这种理想情况。

生产者和消费者(消费者等待)：

当两个线程启动时，若是消费者线程先抢到CPU执行权，但发现并没有任务要执行，这时消费者线程就需要等待wait，此时CPU执行权一定会被生产者线程抢到，生产者开始布置任务，布置完成后，消费者线程还是处于等待状态的，此时生产者线程就需要告诉消费者线程可以执行任务了，这个动作叫做唤醒notify。

  • 消费者（消费数据）：
  • 1.判断桌子上是否有食物
  • 2.如果没有就等待
  • 生产者（生产数据）：
  • 1.制作食物
  • 2.把食物放在桌子上
  • 3.叫醒等待的消费者开吃

生产者和消费者(生产者等待)：

当两个线程启动时，生产者抢到了CPU执行权，没有任务要执行，生产者开始布置任务，布置完成后，即使没有消费者在等待，仍然可以执行唤醒notify操作，而在下一步还是生产者抢到了CPU执行权，但此时已经有任务了，生产者就不能再去布置任务了，所以生产者就要等待wait。

  • 消费者（消费数据）：
  • 1.判断桌子上是否有食物
  • 2.如果没有就等待
  • 生产者（生产数据）：
  • 1.判断桌子上是否有食物
  • 2.有：等待
  • 3.没有：制作食物
  • 4.制作食物
  • 5.把食物放在桌子上
  • 6.叫醒等待的消费者开吃

4.2生产者和消费者的代码实现

  • 桌子：
package com.practice.waitandnotify;
/**
 * @Author YJ
 * @Date 2023/7/22 8:12
 * Description:控制生产者和消费者的执行（桌子）
 */
public class Desk {
    //是否有面条：0.没有  1.有
    public static int foodFlag = 0;
    //总个数
    public static int count = 10;
    //锁对象
    public static Object lock = new Object();
}
  • 生产者（厨师）:
package com.practice.waitandnotify;
/**
 * @Author YJ
 * @Date 2023/7/22 8:11
 * Description:生产者（厨师）
 */
public class Cook extends Thread{
    @Override
    public void run() {
        /**
         * 1.循环
         * 2.同步代码块
         * 3.判断共享数据是否到了末尾（到了末尾）
         * 4.判断共享数据是否到了末尾（没到末尾）
         */
        while (true) {
            synchronized (Desk.lock) {
                if(Desk.count == 0) {
                    break;
                } else{
                    //1.判断桌子上是否有食物
                    if(Desk.foodFlag == 1) {
                        //2.有：等待
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    } else {
                        //3.没有：制作食物
                        System.out.println("厨师做了一碗面条");
                        //4.修改食物状态
                        Desk.foodFlag = 1;
                        //5.唤醒等待的消费者
                        Desk.lock.notifyAll();
                    }
                }
            }
        }
    }
}
  • 消费者（吃货）:
package com.practice.waitandnotify;
/**
 * @Author YJ
 * @Date 2023/7/22 8:11
 * Description:消费者（吃货）
 */
public class Foodie extends Thread{
    @Override
    public void run() {
        /**
         * 1.循环
         * 2.同步代码块
         * 3.判断共享数据是否到了末尾（到了末尾）
         * 4.判断共享数据是否到了末尾（没到末尾）
         */
        while (true) {
            synchronized(Desk.lock) {
                if(Desk.count == 0) {
                    System.out.println("已经吃不下了~~");
                    break;
                } else {
                    //判断桌子上是否有面条
                    if(Desk.foodFlag == 0) {
                        //没有：等待
                        try {
                            Desk.lock.wait();//让当前锁跟这个线程绑定
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    } else {
                        //把吃的总数-1
                        Desk.count--;
                        //有：开吃
                        System.out.println("正在吃，还能再吃" + Desk.count + "碗~");
                        //吃完了：唤醒厨师
                        Desk.lock.notifyAll();
                        //修改桌子状态
                        Desk.foodFlag = 0;
                    }
                }
            }
        }
    }
}
  • 代码运行：**
package com.practice.waitandnotify;
/**
 * @Author YJ
 * @Date 2023/7/22 8:34
 * Description:运行
 */
public class ThreadDemo {
    public static void main(String[] args) {
        //创建线程对象
        Cook cook = new Cook();
        Foodie foodie = new Foodie();
        cook.setName("厨师");
        foodie.setName("吃货");
        cook.start();
        foodie.start();
    }
}
  • 结果：

4.3等待唤醒机制（阻塞队列方式实现）

  • 阻塞队列的继承结构:
  • Iterable
  • Collection
  • Queue
  • BlockingQueue
  • 实现类：
  • ArrayBlockingQueue:底层是数据，有界，必须指定长度
  • LinkedBlockingQueue：底层是链表，无界，但不是真正的无界，最大为int的最大值

代码实现：

细节：生产者和消费者必须使用同一个阻塞队列。

package com.practice.waitandnotifyblockingqueue;
import java.util.concurrent.ArrayBlockingQueue;
/**
 * @Author YJ
 * @Date 2023/7/22 9:13
 * Description:生产者
 */
public class Cook extends Thread{
    ArrayBlockingQueue<String> queue;
    public Cook(ArrayBlockingQueue<String> queue) {
        this.queue = queue;
    }
    @Override
    public void run() {
        while (true) {
            try {
                queue.put("面条");
                System.out.println("厨师放了一碗面条~");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
package com.practice.waitandnotifyblockingqueue;
import java.util.concurrent.ArrayBlockingQueue;
/**
 * @Author YJ
 * @Date 2023/7/22 9:14
 * Description:消费者
 */
public class Foodie extends Thread{
    ArrayBlockingQueue<String> queue;
    public Foodie(ArrayBlockingQueue<String> queue) {
        this.queue = queue;
    }
    @Override
    public void run() {
        while (true) {
            try {
                String food = queue.take();
                System.out.println(food);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
package com.practice.waitandnotifyblockingqueue;
import java.util.concurrent.ArrayBlockingQueue;
/**
 * @Author YJ
 * @Date 2023/7/22 9:13
 * Description:阻塞队列方式实现
 */
public class ThreadDemo {
    public static void main(String[] args) {
        //1.创建阻塞队列对象
        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(1);
        //2.创建线程对象，并把阻塞队列传递过去
        Cook cook = new Cook(queue);
        Foodie foodie = new Foodie(queue);
        //3.开启线程
        cook.start();
        foodie.start();
    }
}

4.4线程的状态

五、线程池

以前写多线程的弊端：

  • 1.用到线程的时候就创建(效率低)
  • 2.用完后线程消失(浪费资源)

改进：

我们可以准备一个容器，用来存放线程，这个容器就叫做线程池，刚开始，容器中是空的，当给线程池提交一个任务时，线程池会自动地创建一个线程，用这个线程执行任务，执行完后，把线程返回给容器，等到下次再执行任务时，就不需要重新创建线程了。

特殊情况：

当第二个任务执行时，第一个任务还没有执行结束，线程池就要再创建一个新的线程，用这个新的线程执行任务，再来任务，继续创建线程，执行完后，都返回给线程池。

线程池中的线程创建是有上限的，可以自己定义最大线程数量，当任务过多，线程创建也达到上限时，未获取线程的任务只能排队等待。

核心原理：

  • 1.创建一个池子，池子中是空的
  • 2.提交任务时，池子会创建新的线程对象，任务执行完毕，线程归还给池子，下次再次提交任务时，不需要创建新的线程，直接复用已有的线程即可
  • 3.如果提交任务时，池子中没有空闲的线程，也无法创建新的线程，任务就会排队等待。

代码实现：

  • 1.创建线程池
  • 2.提交任务
  • 3.所有任务执行完毕，关闭线程池
    Excutors：线程池的工具类，通过调用方法返回不同类型的线程池对象。
    public static ExcutorService newCachedThreadPool()：创建一个没有上限的线程池
    public static ExcutorService newFixedThreadPool()：创建有上限的线程池
package com.practice.mythreadpool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * @Author YJ
 * @Date 2023/7/22 10:20
 * Description:创建没有上限的线程池
 */
public class MyThreadPoolDemo1 {
    public static void main(String[] args) throws InterruptedException {
        //1.获取线程池对象
        ExecutorService pool1 = Executors.newCachedThreadPool();
        Thread.sleep(1000);
        //2.提交任务
        pool1.submit(new MyRunnable());
        Thread.sleep(1000);
        pool1.submit(new MyRunnable());
        Thread.sleep(1000);
        pool1.submit(new MyRunnable());
        Thread.sleep(1000);
        pool1.submit(new MyRunnable());
        Thread.sleep(1000);
        pool1.submit(new MyRunnable());
        //3.销毁线程池
        //pool1.shutdown();
    }
}
package com.practice.mythreadpool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * @Author YJ
 * @Date 2023/7/22 10:20
 * Description:创建有上限的线程池
 */
public class MyThreadPoolDemo2 {
    public static void main(String[] args) throws InterruptedException {
        //1.获取线程池对象
        ExecutorService pool1 = Executors.newFixedThreadPool(3);
        Thread.sleep(100);
        //2.提交任务
        pool1.submit(new MyRunnable());
        Thread.sleep(100);
        pool1.submit(new MyRunnable());
        Thread.sleep(100);
        pool1.submit(new MyRunnable());
        Thread.sleep(100);
        pool1.submit(new MyRunnable());
        Thread.sleep(100);
        pool1.submit(new MyRunnable());
        //3.销毁线程池
        //pool1.shutdown();
    }
}

六、自定义线程池

核心参数：

  • 1.核心线程的数量（不能小于0）
  • 2.线程池中最大线程数量（最大数量>=核心线程数量）
  • 3.空闲时间（值），如60（不能小于0）
  • 4.空闲时间（单位）,如s（用TimeUnit指定）
  • 5.阻塞队列（不能为null）
  • 6.创建线程的方式（不能为null）
  • 7.要执行的任务过多时的解决方案（不能为null）

注意：

自定义线程池可以创建核心线程和临时线程。

假设核心线程有3个，临时线程是3个，队伍长度为3个，表示线程池中最多有6个线程可用，而且其中3个临时线程只有在队伍满的情况下又来了任务才会创建并执行，先提交的任务不一定先执行。

若有8个任务要执行，3个核心线程执行3个任务，三个任务在队伍中等待，此时还有两个任务，那么此时就要创建2个临时线程执行两个任务，队伍中还有3个任务在等待。

若是任务过多，线程池满了，队伍也满了，还是有任务，这时就会触发任务拒绝策略：

  • ThreadPoolExcutor.AbortPolicy：默认策略：丢弃任务并抛出RejectedExecutionException异常
  • ThreadPoolExcutor.DiscardPolicy：丢弃任务，但不抛出异常，不推荐
  • ThreadPoolExcutor.DiscarOldestPolicy：抛弃队列中等待最持久的任务，然后把当前任务加入队列中
  • ThreadPoolExcutor.CallerRunsPolicy：调用任务的run()方法绕过线程池直接执行
package com.practice.mythreadpool2;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
 * @Author YJ
 * @Date 2023/7/22 10:50
 * Description:创建自定义线程池
 */
public class MyThreadPoolDemo1 {
    public static void main(String[] args) throws InterruptedException {
        //创建自定义线程池对象
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                3,//核心线程的数量（不能小于0）
                6,//线程池中最大线程数量（最大数量>=核心线程数量）
                60,//空闲时间（值）（不能小于0）
                TimeUnit.SECONDS,//空闲时间（单位）,如s（用TimeUnit指定）
                new ArrayBlockingQueue<>(3),//阻塞队列（不能为null）
                Executors.defaultThreadFactory(),//创建线程的方式（不能为null）
                // -- Executors.defaultThreadFactory()底层就是new了一个Thread
                new ThreadPoolExecutor.AbortPolicy()//任务拒绝策略
        );
        //提交任务
        //...
    }
}

6.1、最大并行数

以4核8线程为例：

4核表示的是电脑有4个大脑，利用超线程技术，就可以把原本的4个大脑虚拟成8个，也就是8线程。

可以在设备管理器或任务管理器中看到自己电脑的最大并行数：

也可通过Java虚拟机用代码查看：

package com.practice.mythreadpool2;
/**
 * @Author YJ
 * @Date 2023/7/22 11:50
 * Description:获取电脑最大并行数
 */
public class MyThreadPoolDemo2 {
    public static void main(String[] args) throws InterruptedException {
        int count = Runtime.getRuntime().availableProcessors();
        System.out.println(count);
    }
}

6.2、线程池多大合适

CPU密集型运算： 最大并行数+1

I/O密集型运算：（读取本地文件较多、读取数据库文件较多） 最大并行数 * 期望CPU利用率 * （总时间（CPU计算时间+等待时间）） / CPU计算时间

总结

关于多线程的学习其实还有很多，目前介绍学习的是我们平时会用到的，希望会有帮助，我会继续学习并记录博客的学习笔记，欢迎大家关注+点赞！！！

文章标签：
Java
容器
安全
关键词：
线程方法
线程同步
线程线程池
同步线程
代码块方法线程
叶落闲庭
目录
相关文章
洋葱吃不下
|
25天前
|
缓存 监控 安全
Java的线程池和线程安全
Java的线程池和线程安全
洋葱吃不下
26 1
hsfxuebao
|
12天前
|
Java 调度
Java并发基础-线程简介（状态、常用方法）
Java并发基础-线程简介（状态、常用方法）
hsfxuebao
16 0
goyeer
|
20天前
|
开发框架 监控 Java
【.NET Core】多线程之线程池（ThreadPool）详解（二）
【.NET Core】多线程之线程池（ThreadPool）详解（二）
goyeer
31 3
goyeer
|
20天前
|
SQL 开发框架 Java
【.NET Core】多线程之线程池（ThreadPool）详解（一）
【.NET Core】多线程之线程池（ThreadPool）详解（一）
goyeer
24 2
梦回故国楼台梦
|
5天前
|
Java 开发者
线程的诞生之路：Java多线程创建方法的抉择与智慧
【6月更文挑战第19天】Java多线程编程中，开发者可选择继承Thread类或实现Runnable接口。继承Thread直接但受限于单继承，适合简单场景；实现Runnable更灵活，支持代码复用，适用于如银行转账这类需多线程处理的复杂任务。在资源管理和任务执行控制上，Runnable接口通常更优。
梦回故国楼台梦
12 0
进朱者赤
|
18天前
|
缓存 Java 测试技术
Java性能优化(八)-多线程调优-线程池大小设置
Java性能优化(八)-多线程调优-线程池大小设置
进朱者赤
18 0
tao滔不绝
|
20天前
|
安全 Java 容器
多线程（进阶四：线程安全的集合类）
多线程（进阶四：线程安全的集合类）
tao滔不绝
16 0
落雨便归尘
|
2天前
|
存储 Linux C语言
c++进阶篇——初窥多线程(二) 基于C语言实现的多线程编写
本文介绍了C++中使用C语言的pthread库实现多线程编程。`pthread_create`用于创建新线程，`pthread_self`返回当前线程ID。示例展示了如何创建线程并打印线程ID，强调了线程同步的重要性，如使用`sleep`防止主线程提前结束导致子线程未执行完。`pthread_exit`用于线程退出，`pthread_join`用来等待并回收子线程，`pthread_detach`则分离线程。文中还提到了线程取消功能，通过`pthread_cancel`实现。这些基本操作是理解和使用C/C++多线程的关键。
落雨便归尘
13 7
梦回故国楼台梦
|
5天前
|
安全 Java
【极客档案】Java 线程：解锁生命周期的秘密，成为多线程世界的主宰者！
【6月更文挑战第19天】Java多线程编程中，掌握线程生命周期是关键。创建线程可通过继承`Thread`或实现`Runnable`，调用`start()`使线程进入就绪状态。利用`synchronized`保证线程安全，处理阻塞状态，注意资源管理，如使用线程池优化。通过实践与总结，成为多线程编程的专家。
梦回故国楼台梦
18 3
梦回故国楼台梦
|
5天前
|
Java 开发者
告别单线程时代！Java 多线程入门：选继承 Thread 还是 Runnable？
【6月更文挑战第19天】在Java中，面对多任务需求时，开发者可以选择继承`Thread`或实现`Runnable`接口来创建线程。`Thread`继承直接但限制了单继承，而`Runnable`接口提供多实现的灵活性和资源共享。多线程能提升CPU利用率，适用于并发处理和提高响应速度，如在网络服务器中并发处理请求，增强程序性能。不论是选择哪种方式，都是迈向高效编程的重要一步。
梦回故国楼台梦
13 2