Java多线程编程与并发处理

引言

在现代编程中,多线程和并发处理是提高程序运行效率和资源利用率的重要方法。Java提供了丰富的多线程编程支持,包括线程的创建与生命周期管理、线程同步与锁机制、并发库和高级并发工具等。本文将详细介绍这些内容,并通过表格进行总结和示范。

线程的创建与生命周期

使用Thread类

可以通过继承Thread类来创建线程,并重写其run方法。

public class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running.");
    }

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
}

使用Runnable接口

实现Runnable接口并将其实例传递给Thread对象也是创建线程的一种方式。

public class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Runnable is running.");
    }

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

使用线程池

使用ExecutorService可以创建和管理线程池。

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

public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 10; i++) {
            Runnable worker = new MyRunnable();
            executor.execute(worker);
        }
        executor.shutdown();
    }
}

线程的生命周期

线程有以下几种状态:

  • 新建(New)
  • 就绪(Runnable)
  • 运行(Running)
  • 等待/阻塞/休眠(Waiting/Blocked/Sleeping)
  • 终止(Terminated)

线程同步与锁机制

同步方法

使用sychronized关键字可以同步方法,确保同一时刻只有一个线程可以访问该方法。

public class SynchronizedExample {
    private int count = 0;

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

    public static void main(String[] args) {
        SynchronizedExample example = new SynchronizedExample();
        example.increment();
    }
}

同步块

同步块使用sychronized关键字包围代码块,比同步方法更加灵活。

public class SynchronizedBlockExample {
    private int count = 0;
    private final Object lock = new Object();

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

    public static void main(String[] args) {
        SynchronizedBlockExample example = new SynchronizedBlockExample();
        example.increment();
    }
}

ReentrantLock

ReentrantLock提供了更加灵活的锁机制。

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

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

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

    public static void main(String[] args) {
        ReentrantLockExample example = new ReentrantLockExample();
        example.increment();
    }
}

并发库

Executor框架

Executor框架是Java并发库的核心部分,简化了并发任务的执行。

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

public class ExecutorExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);

        for (int i = 0; i < 5; i++) {
            executor.submit(() -> {
                System.out.println(Thread.currentThread().getName() + " is executing task.");
            });
        }

        executor.shutdown();
    }
}

Future和Callable

Callable接口表示一个可以返回结果的任务,Future接口表示异步计算的结果。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class FutureCallableExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();

        Callable<Integer> task = () -> {
            Thread.sleep(2000);
            return 123;
        };

        Future<Integer> future = executor.submit(task);

        try {
            System.out.println("Result: " + future.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();
        }
    }
}

高级并发工具

CountDownLatch

CountDownLatch允许一个或多个线程等待,直到其他线程完成一组操作。

import java.util.concurrent.CountDownLatch;

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

        for (int i = 0; i < count; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + " is running.");
                latch.countDown();
            }).start();
        }

        latch.await();
        System.out.println("All tasks completed.");
    }
}

CyclicBarrier

CyclicBarrier允许一组线程互相等待,直到所有线程都到达一个屏障点,然后继续执行。

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

public class CyclicBarrierExample {
    public static void main(String[] args) {
        int count = 3;
        CyclicBarrier barrier = new CyclicBarrier(count, () -> {
            System.out.println("All threads arrived. Let's continue...");
        });

        for (int i = 0; i < count; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + " is waiting.");
                try {
                    barrier.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

表格总结

线程的创建方法

创建方法描述示例
继承Thread类创建一个新的线程类,重写run方法class MyThread extends Thread { public void run() { ... } }
实现Runnable接口创建一个实现Runnable接口的类,实现run方法class MyRunnable implements Runnable { public void run() { ... } }
使用ExecutorService创建和管理线程池ExecutorService executor = Executors.newFixedThreadPool(5);

线程同步方法

同步方法描述示例
synchronized方法同步整个方法,只允许一个线程访问public synchronized void increment() { ... }
synchronized块同步代码块,只允许一个线程访问指定代码块synchronized (lock) { ... }
ReentrantLock显式锁机制,提供了更灵活的同步控制lock.lock(); try { ... } finally { lock.unlock(); }

并发工具

工具描述示例
CountDownLatch允许一个或多个线程等待,直到其他线程完成一组操作new CountDownLatch(count);
CyclicBarrier允许一组线程互相等待,直到所有线程都到达屏障点new CyclicBarrier(count, Runnable);
Executor框架简化并发任务的执行和管理ExecutorService executor = Executors.newFixedThreadPool(2);
Future和Callable表示异步计算和可返回结果的任务Future<Integer> future = executor.submit(task);

应用场景与实践:生产者-消费者模型

生产者-消费者模型是多线程编程中的经典问题。该模型中,通过使用BlockingQueue可以方便地实现线程之间的安全通信和协调,从而避免资源争用和死锁问题。

示例:生产者-消费者模型

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class ProducerConsumerExample {
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);

        // 生产者
        Runnable producer = () -> {
            int value = 0;
            while (true) {
                try {
                    queue.put(value);
                    System.out.println("Produced: " + value);
                    value++;
                    Thread.sleep(500);  // 模拟生产时间
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        };

        // 消费者
        Runnable consumer = () -> {
            while (true) {
                try {
                    int value = queue.take();
                    System.out.println("Consumed: " + value);
                    Thread.sleep(1000);  // 模拟消费时间
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        };

        new Thread(producer).start();
        new Thread(consumer).start();
    }
}

在以上示例中,BlockingQueue用作存储数据的共享缓冲区,生产者线程不断向队列中添加数据,而消费者线程从队列中取出数据进行处理。通过BlockingQueue的阻塞特性,生产者和消费者在队列满或空时自动等待,从而实现线程间的协调。

表格总结

线程的创建方法

创建方法描述示例
继承Thread类创建一个新的线程类,重写run方法class MyThread extends Thread { public void run() { ... } }
实现Runnable接口创建一个实现Runnable接口的类,实现run方法class MyRunnable implements Runnable { public void run() { ... } }
使用ExecutorService创建和管理线程池ExecutorService executor = Executors.newFixedThreadPool(5);

线程同步方法

同步方法描述示例
synchronized方法同步整个方法,只允许一个线程访问public synchronized void increment() { ... }
synchronized块同步代码块,只允许一个线程访问指定代码块synchronized (lock) { ... }
ReentrantLock显式锁机制,提供了更灵活的同步控制lock.lock(); try { ... } finally { lock.unlock(); }

并发工具

工具描述示例
CountDownLatch允许一个或多个线程等待,直到其他线程完成一组操作new CountDownLatch(count);
CyclicBarrier允许一组线程互相等待,直到所有线程都到达屏障点new CyclicBarrier(count, Runnable);
Executor框架简化并发任务的执行和管理ExecutorService executor = Executors.newFixedThreadPool(2);
Future和Callable表示异步计算和可返回结果的任务Future<Integer> future = executor.submit(task);

线程池与并发框架

Java并发编程中,线程池与并发框架是实现高效多线程的关键组件。线程池可以重复利用线程,减少线程创建和销毁的开销。而并发框架如java.util.concurrent包则提供了丰富的并发工具。

线程池示例:固定大小线程池

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

public class FixedThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3);

        for (int i = 0; i < 5; i++) {
            executor.submit(() -> {
                System.out.println(Thread.currentThread().getName() + " is executing task.");
                try {
                    Thread.sleep(1000);  // 模拟任务执行时间
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }
        
        executor.shutdown();
    }
}

在此示例中,使用Executors.newFixedThreadPool(int)方法创建一个固定大小的线程池,并提交多个任务供线程池执行。线程池能有效管理线程的创建和销毁,优化资源使用。

锁和同步机制

在多线程环境下,正确的锁和同步机制是防止数据竞争和确保数据一致性的关键。

ReentrantLock示例

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

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

    public void increment() {
        lock.lock();
        try {
            count++;
            System.out.println(Thread.currentThread().getName() + " count: " + count);
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        ReentrantLockExample example = new ReentrantLockExample();
        
        Runnable task = example::increment;

        for (int i = 0; i < 5; i++) {
            new Thread(task).start();
        }
    }
}

在上述示例中,ReentrantLock用于显式锁机制,确保同一时刻只有一个线程能够访问共享数据。

结束语

本文详细介绍了Java中的多线程编程和并发处理,包括线程的创建与生命周期、线程同步与锁机制、并发库和高级并发工具等。通过代码示例和表格总结,希望您能更好地理解和应用Java的多线程编程,提高程序性能和资源利用率。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/707634.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

建议收藏!AIGC绘画基础,Midjourney风格码style reference code策展汇总合集

自打Midjourney推出风格码style reference code以来&#xff0c;各路大神都在积极“挖矿”&#xff0c;不断地使用sref random后缀参数来寻找不同风格。 得益于Midjourney爱好者们“分布式挖矿”的力量&#xff0c;很多Midjourney风格被测试出来。我已经把前1000个风格码看了一…

R语言绘制三变量分区地图

参考资料&#xff1a; https://mp.weixin.qq.com/s/5c7gpO2mJ2BqJevePJz3CQ tricolore包教程&#xff1a;https://github.com/jschoeley/tricolore 学习笔记&#xff1a;Ternary choropleth maps 1、测试实例 代码&#xff1a; library(ggplot2) library(rnaturalearthdata) …

使用ant-design/cssinjs向plasmo浏览器插件的内容脚本content中注入antd的ui组件样式

之前写过一篇文章用来向content内容脚本注入antd的ui&#xff1a;https://xiaoshen.blog.csdn.net/article/details/136418199&#xff0c;但是方法就是比较繁琐&#xff0c;需要将antd的样式拷贝出来&#xff0c;然后贴到一个单独的css样式文件中&#xff0c;然后引入到内容脚…

Apple - Metal Programming Guide

本文翻译整理自&#xff1a;Metal Programming Guide&#xff08;更新日期&#xff1a;2016-12-12 https://developer.apple.com/library/archive/documentation/Miscellaneous/Conceptual/MetalProgrammingGuide/Introduction/Introduction.html#//apple_ref/doc/uid/TP400142…

next.js开发中页面回退时报Unhandled Runtime ErrorTypeError destroy is not a function

Next.js开发中页面回退时报Unhandled Runtime Error:TypeError: destroy is not a function 问题描述 在Next.js开发中&#xff0c;从A页面跳转到B页面&#xff0c;再使用浏览器回退到A页面时报上述错误&#xff1a; 错误原因 是因为在B页面里&#xff0c;在使用useEffect时…

从“数据孤岛”、Data Fabric(数据编织)谈逻辑数据平台

提到逻辑数据平台&#xff0c;其核心在于“逻辑”&#xff0c;与之相对的便是“物理”。在过去&#xff0c;为了更好地利用和管理数据&#xff0c;我们通常会选择搭建数据仓库和数据湖&#xff0c;将所有数据物理集中起来。但随着数据量、用数需求和用数人员的持续激增&#xf…

掌握midjourney系列:8 个角色设计关键词

Midjourney V6的角色引用功能非常强大&#xff0c;可以让多张图片生成的角色风格保持一致。在实现同一角色的多张场景图片之前&#xff0c;我们需要先设计好基础角色。 以下是我总结的Midjourney中人物设计套路的常用提示&#xff0c;很高兴与大家分享。 1、角色设定表&#…

南京威雅学校:初中转轨国际化教育,她们打开了成长的另一种可能

“上了大学就轻松了。” 又是一年高考季&#xff0c;每每回想起十八岁前那些没日没夜埋头学习的日子&#xff0c;已经为人父母的你是不是也忍不住想要孩子气地吐槽一句&#xff0c;“骗人”——人不会在一场考试后瞬间长大&#xff0c;试卷里也没有人生的全部答案。 三年前&a…

Java-多线程

概念 进程&#xff1a;程序的基本执行实体 线程&#xff1a;操作系统能够进行运算调度的最小单位&#xff0c;被包含在进程之中&#xff0c;是进程的实际运作单位 并发&#xff1a;同一时刻&#xff0c;多个指令在单个CPU上交替执行。 并行&#xff1a;同一时刻&#xff0c;多…

博物馆藏品管理的重要性

博物馆是人们了解历史文化、传承文明的重要场所。而博物馆的藏品管理是博物馆的核心工作之一&#xff0c;对于展现博物馆的魅力、吸引观众的眼球有着至关重要的影响。并且博物馆藏品管理是一项复杂且专业的工作&#xff0c;它涉及到多个方面&#xff0c;包括但不限于藏品的收集…

前沿重器[49] | 聊聊搜索系统2:常见架构

前沿重器 栏目主要给大家分享各种大厂、顶会的论文和分享&#xff0c;从中抽取关键精华的部分和大家分享&#xff0c;和大家一起把握前沿技术。具体介绍&#xff1a;仓颉专项&#xff1a;飞机大炮我都会&#xff0c;利器心法我还有。&#xff08;算起来&#xff0c;专项启动已经…

Unity 踩坑记录 用自定义类 创建的List不显示在 inspector面板

在 自定义类上面添加 【Serializable 】 扩展&#xff1a; 1&#xff1a;Serializable 序列化的是可序列化的类或结构。并且只能序列化非抽象非泛型的自定义的类 2&#xff1a;SerializeField是强制对私有字段序列化

单例模式、工厂模式 c++关键字 static

static 关键字的作用&#xff1a; 主要作用在于 控制变量或函数的作用域、生命周期以及它们如何被不同部分的程序访问&#xff0c;从而帮助程序员管理内存、避免命名冲突&#xff0c;并实现特定的设计模式&#xff08;如单例模式&#xff09;。 1. 静态局部变量&#xff1a;当…

工具推荐-文件捆绑工具

前提 在之前有突发奇想过&#xff0c;有没有那种我发给别人一个pdf文件&#xff0c;别人点击后看到的是pdf文件的内容&#xff0c;我这边也看到了上线的提示。于是就去研究pdf能加入哪些特殊的功能。看了一段时间后发现pdf的一些不一样的功能 像是打开pdf后弹出一个框 或者是…

什么是端口转发?路由器如何正确的设置端口转发和范围转发?(外网访问必备设置)

文章目录 📖 介绍 📖🏡 演示环境 🏡📒 端口转发 📒🚀 端口转发的应用场景💡 路由器如何设置端口转发(示例)💡 端口范围转发(示例)🎯 范围转发的应用场景🛠️ 设置范围转发📝 范围转发实操示例🎈 注意事项 🎈⚓️ 相关链接 ⚓️📖 介绍 📖 …

wmv转换mp4怎么操作?3个格式转换方法分享

wmv转换mp4怎么操作&#xff1f;将WMV转换为MP4格式&#xff0c;可以方便我们在多种设备和平台上流畅播放视频。MP4格式具有广泛的兼容性和优化过的编码&#xff0c;使其在各种媒体播放器、智能手机、平板电脑以及电视上都能得到良好的支持。此外&#xff0c;MP4格式的视频文件…

手机直播不用麦克风可以吗?一文看懂无线麦克风哪个好

市面上对于无线麦克风的需求有增无减&#xff0c;原因是直播、短视频行业火爆&#xff0c;许多人都开始加入这一行业&#xff0c;不过对于麦克风这类产品的疑问也越来越多。例如&#xff1a;无线麦克风怎么选&#xff1f;实不实用&#xff1f;手机直播不用麦克风可以吗&#xf…

安卓启动流程

还是以高通为例子。这次整理并不是很完善&#xff0c;下来会参考一些文档再整理。。。 高通平台启动过程_高通平台启动流程-CSDN博客 https://www.cnblogs.com/schips/p/how_qualcomm_soc_boot.html 1. 初始启动阶段&#xff08;Boot ROM&#xff09; 处理器复位&#xff1a;…

OpenCV图像变换

一 图像的缩放 resize(src,dst,dsize,fx,fy,interpolation) fx&#xff1a;x轴的缩放因子 fy&#xff1a;y轴的缩放因子 interpolation 插值算法 INTER_NEAREST,临近插值&#xff0c;速度快&#xff0c;效果差 INTER_LINEAR,双线性插值&#xff0c;原图中的4个点 INTER_CUBIC…

【原创】springboot+mysql社区住户综合管理系统设计与实现

个人主页&#xff1a;程序猿小小杨 个人简介&#xff1a;从事开发多年&#xff0c;Java、Php、Python、前端开发均有涉猎 博客内容&#xff1a;Java项目实战、项目演示、技术分享 文末有作者名片&#xff0c;希望和大家一起共同进步&#xff0c;你只管努力&#xff0c;剩下的交…