Java多线程编程与并发处理

news2024/11/21 0:27:42

引言

在现代编程中，多线程和并发处理是提高程序运行效率和资源利用率的重要方法。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的多线程编程，提高程序性能和资源利用率。

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

深度学习常见概念解释（三）——激活函数定义，作用与种类（附公式，求导，图像和代码）

深度学习常见概念解释（三）——激活函数定义，作用与种类（附公式，求导，图像和代码）

激活函数 前言作用激活函数种类1. ReLU (Rectified Linear Unit)2. Leaky ReLU3. ELU (Exponential Linear Unit)4. Sigmoid5. Tanh6. Swish 结论 前言 在深度学习中&#xff0c;激活函数是神经网络中的一个关键组件&#xff0c;起着引入非线性因素的作用&#xff0c;从而增加…
阅读更多...
HTML+CSS 动态卡片

HTML+CSS 动态卡片

效果演示 实现了一个带有动态背景和图片放大效果的卡片展示。卡片的背景是由两种颜色交替组成的斜线条纹&#xff0c;同时背景会以一定速度循环滚动。当鼠标悬停在卡片上时&#xff0c;卡片的图片会放大&#xff0c;并且卡片的背景会变为彩色。 Code HTML <!DOCTYPE html&…
阅读更多...
Windows defender bypass ｜ 免杀

Windows defender bypass ｜ 免杀

官方文档 在制作免杀的过程中，翻找 Windows 官方对 Windows Defender 的介绍，发现有这样一个目录：Configure Microsoft Defender Antivirus exclusions on Windows Server（在 Windows server 中配置defender排除项）。 https://docs.microsoft.com/en-us/microsoft-365/se…
阅读更多...
【复旦邱锡鹏教授《神经网络与深度学习公开课》笔记】线性分类模型损失函数对比

【复旦邱锡鹏教授《神经网络与深度学习公开课》笔记】线性分类模型损失函数对比

本节均以二分类问题为例进行展开&#xff0c;统一定义类别标签 y ∈ { 1 , − 1 } y\in\{1,-1\} y∈{1,−1}&#xff0c;则分类正确时 y f ( x ; w ) > 0 yf(x;w)>0 yf(x;w)>0&#xff0c;且值越大越正确&#xff1b;错误时 y f ( x ; w ) < 0 yf(x;w)<0 yf(x;…
阅读更多...
大数计算器（加减乘除）

大数计算器（加减乘除）

#define _CRT_SECURE_NO_DEPRECATE 1#include<stdio.h> #include<string.h> #define N 200 #define jc_MAX 4000//输入 void input_digit(char s1[], char s2[]) {printf("请输入第一个数&#xff1a;");scanf("%s", s1);printf("请输入第…
阅读更多...
郑州申请大气污染防治乙级资质，这些材料必不可少

郑州申请大气污染防治乙级资质，这些材料必不可少

在郑州申请大气污染防治乙级资质时&#xff0c;以下材料是必不可少的&#xff1a; 一、企业基础资料&#xff1a; 企业法人营业执照副本&#xff1a;需清晰&#xff0c;且在有效期内[1][2]。企业章程&#xff1a;提交企业章程的扫描件或复印件&#xff0c;以展示企业的组织结构…
阅读更多...
基于机器学习和深度学习的轴承故障诊断方法（Python）

基于机器学习和深度学习的轴承故障诊断方法（Python）

在工业早期&#xff0c;设备故障诊断通常由专家通过观察设备运行中的变量参数并结合自身知识进行诊断。但相比传统的机理分析方法&#xff0c;数据驱动的智能设备故障诊断更能充分提取数据中隐含的故障征兆、因果逻辑等关系。智能设备故障诊断的优势表现在其对海量、多源、高维…
阅读更多...
【Python】已完美解决：ERROR: Could not find a version that satisfies the requirement re

【Python】已完美解决：ERROR: Could not find a version that satisfies the requirement re

文章目录 一、问题背景二、可能出错的原因三、错误代码示例四、正确代码示例&#xff08;结合实战场景&#xff09;五、注意事项 已解决&#xff1a;“ERROR: Could not find a version that satisfies the requirement re”的问题 一、问题背景 在使用Python的pip包管理器安…
阅读更多...
codegeex2-6b-int4 部署

codegeex2-6b-int4 部署

codegeex2-6b-int4 模型文件 CodeGeeX2 仓库文件地址 CodeGeeX2 推理教程 conda create -n codegeex2 python3.10 -y conda activate codegeex2 pip install -r requirements.txt -i https://pypi.mirrors.u…
阅读更多...
2024中国翻译行业发展报告

2024中国翻译行业发展报告

来源&#xff1a;中国翻译协会 近期历史回顾&#xff1a; 2024国内工商业储能市场研究报告.pdf 2023幸福企业白皮书.pdf 2024年欧亚地区移动经济报告.pdf 内容供应链变革 2023人工智能与首席营销官&#xff08;CMO&#xff09; AI科技对PC产业的影响.pdf 金融业数据应用发展报…
阅读更多...
成都晨持绪：抖音电商新手怎么做可信

成都晨持绪：抖音电商新手怎么做可信

在如今这个信息爆炸的时代&#xff0c;抖音作为新兴的电商平台&#xff0c;为许多创业者和商家提供了展示和销售产品的新渠道。然而&#xff0c;对于刚入行的新手来说&#xff0c;如何在抖音上建立起一个可信的电商身份&#xff0c;却是一个值得深思的问题。 要确保所售卖的产品…
阅读更多...
短剧分销市场动态：机遇挑战双重解读

短剧分销市场动态：机遇挑战双重解读

一、引言 近年来&#xff0c;随着互联网的快速发展和智能手机的普及&#xff0c;短视频和短剧逐渐成为人们日常娱乐的重要组成部分。短剧以其短小精悍、情节紧凑的特点&#xff0c;吸引了大量观众的关注和喜爱。而短剧分销市场则应运而生&#xff0c;为内容创作者和平台方提供了…
阅读更多...
[数据集][目标检测]减速带检测数据集VOC+YOLO格式5400张1类别

[数据集][目标检测]减速带检测数据集VOC+YOLO格式5400张1类别

数据集格式&#xff1a;Pascal VOC格式YOLO格式(不包含分割路径的txt文件&#xff0c;仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件) 图片数量(jpg文件个数)&#xff1a;5400 标注数量(xml文件个数)&#xff1a;5400 标注数量(txt文件个数)&#xff1a;5400 标注…
阅读更多...
Linux 中 “ 磁盘、进程和内存 ” 的管理

Linux 中 “ 磁盘、进程和内存 ” 的管理

在linux虚拟机中也有磁盘、进程、内存的存在。第一步了解一下磁盘 一、磁盘管理 &#xff08;1.1&#xff09;磁盘了解 track&#xff08; 磁道 &#xff09; &#xff1a;就是磁盘上的同心圆&#xff0c;从外向里&#xff0c;依次排序1号&#xff0c;2号磁盘........等等。…
阅读更多...
ZnO电阻片在低电场区域的泄漏电流及其电阻的负温度系数

ZnO电阻片在低电场区域的泄漏电流及其电阻的负温度系数

在低电场区域,流过ZnO非线性电阻的泄漏电流小于1mA.泄漏电流不仅与施加的电压幅值有关,而且与温度高低有关。图2.6表示温度对泄漏电流的影响,温度越高,电子在电场作用下定向的运动就越激烈,导致泄漏电流增大。因此温度升高将导致电阳值下降,即ZnO 电阻呈现负温度特性。 一般以…
阅读更多...
Siemens-NXUG二次开发-创建平面（无界非关联）、固定基准面[Python UF][20240614]

Siemens-NXUG二次开发-创建平面（无界非关联）、固定基准面[Python UF][20240614]

Siemens-NXUG二次开发-创建平面&#xff08;无界非关联&#xff09;、固定基准面[Python UF][20240614] 1.python uf函数1.1 NXOpen.UF.Modeling.CreatePlane1.2 NXOpen.UF.ModlFeatures.CreateFixedDplane 2.示例代码2.1 pyuf_plane.py 3.运行结果3.1 内部模式3.1.1 NXOpen.UF…
阅读更多...
期末复习5---PTA

期末复习5---PTA

以下是提交正确的代码&#xff1a; int max_len( char *s[], int n ) {int i;int max0;for(i1;i<n;i){if(strlen(s[i])>strlen(s[max]))maxi;}return strlen(s[max]); } 以下是我自己写的代码&#xff1a; 出现的问题是 &#xff1a;括号加的不对&#xff0c;需要细心…
阅读更多...
湖仓一体全面开启实时化时代

湖仓一体全面开启实时化时代

摘要&#xff1a;本文整理自阿里云开源大数据平台负责人王峰&#xff08;莫问&#xff09;老师在5月16日 Streaming Lakehouse Meetup Online 上的分享&#xff0c;主要介绍在新一代湖仓架构上如何进行实时化大数据分析。内容主要分为以下五个部分&#xff1a; Data Lake Dat…
阅读更多...
YOLOv8可视化界面，web网页端检测

YOLOv8可视化界面，web网页端检测

YOLOv8可视化界面&#xff0c;web网页端检测。支持图片检测&#xff0c;视频检测&#xff0c;摄像头检测等&#xff0c;支持检测、分割等多种任务&#xff0c;实时显示检测画面。支持自定义数据集&#xff0c;计数&#xff0c;……
阅读更多...
【教程】从0开始搭建大语言模型：构造GPT模型

【教程】从0开始搭建大语言模型：构造GPT模型

从0开始搭建大语言模型&#xff1a;构造GPT模型 从0开始搭建大语言模型&#xff1a;构造GPT模型GPT模型Layer NormalizationGELU激活函数Feed Forward网络增强shortcut连接构造Transformer Block构造GPT模型使用GPT模型生成文本 从0开始搭建大语言模型&#xff1a;构造GPT模型 …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023