Java并发编程：Java线程(二)

最新推荐文章于 2024-10-10 15:01:58 发布
最新推荐文章于 2024-10-10 15:01:58 发布
阅读量119 收藏
点赞数
分类专栏： Java并发编程 文章标签： java 多线程 thread 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xylitolz/article/details/110881957
版权

文章目录

往期

1.Java并发编程：Java线程(一)

同步与异步

以调用方角度来讲，如果

  • 需要等待结果返回，才能继续运行就是同步
  • 不需要等待结果返回，就能继续运行就是异步

需要等待结果

这时既可以使用同步处理，也可以使用异步来处理

1. join实现(同步)

static int result = 0;
    private static void test1() throws InterruptedException {
        log.debug("开始");
        Thread t1 = new Thread(() -> {
            log.debug("开始");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.debug("结束");
            result = 10;
        }, "t1");
        t1.start();
        t1.join();
        log.debug("结果为:{}", result);
    }

输出

19:46:36.178 [main] DEBUG SyncAndAsync.TestSyncAndAsync - 开始
19:46:36.272 [t1] DEBUG SyncAndAsync.TestSyncAndAsync - 开始
19:46:37.294 [t1] DEBUG SyncAndAsync.TestSyncAndAsync - 结束
19:46:37.294 [main] DEBUG SyncAndAsync.TestSyncAndAsync - 结果为:10

评价

  • 需要外部共享变量，不符合面向对象封装的思想
  • 必须等待线程结束，不能配合线程池使用

2. Future实现(同步)

private static void test2() throws InterruptedException, ExecutionException {
    log.debug("开始");
    FutureTask<Integer> result = new FutureTask<>(() -> {
        log.debug("开始");
        Thread.sleep(1000);
        log.debug("结束");
        return 10;
    });
    new Thread(result, "t1").start();
    log.debug("结果为:{}", result.get());
}

输出

19:48:19.840 [main] DEBUG SyncAndAsync.TestSyncAndAsync - 开始
19:48:19.933 [t1] DEBUG SyncAndAsync.TestSyncAndAsync - 开始
19:48:20.934 [t1] DEBUG SyncAndAsync.TestSyncAndAsync - 结束
19:48:20.935 [main] DEBUG SyncAndAsync.TestSyncAndAsync - 结果为:10

评价

  • 规避了使用join之前的缺点
  • 可以方便配合线程池使用
private static void test3() throws ExecutionException, InterruptedException {
    ExecutorService service = Executors.newFixedThreadPool(1);
    log.debug("开始");
    Future<Integer> result = service.submit(()->{
        log.debug("开始");
        Thread.sleep(1000);
        log.debug("结束");
        return 10;
    });
    log.debug("结果：{},result的类型：{}",result.get(), result.getClass());
    service.shutdown();
}

输出

19:53:07.072 [main] DEBUG SyncAndAsync.TestSyncAndAsync - 开始
19:53:07.177 [pool-1-thread-1] DEBUG SyncAndAsync.TestSyncAndAsync - 开始
19:53:08.177 [pool-1-thread-1] DEBUG SyncAndAsync.TestSyncAndAsync - 结束
19:53:08.177 [main] DEBUG SyncAndAsync.TestSyncAndAsync - 结果：10,result的类型：class java.util.concurrent.FutureTask

评价

  • 仍然是main线程接收结果
  • get方法是让调用线程同步等待

3. 自定义实现-保护性暂停(同步)

  1. 定义

即 Guarded Suspension, 用在一个线程等待另一个线程的执行结果

要点

  • 有一个结果需要从一个线程传递到另一个线程，让他们关联同一个 GuardedObject
  • 如果有结果不断从一个线程到另一个线程那么可以使用消息队列（见生产者/消费者）
  • JDK中，join的实现、Future的实现，采用的就是此模式
  • 因为要等待另一方的结果，因此归类到同步模式

在这里插入图片描述

  1. 实现（带超时版）
class GuardedObject{
    // 结果
    private Object response;

    private static final Logger log = LoggerFactory.getLogger(GuardedObject.class);

    // 获取结果
    // timeout 表示要等待多久
    public Object getResponse(long timeout) throws InterruptedException {
        synchronized (this) {
            // 开始时间
            long begin = System.currentTimeMillis();
            // 经历时间
            long passedTime = 0;
            // 没有结果
            while (response == null) {
                long waitTime = timeout - passedTime;     // 这一轮循环应该等待的时间
                // 经历的时间超过了最大等待时间就退出循环
                if (waitTime <= 0) {
                    break;
                }
                this.wait(waitTime);
                passedTime = System.currentTimeMillis() - begin;
                log.debug("timePassed:{}, object is null {}", passedTime, response == null);
            }
            return response;
        }
    }

    // 产生结果
    public void setResponse(Object response) {
        synchronized (this) {
            // 给结果成员变量赋值
            this.response = response;
            this.notifyAll();
        }
    }
}

应用：一个线程等待另一个线程的执行结果

public class Downloader {
    public static List<String> download() throws IOException {
        HttpURLConnection connection = (HttpURLConnection) new URL("https://www.baidu.com/").openConnection();
        List<String> lines = new ArrayList<>();
        try (BufferedReader reader =
                new BufferedReader(new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF_8))) {
            String line;
            while ((line =reader.readLine()) != null) {
                lines.add(line);
            }
        }
        return lines;
    }
}

public static void main(String[] args) {
        test1();
}
public static void test1() {
    // t1等待t2 的下载结果
    final GuardedObject guardedObject = new GuardedObject();
    new Thread(()->{
        // 等待结果
        log.debug("等待结果");
        try {
            List<String> response = (List<String>)guardedObject.getResponse(2000);
            log.debug("结果大小：{}",response.size());
            //log.debug("{}",response);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    },"t1").start();

    new Thread(()->{
        log.debug("执行下载");
        try {
            List<String> list = Downloader.download();
            guardedObject.setResponse(list);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }, "t2").start();
}

执行结果

20:32:14.327 [t2] DEBUG Share.GuardedSuspension4_8.TestGuardSuspension - 执行下载
20:32:14.327 [t1] DEBUG Share.GuardedSuspension4_8.TestGuardSuspension - 等待结果
20:32:15.332 [t1] DEBUG Share.GuardedSuspension4_8.GuardedObject - timePassed:1000, object is null false
20:32:15.335 [t1] DEBUG Share.GuardedSuspension4_8.TestGuardSuspension - 结果大小：3

4. CompletableFuture实现(异步)

private static void test4() {
    // 进行计算的线程池
    ExecutorService computeService = Executors.newFixedThreadPool(1);
    // 接收结果的线程池
    ExecutorService resultService = Executors.newFixedThreadPool(1);
    log.debug("开始");
    CompletableFuture.supplyAsync(() -> {
        log.debug("开始");
        try {
        	Thread.sleep(1000);
        } catch (InterruptedException e) {
        	e.printStackTrace();
        }
        log.debug("结束");
        return 10;
    }, computeService).thenAcceptAsync((result) -> {
    	log.debug("结果为:{}", result);
    }, resultService);
}

输出

20:36:46.292 [main] DEBUG SyncAndAsync.TestSyncAndAsync - 开始
20:36:46.392 [pool-1-thread-1] DEBUG SyncAndAsync.TestSyncAndAsync - 开始
20:36:47.408 [pool-1-thread-1] DEBUG SyncAndAsync.TestSyncAndAsync - 结束
20:36:47.409 [pool-2-thread-1] DEBUG SyncAndAsync.TestSyncAndAsync - 结果为:10

评价

  • 可以让调用线程异步处理结果，实际是其他线程去同步等待
  • 可以方便地分离不同职责的线程池
  • 以任务为中心，而不是以线程为中心

5. BlockingQueue实现(异步)

private static void test5() {
    ExecutorService consumer = Executors.newFixedThreadPool(1);
    ExecutorService producer = Executors.newFixedThreadPool(1);
    SynchronousQueue<Integer> queue = new SynchronousQueue<>();
    log.debug("开始");
    producer.submit(()->{
        log.debug("开始");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.debug("结束");
        try {
            queue.put(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });
    consumer.submit(()->{
        Integer res = null;
        try {
            res = queue.take();
            log.debug("结果为：{}",res);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });
    consumer.shutdown();
    producer.shutdown();
}

输出结果

20:45:42.931 [main] DEBUG SyncAndAsync.TestSyncAndAsync - 开始
20:45:43.018 [pool-2-thread-1] DEBUG SyncAndAsync.TestSyncAndAsync - 开始
20:45:44.018 [pool-2-thread-1] DEBUG SyncAndAsync.TestSyncAndAsync - 结束
20:45:44.018 [pool-1-thread-1] DEBUG SyncAndAsync.TestSyncAndAsync - 结果为：10

不需要等待结果

Reference

全面深入学习java并发编程

xylitolz
关注
专栏目录
Java 并发编程：线程变量 ThreadLocal
栗筝i的博客
08-10 3412
即线程变量，是 Java 提供的用于实现线程本地变量的工具类。每个线程可以通过对象访问其专属的变量，避免了多线程环境下变量共享导致的数据不一致问题。通常情况下，我们创建的成员变量都是线程不安全的。因为他可能被多个线程同时修改，此变量对于多个线程之间彼此并不独立，是共享变量。而中填充的变量属于当前线程，该变量对其他线程而言是隔离的。Ps：ThreadLocal 很容易让人望文生义，想当然地认为是一个 “本地线程”。其实，
Java 并发从入门到精通
热门推荐
Umbrella Corporation
10-12 1万+
一、线程状态转换 新建（New） 可运行（Runnable） 阻塞（Blocking） 无限期等待（Waiting） 限期等待（Timed Waiting） 死亡（Terminated） 二、使用线程 实现 Runnable 接口 实现 Callable 接口 继承 Thread 类 实现接口 VS 继承 Thread 三、基础线程机制 Executor Daemon sleep...
java并发
qq_25412471的博客
07-17 567
力扣1293bfs超级经典题 记录一下 补充重点： 补充1 JMM（java内存模型不是jvm内存模型） 一定要区分好，JMM 仅仅是java内存模型，和jvm一点关系没有 **JMM：**屏蔽了各种硬件和操作系统的对内存访问差异，以实现让java程序在各种平台下都能达到一致的内存访问效果。用来解决由于多线程操作共享变量时，存在的原子性、可见性（缓存一致性）以及有序性问题。（就像我们想要保证可见性和有序，需要使用内存屏障，而不同平台内存屏障种类不同，例如x86架构只有一个stroeload屏障，因为x
整理—java并发
最新发布
kelvin的博客
10-10 1017
AQS是一个用于构建锁、同步器、协作工具类的工具类。AQS核心思想是，如果被请求的共享资源空闲，那么就将当前请求资源的线程设置为有效的工作线程，将共享资源设置为锁定状态；如果共享资源被占用，主要用CLH队列的变体，将暂时获取不到锁的线程加入到队列中。AQS是通过将每条请求共享资源的线程封装成一个节点来实现锁的分配。使用一个Volatile的int类型的成员变量来表示同步状态，通过内置的FIFO队列来完成资源获取的排队工作，通过CAS完成对State值的修改状态：state；
Java并发
weixin_34257076的博客
05-27 356
声明：Java并发的内容是自己阅读《Java并发编程实战》和《Java并发编程的艺术》整理来的。 个人网站 图文并茂请戳 思维导图下载请戳 目录 (1)基础概念 (2)线程 (3)锁 (4)同步器 (5)并发容器和框架 (6)Java并发工具类 (7)原子操作类 (8)Executor框架(执行机制) (9)其他 (一).基础概念 1...
Java并发编程：如何创建线程？
12-22
　二.Java中如何创建线程 　三.Java中如何创建进程 　一.Java中关于应用程序和进程相关的概念 　在Java中，一个应用程序对应着一个JVM实例（也有地方称为JVM进程），一般来说名字默认为java.exe或者javaw.exe...
Java并发编程示例(六)：等待线程执行终止
09-04
在Java并发编程中，等待线程执行终止是一个关键的概念，特别是在多线程环境中需要确保某个任务完成后才能继续执行后续操作的场景。本示例（Java并发编程示例六）通过一个具体的程序展示了如何使用`Thread.join()`...
JAVA并发
hsw815773943的博客
06-20 267
Synchronized的并发策略是悲观的，不管是否产生竞争，任何数据的操作都必须加锁。乐观锁的核心是CAS，CAS包括内存值、预期值、新值，只有当内存值等于预期值时，才会将内存值修改为新值。（1）锁消除：降低性能损耗锁消除就是虚拟机根据一个对象是否真正存在同步情况，若不存在同步情况，则该对象的访问无需经过加锁解锁的操作。比如StringBuffer的append方法，因为append方法需要判断对象是否被占用，而如果代码不存在锁竞争，那么这部分的性能消耗是无意义的。
Java并发编程：深入理解线程同步与临界区
如果你对Java并发编程感兴趣，特别是线程同步部分，强烈建议回顾前两篇文章《java并发编程专题（一）----线程基础知识》和《java并发编程专题（二）----如何创建并运行java线程》，以建立起完整的知识体系。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

xylitolz

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

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

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

打赏作者

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

抵扣说明：

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

余额充值