Java多线程编程与并发处理

已于 2024-06-15 09:16:15 修改
阅读量1k 收藏 20
点赞数 16
分类专栏： java 文章标签： java jvm 开发语言
于 2024-06-14 07:38:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weidl001/article/details/139668140
版权

引言

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

小魏冬琅
关注
  • 16
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入理解Java多线程与并发编程
08-26
深入理解Java多线程与并发编程 Java多线程与并发编程是Java开发中非常重要的一部分，它涉及到多线程的创建、同步、通信、死锁等问题。下面我们将详细介绍Java多线程与并发编程的相关知识点。 一、多线程三大特性 ...
Java_多线程与并发编程总结.doc
04-14
Java多线程与并发编程是Java开发中至关重要的一部分，它涉及到如何高效地利用CPU资源，以实现程序的并行执行。在操作系统层面，多任务和多进程是通过分配不同的内存空间来实现的，而线程则共享同一进程的内存，这...
Java多线程并发编程 并发三大要素
08-30
Java多线程并发编程并发三大要素 Java多线程并发编程中，存在三个至关重要的要素：原子性、可见性和有序性。这三个要素是Java多线程并发编程的基础，是确保多线程程序的正确性和可靠性的关键。 一、原子性 原子性...
java多线程并发编程 核心技术应用实践
06-21
在《java多线程并发编程核心技术应用实践》中，我们将深入探讨Java平台上的并发机制、线程安全与同步控制、线程池以及实战技巧。 首先，我们需要理解Java中的线程基础。线程是程序执行的最小单位，一个进程可以有多...
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
redis+spring面试题
github_36510643的博客
07-21 146
redis+spring面试题
Java-Lambda
最新发布
lizhiwei21的博客
07-21 136
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 486
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1121
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 1121
JVM-垃圾回收与内存分配
java算法day19
TOMOT77的博客
07-20 174
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
【Java算法】前缀和 下
2302_79806056的博客
07-18 1047
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 499
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
【Java并发编程之美 | 第三篇】Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
踢桃的成长之路
07-21 536
Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
对androidTestDebug 产物进行重新签名
shuizhizhiyin的专栏
07-19 467
在运行 gradle assembleAndroidTestDebug 任务后，自定义的 reSignAndroidTestDebug 任务将会被执行，并对子模块的 androidTestDebug 产物进行重新签名。your_keystore_path.jks、your_keystore_password、your_key_alias 和 your_key_password 需要替换为你的实际路径和密码。如果需要对其他子模块的产物进行重新签名，可以根据需要创建不同的自定义任务。// 设置密钥库密码。
每 日练 习
m0_67187271的博客
07-19 796
正确答案：C 解析：是正确的，这是最基本的类定义形式，没有继承任何类，也没有实现任何接口。也是正确的，这里定义了一个名为x的类，它继承了名为y的类。同样是正确的，这里定义了一个公共类x，它继承了Applet类，这在Java中是合法的，尤其是在创建GUI应用程序时常见。是不正确的，因为在Java中，我们不能使用static关键字来修饰一个类的定义。static关键字只能用于类的方法、变量或者是内部类（即嵌套类），但不能用于顶级类（非嵌套类）。所以，这个选项是错误的。因此，正确答案是C。
《简历宝典》15 - 简历中“项目经历”，实战讲解，Java篇
xingyu_qie的专栏
07-18 227
校招和初级Java开发的项目经历重点是突出自己在实战中的学习。比如对数据库的操作，比如前后端联调工作中遇到问题的解决，比如一些Java基础知识点的逐渐深入掌握，这些都是这个阶段的Java开发需要去不断增强的。和初级前端开发类似，例如你作为一名初级Java开发，负责的是校园图书管理系统的图书信息上传，图书信息管理这个模块的服务端开发，项目经历可以这样编写，如图。
python--实验14 并发编程（多线程）
wumingzei的博客
07-18 942
定义通过声明Thread的派生类，创建一个子类，并重写对象的run方法，然后创建其对象实例，可创建线程。通过对象的start方法，可启动线程，并自动执行对象的run方法。注意子类的构造器一定要先调用基类的构造器直接将线程需要做的事写到run方法中示例。
码农生涯问题杂记
qq_38189542的博客
07-18 165
Q：工作中需要测试一个JNA程序，想着Windows方便，所以就在Windows进行动态库的编译，然后在编译过程中，对应的代码在Linux系统GCC编译是成功的，但是在Windows下死活报错，而且报的错莫名其妙。A：后面经过测试，Vistual Studio在UTF8编码下，对中文支持很糟糕，导致编译的时候，语法解释出错，从而就出现一大堆乱七八糟让人摸不着头脑的错误。后面删除代码中的中文注释，编译成功。
Java多线程与并发编程深度解析
"深入Java多线程和并发编程.pdf" 这篇文档深入探讨了Java中的多线程和并发编程，这是在高性能、高并发场景下开发Java应用程序的关键技术。文档首先介绍了进程与线程的基础概念，进程作为计算机程序的执行实例，具有...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值