JAVA多线程（八）——Callable，FutureTask以及CompletableFuture简介

最新推荐文章于 2024-08-05 22:50:58 发布
最新推荐文章于 2024-08-05 22:50:58 发布
阅读量743 收藏 1
点赞数
分类专栏： 个人笔记 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34754162/article/details/107476393
版权

个人学习笔记——Future

Callale

对于Callable大家应该都很熟悉，它与Runnable属于线程的顶级接口，不过它与Runnale不同的是，它支持线程返回执行结果，下面是它的使用方法：

package com.example.demo.thread;

import java.util.concurrent.*;

/**
 * @author : sun
 * create at:  2020/4/29  22:20
 * @description: 创建线程的方法4--实现Callable接口
 */
public class MyThread04 implements Callable {
    @Override
    public Integer call() throws Exception {
        System.out.println( Thread.currentThread().getName() +" 启动了");
        TimeUnit.SECONDS.sleep(10);
        return 1;
    }

    public static void main(String[] args) throws Exception {
        /**
         * 通过FutreTask包装启动
         */
        MyThread04 myThread04 = new MyThread04();
        FutureTask task = new FutureTask(myThread04);
        Thread thread = new Thread(task,"线程一");
        thread.start();

        System.out.println(task.get());
        /**
         * 通过线程池启动
         */
        ExecutorService service = Executors.newFixedThreadPool(1);
        Future<Integer> result = service.submit(myThread04);
        System.out.println(result.get());
        service.shutdown();
    }
}

从这段代码中，我可以看到Callable一般与FutureTask一起使用。同时在线程池中，我们可以通过submit方法来执行Callable线程来获得一个返回值。

FutureTask

简介

在介绍FutureTask之前我们要先了解一下Future接口，它提供了几个方法，其中最主要的get方法就是我们FutureTask的一个重点方法，他们的关系图如下：
在这里插入图片描述
从这个关系图中我们可以看出，FutureTask实现的RunnableFuture接口继承了Runnable，所以FutureTask也可以看作一个线程类，它可以自己启动一个线程，也可以将它交给线程池执行。
接下来我们来分析它的重要方法：

get方法

在这里插入图片描述
get方法是它最常用的方法，它提供了无参和有参的get方法，从参数可以看到，有参的get方法其实是入参了一个时间和这个时间单位，联系get方法会造成阻塞，我们可以想象到，他应该是规定了我get方法阻塞的时间，如果超过这个时间我就不会一直阻塞在那。
它的执行流程时：判断state状态（需要注意的是这个值是volatile修饰的，保证了线程之间的可见性），如果状态是未执行或者执行中调用awaitDone方法等待任务结束；如果执行完成，调用report方法返回执行结果。report方法就是看线程时正常结束还是异常结束，如果正常结束，返回执行结果；如果是CANCELLED状态、INTERRUPTING状态（中断中）或者INTERRUPTED状态（中断），则抛出异常。
state状态介绍

状态值状态说明介绍
0NEW刚刚创建，初始状态
1COMPLETING表示一个新的任务，初始状态
2NORMAL任务正常结束
3EXCEPTIONAL任务异常而结束
4CANCELLED任务被取消
5INTERRUPTING中断中，任务调用cancel(true)
6INTERRUPTED这是INTERRUPTING的最终状态，中断状态

awaitDone方法

在这里插入图片描述
这段代码可以看出，方法内部维护了一个state状态，根据这个状态值判断操作。它里面有个循环，直到state达到一个最终态或者等待时间超时或者线程中断才会跳出循环，即拿到结果。

cancel方法

在这里插入图片描述
同样，cancel取消任务，首先也要对state状态进行判断，如果线程还没启动，那就直接返回false，如果可以中断线程，那就中断线程。

上面的状态说明表格中，最后的CANCELLED与INTERRUPTING状态都是调用cancel（true）出现的

看了这两个方法，是不是很有印象，state+自旋，所以FutureTask也是基于ASQ模板来实现的。关于AQS的介绍可以查看我另一篇文章AQS——个人学习笔记

run方法

在这里插入图片描述
在它的核心run方法中，首先会先判断state状态，如果任务不是创建（NEW）状态或者通过自旋无法替换成当前线程，直接返回；接着就是通过callable的call方法来获得线程执行结果。（callable对象是通过FutureTask的构造函数获得的）；任务结束后需要将工作线程设置为null。

FutureTask使用样例

package com.example.demo.thread.future;

import java.util.concurrent.*;

/**
 * @author: sunzhinan
 * @create: 2020-07-21 00:01
 * @description: FutureTask测试类
 */
public class TestFutureTask {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        /*
         * 方法一
         */
        FutureTask<Integer> futureTask = new FutureTask<>(new MyCallable());
        //这里需要注意的是，将futuretask交由Thread其本意是创建一个线程来执行子任务
        //当然你也可以直接调用futuretask的run方法，那么执行这个任务的线程就是主线程
        Thread thread = new Thread(futureTask,"线程1");
        thread.start();

        System.out.println("开始调用get方法");
        System.out.println(futureTask.get());
        System.out.println("调用get方法结束");


        /*
         * 方法二
         */
        System.out.println("----通过线程池----");
        FutureTask<Integer> task = new FutureTask<>(new MyCallable());
        ExecutorService executor = Executors.newFixedThreadPool(2);
        executor.submit(task);
        //注意这里是task来get
        System.out.println("future,我的执行结果为：" + task.get());
        executor.shutdown();

    }
}

实际场景应用

目前还没找到，如果以后有发现会进行补充。

CompletableFuture

简介

CompletableFutrue是JDK8后新加入的一个类，在介绍FutureTask的时候就说过，FutureTask取结果的时候会造成阻塞，虽然它提供了isDone方法来循环判断任务是否完成，但是它会消耗系统性能，所以我们不调用get方法就不知道任务什么时候能完成，可以取出结果。
而CompletableFuture就解决了上诉阻塞这个缺点，在任务完成时，需要用到结果时，无需等待，可以将处理结果交给另一个处理线程来处理。

使用示例

package com.example.demo.thread.threadpool;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

/**
 * @author: sunzhinan
 * @create: 2020-05-24 15:45
 * @description: CompletableFuture
 */
public class TestCompletableFuture {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //通过看supplyAsync方法还有一个两个参数的supplyAsync(Supplier<U> supplier,Executor executor)
        //然后通过源码可以看出，其实supplyAsync会将参数一任务交给它默认的ForkJoinPool线程池执行。
        //同时你也可以通过第二个参数指定一个线程池
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(()->{
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("执行任务");
            return 20;
        });

        //CompletableFuture也有get方法和FutureTask一样都会造成阻塞
        //System.out.println(future.get());

        //thenAccept没有返回值，也就是说拿到CompletableFuture执行结果后再进行处理，不需要返回什么
        System.out.println("------thenAccept start------");
        future.thenAccept((i)->{
            System.out.println("------------");
            System.out.println(i);
        });
        System.out.println("------thenAccept end------");
        
        //thenApply有返回值，也就是说拿到CompletableFuture执行结果后再进行处理，可以再获得结果再返回
        System.out.println("------thenApply start------");
        CompletableFuture<String> cFuture = future.thenApply((i)->{
            System.out.println("------------");
            System.out.println(i);
            return "222";
        });
        System.out.println("------thenApply end------");

        //上面的thenAccept和thenApply方法都有对应的Async异步操作，也即是thenAcceptAsync和thenApplyAsync
        //同样，他们也是将任务交给线程池执行，你也可以指定线程池

        //这里一定要加上，因为主线程不能结束，如果主线程（理解为初始化CompletableFuture的线程）结束，
        //则CompletableFuture使用的线程池会立刻关闭
        System.out.println("让主线程等待");
        TimeUnit.SECONDS.sleep(10);
        System.out.println("cFuture : " + cFuture.get());
        System.out.println("------OK------");
    }
}

常见方法说明

通过阅读源码，发现CompletableFuture还有很多方法，这里我整理了一下：

方法参数说明
runAsyncrunAsync(Runnable runnable)，runAsync(Runnable runnable,Executor executor)runAsync方法不支持返回值
supplyAsyncsupplyAsync(Supplier< U > supplier)，supplyAsync(Supplier< U > supplier, Executor executor)supplyAsync可以支持返回值
thenApplythenApply( Function<? super T,? extends U> fn)将任务串行，下一个任务需要等待上一个执行任务的线程执行完毕
thenApplyAsyncthenApplyAsync(Function<? super T,? extends U> fn)，thenApplyAsync(Function<? super T,? extends U> fn, Executor executor)等上一个任务执行完毕后可以使用线程池中的空闲的线程执行此任务
thenAcceptthenAccept(Consumer<? super T> action)用于获得任务处理的结果
thenAcceptAsyncthenAcceptAsync(Consumer<? super T> action)，thenAcceptAsync(Consumer<? super T> action, Executor executor)使用空闲线程来获得任务处理的结果
thenRunthenRun(Runnable action)与thenAccept的区别是不关心结果，它同样有Async异步的方法
whenCompletewhenComplete(BiConsumer<? super T, ? super Throwable> action)执行之前任务的线程继续执行 whenComplete 的任务
whenCompleteAsyncwhenCompleteAsync( BiConsumer<? super T, ? super Throwable> action)，whenCompleteAsync( BiConsumer<? super T, ? super Throwable> action, Executor executor)使用其他线程执行whenCompleteAsync的任务
handlehandle( BiFunction<? super T, Throwable, ? extends U> fn)与whenComplete有返回和无返回的区别
handleAsynchandleAsync(BiFunction<? super T, Throwable, ? extends U> fn)，handleAsync(BiFunction<? super T, Throwable, ? extends U> fn, Executor executor)与whenCompleteAsync有返回和无返回的区别
anyOfanyOf(CompletableFuture<?>… cfs)CompletableFuture任务哪个先执行完毕获得哪个结果
thenCombinethenCombine(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn)将两个CompletableFuture任务结果处理返回
thenCombineAsyncthenCombineAsync(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn)等与thenCombine不同的是会使用线程池中的空闲线程处理事件
thenAcceptBoththenAcceptBoth(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action)与thenCombine区别是没有返回值
thenAcceptBothAsyncthenAcceptBothAsync(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action)与thenCombineAsync区别是没有返回值

这里我先列举上述的这些方法，除此之外还有：thenCompose，runAfterBoth，runAfterEither ，
acceptEither ，applyToEither 等方法。这些方法其实大多数差不多，有兴趣的同学可以去编写代码试
试，下面就是我写的一些方法示例，可做参考。

thenApply与thenApplyAsync

package com.example.demo.thread.completableFuture;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

/**
 * @author: sunzhinan
 * @create: 2020-05-24 16:49
 * @description: CompletableFuture
 */
public class TestCompletableFuture01 {

    public static void main(String[] args) throws InterruptedException {

        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(()->{

            System.out.println(" future1 开始执行, 当前线程：" + Thread.currentThread().getName());
            System.out.println("开始获得商品");
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("获得商品结束");
            return "aaa";
        });

        CompletableFuture<Double> future2 = future1.thenApplyAsync((name)->{

            System.out.println(" future2 开始执行 , 当前线程：" + Thread.currentThread().getName());
            System.out.println("商品是： " + name);
            System.out.println("开始获得价格");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("获得价格结束");
            return 2.5;
        });

        CompletableFuture<Integer> future3 = future2.thenApplyAsync((price)->{

            System.out.println(" future3 开始执行, 当前线程：" + Thread.currentThread().getName());
            System.out.println("3: 商品价格是： " + price);
            System.out.println("开始获得热度");
            try {
                TimeUnit.SECONDS.sleep(7);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("获得热度结束");
            return 22500;
        });

        CompletableFuture<String> future4 = future2.thenApplyAsync((price)->{

            System.out.println(" future4 开始执行, 当前线程：" + Thread.currentThread().getName());
            System.out.println("4: 商品价格是： " + price);
            System.out.println("开始获得评论");
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("获得评论结束");
            return "OK";
        });

        CompletableFuture<Integer> future5 = future2.thenApply((price)->{

            System.out.println(" future5 开始执行, 当前线程：" + Thread.currentThread().getName());
            System.out.println("5: 商品价格是： " + price);
            System.out.println("开始获得销量");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("获得销量结束");
            return 500;
        });

        CompletableFuture<Integer> future6 = future5.thenApplyAsync((num)->{

            System.out.println(" future6 开始执行, 当前线程：" + Thread.currentThread().getName());
            System.out.println("6: 商品销量是： " + num);
            System.out.println("开始获得人气");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("获得人气结束");
            return 1000;
        });

        future3.thenAccept((result)-> System.out.println("result3 : " + result));

        future4.thenAccept((result)-> System.out.println("result4 : " + result));

        //如果使用thenAcceptAsync你可以发现比thenAccept多了一个线程
//        future5.thenAcceptAsync((result)-> System.out.println("result5 : " + result));
        future5.thenAccept((result)-> System.out.println("result6 : " + result));

        future6.thenAccept((result)-> System.out.println("result6 : " + result));
        //thenRun不关心结果
//        future6.thenRun(() -> System.out.println("result6 :"));

        System.out.println("让主线程等待");
        TimeUnit.SECONDS.sleep(30);
        System.out.println("------OK------");
    }
}

anyOf

package com.example.demo.thread.completableFuture;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

/**
 * @author: sunzhinan
 * @create: 2020-05-24 17:06
 * @description: CompletableFuture 并行
 */
public class TestCompletableFuture02 {

    public static void main(String[] args) throws InterruptedException {

        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(()->{
            System.out.println("开始获得商品1");
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("获得商品1结束");
            return "aaa";
        });

        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(()->{
            System.out.println("开始获得商品2");
            try {
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("获得商品2结束");
            return "bbb";
        });

        CompletableFuture<String> future3 = CompletableFuture.supplyAsync(()->{
            System.out.println("开始获得商品3");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("获得商品3结束");
            return "bbb";
        });

        // 用anyOf合并
        CompletableFuture<Object> nameFuture = CompletableFuture.anyOf(future1, future2,future3);

        nameFuture.thenAccept((result) -> {
            System.out.println("------name------");
            System.out.println("name: " + result);
            System.out.println("------name------");
        });

        // 两个CompletableFuture执行异步查询:
        CompletableFuture<Double> dFuture1 = nameFuture.thenApplyAsync((price) -> {
            System.out.println("开始获得价格1");
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("获得价格1结束");
            return 3.5;
        });
        CompletableFuture<Double> dFuture2 = nameFuture.thenApplyAsync((price) -> {
            System.out.println("开始获得价格2");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("获得价格2结束");
            return 2.6;
        });

        //合并
        CompletableFuture<Object> priceFuture = CompletableFuture.anyOf(dFuture1, dFuture2);

        priceFuture.thenAccept((result) -> {
            System.out.println("------price------");
            System.out.println("price: " + result);
            System.out.println("------price------");
        });

        System.out.println("让主线程等待");
        TimeUnit.SECONDS.sleep(15);
        System.out.println("------OK------");
    }
}

whenComplete与whenCompleteAsync

package com.example.demo.thread.completableFuture;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

/**
 * @author: sunzhinan
 * @create: 2020-07-22 22:34
 * @description: whenComplete
 */
public class TestCompletableFuture03 {

    public static void main(String[] args) throws InterruptedException {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(()->{
            System.out.println("future1 开始执行,当前线程是： " + Thread.currentThread().getName());
            try {
                //处理
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("future1 执行结束");
            return 100;
        });

        //位置1--
        CompletableFuture<Integer> future2 = future1.whenComplete((a,throwable) ->{
            System.out.println(" future1 的执行结果是 ：" + a);
            System.out.println("future2 开始执行,当前线程是： " + Thread.currentThread().getName());
            try {
                //处理
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("future2 执行结束");
        });
        //位置1--

        //位置2--
        CompletableFuture<Integer> future3 = future1.whenCompleteAsync((a,throwable) ->{
            System.out.println(" future1 的执行结果是 ：" + a);
            System.out.println("future3 开始执行,当前线程是： " + Thread.currentThread().getName());
            try {
                //处理
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("future3 执行结束");
        });
        //位置2--

        CompletableFuture<Integer> future4 = future1.whenComplete((a,throwable) ->{
            System.out.println(" future1 的执行结果是 ：" + a);
            System.out.println("future4 开始执行,当前线程是： " + Thread.currentThread().getName());
            try {
                //处理
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("future4 执行结束");
        });

        CompletableFuture<Integer> future5 = future1.whenComplete((a,throwable) ->{
            System.out.println(" future1 的执行结果是 ：" + a);
            System.out.println("future5 开始执行,当前线程是： " + Thread.currentThread().getName());
            try {
                //处理
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("future5 执行结束");

        });

        future1.thenAccept((result)-> System.out.println("result1 : " + result));
        future2.thenAccept((result)-> System.out.println("result2 : " + result));
        future3.thenAccept((result)-> System.out.println("result3 : " + result));
        future4.thenAccept((result)-> System.out.println("result4 : " + result));
        future5.thenAccept((result)-> System.out.println("result5 : " + result));

        System.out.println("让主线程等待");
        TimeUnit.SECONDS.sleep(8);
        System.out.println("------OK------");

        /**
         * 结果：
         * future1 开始执行,当前线程是： ForkJoinPool.commonPool-worker-1
         * 让主线程等待
         * future1 执行结束
         * result1 : 100
         *  future1 的执行结果是 ：100
         * future5 开始执行,当前线程是： ForkJoinPool.commonPool-worker-1
         * future5 执行结束
         * result5 : 100
         *  future1 的执行结果是 ：100
         * future4 开始执行,当前线程是： ForkJoinPool.commonPool-worker-1
         * future4 执行结束
         * result4 : 100
         *  future1 的执行结果是 ：100
         * future2 开始执行,当前线程是： ForkJoinPool.commonPool-worker-1
         *  future1 的执行结果是 ：100
         * future3 开始执行,当前线程是： ForkJoinPool.commonPool-worker-2
         * future2 执行结束
         * future3 执行结束
         * result2 : 100
         * result3 : 100
         * ------OK------
         * 从上述结果可以看出，执行whenComplete任务的线程是之前执行future所使用的线程，
         * 同时后面的whenComplete会在之前的whenComplete先执行，
         * whenCompleteAsync会等所有whenComplete执行完毕再执行，这个whenCompleteAsync的位置没有关系
         * 既：位置1和位置2的代码对换，其执行结果没有变化
         * 参数：throwable 异常
         */
    }
}

thenCombine与thenAcceptBoth

package com.example.demo.thread.completableFuture;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
import java.util.function.BiFunction;

/**
 * @author: sunzhinan
 * @create: 2020-07-22 23:14
 * @description: 合并
 */
public class TestCompletableFuture04 {

    public static void main(String[] args) throws InterruptedException {
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(()->{
            System.out.println("开始获得商品1");
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("获得商品1结束");
            return "aaa";
        });

        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(()->{
            System.out.println("开始获得商品2");
            try {
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("获得商品2结束");
            return "bbb";
        });

        CompletableFuture<String> future3 = future1.thenCombine(future2,(a,c)-> {
            System.out.println("当前线程： " + Thread.currentThread().getName());
            return a+c;
        });

        CompletableFuture<String> future4 = future1.thenCombineAsync(future2,(a,c)-> {
            System.out.println("当前线程： " + Thread.currentThread().getName());
            return a+"   "+c;
        });

       future1.thenAcceptBoth(future2,(a, c)-> {
           System.out.println("a : " + a);
           System.out.println("c : " + c);
           System.out.println("当前线程： " + Thread.currentThread().getName());
        });

        future3.thenAccept((result)->System.out.println("result3 : " + result));
        future4.thenAccept((result)->System.out.println("result4 : " + result));

        System.out.println("让主线程等待");
        TimeUnit.SECONDS.sleep(8);
        System.out.println("------OK------");
    }
}
勿白头空悲切
关注
专栏目录
Java并发编程（一）—— FutureTask超详细教程
gmHappy
12-17 430
Java并发编程—— FutureTask超详细教程（源码分析）
Java并发编程（6）—— Java 多线程的返回对象和资源独享线程
shangjg3的博客
11-05 187
使用 Callable 接口的限制是：其只能使用线程池提交，而不能使用单独的线程进行提交。此时通过 ExecutorService.submit() 进行提交，得到的是一个 Future 对象，它包含了线程的执行结果，当你调用其 get() 方法时，它会阻塞直至获取到线程的返回结果。ThreadLocal 是以增加资源的方式来避免竞态，它会为每一个线程创建一份私有的资源，从而避免对公共资源的竞争。1.3.4 组合多个 CompletableFuture。1. 多线程的返回对象-1.3.1 等待唤醒。
Delphi中多线程同步过程Synchronize的一些说明
热门推荐
gogogo的专栏
08-21 2万+
在windows原生应用程序开发中，经常伴随多线程的使用，多线程开发很简单，难点就是在于线程的同步，在Delphi中提供了VC中不具备的一个过程Synchronize，使用起来非常方便，解决了很多VC开发中碰到的常见问题，但是在看了很多Delphi代码后，发现很多人对于Synchronize的理解还是有问题的，不能很好地正确使用Synchronize过程，本文对Synchronize过程的使用提出
delphi vcl线程同步synchronize
09-21
delphi vcl线程同步synchronize
FutureTask详解
最新发布
落日的博客
08-05 1256
接口功能描述主要方法/特点适用场景Runnable定义要执行的任务，无返回值run()用于执行不需要结果的任务，如线程的任务Callable定义要执行的任务，有返回值，并可能抛出异常call()用于执行有返回值的任务Future管理异步计算的结果，检查状态和处理异常get()cancel()isDone()用于管理异步任务的结果和状态结合Runnable和Future的功能，可以执行任务并管理结果继承Runnable和Future用于需要同时支持Runnable和Future功能的场景，如。
Delphi：与VCL同步（Synchronize()、用消息来同步）
weixin_30512043的博客
05-15 601
看本文时，可以同时参考:Delphi中线程类 TThread实现多线程编程（事件、临界区、Synchronize、WaitFor……） 先说一下RTL和VCL 　　RTL（Run-Time library），运行时库，包括System、SysUtils、Math三个单元，提供的函数与语言、编译器、操作系统及进程有关 　　RTL提供类之间继承于 TObject 和 RTL内部的类 　　...
delphi中线程应用之Synchronize
weixin_30527323的博客
12-23 150
当一个线程在使用时，如果这个函数使用了Synchronize修钸的话就不允许别一个线程来调用这个函数，它的目的是避免多个子线程同时访问主线程资源。示例：procedure TTaskThread.ShowSuccess; begin frmMain.Memo1.Lines.Append('操作成功'); //操作主线程资源 end; procedur...
delphi.thread.同步
weixin_30386713的博客
11-07 157
注意：此文只是讲线程间的同步，其它同步不涉及。 线程同步是个好话题，因为写线程经常会遇到，所以就写写自己知道的东西。 D里面，同步（特指线程同步）从线程的角度来分，有几种情况： 　　1：主线程与工作线程的同步 　　2：工作线程与主线程的同步 　　3：工作线程之间的同步。 同步，嗯，直白点讲，或可以说成是：A线程怎么通知B线程去做某某事，或者说某事需要：如何控制某一时间段内，A能...
多线程文章目录
01-21
Java多线程①——线程知识梳理 有助于新手初步了解线程相关的知识同时加深对基础的理解。 了解线程的状态、常用方法以及Thread、Runnable、Callable、Future、FutureTask这些基础概念和简单应用。 Java多线程②——...
Java中的多线程机制
swimming_in_IT_的博客
08-10 1631
对于线程的理解一直有限，最近回看下线程，然后自己做个详细的记录吧！ 一 线程和进程的区别 进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1--n个线程。 线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小。 线程和进程一样分为五个阶段：创建、就绪、运行、阻塞、终止。 多进程是指操作系统能同时运行多
Java多线程和并发编程面试题和参考答案100多道（持续更新）
大模型大数据攻城狮的专栏
05-20 209
守护线程（Daemon Thread）是一种特殊的线程，它在执行时不会阻止JVM的退出。当所有的非守护线程都结束运行时，JVM会自动退出，即使守护线程还在运行。守护线程主要用于执行一些后台任务，如垃圾回收、监控等。用途举例垃圾回收线程：JVM内部的垃圾回收线程就是一个典型的守护线程，它负责监控对象的使用情况，并在适当的时候回收不再使用的对象，释放内存资源。日志记录线程。
Delphi中多线程用Synchronize实现VCL数据同步显示
程序点滴
05-12 1万+
Delphi中多线程用Synchronize实现VCL数据同步显示Lanno Ckeeke 2006-5-12概述：       VCL实现同步的另一种方法就是调用线程类的Synchronize的过程，此过程需要一个无参数的procedure，故在此procedure中无法传递参数值，但可以通过类的成员来实现。在类的Execute中只须调用Synchronize就可以了。实
delphi TThread线程同步
10-07 960
//线程 TThread.CreateAnonymousThread(       procedure     begin      //内容      end //此处无分号   ).Start; //同步   TThread.Synchronize(nil,     procedure     begin    //     end);...
delphi中Synchronize
互联网产品管理、交互、设计、开发、用户体验专栏
06-01 7530
<br />delphi中Synchronize这个东东有什么用？我知道是线程同步使用的<br />是否是一个函数或变量，当一个线程在使用时，如果这个函数使用了Synchronize修钸的话就不允许别一个线程来调用这个函数 <br /> <br />1楼：别的线程会等待该操作完成后才能继续 <br />2楼：你说的基本是这个意思。它的目的是避免多个子线程同时访问主线程资源。 <br />示例： <br />procedure ServerThread.ListItemEnd; //子线程的一个方法 <br
delphi 线程同步的基本方法
chinajobs的专栏
05-23 2003
上次跟大家分享了线程的标准代码，其实在线程的使用中最重要的是线程的同步问题，如果你在使用线程后，发现你的界面经常被卡死，或者无法显示出来，显示混乱，你的使用的变量值老是不按预想的变化，结果往往出乎意料，那么你很有可能是忽略了线程同步的问题。 当有多个线程的时候，经常需要去同步这些线程以访问同一个数据或资源。例如，假设有一个程序，其中一个线程用于把文件读到内存，而另一个线程用于统计文件中的字符
Synchronization in Delphi TThread class : Synchronize, Queue
weixin_34268843的博客
10-02 222
http://embarcadero.newsgroups.archived.at/public.delphi.rtl/201112/1112035763.html &gt; Hi,&gt;&gt; What is the difference between these two definitions:&gt;&gt;  TThreadMethod = procedure of object;...
TThread.Synchronize同步方法及弊端
rabbitsaviola' Blog
03-04 6847
In effect it borrows time from the main VCL thread to do this. This doesnt work arbitrarily between threads. If you have two non-VCL threads, X and Y, you cant call synchronize in X alone and then m
Delphi中多线程中Synchronize的运用
三岔路口，每一条路都有自己的精彩......
09-22 1万+
Delphi中多线程用Synchronize实现VCL数据同步显示,Delphi中多线程用Synchronize实现VCL数据同步显示转自:http://blog.csdn.net/maxcode/archive/2006/05/12/726766.aspx概述：        VCL实现同步的另一种方法就是调用线程类的Synchronize的过程，此过程需要一个无参数的procedure，故
Delphi中线程类TThread实现多线程编程2---事件、临界区、Synchronize、WaitFor……
weixin_30809173的博客
04-23 464
　　接着上文介绍TThread。 　　现在开始说明 Synchronize和WaitFor 　　但是在介绍这两个函数之前，需要先介绍另外两个线程同步技术：事件和临界区 事件（Event） 　　事件（Event）与Delphi中的事件有所不同。从本质上讲，Event其实就相当于一个全局的布尔变量。它有两个赋值操作：Set和ReSet，相当于把它设置为 True或False。而检查它的值是通过...
Java多线程：Future、FutureTask与CompletableFuture及ThreadLocal解析
文档主要介绍了Future、FutureTask和CompletableFuture这三个与Java多线程返回对象相关的概念，以及ThreadLocal在资源独享线程中的应用。" 在Java多线程编程中，处理线程的返回值是一项挑战。通常，直接使用`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值