javaSE——多线程

最新推荐文章于 2024-10-16 16:34:42 发布
最新推荐文章于 2024-10-16 16:34:42 发布
阅读量163 收藏
点赞数
分类专栏： JavaSE 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41819893/article/details/121069290
版权

一、线程

1、概念

线程是指进程中的一个执行流程，一个进程可以由多个线程组成，即一个进程中可以同时运行多个不同的线程，它们分别执行不同的任务。当进程内的多个线程同时运行时，这种运行方式成为并发运行。

2、线程和进程的区别

  • 每个进程都有独立的代码和存储空间（进程上下文），进程切换的开销大。

  • 线程没有独立的存储空间，而是和所属进程中其他的线程共享代码和存储空间，但每个线程有独立的运行栈和程序计数器，因此线程切换的开销较小。

  • 多进程——在操作系统中能同时运行多个任务（程序），也称多任务。

  • 多线程——在同一应用程序中有多个顺序流同时执行。

二、线程的创建

1、继承Thread类创建线程

Thread存放在java.lang类库里，但编译器会自动加载此类库，而run()方法是定义在Thread里面的一个方法，所以线程的程序代码编写在run()里面

激活线程的语法

class 类名 extends Thread    //从Thread类扩展出子类
{
    属性
    方法
    修饰符 run(){
        以线程处理的程序;
    }
}

步骤：

  1. 定义Thread类的子类，并重写该类的run（）方法，该run（）方法体就代表了线程需要完成的任务，因此把run（）方法称为线程执行体

  2. 创建Thread子类的实例，即创建了线程对象

  3. 调用线程对象的sttart（）方法来启动该线程

2、实现Runnable接口创建线程

步骤：

  1. 定义Runnable接口的实现类，并重写该接口的run（）方法，该run（）方法的方法体同样是该线程的线程执行体

  2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象

  3. 调用线程对象的start（）方法来启动该线程

3、使用Callable和Future创建进程

Callable接口包含一个方法call，实现该方法来定义一个任务，这个任务具有返回值V。该方法可以抛出异常。

java5提供了Future接口来代表Callable接口里的call()方法的返回值，并为Future接口提供了一个FutureTask实现类，该实现类实现了Future接口，并实现了Runnable接口，所以这样可以作为Thread的target。

创建并启动有返回值的线程的步骤

  • 创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，且该call()方法没有返回值，再创建Callable实现类的实例。（从java8开始，可以直接使用Lambda表达式创建Callable对象）。

  • 使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。

  • 使用FutureTask作为Thread对象的target创建并启动新线程。

  • 调用FutureTask对象的get方法来获得子线程执行结束后的返回值。

4、创建线程的三种方法对比

采用实现 Runnable、Callable 接口的方式创建多线程的优缺点

  1. 线程类只是实现了 Runnable 接口或 Callable 接口，还可以继承其他类。

  2. 在这种方式下，多个线程可以共享同一个 target 对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将 CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。

  3. 劣势是，编程稍稍复杂，如果需要访问当前线程，则必须使用 Thread.currentThread(方法。

采用继承 Thread 类的方式创建多线程的优缺点：

  1. 劣势是，因为线程类已经继承了 Thread 类，所以不能再继承其他父类。

  2. 优势是，编写简单，如果需要访问当前线程，则无须使用 Thread.currentThread(方法，直接使用this 即可获得当前线程。

三、线程的生命周期

1、新建和就绪状态

当程序使用 new 关键字创建了一个线程之后，该线程就处于新建状态，此时它和其他的 Java 对象一样，仅仅由 Java 虚拟机为其分配内存，并初始化其成员变量的值。此时的线程对象没有表现出任何的动态特征，程序也不会执行线程的执行体。

当线程对象调用了 start() 方法之后，该线程处于 就绪状态， Java 虚拟机会为其创建方法调用栈和程序计数器，处于这种状态中的线程并没有开始运行，只是表示该线程可以运行了，至于该线程何时开始运行，取决于 JVM 里线程调度器的调度

注意：如果直接调用线程对象的 run() 方法，系统把线程对象当成一个普通对象，而 run() 方法也是一个普通方法，而不是一个线程执行体。

2、运行和阻塞状态

处于就绪状态的线程获得了CPU，开始执行 run() 方法的线程执行体，则该线程处于运行状态，如果计算机只有一个 CPU ，那么在任何时刻只有一个线程处于运行状态，当然，在一个多处理器的机器上，将会有多个线程并行执行；当线程数大于处理器数时，依然会存在多个线程在同一个 CPU 上轮换的现象。

当发生如下情况时，线程将会进入阻塞状态。

  • 线程调用 sleep() 方法主动放弃所占用的处理器资源

  • 线程调用了一个阻塞式 IO 方法，在该方法返回之前，该线程被阻塞。

  • 线程试图获得一个同步监视器，但该同步监视器正在被其他线程所持有

  • 线程在等待某个通知 (notify)

  • 程序调用了线程的 suspend() 方法将该线程挂起。但这个方法容易导致死锁，所以应该尽量避免使用该方法

3、线程死亡

线程会以如下三种方式结束，结束后就处于死亡状态。

  • run() 或 call() 方法执行完成，线程正常结束。

  • 线程抛出一个未捕获的 Exception 或 Error

  • 直接调用该线程的 stop() 方法来结束该线程——该方法容易导致死锁，通常不推荐

注意：当主线程接收时，其他线程不受任何影响，并不会随之结束。一旦子线程启动来后，它就拥有和主线程相同的地位，它不会受主线程的影响。

线程对象的 isAlive() 方法，测试某个线程是否已经死亡

  1. 线程处于就绪、运行、阻塞、三种状态，该方法返回 true

  2. 线程处于新建、死亡两种状态，该方法返回 false

注意：不要试图对一个死亡的线程调用 start() 方法使它重新启动，死亡就是死亡，该线程将不可再次作为线程执行（对新建状态的线程两次调用 start() 方法也是错误的）

四、控制线程

1、join线程

在自己的线程中加入别的线程，也就是调用别的线程的 join()方法，使得自己的线程阻塞，会等待加入的线程结束后才继续执行。

join（）方法的三种重载形式

  • join()：等待被 join 的线程执行完成

  • join(long millis)：等待被 join 的线程的时间最长为 mills 毫秒。如果在 millis 毫秒内被 join 的线程还没有执行结束，就不再等待。

  • join(long millis, int nanos)：等待被 join 的线程的时间最长为 mills 毫秒加 nanos 毫微秒。

2、后台线程

setDaemon() 后台线程是一种在后台运行的，任务是为其他的线程提供服务的线程。JVM 的垃圾回收线程就是一种后台线程。

  • 前台线程创建的子线程默认是前台线程，后台线程创建的子线程默认是后台线程

  • 设置后台线程 setDaemon()必须要在 start()方法前调用，否则报错

  • setDaemon()：用于设置线程为后台线程。

  • isDaemon()：用于判断指定线程是否是后台线程。

3、线程睡眠

sleep()使当前线程暂停一段时间，进入阻塞状态，时间结束后直接进入就绪态。

以下代码中，定义实现了Runnable接口的类，重写run()方法，在while死循环中调用sleep()方法让当前线程睡眠1s，当线程调用interrupt方法时发生打断线程的异常，catch捕获并使用break跳出循环

4、线程让步

当线程调用Thread类的yield()静态方法时，线程让出cpu资源，从运行态转为阻塞态。

下面代码的run()方法中，当i可以被3整除时调用yield()方法让出cpu。从运行结果可以看出，当线程Thraed1执行到可以被3整除时，让出线程给Thread2执行，反之，Thread2让出线程给Thread1执行。

5、改变线程优先级

每一个线程都有一定的优先级，其中有三个常量：

    MAX_PRIORITY：值为 10

    MIN_PRIORITY：值为 1

    NORM_PRIORITY：值为 5

也可以自己设置不同的优先级，范围是 1~10 之间的整数。

子线程的优先级都与创建的它的父线程的优先级相同，其中 main 方法默认是普通优先级为 5。

可通过 setPriority()和 getPriority()方法设置或获取当前线程的优先级。

五、线程同步

1、线程同步

同步是使用synchronized关键字定义的代码块，但同步时需要设置一个对象锁，一般会给当前对象this上锁

2、同步方法

如果在一个方法中使用了synchronized定义，则此方法就是同步方法

3、同步锁（Lock）

Lock对象提供了比 synchronized 方法和 synchronized 代码块更广泛的锁定操作，Lock 允许实现更灵活的结构，可以具有差别很大的属性，并且支持多个相关的 Condition 对象。

Lock 是控制多个线程对共享资源进行访问的工具。通常，锁提供了对共享资源的独占访问，每次只能有一个线程对 Lock 对象加锁，线程开始访问共享资源之前应先获得 Lock 对象。

某些锁可能允许对共享资源并发访问，如 ReadWriteLock（读写锁)，Lock、ReadWriteLock 是 Java 5提供的两个根接口，并为 Lock 提供ReentrantLock（可重入锁）实现类，为 ReadWriteLock 提供了ReentrantReadWriteLock 实现类。

Java 8 新增了新型的 StampedLock 类,在大多数场景中它可以替代传统的 ReentrantReadWriteLock。ReentrantReadWriteLock 为读写操作提供了三种锁模式：

  1. Writing

  2. ReadingOptimistic

  3. Reading。

在实现线程安全的控制中，比较常用的是 ReentrantLock（可重入锁)。使用该 Lock 对象可以显式

地加锁、释放锁，通常使用 ReentrantLock 的代码格式如下：

class X
{
    //定义对象
       private final ReentrantLock Lock = new ReentrantLock();
    //定义需要保证线程安全的方法
    public void m(){
        //加锁
        lock.lock();
                try{
                    //需要保证线程安全的代码
                    //……method body
                }
                //使用finally块来保证释放锁
                finally
                {
                    lock.unlock();
                }
        }    
}

使用ReentrantLock对象来进行同步，加锁和释放锁出现在不同的作用范围内时，通常建议使用finally块来确保在必要时释放锁。通过使用ReentrantLock对象，我们可以把Account类改为如下形式，它依然是线程安全的：

public class Account {
    // 定义锁对象
    private  final ReentrantLock lock = new ReentrantLock();
    // 封装账户编号、账户余额两个Field
    private String accountNo;
    private double balance;

    public Account() {
    }
    // 构造器
    public Account(String accountNo, double balance){
        this.accountNo=accountNo;
        this.balance=balance;
    }
    public String getAccountNo(){
        return this.accountNo;
    }

    public void setAccountNo(String accountNo) {
        this.accountNo = accountNo;
    }
    // 因为账户余额不允许随便修改，所以只为balance提供getter方法
    public double getBalance() {
        return this.balance;
    }
    // 提供一个线程安全的draw()方法来完成取钱操作
    public void draw(double drawAmount) {
        lock.lock();
        try {
            // 账户余额大于取钱数目
            if (balance >= drawAmount) {
                // 吐出钞票
                System.out.println(Thread.currentThread().getName()
                        + "取钱成功！吐出钞票:" + drawAmount);
                try {
                    Thread.sleep(1);
                } catch (InterruptedException ex) {
                    ex.printStackTrace();
                }
                // 修改余额
                balance -= drawAmount;
                System.out.println("\t余额为: " + balance);
            } else {
                System.out.println(Thread.currentThread().getName()
                        + "取钱失败！余额不足！");
            }
        }finally {
            lock.unlock();
        }
    }
    public int hashCode() {
        return accountNo.hashCode();
    }
    public boolean equals(Object obj) {
        if(this == obj)
            return true;
        if (obj != null && obj.getClass()==Account.class) {
            Account target = (Account)obj;
            return target.getAccountNo().equals(accountNo);
        }
        return false;
    }
}

六、线程通信

生产者-消费者问题：

生产者将生产的产品放到仓库中，而消费者从仓库中取走产品。仓库一次存放固定数量的产品。如果仓库满了，生产者停止生产，等待消费者消费产品；如果仓库不满，生产者继续生产；如果仓库是空的，消费者停止消费，等仓库有产品再继续消费。

public class ProducerConsumer{
     public static void main(String[] args) {
         Stack s = new Stack();      //创建对象s
         Producer p = new Producer(s);        //创建生产者对象
         Consumer c = new Consumer(s);        //创建消费者对象
         new Thread(p).start();         //创建生产者进程1      
         new Thread(p).start();         //创建生产者进程2
         new Thread(p).start();         //创建生产者进程3
         new Thread(c).start();         //创建消费者进程
     }
}
//Rabbit类（产品）
class Rabbit{
     int id;           //类的成员变量
     Rabbit(int id){
         this.id = id;
     }
     public String toString() {
         return "玩具："+id;
     }
}
//栈（存放玩具兔的仓库）
class Stack{
     int index = 0;
     Rabbit[] rabbitArray = new Rabbit[6];         //存放玩具兔的数组
     public synchronized void push(Rabbit wt) {         //玩具兔放入数组的方法
         while(index == rabbitArray.length) {
              try {
                  this.wait();            //栈满，等待消费者消费
              }catch(InterruptedException e) {
                  e.printStackTrace();
              }
         }
         this.notifyAll();            //唤醒所有生产者进程
         rabbitArray[index] = wt;        //将玩具兔放入栈
         index++;
     }
     public synchronized Rabbit pop() {        //将玩具兔取走的方法
         while(index == 0) {         //如果栈空
              try {
                  this.wait();        //等待生产玩具兔
              }catch(InterruptedException e) {
                  e.printStackTrace();
              }
         }
         this.notifyAll();         //栈不空唤醒所有消费者线程
         index--;
         return rabbitArray[index];
     }
}
//生产者类
class Producer implements Runnable{
     Stack st = null;
     Producer(Stack st){
         this.st = st;          //构造方法，为类的成员变量ss赋值
     }
     public void run() {                  //线程体
         for(int i = 0;i<20;i++) {            //循环生产20个玩具
              Rabbit r = new Rabbit(i);            //创建玩具兔类
              st.push(r);               //将生产的玩具兔放入栈
              //输出生产了玩具r，默认调用了玩具兔类的toString()
              System.out.println("生产-"+r);
              try {
                  Thread.sleep((int)(Math.random()*200));     //生产一个玩具兔后睡眠
              }catch(InterruptedException e) {
                  e.printStackTrace();
              }
         }
     }
}
//消费者类
class Consumer implements Runnable{
     Stack st = null;
     Consumer(Stack st){                  //构造方法，为类的成员变量ss赋值
         this.st = st;
     }
     public void run() {
         for(int i =0;i<20;i++) {        //循环消费，即取走20个玩具兔
              Rabbit r = st.pop();        //从栈中取走一个玩具兔
              System.out.println("消费-"+r);
              try {
                  Thread.sleep((int)(Math.random()*200));
              }catch(InterruptedException e) {
                  e.printStackTrace();
              }
         }
     }
}

七、线程池

1、简介

线程池其实就是一种多线程处理形式，处理过程中可以将任务添加到队列中，然后在创建线程后自动启动这些任务

2、优点

  • 线程和任务分离,提升线程重用性;

  • 控制线程并发数量,降低服务器压力,统一管理所有线程; 

  • 提升系统响应速度,假如创建线程用的时间为T1，执行任务用的时间为T2,销毁线程用的时间为T3，那么使用线程池就免去了T1和T3的时间；

3、ThreadPoolExecutor源码

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), defaultHandler);
}
 
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         threadFactory, defaultHandler);
}
 
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          RejectedExecutionHandler handler) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), handler);
}
 
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
    if (corePoolSize < 0 ||
        maximumPoolSize <= 0 ||
        maximumPoolSize < corePoolSize ||
        keepAliveTime < 0)
        throw new IllegalArgumentException();
    if (workQueue == null || threadFactory == null || handler == null)
        throw new NullPointerException();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

  • corePoolSize（必需）：核心线程数。默认情况下，核心线程会一直存活，但是当将 allowCoreThreadTimeout 设置为 true 时，核心线程也会超时回收。

  • maximumPoolSize（必需）：线程池所能容纳的最大线程数。当活跃线程数达到该数值后，后续的新任务将会阻塞。

  • keepAliveTime（必需）：线程闲置超时时长。如果超过该时长，非核心线程就会被回收。如果将 allowCoreThreadTimeout 设置为 true 时，核心线程也会超时回收。

  • unit（必需）：指定 keepAliveTime 参数的时间单位。常用的有：TimeUnit.MILLISECONDS（毫秒）、TimeUnit.SECONDS（秒）、TimeUnit.MINUTES（分）。

  • workQueue（必需）：任务队列。通过线程池的 execute() 方法提交的 Runnable 对象将存储在该参数中。其采用阻塞队列实现。

  • threadFactory（可选）：线程工厂。用于指定为线程池创建新线程的方式。

  • handler（可选）：拒绝策略。当达到最大线程数时需要执行的饱和策略。

线程池的使用流程

// 创建线程池
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(CORE_POOL_SIZE,
                                             MAXIMUM_POOL_SIZE,
                                             KEEP_ALIVE,
                                             TimeUnit.SECONDS,
                                             sPoolWorkQueue,
                                             sThreadFactory);
// 向线程池提交任务
threadPool.execute(new Runnable() {
    @Override
    public void run() {
        ... // 线程执行的任务
    }
});
// 关闭线程池
threadPool.shutdown(); // 设置线程池的状态为SHUTDOWN，然后中断所有没有正在执行任务的线程
threadPool.shutdownNow(); // 设置线程池的状态为 STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表

4、线程池的工作原理

5、线程池的参数

（1）、任务队列（workQueue）

任务队列是基于阻塞队列实现的，即采用生产者消费者模式，在 Java 中需要实现 BlockingQueue 接口。但 Java 已经为我们提供了 7 种阻塞队列的实现：

  • ArrayBlockingQueue：一个由数组结构组成的有界阻塞队列（数组结构可配合指针实现一个环形队列）。

  • LinkedBlockingQueue： 一个由链表结构组成的有界阻塞队列，在未指明容量时，容量默认为 Integer.MAX_VALUE。

  • PriorityBlockingQueue： 一个支持优先级排序的无界阻塞队列，对元素没有要求，可以实现 Comparable 接口也可以提供 Comparator 来对队列中的元素进行比较。跟时间没有任何关系，仅仅是按照优先级取任务。

  • DelayQueue：类似于PriorityBlockingQueue，是二叉堆实现的无界优先级阻塞队列。要求元素都实现 Delayed 接口，通过执行时延从队列中提取任务，时间没到任务取不出来。

  • SynchronousQueue： 一个不存储元素的阻塞队列，消费者线程调用 take() 方法的时候就会发生阻塞，直到有一个生产者线程生产了一个元素，消费者线程就可以拿到这个元素并返回；生产者线程调用 put() 方法的时候也会发生阻塞，直到有一个消费者线程消费了一个元素，生产者才会返回。

  • LinkedBlockingDeque： 使用双向队列实现的有界双端阻塞队列。双端意味着可以像普通队列一样 FIFO（先进先出），也可以像栈一样 FILO（先进后出）。

  • LinkedTransferQueue： 它是ConcurrentLinkedQueue、LinkedBlockingQueue 和 SynchronousQueue 的结合体，但是把它用在 ThreadPoolExecutor 中，和 LinkedBlockingQueue 行为一致，但是是无界的阻塞队列。

注意有界队列和无界队列的区别：如果使用有界队列，当队列饱和时并超过最大线程数时就会执行拒绝策略；而如果使用无界队列，因为任务队列永远都可以添加任务，所以设置 maximumPoolSize 没有任何意义。

（2）、线程工厂（threadFactory）

线程工厂指定创建线程的方式，需要实现 ThreadFactory 接口，并实现 newThread(Runnable r) 方法。该参数可以不用指定，Executors 框架已经为我们实现了一个默认的线程工厂：

/**
 * The default thread factory.
 */
private static class DefaultThreadFactory implements ThreadFactory {
    private static final AtomicInteger poolNumber = new AtomicInteger(1);
    private final ThreadGroup group;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix;
 
    DefaultThreadFactory() {
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() :
                              Thread.currentThread().getThreadGroup();
        namePrefix = "pool-" +
                      poolNumber.getAndIncrement() +
                     "-thread-";
    }
 
    public Thread newThread(Runnable r) {
        Thread t = new Thread(group, r,
                              namePrefix + threadNumber.getAndIncrement(),
                              0);
        if (t.isDaemon())
            t.setDaemon(false);
        if (t.getPriority() != Thread.NORM_PRIORITY)
            t.setPriority(Thread.NORM_PRIORITY);
        return t;
    }
}

（3）、拒绝策略（handler）

当线程池的线程数达到最大线程数时，需要执行拒绝策略。拒绝策略需要实现 RejectedExecutionHandler 接口，并实现 rejectedExecution(Runnable r, ThreadPoolExecutor executor) 方法。不过 Executors 框架已经为我们实现了 4 种拒绝策略：

  • AbortPolicy（默认）：丢弃任务并抛出 RejectedExecutionException 异常。

  • CallerRunsPolicy：由调用线程处理该任务。

  • DiscardPolicy：丢弃任务，但是不抛出异常。可以配合这种模式进行自定义的处理方式。

  • DiscardOldestPolicy：丢弃队列最早的未处理任务，然后重新尝试执行任务。

6、功能线程池

（1）、定长线程池（FixedThreadPool）

特点：只有核心线程，线程数量固定，执行完立即回收，任务队列为链表结构的有界队列。

应用场景：控制线程最大并发数。

// 1. 创建定长线程池对象 & 设置线程池线程数量固定为3
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
// 2. 创建好Runnable类线程对象 & 需执行的任务
Runnable task =new Runnable(){
  public void run() {
     System.out.println("执行任务啦");
  }
};
// 3. 向线程池提交任务
fixedThreadPool.execute(task);

（2）、定时线程池（ScheduledThreadPool ）

特点：核心线程数量固定，非核心线程数量无限，执行完闲置 10ms 后回收，任务队列为延时阻塞队列。

应用场景：执行定时或周期性的任务。

// 1. 创建 定时线程池对象 & 设置线程池线程数量固定为5
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
// 2. 创建好Runnable类线程对象 & 需执行的任务
Runnable task =new Runnable(){
  public void run() {
     System.out.println("执行任务啦");
  }
};
// 3. 向线程池提交任务
scheduledThreadPool.schedule(task, 1, TimeUnit.SECONDS); // 延迟1s后执行任务
scheduledThreadPool.scheduleAtFixedRate(task,10,1000,TimeUnit.MILLISECONDS);// 延迟10ms后、每隔1000ms执行任务

（3）、可缓存线程池（CachedThreadPool）

特点：无核心线程，非核心线程数量无限，执行完闲置 60s 后回收，任务队列为不存储元素的阻塞队列。

应用场景：执行大量、耗时少的任务。

// 1. 创建可缓存线程池对象
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
// 2. 创建好Runnable类线程对象 & 需执行的任务
Runnable task =new Runnable(){
  public void run() {
     System.out.println("执行任务啦");
  }
};
// 3. 向线程池提交任务
cachedThreadPool.execute(task);

（4）、单线程化线程池（SingleThreadExecutor）

特点：只有 1 个核心线程，无非核心线程，执行完立即回收，任务队列为链表结构的有界队列。

应用场景：不适合并发但可能引起 IO 阻塞性及影响 UI 线程响应的操作，如数据库操作、文件操作等。

// 1. 创建单线程化线程池
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
// 2. 创建好Runnable类线程对象 & 需执行的任务
Runnable task =new Runnable(){
  public void run() {
     System.out.println("执行任务啦");
  }
};
// 3. 向线程池提交任务
singleThreadExecutor.execute(task);

（5）、对比

DF10F-0001A
关注
专栏目录
JavaSE——多线程编程
weixin_42067873的博客
02-05 412
数据不同步问题解决 测试类中，有一个静态成员a，定义2000个子线程，分别执行对静态变量a的++操作，然后在主线程中输出累加后的a值 MyRunnable: public class MyRunnable implements Runnable{ Object lock = new Object(); @Override public void run() { synchronized (lock) { MyTest.a++; ..
Java 多线程总结
鳄鱼儿
01-04 520
????Process 和 Thread 程序是指令和数据的有序集合，而进程是执行程序的一次执行过程，是系统资源分配的单位。 一般在一个进程中可以包括若干个线程，一个进程中至少有一个线程。 线程是CPU调度和执行的单位。 ????线程的创建 三种创建线程方式 1.Thread class，继承Thread类 2.Runnable接口，实现Runnable接口 3.Callable接口，实现Callable接口 ...
JavaSE——多线程
m0_62823517的博客
09-16 1043
创建一个线程对象后，该线程对象就处于新建状态。此时它不能运行，仅仅是Java虚拟机为其分配了内存。
JavaSE——多线程详细
weixin_51351637的博客
12-12 708
一个应用程序，一个进程就是一个软件：一个进程中的执行场景/执行单元对于java程序来说，当在DOS命令窗口中输入java HelloWorld回车之后，会先启动JVM，而JVM就是一个进程，JVM再启动一个主线程调用main方法，同时再启动一个垃圾回收线程负责看护，回收垃圾，也就是说java程序中至少有两个线程并发，一个是垃圾回收线程，一个是执行main方法的主线程。
JavaSE——多线程基础
PYKE_CHEN的博客
09-19 845
程序是含有指令和数据的文件，被存储在磁盘或其他的数据存储设备中，可以理解为程序是包含静态代码的文件。例如：浏览器文件、音乐播放器软件等软件的安装目录和文件。进程是程序的一次执行过程，是系统运行程序的基本单位。在Windows系统中，每一个正在执行的exe文件或后台服务，都是一个进程，由操作系统同意管理并分配资源，因此进程是动态的。例如：正在允许中的浏览器就是一个进程，正在允许中的音乐播放器是另一个进程，同理，正在允许中的QQ和WPS等都是进程。操作系统运行一个程序，即是一个进程从创建，运行到消亡的过程。
Javase——多线程
luo981695830的博客
09-29 332
多线程 程序：一段静态代码 进程：加载到内存中的正在运行中的程序，一个程序可以启动多个进程 线程：进程中子任务，线程间通信非常容易 java.lang.Thread类来表示 入口方法是run() 启动方法是start() 创建并启动线程的步骤 方式一：实现Runnable接口 写一个具体类，实现Runnable接口，重写run()方法 创建这个类的对象，将对象作为实...
javaSE——多线程基础
成长中的白嫖党
11-25 683
目录 进程和线程的定义、区别、组成 一、进程和线程的定义、区别 1. 定义： 2. 区别： 进程是操作系统资源分配的基本单位，线程是CPU的基本调度单位 一个程序运行后至少有一个进程 一个进程可以包含多个线程，但至少要有一个线程，不然该进程没有意义 进程间不能共享数据地址，但同个进程下的多个线程间可以共享。 3. 线程的组成： ③④⑤ 任何一个线程都具有基本的组成部分： –①CPU时间片：操作系统 （OS）为每个线程分配的执行时间 –②运行数据： ——堆空间：存储线程需要使用的对象，多个线程
Day23JavaSE——多线程&实现
adAir_liu的博客
06-16 1289
Day23JavaSE——多线程&实现 文章目录Day23JavaSE——多线程&实现进程的概述和多进程的意义并行和并发的区别Java程序运行原理和JVM的启动是多线程的吗多线程实现方式一案例利用多线程复制文件线程优先级问题线程控制实现多线程方式二(解决了Java中只能单继承问题)实现多线程方式3卖电影票案例继承Thread类的方式卖电影票案例实现Runnable接口的方式卖电影票线程安全问题生产消费者线程案例同步代码块解决线程安全问题同步方法锁JVM内存模型JVM内存模型 多线程 进程
JavaSE——多线程：Lock体系
LiLiLiLaLa的博客
07-04 421
1.初识Lock与AbstractQueuedSynchronizer(AQS) 1.1.Lock简介 锁是用来控制多个线程访问共享资源的方式，一般来说，一个锁能够防止多个线程同时访问共享资源。在Lock接口出现之前，java程序主要是靠synchronized关键字实现锁功能的，而JDK5之后，并发包中增加了lock接口，它提供了与synchronized一样的锁功能。虽然它失去了像synchr...
javase之多线程技术
10-16
Java中的多线程技术是Java进阶学习的重要组成部分，它涉及到并发编程的理论与实践，旨在提高程序的执行效率和响应速度。以下是对多线程技术的详细解释： 1. **CPU调度算法原理** - **先来先服务（FCFS）**：按照...
JAVASE —— 11多线程
weixin_46033397的博客
03-08 208
多线程
【C++刷题】力扣-#121-买卖股票的最佳时机
会写代码的饭桶
10-16 222
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 281
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
2024.10月12日--- SpringMVC异常处理
whisper_Java 的博客
10-12 905
*** 用户【】 IP[]* 在【时间】* 操作【Controller.find】 发生如下异常*/@OverrideSystem.out.println("---------执行了自定义异常处理器------------");// 根据不同的异常类型，设置不同的响应状态码// 可以添加更多的自定义处理逻辑//}else {// 记录日志或其他处理逻辑// 可以将异常信息放入模型中供视图展示。
Backend - Java 基础
是萝卜干呀的博客
10-11 833
知识量决定了未来能走多远
JavaWeb Servlet--09深入：注册系统04--修改页面
最新发布
weixin_62189092的博客
10-16 149
这里就会获取要修改的用户的id，返回用户，再把这个用户重定向跳转到update.jsp页面。在再UserServlet里书写修改的代码。分析：点击修改超链接，就跳转到一个修改界面，要显示原本的数据，且密码显示出来，在该页面将对用户的数据的进行修改，最后提交。findUserByID()----显示原本的内容，update()---修改数据库内容的方法。注意：修改信息是要展示密码的文本内容，所以在password处type="text";写法和register没有太大的区别，主要是对文本框获得值。
JavaSE——认识异常
wx2023_10_15的博客
10-12 957
本文主要是正在学习异常的总结，主要讲了异常的概念、体系结构、分类、处理以及捕获，还有自定义异常类
Java SE多线程基础与实战清单
首先，我们介绍多线程的创建方式之一——继承Thread类。创建步骤如下： - **定义Thread子类**：创建一个新的类，如`Demo`，它继承自Thread类。例如，`class Demo extends Thread`。 - **重写run()方法**：这个方法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

DF10F-0001A

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

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

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

打赏作者

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

抵扣说明：

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

余额充值