Java并发编程

Java并发编程的艺术—— 一本系统全面的Java并发编程书籍 作者:禅与计算机程序设计艺术 1.背景介绍 什么是Java并发编程? 在过去的几十年里,由于计算机的性能的增长和分布式计算的普及,使得多核CPU和服务器的普及,同时也带来了一种编程模式:并行编程。 对于并行编程来说,无论是在单核CPU还是多核CP 阅读详情

在Java并发编程中,通过代码示例可以更直观地理解线程管理、同步机制和并发工具类的使用。以下是一些常见的Java并发编程示例,涵盖线程创建、同步控制、线程池、并发工具类等关键概念。

线程创建与启动

Java中创建线程的两种主要方式是继承Thread类和实现Runnable接口。这两种方式都可以用于定义线程任务并启动执行。

// 继承Thread类
public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("线程运行中: " + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        new MyThread().start();
    }
}
// 实现Runnable接口
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("线程运行中: " + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        new Thread(new MyRunnable()).start();
    }
}

线程池是一种更高效的线程管理方式,适用于并发任务较多的场景。Java提供了ExecutorService来简化线程池的使用。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            executorService.execute(() -> {
                System.out.println("任务执行中: " + Thread.currentThread().getName());
            });
        }
        executorService.shutdown();
    }
}

线程同步机制

在多线程环境下,多个线程可能同时访问共享资源,这可能导致数据不一致。Java提供了synchronized关键字和ReentrantLock来实现线程同步。

// 使用 synchronized 关键字
public class SynchronizedExample {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public static void main(String[] args) throws InterruptedException {
        SynchronizedExample example = new SynchronizedExample();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println("最终计数值: " + example.count);
    }
}
// 使用 ReentrantLock
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {
    private int count = 0;
    private Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ReentrantLockExample example = new ReentrantLockExample();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println("最终计数值: " + example.count);
    }
}

使用Condition实现线程协作

Condition接口与ReentrantLock结合使用,可以实现线程间的等待/通知机制,比传统的wait()和notify()更加灵活。

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ConditionExample {
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    private boolean flag = false;

    public void await() throws InterruptedException {
        lock.lock();
        try {
            while (!flag) {
                condition.await();
            }
            System.out.println("等待结束");
        } finally {
            lock.unlock();
        }
    }

    public void signal() {
        lock.lock();
        try {
            flag = true;
            condition.signal();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ConditionExample example = new ConditionExample();
        Thread t1 = new Thread(() -> {
            try {
                example.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        t1.start();

        Thread.sleep(2000);
        example.signal();
    }
}

使用CountDownLatch实现线程等待

CountDownLatch是一种同步工具类,它允许一个或多个线程等待其他线程完成操作。它通过计数器来控制线程的阻塞与释放。

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    public static void main(String[] args) throws InterruptedException {
        int threadCount = 3;
        CountDownLatch latch = new CountDownLatch(threadCount);

        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                System.out.println("线程 " + Thread.currentThread().getName() + " 完成任务");
                latch.countDown();
            }).start();
        }

        latch.await();
        System.out.println("所有线程任务已完成");
    }
}

使用CyclicBarrier实现线程阶段性同步

CyclicBarrier用于协调多个线程在某个屏障点汇合,所有线程必须到达屏障后才能继续执行。适用于并行计算中的阶段性任务同步。

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierExample {
    public static void main(String[] args) {
        int parties = 3;
        CyclicBarrier barrier = new CyclicBarrier(parties, () -> {
            System.out.println("所有线程已到达屏障点");
        });

        for (int i = 0; i < parties; i++) {
            new Thread(() -> {
                try {
                    System.out.println("线程 " + Thread.currentThread().getName() + " 到达屏障");
                    barrier.await();
                    System.out.println("线程 " + Thread.currentThread().getName() + " 继续执行");
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

使用Future和Callable实现异步计算

Callable接口与Future结合使用,可以实现带有返回值的异步任务执行。

import java.util.concurrent.*;

public class FutureExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<Integer> future = executor.submit(() -> {
            Thread.sleep(1000);
            return 42;
        });

        System.out.println("任务执行中...");
        System.out.println("任务结果: " + future.get());
        executor.shutdown();
    }
}

使用CompletableFuture实现异步编程

CompletableFuture是Java 8引入的异步编程工具,支持链式调用和组合多个异步任务。

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            return "Hello";
        }).thenApply(s -> s + " World");

        System.out.println(future.get());
    }
}

思维导图

Java并发

java 多线程并发实例 代码里面包含一个并发4个线程同时运行 全部开始 全部停止 单个停止还有点问题。 还有生产者消费者 里面的里面能帮助你理解多线程的运用! 立即下载

相关推荐

Silly Tavern(酒馆)AI 角色扮演下载与安装教程(Windows本地部署)

SillyTavern是一款开源AI角色扮演前端工具,支持沉浸式对话和长期角色互动。本文详细介绍了在Windows系统F盘部署SillyTavern的完整流程,包括下载项目、安装Node.js和Git环境、配置路径、启动服务等关键步骤,并特别说明非系统盘路径可能遇到的npm安装问题及解决方法。成功启动后,用户可通过浏览器访问本地地址使用该工具进行AI角色扮演互动。

Tan3851的博客 1万+

Java之并发编程

并行:在同一个时间节点上,同时发生(是真正意义上的同时执行)并发:在一段时间内,对某个事情交替执行并发编程:在例如抢票,抢购,秒杀等等场景下,有大量的请求访问同一个资源。会出现线程安全的问题,所以需要通过编程来控制解决让多个线程依次访问资源,称为并发编程。抽象同步队列是JUC其它锁实现的基础。思路:​ 在类中维护一个state变量,然后还维护一个队列,以及获取锁,释放锁的方法。​ 当线程创建后,先判断state的值,如果为0,没有线程使用,state = 1,执行完成后,再将state = 0。

m0_62254872的博客 2369

手把手教你配置MAX96712解串器:从I2C地址分配到PWM帧同步

本文详细解析了MAX96712解串器在自动驾驶视觉链路中的核心配置流程。从I2C地址分配、GMSL2数据流映射到实现多摄像头精准同步的PWM帧同步触发,手把手指导工程师构建高可靠性的图像传输系统,并提供了实用的Linux调试技巧与问题排查思路。

weixin_29297127的博客 929

Java 并发编程

线程创建、线程方法、线程同步、线程池、线程状态

We choose to go to the moon in this decade and do the other things, not because they are easy, but beacase they are hard. 3413

iOS反编译-hook微信之艾特所有人

all。

2501_90243249的博客 761

Dify 1.1.3部署避坑指南:用wait-for-it.sh解决PostgreSQL初始化失败问题

本文详细解析了Dify 1.1.3部署中遇到的插件数据库初始化失败问题,并提供了使用wait-for-it.sh脚本的实战解决方案。通过剖析Docker Compose服务依赖管理的局限性,指导用户如何改造镜像与配置,确保服务按正确顺序启动,从而有效解决数据库连接失败等部署难题。

wdx012345的博客 1004

Java的异常处理、注解、Lambda表达式、流式API 、并发编程示例

Java 中的注解是一种元数据,它提供了在源代码中添加元数据的方式,可以帮助开发者在代码中添加一些附加信息。在上面的代码中,我们使用了 Lambda 表达式来遍历集合和计算集合中字符串的长度之和。线程池是一种重复利用线程的机制,它可以在程序启动时创建一定数量的线程,并将这些线程保存在一个池中,当需要执行任务时,从池中取出一个线程执行任务,执行完毕后将线程放回池中,等待下一次任务。流式 API 的主要特点是支持链式调用,可以通过一系列的操作来处理数据,并返回一个新的流,从而实现复杂的数据处理逻辑。

polsnet的专栏 1039

Nvivo12新手避坑指南:从安装到编码的完整流程(附实战案例)

本文为Nvivo12新手提供了从软件安装、初始设置到数据导入和编码分析的完整避坑指南。通过一个“校园欺凌现象的学生访谈研究”实战案例,详细拆解了处理中文文本、创建项目结构、执行手动编码及高级查询等关键步骤,帮助研究者避开常见错误,快速上手并高效完成质性数据分析。

resnet7explorer的博客 320

《Java并发编程的艺术》之 Java并发编程基础

《Java并发编程的艺术》之 Java并发编程基础 文章目录《Java并发编程的艺术》之 Java并发编程基础线程简介什么是线程代码清单4-1 MultiThread.java解析为什么要使用多线程更多的处理器核心更快的响应时间线程优先级代码清单4-2 Priority.java结果注意参数解析线程的状态注意Daemon线程注意注意启动和终止线程构造线程代码清单4-6 Thread.java启动线程注意理解中断代码清单4-7 Interrupted.java过期的suspend()、resume()和sto

weixin_44019182的博客 2496

用Python绘制DCA曲线详解及示例代码

在这篇文章中,我们将详细解释如何使用Python绘制DCA曲线,并提供示例代码。通过使用上述的示例代码和解释,你可以自己尝试不同的投资金额、期数和增长率来绘制自定义的DCA曲线。通过运行上述代码,我们将得到一个绘制了DCA曲线的图表。该图表将显示出DCA投资策略在给定投资金额、投资期数和增长率下的投资价值随时间的变化情况。在上述代码中,我们使用一个循环来计算每个投资期的DCA曲线值。现在,我们可以使用上述函数来计算DCA曲线的值,并将其绘制成图表。最后,我们返回计算得到的DCA曲线值列表。

TechPr的博客 1411

CloudCompare 二次开发(17)——点云添加均匀分布的随机噪声

使用CloudCompare编程实现点云添加随机噪声。

点云侠的博客 840

【Java并发编程 零】Java并发编程看这一篇就够了

本篇Blog为接下来的Java并发编程精华版本,重点知识,如果某个知识点不理解,可以再深入的看本专栏中的其它Blog内容介绍。为了突出重点,本篇Blog以问答的形式展示,将所有的知识点进行串联。 ...

MaoLin Tian's Blog 1094

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

【Java 并发编程】详解

在并发编程中,使用普通的集合类(如 ArrayList、HashMap 等)往往会出现线程安全问题,因为它们在设计时并没有考虑多线程并发访问的情况。Java 提供了一系列并发容器来解决这个问题,这些并发容器在保证高效性能的同时,能够支持多线程安全地进行读写等操作。

架构师之路 1124

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

【免费下载】 探索Java并发编程的奥秘:《JAVA并发编程艺术》高清PDF下载

探索Java并发编程的奥秘:《JAVA并发编程艺术》高清PDF下载 【下载地址】JAVA并发编程艺术高清PDF下载 本仓库提供了一份名为《JAVA并发编程艺术》的高清PDF文件下载。该资源详细介绍了Java并发编程的各个方面,涵盖了从基础概念到高级技术的全面内容 ...

gitblog_06678的博客 1199

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

java并发编程简介

最近看完《Java并发编程的艺术》一书,收获颇丰,在此写一下java并发编程的概要之类的文章,概述java并发编程的一些工具和原理。 《Java并发编程的艺术》和《java编程思想》大概内容差不多,《Java并发编程的艺术》多了些并发编程工具的原理介绍,介绍的比较深入。它里面讲的关于多核心的cpu如何进行多线程操作,线程之间的共享变量的可见性如何实现。顺序优化方面,介绍了java的编译器顺序优化、指令级优化、内存系统重排序,而为了结果的一致性,java编译器会进行插入内存屏障来限制java语句的顺序重排。然

qq_22744093的博客 3100

java书籍_java并发编程书籍推荐

java并发编程书籍推荐并发编程是我们程序员进阶必须掌握的技能,今天推荐两本书,非常适合学习并发编程(都是我自己看过的),都是阿里大佬写的,这两本书上的知识掌握了,可以说应对大厂的面试没有任何问题。java并发编程之美《Java并发编程之美》通过图文结合、通俗易懂的讲解方式帮助大家完成多线程并发编程从入门到实践的飞跃!《Java并发编程之美》分为三部分,第一部分为Java 并发编程基础篇,主要讲解...

weixin_39538962的博客 990

java并发编程

什么是java并发编程如何进行并发编程

m0_64021225的博客 1724

Java语言的并发编程

Java语言的并发编程通过线程、线程池、同步机制和高级并发工具,使得开发者能够方便地实现高效的并发控制。尽管并发编程能大幅提升计算性能,但同时也可能带来复杂性和潜在的错误,如竞态条件、死锁等。因此,在编写并发程序时,开发者需要对并发机制有深入的理解,并谨慎选择合适的工具和策略。通过本文的介绍,相信读者可以对Java并发编程有一个全面的认识,并能在实际项目中有效地运用这些知识,提高程序的性能和响应能力。无论是在日常小项目,还是大规模的分布式系统,掌握并发编程都是现代软件开发者不可或缺的一项技能。

2401_90032385的博客 977

Java 并发编程的艺术

内容简介 书中采用循序渐进的讲解方式,从并发编程的底层实现机制入手,逐步介绍了在设计 Java 并发程序时各种重要的技术、设计模式与应用,同时辅以丰富的示例代码,使得开发人员能够更快地领悟 Java 并发编程的要领,围绕着 Java 平台的基础并发功能快速地构建大规模的并发应用程序。 第1章介绍 Java 并发编程的挑战,会向读者说明可能会遇到哪些问题,以及如何解决。 第2章 Java 并发编程...

GitChat 2694

【JAVA】一文掌握Java并发编程

Java 开发中,并发编程属于相当重要的一个知识点,可以说,Java 的并发能力,是成就今日 Java 地位的因素之一。Java 的并发编程由浅入深实质上是包含 Java(API)层、JVM(虚拟机)层、内核(操作系统)层和 CPU 层。本文从原理上,由浅入深的解释 Java 并发原理。掌握并发原理,才能更好地使用 Java 并发编程!

一个天蝎座的程序猿 1043
上一篇: Java中Queue
下一篇: Java 虚拟机(JVM)
HuiSoul200
博客等级 码龄8年 274粉丝 82原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值