Java中的多线程与并发编程

于 2024-08-14 07:00:00 发布
阅读量423 收藏 23
点赞数 19
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44626980/article/details/140439201
版权

Java中的多线程与并发编程

大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！今天我们来探讨一下Java中的多线程与并发编程。多线程编程可以充分利用CPU资源，提高程序的运行效率。然而，由于多线程编程的复杂性，开发过程中需要特别注意线程安全和死锁等问题。本文将介绍Java多线程的基本概念、线程的创建与管理、同步机制以及常见的并发工具类。

一、多线程的基本概念

在单线程环境中，一个时间点只能有一个任务执行，多线程则允许多个任务同时执行，从而提高系统的吞吐量。Java中的多线程是通过java.lang.Thread类和java.lang.Runnable接口来实现的。

二、线程的创建与管理

  1. 继承Thread类

    package cn.juwatech.multithreading;

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

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

  2. 实现Runnable接口

    package cn.juwatech.multithreading;

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

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

  3. 使用Callable和Future

    Callable接口类似于Runnable，但它可以返回结果并且可以抛出异常。Future接口表示异步计算的结果。

    package cn.juwatech.multithreading;

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 MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "Callable result";
    }

    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(new MyCallable());

        try {
            String result = future.get();
            System.out.println(result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();
        }
    }
}

三、线程同步

多线程环境下，多个线程同时访问共享资源可能导致数据不一致的问题。Java提供了多种同步机制来解决这个问题。

  1. 同步方法和同步块

    package cn.juwatech.multithreading;

public class SynchronizedExample {
    private int count = 0;

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

    public void incrementWithSyncBlock() {
        synchronized (this) {
            count++;
        }
    }

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

        for (int i = 0; i < 1000; i++) {
            new Thread(example::increment).start();
        }

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Count: " + example.count);
    }
}

  2. 使用ReentrantLock

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

    package cn.juwatech.multithreading;

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

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

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

    public static void main(String[] args) {
        LockExample example = new LockExample();

        for (int i = 0; i < 1000; i++) {
            new Thread(example::increment).start();
        }

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Count: " + example.count);
    }
}

四、线程间通信

  1. 使用wait()、notify()和notifyAll()

    package cn.juwatech.multithreading;

public class WaitNotifyExample {
    private final Object lock = new Object();

    public void produce() throws InterruptedException {
        synchronized (lock) {
            System.out.println("Producer is producing...");
            lock.wait();
            System.out.println("Producer resumed.");
        }
    }

    public void consume() throws InterruptedException {
        Thread.sleep(1000);
        synchronized (lock) {
            System.out.println("Consumer is consuming...");
            lock.notify();
        }
    }

    public static void main(String[] args) {
        WaitNotifyExample example = new WaitNotifyExample();

        Thread producer = new Thread(() -> {
            try {
                example.produce();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread consumer = new Thread(() -> {
            try {
                example.consume();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

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

  2. 使用BlockingQueue

    BlockingQueue提供了线程安全的生产者-消费者模式。

    package cn.juwatech.multithreading;

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

public class BlockingQueueExample {
    private static BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);

    public static void main(String[] args) {
        Thread producer = new Thread(() -> {
            try {
                for (int i = 0; i < 100; i++) {
                    queue.put(i);
                    System.out.println("Produced: " + i);
                    Thread.sleep(50);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread consumer = new Thread(() -> {
            try {
                while (true) {
                    int value = queue.take();
                    System.out.println("Consumed: " + value);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

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

五、并发工具类

Java的java.util.concurrent包提供了丰富的并发工具类，简化了多线程编程。

  1. CountDownLatch

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

    package cn.juwatech.multithreading;

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    private static final int TASK_COUNT = 5;

    public static void main(String[] args) {
        CountDownLatch latch = new CountDownLatch(TASK_COUNT);

        for (int i = 0; i < TASK_COUNT; i++) {
            new Thread(() -> {
                try {
                    System.out.println("Task started.");
                    Thread.sleep((long) (Math.random() * 1000));
                    System.out.println("Task completed.");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    latch.countDown();
                }
            }).start();
        }

        try {
            latch.await();
            System.out.println("All tasks completed.");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

  2. CyclicBarrier

    CyclicBarrier允许一组线程互相等待，直到到达公共屏障点。

    package cn.juwatech.multithreading;

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

public class CyclicBarrierExample {
    private static final int THREAD_COUNT = 3;

    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(THREAD_COUNT, () -> {
            System.out.println("All threads have reached the barrier.");
        });

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

六、线程池

线程池通过重用线程来提高性能，避免频繁创建和销毁线程的开销。Java提供了ExecutorService来管理线程池。

package cn.juwatech.multithreading;

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++) {
            executor.submit(() -> {
                System.out.println(Thread.currentThread().getName() + " is executing a task.");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        executor.shutdown();
    }
}

著作权归聚娃科技微赚淘客系统开发者团队，转载请注明出处！

weixin_836869520
关注
  • 19
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
博客
Java中的方法重载与重写
08-14 186
今天我们来深入探讨Java中的方法重载（Method Overloading）与方法重写（Method Overriding）这两个重要的概念及其在实际开发中的应用。在实际开发中，方法重载和方法重写是面向对象编程的重要特性，能够帮助我们编写更加灵活和可维护的代码。方法重载是指在一个类中，可以定义多个方法名相同但参数列表不同（参数类型、个数或顺序不同）的方法。编译器根据调用的方法参数的数量和类型来决定调用哪个重载方法。根据方法调用时传入的参数类型和数量的不同，编译器可以正确地选择调用相应的方法。
博客
如何使用Java串口进行数据通信及应用案例
08-14 160
通过本文的介绍，我们了解到Java中实现串口通信的方法和一些应用案例。串口通信在特定领域仍然发挥着重要作用。合理配置串口参数、监听串口事件、控制硬件设备等技巧对于开发相关应用非常关键。本文著作权归聚娃科技微赚淘客系统开发者团队，转载请注明出处！
博客
Java中的JVM内存结构详解
08-13 510
JVM内存结构主要分为五个部分：方法区（Method Area）、堆区（Heap Area）、虚拟机栈（JVM Stacks）、程序计数器（Program Counter Register）和本地方法栈（Native Method Stacks）。方法区是所有线程共享的一块内存区域，它存储了每个类的结构信息，如运行时常量池、字段和方法数据、构造方法和普通方法的字节码内容。虚拟机栈为虚拟机执行Java方法（也就是字节码）服务，而本地方法栈则为虚拟机使用到的Native方法服务。可以通过调整元空间大小来解决。
博客
使用Spring Boot集成Kafka
08-13 303
Spring Boot的集成使得我们可以更加便捷地开发出可靠的消息驱动应用程序，提升了系统的可扩展性和性能。在实际项目中，结合Kafka的分布式特性和Spring Boot的便捷开发，可以有效地实现各种复杂的消息处理需求，如日志收集、实时数据分析和事件驱动微服务等。希望本文能够帮助开发者更好地理解和应用Spring Boot与Kafka集成的技术，提升应用的效率和性能。Spring Boot提供了简化的配置和强大的依赖注入机制，使得在应用中集成Kafka变得更加轻松和高效。
博客
返利机器人的智能推荐系统与实现技术
08-12 736
返利机器人的智能推荐系统是提升用户体验和增加用户粘性的关键。通过不断优化推荐算法和提升系统性能，可以为用户提供更加个性化和精准的推荐服务。本文著作权归聚娃科技微赚淘客系统开发者团队，转载请注明出处！
博客
Java中的接口与抽象类详解
08-12 245
在Java编程语言中，接口（Interface）和抽象类（Abstract Class）是面向对象编程中重要的概念。它们都可以用来实现类之间的继承关系，但在用法和实现上有一些显著的区别。抽象类是不能实例化的类，它用于定义子类的通用行为，可以包含抽象方法和具体方法的实现。接口是一种抽象数据类型，它定义了一个类需要遵循的行为规范，但不包含任何具体实现。），一个类可以实现多个接口，实现接口的类必须实现接口中定义的所有方法。），子类必须实现抽象类中的所有抽象方法，否则子类也必须声明为抽象类。
博客
Java中的死锁与避免策略
08-12 311
通过本文的讨论，我们深入了解了死锁的形成原理及其常见的避免策略，并通过代码示例演示了死锁的实际情况。大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！例如，如果线程A需要先获取锁1再获取锁2，那么线程B也必须按照相同的顺序获取锁，即先锁1后锁2。死锁是指两个或多个线程在执行过程中，由于互相持有对方所需的资源而造成的一种互相等待的现象，导致所有线程都无法继续执行下去。设置一个超时时间，在尝试获取锁的过程中，如果超过了指定的时间仍未获取到锁，可以尝试释放已经获取的锁并重新开始。
博客
Java中的内存模型与并发编程
08-11 407
通过学习和理解Java内存模型的概念、volatile和synchronized关键字的使用，以及并发工具类的应用，可以帮助开发者编写高效、线程安全的Java多线程程序。Java内存模型把主内存（Main Memory）作为所有线程共享的内存区域，每个线程都有自己的工作内存（Working Memory），线程的工作内存中保存了该线程使用到的变量的副本。线程之间的通信必须通过主内存来完成。今天我们将深入探讨Java中的内存模型及其与并发编程的关系，这是每位Java开发者都应该熟悉和理解的重要主题。
博客
使用Spring Boot集成Redis
08-11 604
通过本文的介绍，我们深入了解了如何利用Spring Boot快速集成Redis，并展示了常见的Redis操作示例。合理地利用Redis可以极大地提升系统的性能和扩展性，是现代Web应用开发中不可或缺的技术栈之一。大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！今天我们将探讨如何利用Spring Boot集成Redis，实现高效的数据缓存和存储，这对于提升应用性能和扩展性至关重要。例如，可以将Redis用作缓存存储频繁访问的数据，以减轻数据库压力，或者作为分布式锁的实现方式。
博客
进程间通信（IPC）：理论与实现
08-10 345
进程间通信（Inter-Process Communication，IPC）是指在操作系统中，不同进程之间交换数据和信息的机制。IPC的主要目的是实现进程间的同步与数据共享，常见的IPC机制包括管道、消息队列、共享内存、信号量和套接字等。进程间通信是操作系统和并发编程中的重要概念，通过不同的IPC机制，可以实现进程之间的数据交换与同步。管道是一种半双工的通信方式，数据只能在一个方向上传输，通常用于父子进程间的通信。在这个例子中，服务器和客户端通过套接字通信，服务器接收并打印客户端发送的消息。
博客
random函数在不同编程语言中的实现
08-10 149
通过以上不同编程语言中random函数的实现，我们可以看到每种语言都有自己的方式来生成随机数，但基本原理是相似的。理解这些实现方式可以帮助我们在不同的编程环境中应用随机数生成。大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！在本文中，我们将探讨random函数在不同编程语言中的实现，展示如何在各种编程环境中生成随机数。生成一个0.0到1.0之间的随机浮点数，并使用。在Python中，随机数生成使用。生成一个0到99之间的随机整数。在上面的代码中，我们创建了一个。
博客
Kubernetes（k8s）经典理论与实战
08-09 1212
Kubernetes 提供了强大的容器编排能力，通过定义和管理 Pod、Deployment、Service、ConfigMap 和 Secret 等资源，使得应用程序的部署和管理变得更加高效和可靠。它解决了在多个容器和主机上管理应用程序的复杂性，使得应用程序可以在不同的环境中高效运行。Deployment 是 Kubernetes 中的一种控制器，用于声明式地管理 Pod 的副本和滚动更新。Service 提供了稳定的网络访问方式，允许外部流量访问运行在 Pod 中的应用程序，并实现负载均衡。
博客
Linux关机命令详解：安全关机与重启
08-09 402
在 Linux 系统中，关机和重启是日常操作中不可避免的任务。Linux 提供了多种命令来实现这些任务，了解它们的用法和效果是每个系统管理员的必修课。Linux 提供了多种命令来执行关机和重启操作，每种命令都有其特定的用途和效果。了解这些命令的用法，可以帮助你在不同情况下选择最合适的操作方式。大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！命令是最常用的关机命令，支持安全地关闭系统。命令用于立即重启系统，执行该命令的用户通常需要有管理员权限。上述命令会在 10 分钟后关机。
博客
SQL数据库学习指南：查询优化与数据管理
08-08 290
大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！事务管理确保数据库操作的原子性、一致性、隔离性和持久性（ACID特性）。备份是防止数据丢失的重要手段。本文著作权归聚娃科技微赚淘客系统开发者团队，转载请注明出处！查询优化是提升数据库性能的关键。数据管理包括数据库的创建、备份和恢复等。通过重写查询来优化性能。索引是加速数据库查询的有效方法。用于在事务失败时回滚所有操作。
博客
Android多线程编程：提高应用响应速度
08-08 228
本文将介绍几种常用的多线程技术，包括Thread、Handler、AsyncTask和ExecutorService，并通过代码示例展示它们的使用方法。通过合理使用Thread、Handler、AsyncTask和ExecutorService，可以有效地管理和执行后台任务，确保主线程的流畅运行。AsyncTask是Android提供的轻量级异步任务类，适用于需要在后台线程中执行任务并在主线程中更新UI的场景。大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！
博客
数据库教程：从基础操作到高级应用
08-07 567
本文将从基础操作开始，逐步深入到数据库的高级应用，包括SQL语句、事务处理、索引优化和存储过程等方面。事务是数据库操作的基本单元，确保一组操作要么全部成功，要么全部失败。包来进行数据库操作。在这个示例中，我们使用JDBC连接到MySQL数据库，并执行一个查询以获取用户表中的数据。存储过程和函数用于封装复杂的操作，并在数据库端执行。大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！，分别用于获取用户的所有订单和计算用户的总订单金额。索引可以显著提高查询速度，尤其是对大数据量的表。
博客
分词算法：自然语言处理中的关键技术
08-07 540
分词（Tokenization）是自然语言处理（NLP）中的一项基础技术，旨在将文本拆分成有意义的单位，如单词或词组。例如，通过分词技术将用户输入的查询分解为关键词，以提供更精确的搜索结果。N-gram模型是基于统计的分词方法，通过分析文本中n个连续词的出现频率来实现分词。基于规则的分词算法依赖于预定义的规则和词典，通常用于英文等空格分隔的语言。常用的方法包括基于字典的分词和基于统计的分词方法。使用一个大于一的n值（例如bigram）来生成n-gram，并统计每个n-gram的出现次数。
博客
Java中的方法句柄详解
08-06 163
方法句柄（Method Handle）是Java语言中一种轻量级、灵活的函数指针，它可以视作是对方法的引用。与传统的反射相比，方法句柄提供了更高效的方法调用方式，尤其在动态性能优化和安全访问控制方面有显著优势。
博客
使用Spring Boot集成RabbitMQ
08-06 373
RabbitMQ是一个开源的消息代理软件，它实现了高级消息队列协议（AMQP），被广泛应用于构建分布式系统中的消息中间件。本文将介绍如何使用Spring Boot集成RabbitMQ来实现消息的生产者和消费者。
博客
如何设计可伸缩的分布式架构以应对淘客返利系统的增长
08-05 2082
通过本文的讲解，我们详细探讨了如何设计一个可伸缩的分布式架构以应对淘客返利系统的增长。我们介绍了微服务架构的设计，并通过Java代码实例展示了服务注册与发现、负载均衡、数据持久化与缓存、异步处理与消息队列的实现。分布式架构是指系统的组件分布在不同的网络节点上，通过网络通信进行协作，共同完成系统的功能。微服务架构是一种常见的分布式架构，它将系统划分为多个独立的服务，每个服务都可以独立部署和扩展。下面我们通过一个简单的Java示例，展示如何实现微服务架构中的服务注册与发现和负载均衡。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值