JAVA 多线程实现、线程池创建使用、多线程的异步操作

SpringBoot 中异步任务实现及自定义线程池执行异步任务 java复制代码import org.springframework.context.annotation.Bean;// 核心线程数// 最大线程数// 任务队列大小// 线程池名称前缀// 允许线程的空闲时间/*** 拒绝处理策略* CallerRunsPolicy():交由调用方线程运行,比如 main 线程。* AbortPolicy():直接抛出异常。* DiscardPolicy():直接丢弃。 阅读详情

目录

二、多线程的实现方式(四种)

三、线程池的创建使用(五种)

1、newFixedThreadPool定长线程池 

2、CachedThreadPool可缓存线程池

3、newSingleThreadExecutor单线程化线程池

4、newScheduledThreadPool周期性线程池

无返回值的周期性线程池

有返回值的周期性线程池

5、ThreadPoolExecutor(手动创建线程池)

线程池的submit和execute方法区别

一、初认多线程

1、什么是线程

进程是:一个应用程序(1个进程是一个软件)。

线程是:一个进程中的执行场景/执行单元。

注意: 一个进程可以启动多个线程。

java主线程: 每个java程序都含有一个线程,那就是主线程(main线程)。Java应用程序都是从主类main方法执行的,当jvm加载代码,发现卖弄方法之后,就会启动一个线程,这个线程就是主线程,负责执行main方法。如果在主线程里面创建其他线程,就会在主线程和其他线程来回切换,直到其他所有线程结束才会结束主线程。

所谓多线程,就是说一个应用程序有多条执行路径,每当我们打开一个应用程序的时候,就像当与打开了一个进程,而进程中执行的操作(这就是一条线程对应用程序进行访问),就是线程。以迅雷为例,打开迅雷就相当于打开一个进程,下载文件的操作就是线程,多线程就是同时下载多个文件。

以接口为例,当许多人同时调用一个接口,我们就可以把每一个人看做一条线程去调用我们的接口。

二、多线程的实现方式(四种)

1、继承 Thread 类

通过继承 Thread 类实现多线程的步骤如下:

  1. 创建 MyThread 类,让其继承 Thread 类并重写 run() 方法。
  2. 创建 MyThread 类的实例对象,即创建一个新线程。
  3. 调用 start() 方法,启动线程。
public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("我是通过继承 Thread 类创建的多线程,我叫" + Thread.currentThread().getName());
    }
}

class TestMyThread {
    public static void main(String[] args) {
        MyThread myThread1 = new MyThread();
        myThread1.setName("Thread-1");
        MyThread myThread2 = new MyThread();
        myThread2.setName("Thread-2");
        MyThread myThread3 = new MyThread();
        myThread3.setName("Thread-3");

        myThread1.start();
        myThread2.start();
        myThread3.start();
    }
}

为了演示线程执行顺序的随机性,我特意创建了三个线程,并为每一个线程命名,下面是我运行五次程序的执行结果:

// 第一次
我是通过继承 Thread 类创建的多线程,我叫Thread-2
我是通过继承 Thread 类创建的多线程,我叫Thread-1
我是通过继承 Thread 类创建的多线程,我叫Thread-3

// 第二次
我是通过继承 Thread 类创建的多线程,我叫Thread-1
我是通过继承 Thread 类创建的多线程,我叫Thread-3
我是通过继承 Thread 类创建的多线程,我叫Thread-2

// 第三次
我是通过继承 Thread 类创建的多线程,我叫Thread-1
我是通过继承 Thread 类创建的多线程,我叫Thread-3
我是通过继承 Thread 类创建的多线程,我叫Thread-2

从上面的执行结果我们可以看到线程的执行顺序和代码中编写的顺序没有关系,线程的执行顺序是具有随机性的。

2、实现 Runnable 接口

通过实现 Runnable 接口实现多线程的步骤如下:

1.创建 MyRunnable 类实现 Runnable 接口。

2.创建 MyRunnable 类的实例对象 myRunnable 。

3.把实例对象 myRunnable 作为参数来创建 Thread 类的实例对象 thread,实例对象 thread 就是一个新线程。

4.调用 start() 方法,启动线程。、

public class RunnableTest implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                System.out.println("我是通过实现 Runnable 接口创建的多线程,我叫" + Thread.currentThread().getName());
            }

        }
    }
    
 class Test {
    public static void main(String[] args) {
        Thread myThread1 = new Thread(new RunnableTest());
        Thread myThread2 = new Thread(new RunnableTest());
        myThread1.start();
        myThread2.start();
    }
}

执行结果如下:

我是通过实现 Runnable 接口创建的多线程,我叫Thread-1
我是通过实现 Runnable 接口创建的多线程,我叫Thread-0
我是通过实现 Runnable 接口创建的多线程,我叫Thread-1
我是通过实现 Runnable 接口创建的多线程,我叫Thread-0
我是通过实现 Runnable 接口创建的多线程,我叫Thread-1
我是通过实现 Runnable 接口创建的多线程,我叫Thread-0
我是通过实现 Runnable 接口创建的多线程,我叫Thread-1
我是通过实现 Runnable 接口创建的多线程,我叫Thread-0
我是通过实现 Runnable 接口创建的多线程,我叫Thread-1
我是通过实现 Runnable 接口创建的多线程,我叫Thread-0

注:

相比于继承 Thread 类的方法来说,实现 Runnable 接口是一个更好地选择,因为 Java 不支持多继承,但是可以实现多个接口。

有一点值得注意的是 Thread 类也实现了 Runnable 接口,这意味着构造函数 Thread(Runnable target) 不仅可以传入 Runnable 接口的对象,而且可以传入一个 Thread 类的对象,这样就可以将一个 Thread 对象中的 run() 方法交由其他线程进行调用。

3、实现 Callable 接口

Callable 接口只有一个 call() 方法,源码如下:

public interface Callable<V> {
    V call() throws Exception;
}

从源码我们可以看到 Callable 接口和 Runnable 接口类似,它们之间的区别在于 run() 方法没有返回值,而 call() 方法是有返回值的。

通过实现 Callable 接口实现多线程的步骤如下:

1.创建 MyCallable 类实现 Callable 接口。

2.创建 MyCallable 类的实例对象 myCallable。

3.把实例对象 myCallable 作为参数来创建 FutureTask 类的实例对象 futureTask。

4.把实例对象 futureTask 作为参数来创建 Thread 类的实例对象 thread,实例对象 thread 就是一个新线程。

5.调用 start() 方法,启动线程。

public class CallbaleTest implements Callable {
        @Override
        public Integer call() throws Exception {
            int a = 6;
            int b = 9;
            System.out.println("我是通过实现 Callable 接口创建的多线程,我叫" + Thread.currentThread().getName());
            return a + b;
        }
    }

    class TestMyCallable {
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            CallbaleTest myCallable = new CallbaleTest();
            FutureTask<Integer> futureTask = new FutureTask(myCallable);
            Thread thread = new Thread(futureTask);
            Thread thread1 = new Thread(futureTask);
            thread.start();
            thread1.start();
            Integer integer = futureTask.get();
            System.out.println("返回值为:" + integer);
        }
    }

执行后的结果如下:

我是通过实现 Callable 接口创建的多线程,我叫Thread-0
返回值为:15

注:FutureTask 类提供了一个 get() 方法用来获取 call() 方法的返回值,但需要注意的是调用这个方法会导致程序阻塞,必须要等到线程结束后才会得到返回值。

4、线程池(下面讲)

三、线程池的创建使用(五种)

上面讲的是通过new Thread等方式创建线程,这种方式的弊端是:

a. 每次new Thread新建对象性能差。

b. 线程缺乏统一管理,可能无限制新建线程,相互之间竞争,及可能占用过多系统资源导致死机或oom。

c. 缺乏更多功能,如定时执行、定期执行、线程中断。

下面将要介绍的是Jdk提供的四种线程池的好处在于:

a. 重用存在的线程,减少对象创建、消亡的开销,性能佳。

b. 可有效控制最大并发线程数,提高系统资源的使用率,同时避免过多资源竞争,避免堵塞。

c. 提供定时执行、定期执行、单线程、并发数控制等功能。

1、newFixedThreadPool定长线程池

Executors.newFixedThreadPool:创建一个固定大小的线程池,可控制并发的线程数,超出的线程会在队列中等待。

import java.util.concurrent.*;

public class Test {
    public static void main(String[] args) {
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(2);
        for (int j = 0; j < 3; j++) {
            fixedThreadPool.execute(() -> {
                for (int i = 0; i < 2; i++) {
                    System.out.println("线程名:" + Thread.currentThread().getName() + " i是:" + i);
                }
            });
        }
      fixedThreadPool.shutdown();//关闭线程池
    //shutdownNow();//停止接收新任务,原来的任务停止执行,但是它并不对正在执行的任务做任何保证,有可能它们都会停止,也有可能执行完成。
    }
}

输出:

线程名:pool-1-thread-1 i是:0
线程名:pool-1-thread-1 i是:1
线程名:pool-1-thread-2 i是:0
线程名:pool-1-thread-1 i是:0
线程名:pool-1-thread-1 i是:1
线程名:pool-1-thread-2 i是:1

2、CachedThreadPool可缓存线程池

Executors.newCachedThreadPool:创建一个可缓存的线程池,若线程数超过处理所需,缓存一段时间后会回收,若线程数不够,则新建线程。

可缓存线程池为无限大,当执行第二个任务时第一个任务已经完成,会回收复用第一个任务的线程,而不用每次新建线程,可灵活回收空闲线程,若无可回收,则新建线程。

public class Test {
    public static void main(String[] args) {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int j = 0; j < 3; j++) {
            cachedThreadPool.execute(() -> {
                for (int i = 0; i < 2; i++) {
                    System.out.println("线程名:" + Thread.currentThread().getName() + " i是:" + i);
                }
            });
        }
        cachedThreadPool.shutdown();//关闭线程池
    }
}

输出:

线程名:pool-1-thread-1 i是:0
线程名:pool-1-thread-1 i是:1
线程名:pool-1-thread-3 i是:0
线程名:pool-1-thread-2 i是:0
线程名:pool-1-thread-2 i是:1
线程名:pool-1-thread-3 i是:1

使用场景:

CachedThreadPool 是根据短时间的任务量来决定创建的线程数量的,所以它适合短时间内有突发大量任务的处理场景。

3、newSingleThreadExecutor单线程化线程池

newSingleThreadExecutor线程池你可以理解为特殊的newFixedThreadPool线程池,它只会创建一个线程,并且所有任务按照指定顺序。如果你创建了多个任务,因为只会有一个线程,多余的任务会被阻塞到队列里依次执行。

下面的示例循环3次,每次都是用的一个线程,这个线程会先执行第一个循环的任务,在执行第二个循环的任务,再执行第三个循环的任务,所以输出的 i 是有序的。

public class newSingleThreadExecutor {
    public static void main(String[] args) {
        ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
            for (int j = 0; j < 3; j++) {
                singleThreadPool.execute(() -> {
                    for (int i = 0; i < 3; i++) {
                        System.out.println("线程名:" + Thread.currentThread().getName() + " i是:" + i);
                    }
                });
            }
            System.out.println("准备关闭线程池");
            singleThreadPool.shutdown();//关闭线程池
        }
    }

输出:

准备关闭线程池
线程名:pool-1-thread-1 i是:0
线程名:pool-1-thread-1 i是:1
线程名:pool-1-thread-1 i是:2
线程名:pool-1-thread-1 i是:0
线程名:pool-1-thread-1 i是:1
线程名:pool-1-thread-1 i是:2
线程名:pool-1-thread-1 i是:0
线程名:pool-1-thread-1 i是:1
线程名:pool-1-thread-1 i是:2

单个线程的线程池有什么意义?

单个线程的线程池相比于线程来说,它的优点有以下 2 个:

可以复用线程:即使是单个线程池,也可以复用线程。

提供了任务管理功能:单个线程池也拥有任务队列,在任务队列可以存储多个任务,这是线程无法实现的,并且当任务队列满了之后,可以执行拒绝策略,这些都是线程不具备的。

4、newScheduledThreadPool周期性线程池

周期性线程池用来处理延时任务或定时任务。

无返回值的周期性线程池

public class newScheduledThreadPool {
        public static void main(String[] args) {
            ScheduledExecutorService scheduleThreadPool = Executors.newScheduledThreadPool(3);
            System.out.println("测试1");
            for (int i = 0; i < 5; i++) {
                scheduleThreadPool.schedule(() -> {
                    System.out.println("线程名:" + Thread.currentThread().getName() + "已经过了3秒");
                }, 3, TimeUnit.SECONDS);
            }
            System.out.println("测试2");
            scheduleThreadPool.shutdown();//关闭线程池
        }
    }

说明:

我们声明了3个线程,创建的时候用循环创建了5个,多出来的2个会阻塞直到前3个线程有执行完的再复用他们的线程;因为采用了延时3秒输出,所以会先输出测试1、测试2,然后等待3秒后再执行输出线程的内容。

输出:

测试1
测试2
线程名:pool-1-thread-2已经过了3秒
线程名:pool-1-thread-3已经过了3秒
线程名:pool-1-thread-1已经过了3秒
线程名:pool-1-thread-3已经过了3秒
线程名:pool-1-thread-2已经过了3秒

有返回值的周期性线程池

public static void main(String[] args) {
            ScheduledExecutorService scheduleThreadPool = Executors.newScheduledThreadPool(3);
            System.out.println("测试1");
            ScheduledFuture<String> scheduledFuture = scheduleThreadPool.schedule(() -> {
                return "线程名:" + Thread.currentThread().getName() + "已经过了3秒";
            }, 3, TimeUnit.SECONDS);

            System.out.println("测试2");
            try {
                //获取线程返回的值并输出
                System.out.println(scheduledFuture.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
            scheduleThreadPool.shutdown();//关闭线程池
        }
    }

输出:

测试1
测试2
线程名:pool-1-thread-1已经过了3秒

定时线程执行

定时执行可以用scheduleAtFixedRate方法进行操作,里面的参数4表示代码或启动运行后第4秒开始执行,3表示每3秒执行一次。因为我们设置了3个线程,所以运行后线程会在第4秒开始用3个线程每3秒执行一次。

public static void main(String[] args) {
        ScheduledExecutorService scheduleThreadPool = Executors.newScheduledThreadPool(3);
        System.out.println("测试1");
        scheduleThreadPool.scheduleAtFixedRate(() -> {
            System.out.println("线程名:" + Thread.currentThread().getName() + "已经过了3秒");
        }, 4, 3, TimeUnit.SECONDS);
        System.out.println("测试2");

    }

输出:

测试1
测试2
线程名:pool-1-thread-1已经过了3秒
线程名:pool-1-thread-1已经过了3秒
线程名:pool-1-thread-2已经过了3秒
线程名:pool-1-thread-3已经过了3秒
......

5、ThreadPoolExecutor(手动创建线程池)

上面我们介绍了四种JDK自带的线程池,但是平常不推荐使用。

ThreadPoolExecutor 相比于其他创建线程池的优势在于,它可以通过参数来控制最大任务数和拒绝策略,让线程池的执行更加透明和可控,所以在阿里巴巴《Java开发手册》是这样规定的:

【强制要求】线程池不允许使用 Executors 去创建,而是通过 ThreadPoolExecutor 的方式,这样的处理方式让写的同学更加明确线程池的运行规则,规避资源耗尽的风险。

这一方面是由于jdk中自带的线程池,都有其局限性,不够灵活;另外使用ThreadPoolExecutor有助于大家明确线程池的运行规则,创建符合自己的业务场景需要的线程池,避免资源耗尽的风险。

需要进行线程池的初始化,所以引入以下依赖:

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>29.0-jre</version>
</dependency>

在开始前需要注意线程池的几个参数:

(在下面代码的ThreadPoolExecutor里你会看到这些参数):

corePoolSize=>    线程池里的核心线程数量
maximumPoolSize=> 线程池里允许有的最大线程数量
keepAliveTime=>   空闲线程存活时间
unit=>            keepAliveTime的时间单位,比如分钟,小时等
workQueue=>       缓冲队列
threadFactory=>   线程工厂用来创建新的线程放入线程池
handler=>        线程池拒绝任务的处理策略,比如抛出异常等策略

线程池按以下行为执行任务
    1. 当线程数小于核心线程数时,创建线程。
    2. 当线程数大于等于核心线程数,且任务队列未满时,将任务放入任务队列。
    3. 当线程数大于等于核心线程数,且任务队列已满
        -1 若线程数小于最大线程数,创建线程
        -2 若线程数等于最大线程数,抛出异常,拒绝任务

无返回值的线程创建

代码初始化了线程池并用 executorService.execute 分别创建了两个线程,一个用来输出本线程的名字,另一个用来异步调用 printA() 方法。

public static void main(String[] args) {
        System.out.println("开始");
        //线程池的初始化
        ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFormat("demo-pool-%d").build();
        ExecutorService executorService = new ThreadPoolExecutor(
                60,
                100,
                0L,
                TimeUnit.MILLISECONDS,
                new LinkedBlockingDeque<>(1024),
                namedThreadFactory,
                new ThreadPoolExecutor.AbortPolicy());

        //开启一个新线程用来输出线程的名字
        executorService.execute(() -> System.out.println("第1个线程名字" + Thread.currentThread().getName()));

        //再开启一个新线执行printA()
        executorService.execute(() -> {
            System.out.println("第2个线程名字" + Thread.currentThread().getName());
            printA();
        });

        System.out.println("完成");
        executorService.shutdown();
    }

    public static void printA() {
        for (int i = 0; i < 3; i++) {
            System.out.println("打印:aaaaaaaaaaaaa");
        }
    }

输出:

开始
完成
第1个线程名字demo-pool-0
第2个线程名字demo-pool-1
打印:aaaaaaaaaaaaa
打印:aaaaaaaaaaaaa
打印:aaaaaaaaaaaaa

有返回值的多线程调用

使用submit

public static void main(String[] args) {
        System.out.println("开始");

        //线程池的初始化
        ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFormat("demo-pool-%d").build();
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10,
                0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingDeque<>(1024), namedThreadFactory,
                new ThreadPoolExecutor.AbortPolicy());

        //异步调用对象integerCallableTask中的call()计算1-100的和
        Future<Integer> future = threadPoolExecutor.submit(() -> {
            int nummber = 100;
            int sum = 0;
            for (int i = 0; i <= nummber; i++) {
                sum += i;
            }
            return sum;
        });

        try {
            //获取计算的结果
            Integer result = future.get();
            System.out.println("和是:" + result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        System.out.println("完成");
        //shutdown():停止接收新任务,原来的任务继续执行
        //shutdownNow():停止接收新任务,原来的任务停止执行
        threadPoolExecutor.shutdown();
    }

输出:

开始
和是:5050
完成

线程池的submit和execute方法区别

1、接收的参数不一样

execute接收的参数是new Runnable(),重写run()方法,是没有返回值的:

源码:

public interface Executor {

    /**
     * Executes the given command at some time in the future.  The command
     * may execute in a new thread, in a pooled thread, or in the calling
     * thread, at the discretion of the {@code Executor} implementation.
     *
     * @param command the runnable task
     * @throws RejectedExecutionException if this task cannot be
     * accepted for execution
     * @throws NullPointerException if command is null
     */
    void execute(Runnable command);
}

submit接收的参数是Callable<Object>,重写call()方法,是有返回值的:

源码:

/**
     * @throws RejectedExecutionException {@inheritDoc}
     * @throws NullPointerException       {@inheritDoc}
     */
    public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task);
        execute(ftask);
        return ftask;
    }

2、submit有返回值用于返回多线程计算后的值,而execute没有返回值

多线程 - 自定义ThreadPoolTaskExecutor 来实现线程池模拟异步任务 Service@Slf4j@Autowired@Async@Overridelog.info("开始做任务一");// 创建计时器try {log.info("任务一 : {}", RANDOM.nextInt(100000));log.error("任务一执行异常", e);// 停止计时器// 输出总耗时。 阅读详情

相关推荐

实战派指南:反激电源EMI滤波器设计,从理论计算到PCB布局避坑

本文详细解析了反激式开关电源EMI滤波器设计的全流程,从理论计算到PCB布局避坑,结合34W PD快充电源案例,系统介绍了共模与差模干扰的识别、关键元件选型、参数计算优化及PCB布局技巧,帮助工程师有效解决传导测试超标等常见问题。

weixin_29230805的博客 373

java 实现开启异步线程的几种方式

需要注意的是,无论使用哪种方式,都应该根据具体情况选择合适的线程池和调度器,以确保异步操作在适当的线程上执行,并在需要更新UI时切换回主线程。在Java中,有多种方式可以实现异步线程以避免在主线程中执行耗时操作导致界面卡顿的问题。

Sico2Sico 3150

Visual MODFLOW Flex 6.1新手入门:从数据导入到3D建模的完整工作流解析

本文为Visual MODFLOW Flex 6.1新手提供了从零开始构建地下水数值模型的完整工作流指南。详细解析了从项目规划、数据准备与导入,到构建三维概念模型、生成并运行数值模型,直至结果可视化与校准的核心步骤。帮助水文地质与环工领域初学者快速掌握这一专业软件,高效完成从数据到三维建模的全过程。

a1b2c的博客 814

java 线程池——异步任务

 为了解决这些问题,Jdk1.5之后加入了java.util.concurrent包,这个包中主要介绍java中线程以及线程池的使用。为我们在开发中处理线程的问题提供了非常大的帮助

guanshengg的博客 4078

基于Matlab的MIMO通信系统仿真_Simulink实现

瑞利衰落信道中使用空时分组码的BPSK调制的BER 1、2发1收 参数设置: 双极性信号元+1和-1,每符号含1bit; 采样时间=符号时间=1s; 采用基于数据帧的仿真计算模式,每帧中有2个采样值; 仿真时间=出现100个误码后停止仿真; 随机整数种子=22; Jakes衰落模型中每个信道上的多普勒频移=0.01Hz; 输人信号功率=2W; Alamouti码:两根发送天线,一根接收天线(分集阶= 2); 平均信道信噪比= 18dB; 仿真得出的误码率统计BER =0. 00017. 2、2发

太阳帅帅的博客 9688

ADS系列之SI&PI仿真笔记:ADS多种版本的安装、卸载&重装(一)

此系列仅作为ADS学习过程的记录,如有错误的地方还请大佬指正! 一、下载&安装 ADS软件下载&安装还算比较简单,目前接触到有两个版本:ADS2017和ADS2019。这里贴下链接,破解教程里面都有: ADS2017下载地址:https://pan.baidu.com/s/1l-Bs9owKRmp5Pv0Mt92OYA 提取码:wuzf ADS2019下载地址:吴川斌的博客-w...

Claudedy的博客 3万+

Java 的异步编程 (5 种异步实现方式详解)

1.创建一个异步线程2.创建主线程,在主线程中创建异步线程执行异步线程,实现异步编程3.优化:由于线程的频繁创建和销毁浪费系统资源,我们可以使用线程池进行优化线程池的使用:创建一个类,将线程池设置为全局变量执行线程时只需要创建执行对象调用执行方法就可以了。

a18372016358的博客 9388

【ArcGIS Pro微课1000例】0065:制作千层饼多图层叠加效果

右键dem图层,点击符号系统,在右侧的符号系统窗口中,选择拉伸,勾选【显示名称】和【显示全部】,选择高程色带7。由于数据具有高程源,因此可以将数据进行三维显示。右键地面→添加高程源图层。打开ArcGIS PRo,新建一个局部场景,命名为千层饼。设置了高程源数据之后,千层饼一下子就变成了三维形状。数据默认都是在一个平面上,以默认的符号系统显示。到此为止,每个图层均为平面的千层饼已经做好了。将TIN图层的高程偏移设置为-1000。最后将等高线的高程设为2000.移除工程默认加载的图层。默认即可,不需要做修改。

智慧空间实验室 1157

java多线程异步教程_Java使用多线程异步执行批量更新操作方法

写在前面:相信不少开发者在遇到项目对数据进行批量操作的时候,都会有不少的烦恼,尤其是针对数据量极大的情况下,效率问题就直接提上了菜板。因此,开多线程来执行批量任务是十分重要的一种批量操作思路,其实这种思路实现起来也十分简单,就拿批量更新的操作举例:整体流程图步骤 获取需要进行批量更新的大集合A,对大集合进行拆分操作,分成N个小集合A-1 ~ A-N 。开启线程池,针对集合的大小进行调参,对小集合进...

weixin_35656078的博客 519

096、PCIE环回模式(Loopback):调试时自己和自己对话的利器

摘要: PCIE环回模式是调试利器,通过让芯片内部数据自环来定位问题层级。文章详解三种环回模式:物理层环回验证基础收发,数据链路层环回测试DLLP机制,事务层环回验证端到端协议。分享了实战中的典型问题(时钟异常、状态机卡死、计数器失真)和"从下往上"的调试流程,强调要区分调试与生产功能,建议早期验证环回模式。通过具体代码示例和调试案例,说明合理使用环回模式能显著提升排查效率,是PCIE调试必备技能。(149字)

z534437748的博客 107

PostgreSQL核心原理:数据库崩溃恢复的唯一真相详解

PostgreSQL崩溃恢复机制通过WAL日志确保数据一致性和持久性。核心流程包括:触发恢复(非正常关闭时)、读取控制文件获取检查点LSN、顺序扫描WAL日志进行Redo阶段重做已提交事务、利用MVCC标记未提交事务为ABORTED实现逻辑撤销,最后执行检查点完成恢复。该机制依赖WAL原子性、检查点锚点和无Undo的可见性模型三大支柱,保证即使系统崩溃也能恢复到逻辑一致状态。关键设计包括延迟写入、LSN顺序控制和FPW防部分写,最终通过确定性重放实现ACID特性。

数据知道的博客 2667

Android多线程和线程池

线程创建、线程池

qq_14931305的博客 716

Wsl/InstallDistro/Service/RegisterDistro/CreateVm/HCS/E_INVALIDARG

摘要:安装WSL2时遇到E_INVALIDARG错误(多核CPU问题),可通过创建.wslconfig配置文件解决。配置内容包括:渐进式内存回收、自动代理、模拟虚拟系统调用、限制内存为4GB和处理器核心数为4。需确保已启用虚拟机平台和Linux子系统功能。 (98字)

猿小白的博客 1050

Java|Java多线程案例

线程的创建及状态 1.线程的生命周期 2.创建一个线程 import java.util.concurrent.TimeUnit; public class ThreadStateTest { public static void main(String[] args) throws InterruptedException { // 创建一个线程对象 Thread thread = new Thread(); System.out.println

Autovy blog 3557

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

多线程 线程池设置

// 多线程处理 ExecutorService executor = Executors.newFixedThreadPool(50); Runnable task = new Runnable() { public void run() { //业务代码 } }; // 将线程放入池中进行执行 executor.execute(...

泰坦巨人 298

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

java 多线程发送邮件_多线程实现发送邮件功能

通过Internet发送邮件,可能会在网络传输上面使用较多的时间,如果调用发送邮件的线程与发送邮件线程是同一个的话,那么有可能会照成系统等待较长的时间而无法继续执行,影响系统效率。那么这时可考虑使用多线程,实现异步发送,而不用等待邮件发送者的返回。首先,是发送邮件的抽象任务类。其子类负责发送邮件操作。public abstract class AbstractTask implements Run...

weixin_42312523的博客 2063

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

Java多线程基础知识总结

题目来源于网络,答案都是自己搜集或者自己总结得出 ,如有错误,请指出谢谢~ 1) 什么是线程? 线程是现代操作系统调度的最小单元。例如启动一个java程序,这时操作系统便会创建一个java进程,在一个进程中可以创建多个线程,每个线程都有自己的计数器、堆栈内存和局部变量等属性,而且可以访问共享的内存变量。而每个java程序其实都是多线程的,例如一个print("hello world")的简单程序...

Hollake的博客 350

Java培训多线程+List分段解决批量更新太慢

获取需要进行批量更新的大集合A,对大集合进行拆分操作,分成N个小集合A-1 ~ A-N 。开启线程池,针对集合的大小进行调参,对小集合进行批量更新操作_java培训。对流程进行控制,控制线程执行顺序。...

weixin_45695430的博客 275

java callback 多线程_JAVA Callback效率测试

在最近的联网电商项目中,想要实现单个web容器内的支付请求,全部能够统一宏观上同步,实现粒度上面异步,找来找去,没有相关方面的框架或者方案,于是最后基于现实场景,打算使用Java callback 的多线程方式,假象伪并发量为100000/**** @author gyx**/public class A{private double id = 0;public A(double id){th...

weixin_42499363的博客 551

【JAVA】多线程

多线程

小朋友的博客 257

Java中的并行计算:如何优化多线程与多进程的性能

例如,可以使用多进程来分配不同的任务模块,而在每个进程内部使用多线程来处理并发任务,从而实现更高效的并行计算。与多线程相比,多进程能够更好地利用多核CPU,因为每个进程都有独立的内存空间,但其通信成本较高。在设计多进程架构时,尽量减少进程间的通信,可以通过消息队列、文件系统等手段传递必要的信息,而不是频繁地进行数据交换。线程池是Java并发库提供的一种高效的多线程处理机制,通过复用线程减少创建和销毁线程的开销。在多线程编程中,如何提高线程的执行效率和减少线程间的冲突是关键。接口是实现多线程的基本方式。

微赚淘客系统开发者博客 1425

2.多线程的创建方式

以下内容全部都来自 bilibili 宋红康老师java基础部分内容P415 ~ P446 小节中 https://www.bilibili.com/video/BV1Kb411W75N?p=415 多线程的创建方式共有 4 种 继承Thread类的方式 实现Runnable接口的方式 实现Callable接口的方式 使用线程池创建 本篇文章讲前面 3 种 1、使用继承Thread类的方式创建多线程 *步骤:* 创建一个继承与Thread类的子类 重写Thread类的run() 方法 ,将想要用子线程

qq_37385585的博客 334

多线程系列-从学会创建多线程开始

多线程 4 多线程常见场景 客户端(移动端App端)开发 异步发送短信/邮件 执行比较耗时的代码改用多线程异步执行,提高接口的响应速度 异步写入日志(日志框架底层) 多线程下载 5 多线程的创建方式 5.1 继承Thread类 /** * @ClassName ThreadDemo * @Description 继承Thread * @Author Fclever * @Date 2021/12/16 11:12 **/ public class ThreadDemo extends Thre

qq_41649001的博客 750

Java从入门到实战总结-3.4、Java多线程

Java从入门到实战总结-3.4、Java多线程 文章目录Java从入门到实战总结-3.4、Java多线程1、多线程技术概述(1)、线程与进程(2)、线程调度(3)、异步和同步(4)、并发和并行2、继承Thread实现线程3、实现Runnable接口实现线程4、Thread类(1)、类方法(2)、设置和获取线程名称(3)、线程休眠sleep(4)、线程阻塞(5)、线程中断(6)、守护线程5、线程安全问题(1)、线程安全问题情形(2)、隐式锁-同步代码块(3)、隐式锁-同步方法(4)、显式锁Lock(5)、

逍遥游的博客 300
上一篇: 【Java编程题】
下一篇: 【JAVA后端开发】Part1--瑞吉外卖项目
javaYY_
博客等级 码龄4年 148粉丝 69原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值