首页 / JAVA / JAVA 多线程、CompleableFuture异步

JAVA 多线程、CompleableFuture异步

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了JAVA 多线程、CompleableFuture异步，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含16502字，纯文字阅读大概需要24分钟。

内容图文

初始化线程的四种办法

继承Thread类
实现Rannable 接口
实现callable 接口 + FutureTask （可以获取处理结果和处理异常）
线程池

继承Thread实现

public class ThreadTest {
    public static void main(String[] args) {
        System.out.println("主线程启动");
        Thread1 thread1 = new Thread1();
        thread1.start();
        System.out.println("主线程结束");
    }

    public static class Thread1 extends Thread{
        @Override
        public void run() {
            System.out.println("===========================");
            System.out.println("当前线程---->"+Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("当前线程处理结果---->"+i);
            System.out.println("===========================");
        }
    }
}

执行结果：
JAVA 多线程、CompleableFuture异步 - 文章图片

实现Runnable接口实现

public class ThreadTest {
    public static void main(String[] args) {
        System.out.println("主线程启动");
        new Thread(new Thread1()).start();
        System.out.println("主线程结束");
    }

    public static class Thread1 implements Runnable{
        @Override
        public void run() {
            System.out.println("===========================");
            System.out.println("当前线程---->"+Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("当前Runnable线程处理结果---->"+i);
            System.out.println("===========================");
        }
    }
}

执行结果：
JAVA 多线程、CompleableFuture异步 - 文章图片

实现Runnable实现

可以使用FatureTask接收异步线程的执行结果，只有所有线程执行完才能得到结果，是阻塞等待

public class ThreadTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("主线程启动");
        FutureTask<Integer> futureTask = new FutureTask<>(new Thread1());
        new Thread(futureTask).start();
        //阻塞等待，当所有线程执行完才能得到结果
        //等待整个线程执行完，获取执行结果
        Integer integer = futureTask.get();
        System.out.println("futureTask执行结果："+integer);
        System.out.println("主线程结束");
    }

    public static class Thread1 implements Callable<Integer> {
        @Override
        public Integer call() throws Exception {
            System.out.println("===========================");
            System.out.println("当前线程---->"+Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("当前Callable线程处理结果---->"+i);
            System.out.println("===========================");
            return i;
        }
    }
}

执行结果：
JAVA 多线程、CompleableFuture异步 - 文章图片

线程池

为什么使用线程池：
降低资源消耗：通过重复利用已经创建好的线程，减少线程创建销毁的损耗。

提高响应速度：因为线程池线程没有超过最大线程数时，有的线程处于空闲等待任务状态，当任务进来无需创建新的线程就能执行

提高线程的可管理性：线程池会根据系统的特点会对线程池内线程进行优化处理，减少创建和销毁带来的系统开销，无限的创建和销毁线程不仅损耗系统性能，还降低系统的稳定性，使用线程池来进行统一的管理分配

在我们的业务代码中，都不用以上三种但是，因为可能会导致我们的资源耗尽，这将会是没有更多的资源来处理核心业务。应该将所有的多线程异步任务都交给线程池，这样只有一个执行完才能继续拿到线程资源执行下一个任务，这样能有效的控制我们的资源。

创建线程池的方式

使用JUC包下的Executors来创建一个线程池

		//固定长度的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        service.execute(new Thread(()-> System.out.println("异步线程执行")));

这种方式有常见的四种线程池

Executors.newCachedThreadPool()：创建一个可缓存线程池，如果线程池长度超过需要处理，可灵活的回收空闲线程，没有则创建新线程

	public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

Executors.newFixedThreadPool():创建一个固定大小的线程池，可控制线程的最大并发量，超出的将会在队列中等待。核心线程数等于最大线程数

	public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

Executors.newScheduledThreadPool():创建一个定时线程池，支持定时或周期性的执行任务
Executors.newSingleThreadExecutor()：创建一个单线程的线程池，后台从队列中获取任务,挨个执行

	public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

使用new ThreadPoolExecutor();来创建线程池，

ThreadPoolExecutor七大参数：

int corePoolSize：核心线程数，线程池创建好就准备就绪的线程数，等待异步任务执行，这些线程将会一直存在，除非allowCoreThreadTimeOut
int maximumPoolSize：最大线程数，用来控制资源并发
long keepAliveTime：存活时间，当线程数大于核心时，这是多余空闲线程在终止前等待新任务的最长时间，超过存活时间将会释放空闲线程
TimeUnit unit：时间单位，存活时间的时间单位
BlockingQueue workQueue：阻塞队列，如果任务有很多，查出最大线程数，多余的任务将会放入队列，等待线程空闲从队列中取出并继续执行
ThreadFactory threadFactory：线程的创建工厂
RejectedExecutionHandler handler：拒绝处理控制器,如果队列的满了，按照我们指定的拒绝策略来拒绝执行任务

工作顺序：

线程池创建，准备好核心线程数的核心线程，准备接收任务
如果核心线程已经满了，后续进来的任务将放到阻塞队列中等待，当核心线程执行完以后就会从队列中获取任务执行
如果阻塞队列满了，将会启动新的线程执行任务，最大数不能超过最大线程数，来进行资源控制
如果最大线程数也用完，将会执行我们的拒绝策略RejectedExecutionHandler来拒绝任务
如果最大线程数都执行完，有很多空闲的线程，这些线程将会在执行的存活之间过后进行释放，释放最大线程数-核心线程数，核心线程会一直存在

创建线城池
创建一个核心数为10、最大线程数为100、存活时间为10秒，JUC包下LinkedBlockingDeque长度为1000的阻塞队列，JUC下默认的线程工厂defaultThreadFactory，ThreadPoolExecutor.AbortPolicy()直接丢弃的拒绝策略的线程池

ThreadPoolExecutor executor = new ThreadPoolExecutor(
                10,
                100,
                10,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(1000),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );

比如一个线程池，核心线程8、最大线程20、阻塞队列50，如果此时进来100个请求进来将会怎么分配。

首先核心线程直接执行8个，这时候不会直接开其他线程，将会放到队列50个，队列满了以后将会开启12个线程，其他的任务都会被丢弃。

如果不想直接被丢弃，可以采用DiscardPolicy这种拒绝策略，这将会直接执行线程的run()方法，是同步执行
JAVA 多线程、CompleableFuture异步 - 文章图片

区别

继承Thread、实现Rannable接口创建出来的线程都不能得到返回值，Callable可以获取返回值
以上三种都不能有效的控制资源
使用线程池的方式来执行多线程任务可以有效控制资源，让性能更加稳定

CompletableFature异步编排

假设有三个异步任务A、 B、 C，异步任务都是同时执行，但是C任务需要A任务的执行结果来进行，这种情况就可以用到异步编排

 * @author Doug Lea
 * @since 1.8
 */
public class CompletableFuture<T> implements Future<T>, CompletionStage<T> {
/**
 * 可以看到CompletableFuture实现了Future，和我们的Callablel实现线程的FutureTask类似，
 * 都实现了Fature接口，可以获取异步任务的结果
 */
public class FutureTask<V> implements RunnableFuture<V> {

public interface RunnableFuture<V> extends Runnable, Future<V> {

CompletableFature提供了四个方法给我们执行异步操作


/**
 * 没有返回值的
 */
public static CompletableFuture<Void> runAsync(Runnable runnable) {
        return asyncRunStage(asyncPool, runnable);
}
/**
 * 指定线程池的
 */
public static CompletableFuture<Void> runAsync(Runnable runnable,
                                                   Executor executor) {
        return asyncRunStage(screenExecutor(executor), runnable);
}

/**
 * 有返回值的
 */
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier) {
        return asyncSupplyStage(asyncPool, supplier);
}

/**
 * 指定线程池的
 */
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier,
                                                       Executor executor) {
        return asyncSupplyStage(screenExecutor(executor), supplier);
}

runAsync测试

public class ThreadTest {

    private static ThreadPoolExecutor executor = new ThreadPoolExecutor(
            10,
            100,
            10,
            TimeUnit.SECONDS,
            new LinkedBlockingDeque<>(1000),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.CallerRunsPolicy()
    );
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("主线程启动");
        CompletableFuture.runAsync(()->{
            int i = 10 / 5;
            System.out.println(i);
        },executor);
        System.out.println("主线程结束");
    }

}

JAVA 多线程、CompleableFuture异步 - 文章图片

supplyAsync测试

public class ThreadTest {

    private static ThreadPoolExecutor executor = new ThreadPoolExecutor(
            10,
            100,
            10,
            TimeUnit.SECONDS,
            new LinkedBlockingDeque<>(1000),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.CallerRunsPolicy()
    );
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("主线程启动");
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            int i = 10 / 5;
            System.out.println(i);
            return i;
        }, executor);
        Integer integer = future.get();
        System.out.println("异步执行结果："+integer);
        System.out.println("主线程结束");
    }
}

JAVA 多线程、CompleableFuture异步 - 文章图片

线程执行完回调

public class ThreadTest {

    private static ThreadPoolExecutor executor = new ThreadPoolExecutor(
            10,
            100,
            10,
            TimeUnit.SECONDS,
            new LinkedBlockingDeque<>(1000),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.CallerRunsPolicy()
    );
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("主线程启动");
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            int i = 10 / 0;
            return i;
        }, executor).whenComplete((result,exception)->{
            System.out.println("线程执行结果："+result);
            System.out.println("线程执行异常："+exception);
        }).exceptionally(throwable -> {
            return 0;
        });
        Integer integer = future.get();
        System.out.println("异步执行结果："+integer);
        System.out.println("主线程结束");
    }
}

JAVA 多线程、CompleableFuture异步 - 文章图片
链式调用whenComplete只能感知是否发生异常，并不能处理异常

使用handle来处理结果

public class ThreadTest {

    private static ThreadPoolExecutor executor = new ThreadPoolExecutor(
            10,
            100,
            10,
            TimeUnit.SECONDS,
            new LinkedBlockingDeque<>(1000),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.CallerRunsPolicy()
    );
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("主线程启动");
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            int i = 10 / 2;
            return i;
        }, executor).handle((result,exception)->{
            if (result != null){
                return result;
            }
            if (exception != null){
                return 0;
            }
            return 0;
        });
        Integer integer = future.get();
        System.out.println("异步执行结果："+integer);
        System.out.println("主线程结束");
    }
}

线程串行化

     /**
      * 当一个线程依赖上一个线程时，获取上一个线程返回结果，并返回当前线程的结果
      *  A B两个线程，B 依赖 A 的返回结果时，B 可以获取 A 的返回结果拿过来计算，并返回 B 线程的执行结果
      */
	 public <U> CompletableFuture<U> thenApply(
        Function<? super T,? extends U> fn) {
        return uniApplyStage(null, fn);
    }

    public <U> CompletableFuture<U> thenApplyAsync(
        Function<? super T,? extends U> fn) {
        return uniApplyStage(asyncPool, fn);
    }

    public <U> CompletableFuture<U> thenApplyAsync(
        Function<? super T,? extends U> fn, Executor executor) {
        return uniApplyStage(screenExecutor(executor), fn);
    }

	//===============================================================================

	/**
	 *  当一个线程依赖上一个线程时，获取上一个线程返回结果，并拿来计算，当前线程并无返回结果
	 *  A B 两个线程，B 可以拿到 A 线程的返回结果，并用 A 的返回结果来计算操作，B 没有返回结果
	 */
    public CompletableFuture<Void> thenAccept(Consumer<? super T> action) {
        return uniAcceptStage(null, action);
    }

    public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action) {
        return uniAcceptStage(asyncPool, action);
    }

    public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action,
                                                   Executor executor) {
        return uniAcceptStage(screenExecutor(executor), action);
    }

	//===============================================================================

	/**
	 *  只要上面的任务执行完成，就执行ThenRun（）方法，只是一个后续操作
	 */

    public CompletableFuture<Void> thenRun(Runnable action) {
        return uniRunStage(null, action);
    }

    public CompletableFuture<Void> thenRunAsync(Runnable action) {
        return uniRunStage(asyncPool, action);
    }

    public CompletableFuture<Void> thenRunAsync(Runnable action,
                                                Executor executor) {
        return uniRunStage(screenExecutor(executor), action);
    }

带有Async的都是异步的，就是另外开一个线程，不带的都是和上一个线程公用一个线程

thenRun测试

thenRun:没有返回值，不能过去到上个任务的执行结果

public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("主线程启动");
        CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
            int i = 10 / 2;
            System.out.println("任务一执行完成");
            return i;
        }, executor).thenRunAsync(() -> {
            System.out.println("任务二执行完成");
        }, executor);
        System.out.println("主线程结束");
    }

JAVA 多线程、CompleableFuture异步 - 文章图片

thenAccept测试

thenAccept：可以获取到上一任务的执行结果，没有返回值

public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("主线程启动");
        CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
            int i = 10 / 2;
            System.out.println("任务一执行完成");
            return i;
        }, executor).thenAcceptAsync(res -> {
            System.out.println("任务一执行结果："+res);
        },executor);
        System.out.println("主线程结束");
    }

JAVA 多线程、CompleableFuture异步 - 文章图片

thenApply测试

thenApply：可以接收到上一个任务的执行结果，并且也有返回值

public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("主线程启动");
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            int i = 10 / 2;
            System.out.println("任务一执行完成");
            return i;
        }, executor).thenApplyAsync(res -> {
            System.out.println("任务一执行结果：" + res);
            return res;
        }, executor);
        System.out.println(future.get());
        System.out.println("主线程结束");
    }

JAVA 多线程、CompleableFuture异步 - 文章图片

两个任务组合，都要完成

当两个CompletableFuture组合完成之后，如果还需继续执行其他任务，可以使用任务组合,必须等待前两个任务执行完才能继续执行

runAfterBoth()：当两个任务执行完成之后，继续执行第三个任务，不能获取其他任务的返回结果，没有返回值

public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("主线程启动");
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            int i = 10 / 2;
            System.out.println("任务一执行完成");
            return i;
        }, executor);

        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务二执行完成");
            return "hello world";
        });
        CompletableFuture<Void> voidCompletableFuture = future.runAfterBothAsync(future1, () -> {
            System.out.println("任务三执行完成");
        }, executor);
        System.out.println(future.get());
        System.out.println("主线程结束");
    }

JAVA 多线程、CompleableFuture异步 - 文章图片
thenAcceptBoth():当两个任务执行完成之后，继续执行第三个任务，可以获取前两个任务的执行结果，没有返回值

public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("主线程启动");
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            int i = 10 / 2;
            System.out.println("任务一执行完成");
            return i;
        }, executor);

        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务二执行完成");
            return "hello world";
        });
        CompletableFuture<Void> voidCompletableFuture = future.thenAcceptBothAsync(future1, (f1,f2) -> {
            System.out.println("任务一的执行结果："+f1);
            System.out.println("任务二的执行结果："+f2);
            System.out.println("任务三执行完成");
        }, executor);
        System.out.println(future.get());
        System.out.println("主线程结束");
    }

JAVA 多线程、CompleableFuture异步 - 文章图片
thenCombine()：当两个任务执行完成之后，继续执行第三个任务，可以获取前两个任务的执行结果，有返回值

public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("主线程启动");
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            int i = 10 / 2;
            System.out.println("任务一执行完成");
            return i;
        }, executor);

        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务二执行完成");
            return "hello world";
        });
        CompletableFuture<String> future2 = future.thenCombineAsync(future1, (f1, f2) -> {
            System.out.println("任务一的执行结果：" + f1);
            System.out.println("任务二的执行结果：" + f2);
            System.out.println("任务三执行完成");
            return f1 + f2;
        }, executor);
        System.out.println("任务三执行结果"+future2.get());
        System.out.println("主线程结束");
    }

JAVA 多线程、CompleableFuture异步 - 文章图片

两个任务组合，一个完成

当两个CompletableFuture组合完成之后，如果还需继续执行其他任务，可以使用任务组合,只需等待两个中的其中一个执行完成，就可以执行其他任务

runAfterEither()：当两个任务其中一个执行完成之后，就执行第三个任务，不能获取其他任务的返回结果，没有返回值
acceptEither()：当两个任务其中一个执行完成之后，就执行第三个任务，可以获取其他任务的返回结果，没有返回值
acceptEither()：当两个任务其中一个执行完成之后，就执行第三个任务，可以获取其他任务的返回结果，有返回值

多任务组合

CompletableFuture.allOf(future, future1)：等待所有的任务执行完成
CompletableFuture.anyOf()：只要有一个任务执行完就结束

public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("主线程启动---"+ LocalDateTime.now());
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            System.out.println("任务一执行完成");
        }, executor);

        CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> {
            try {
                Thread.sleep(3000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务二执行完成");
        }, executor);
        CompletableFuture<Void> allOf = CompletableFuture.allOf(future, future1);
        allOf.get();//等待所有任务执行完
        System.out.println("主线程结束---"+ LocalDateTime.now());

    }

内容总结

以上是互联网集市为您收集整理的JAVA 多线程、CompleableFuture异步全部内容，希望文章能够帮你解决JAVA 多线程、CompleableFuture异步所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/611217.html

来源：【匿名】

【上一篇】JavaCV开发详解之27：使用javacv把视频切割成多个视频分片文件，以mp4为例，把视频切割成MP4分片文件【下一篇】JAVA/JSP学习系列之五

更多 ►

【JAVA 多线程、CompleableFuture异步】教程文章相关的互联网学习教程文章

java多线程 21 ： ReentrantReadWriteLock ，synchronized和ReentrantLock的对比【代码】

读写锁ReentrantReadWriteLock概述大型网站中很重要的一块内容就是数据的读写，ReentrantLock虽然具有完全互斥排他的效果（即同一时间只有一个线程正在执行lock后面的任务），但是效率非常低。所以在JDK中提供了一种读写锁ReentrantReadWriteLock，使用它可以加快运行效率。读写锁表示两个锁，一个是读操作相关的锁，称为共享锁；另一个是写操作相关的锁，称为排他锁。我把这两个操作理解为三句话：1、读和读之间不互斥，因为读操作...

JAVA多线程（七）模式-Producer Consumer【代码】

Producer Consumer生产者创建数据，通过中介控制流量并安全传递给消费者。适用环境生产者生产数据的速度与消费者处理数据的速度不一致，中介者通过缓存和阻塞对消费者的数据压力进行调整。样例4生产者生产产品，放入市场，2消费者消费。产品package ProducerConsumer;public class Product {private String prdId=null;public Product(String prdId) {this.prdId=prdId;}public String getOrderId(){return this.prdId;} }市场pack...

Java多线程:线程同步与关键字synchronized

一、同步的特性1. 不必同步类中所有的方法, 类可以同时拥有同步和非同步方法.2. 如果线程拥有同步和非同步方法, 则非同步方法可以被多个线程自由访问而不受锁的限制. 参见实验1:http://blog.csdn.net/huang_xw/article/details/73185613. 如果两个线程要执行一个类中的同步方法, 并且两个线程使用相同的实例来调用方法, 那么一次只能有一个线程能够执行方法, 另一个需要等待, 直到锁被释放. 参见实验2:http://blog.csdn.net/huang_...

JAVA多线程之wait/notify【代码】【图】

本文主要学习JAVA多线程中的 wait()方法与 notify()/notifyAll()方法的用法。①wait() 与 notify/notifyAll 方法必须在同步代码块中使用②wait() 与 notify/notifyAll() 的执行过程③中断调用wait()方法进入等待队列的线程④notify 通知的顺序不能错⑤多线程中测试某个条件的变化用 if 还是用 while？ ①wait() 与 notify/notifyAll 方法必须在同步代码块中使用wait() 与 notify/notifyAll() 是Object类的方法，在执行两个方法...

【JAVA】HashMap的原理及多线程下死循环的原因【图】

再次翻到以前工作中遇到的一个问题，HashMap在多线程下会出现死循环的问题，以前只是知道会死循环，导致CPU100%把机器拖跨，今天来彻底看看首先来看下，HashMap的原理：HashMap是一个数组，对key使用hash算法计算出数组对应的下标i，然后把<key, value>插到table[i]，如果两个不同的key被算在同一个i，那就出现冲突，又叫碰撞，这样就会在table[i]上形成一个链表；总结下来HashMap是一个数组+链表组成的数据结构；我们知道，在往...

关于java多线程死锁的实验【代码】

先上完整的代码后续再依次修改代码块得到相应的结论 1//尝试写一个死锁感受一下 2publicclass DeadLock {3publicstaticvoid main(String[] args) {4 Object o1 = new Object();5 Object o2 = new Object();6//创建两个object对象7//创建两个Thread线程 8 Thread T1 = new Thread(new process1(o1,o2)); //两个线程T1、T2共享了相同的两个对象o1、o2 9 Thread T2 = new Thread(new process2(o1,o2)); 10 T1....

十七、Java从头开始-多线程编程：聊天室升级版

多线程编程：聊天室升级版?????? 还记得上一章的聊天室吗，不如说是单向发送器，我只能单方面的发送信息给客户端，不能接收消息，不能看到其他室友的发送的信息，我想要的是一个真正的聊天室，在发送信息的同时能看到我和其他室友发送的聊天记录，这里就不得不一边发送一边接收，意味着在用户与GUI交互的同时不能打断它，需要一个单独的执行空间来执行接收功能，就必须引进一个新的线程（Thread）。一、创建线程????? 创建一个线程...

java程序中的多线程(转)【代码】

为什么会排队等待？下面的这个简单的 Java 程序完成四项不相关的任务。这样的程序有单个控制线程，控制在这四个任务之间线性地移动。此外，因为所需的资源 ― 打印机、磁盘、数据库和显示屏 -- 由于硬件和软件的限制都有内在的潜伏时间，所以每项任务都包含明显的等待时间。因此，程序在访问数据库之前必须等待打印机完成打印文件的任务，等等。如果您正在等待程序的完成，则这是对计算资源和您的时间的一种拙劣使用。改进此程序的...

Java多线程间的通信问题扩展

到底什么是线程间的通信？线程间需要通过一些协调性的通信，实现共同完成同一件任务，简单说就是，你想做这件事，我也想做这件事，我们两个相互交流，共同做这件事，而共同任务的同步性的实现，就必须通过同步锁，每一个对象实例都有自己的一把锁，当一个线程想要对这个任务进行处理的时候，就必须获得这把锁。线程之间锁的释放与获取，是通过Object类中的wait()/notify()方法实现的。wait()方法是将当前拥有锁的线程至于等待状态让...

java多线程学习(四)——线程的交互

线程交互中用到的三个基本函数：void notify()；唤醒在此对象监视器上等待的单个线程。void notifyAll()；唤醒在此对象监视器上等待的所有线程。void wait();导致当前的线程等待，直到其他线程调用此对象的notify()或者notifyAll()方法。void wait(long timeout);wait()的重载版本，同样导致当前线程等待，直到其他线程调用此对象的notify()或者notifyAll()方法，或者等待超过指定的时间后不再等待。void wait(long timeout,int na...

JAVA程序设计(17)----- 制作文件拷贝软件进程输入流输出流 NIO 进度条底层拷贝多线程

使用NIO对文件进行底层拷贝（按照字节）多线程技术初级应用不阻塞程序运行package com.lovo.homework01;import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.nio.ByteBuffer; import java.nio.channels.FileChannel;import javax.swing.JButton; impor...

Java多线程17：中断机制【代码】

概述之前讲解Thread类中方法的时候，interrupt()、interrupted()、isInterrupted()三个方法没有讲得很清楚，只是提了一下。现在把这三个方法同一放到这里来讲，因为这三个方法都涉及到多线程的一个知识点----中断机制。Java没有提供一种安全、直接的方法来停止某个线程，而是提供了中断机制。中断机制是一种协作机制，也就是说通过中断并不能直接终止另一个线程，而需要被中断的线程自己处理。有个例子举个蛮好，就像父母叮嘱出门在...

java实现多线程断点续传,上传下载【代码】【图】

采用apache 的 commons-net-ftp-ftpclient import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.io.PrintWriter; import java.io.RandomAccessFile;import org.apache.commons.net.PrintCommandListener; import org.apache.commons.net.ftp.FTP; import org.apache.commons.net.ftp.FTPClient; import org.apache.commons...

Java 中的多线程你只要看这一篇就够了【代码】【图】

引如果对什么是线程、什么是进程仍存有疑惑，请先Google之，因为这两个概念不在本文的范围之内。用多线程只有一个目的，那就是更好的利用cpu的资源，因为所有的多线程代码都可以用单线程来实现。说这个话其实只有一半对，因为反应“多角色”的程序代码，最起码每个角色要给他一个线程吧，否则连实际场景都无法模拟，当然也没法说能用单线程来实现：比如最常见的“生产者，消费者模型”。很多人都对其中的一些概念不够明确，如同步...

Java中多线程的使用！！【代码】

简介： 1.要了解多线程，首先我们得先了解进程和线程。那么什么是进程？进程就是一个正在运行的程序分配内存让应用程序能够运行的叫做进程。那么什么又是线程呢？线程：在一个程序中，负责代码的执行，就是一个进程中的执行路劲的称为线程。然而，在一个进程中，同时又多个线程在执行不同的任务时，我们就称为多线程。 2.我们为什么要使用多线程呢？因为在一个进程中，有时候执行的任务，不仅仅只执行的是一个任务，有...

首页 / JAVA / JAVA 多线程、CompleableFuture异步

JAVA 多线程、CompleableFuture异步

内容导读

内容图文

初始化线程的四种办法

继承Thread实现

实现Runnable接口实现

实现Runnable实现

线程池

使用JUC包下的Executors来创建一个线程池

使用new ThreadPoolExecutor();来创建线程池，

区别

CompletableFature异步编排

runAsync测试

supplyAsync测试

线程执行完回调

线程串行化

thenRun测试

thenAccept测试

thenApply测试

两个任务组合，都要完成

两个任务组合，一个完成

多任务组合

内容总结

内容备注

内容手机端

【JAVA 多线程、CompleableFuture异步】教程文章相关的互联网学习教程文章

JAVA - 相关标签

多线程 - 相关标签

异步 - 相关标签

JAVA - 技术教程分类

JAVA - 最新教程

JAVA - 最热教程