JAVA-线程和并发

最新推荐文章于 2024-10-15 15:06:01 发布
最新推荐文章于 2024-10-15 15:06:01 发布
阅读量1.1k 收藏 33
点赞数 34
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a787769407/article/details/140497269
版权

1. 线程的基本概念

**线程（Thread）**是操作系统能够进行运算调度的最小单位，它是程序执行的基本单元。Java 是一种支持多线程的语言，允许多个线程同时运行，从而提高应用程序的响应能力和性能。

2. 创建线程的方式

Java 提供两种主要方式来创建线程：

2.1 继承 Thread 类

步骤：

  1. 创建一个类继承 Thread。
  2. 重写 run() 方法。
  3. 创建线程对象并调用 start() 方法。

示例：

class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " - Count: " + i);
            try {
                Thread.sleep(500); // 模拟工作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ThreadExample {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();
        thread1.start(); // 启动线程
        thread2.start(); // 启动另一个线程
    }
}

解析：在这个例子中，两个线程同时运行，输出各自的计数。

2.2 实现 Runnable 接口

步骤：

  1. 创建一个类实现 Runnable 接口。
  2. 重写 run() 方法。
  3. 创建 Thread 对象并传入 Runnable 实现。

示例：

class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " - Count: " + i);
            try {
                Thread.sleep(500); // 模拟工作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class RunnableExample {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new MyRunnable());
        Thread thread2 = new Thread(new MyRunnable());
        thread1.start(); // 启动线程
        thread2.start(); // 启动另一个线程
    }
}

解析：使用 Runnable 接口可以更灵活地使用线程，支持多个线程共享同一个 Runnable 实例。

3. 线程的生命周期

Java 线程的生命周期主要包括以下几个状态：

状态描述
新建线程被创建，但尚未启动。
就绪线程准备好执行，但可能因资源争用而被暂停。
运行线程正在执行任务。
阻塞线程等待某个资源（如 I/O 操作）。
死亡线程执行完毕或异常退出。

状态转换示意：

  • 从新建到就绪：调用 start() 方法。
  • 从就绪到运行：操作系统调度线程运行。
  • 从运行到阻塞：调用 wait()、sleep()、join() 等方法。
  • 从运行到死亡：run() 方法执行完毕或抛出异常。

4. 线程的同步

多线程编程中，多个线程可能会同时访问共享资源，这时需要进行同步，以避免数据不一致或冲突。

4.1 使用 synchronized 关键字

方法同步：

class Counter {
    private int count = 0;

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

    public int getCount() {
        return count;
    }
}

解析：increment() 方法被 synchronized 修饰，确保同一时间只有一个线程可以访问该方法，避免数据竞争。

对象锁：

class Counter {
    private int count = 0;

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

    public int getCount() {
        return count;
    }
}

解析：在这种方式下，使用 synchronized 块来控制访问范围，可以提高效率。

4.2 使用 Lock 接口

使用 java.util.concurrent.locks 包中的 Lock 接口提供更灵活的锁机制。

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

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

    public void increment() {
        lock.lock(); // 获取锁
        try {
            count++;
        } finally {
            lock.unlock(); // 确保释放锁
        }
    }

    public int getCount() {
        return count;
    }
}

解析：使用 ReentrantLock 提供显式锁，确保线程安全，并且在 finally 块中释放锁，避免死锁。

5. Java 并发包 java.util.concurrent

Java 提供的 java.util.concurrent 包包含许多用于构建并发程序的高级工具和类。

5.1 常用的并发工具
  • Executor 框架：用于管理线程池，简化线程管理。

示例：

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

public class ExecutorExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 5; i++) {
            executor.submit(() -> {
                System.out.println("Task is running in " + Thread.currentThread().getName());
            });
        }
        executor.shutdown(); // 关闭线程池
    }
}

解析：使用 ExecutorService 创建一个固定大小的线程池，提交任务后，线程池会管理线程的创建和销毁。

  • 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 FutureExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<Integer> future = executor.submit(() -> {
            Thread.sleep(1000);
            return 123; // 返回结果
        });

        System.out.println("Result: " + future.get()); // 阻塞，直到结果准备好
        executor.shutdown();
    }
}

解析：通过 Future 可以获取异步任务的执行结果，get() 方法会阻塞直到结果可用。

  • CountDownLatch：用于实现线程间的等待机制。

示例：

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3);
        
        Runnable task = () -> {
            try {
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName() + " has completed.");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                latch.countDown(); // 计数减一
            }
        };

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

        latch.await(); // 等待计数器为0
        System.out.println("All tasks completed.");
    }
}

 解析：CountDownLatch 允许主线程等待所有子线程完成后再继续执行。

5.2 线程安全的集合类

Java 提供了一些线程安全的集合类，常见的有：

  • ConcurrentHashMap：一个高效的线程安全哈希表。

示例：

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentMapExample {
    public static void main(String[] args) {
        ConcurrentHashMap<Integer, String> map = new ConcurrentHashMap<>();
        map.put(1, "One");
        System.out.println(map.get(1));

        map.putIfAbsent(2, "Two"); // 只有在键2不存在时才插入
        System.out.println(map.get(2));
    }
}

 解析：ConcurrentHashMap 在多线程环境中安全地处理并发读写操作。

  • CopyOnWriteArrayList：适合读多写少的场景。

示例：

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

public class CopyOnWriteExample {
    public static void main(String[] args) {
        List<String> list = new CopyOnWriteArrayList<>();
        list.add("A");
        list.add("B");
        System.out.println(list);
        
        list.remove("A"); // 安全删除
        System.out.println(list);
    }
}

 解析：在读操作频繁且写操作少的情况下，CopyOnWriteArrayList 可以有效避免并发问题。

6. 线程的常用方法

  • start()：启动线程，调用 run() 方法。
  • run()：线程执行的方法，不能直接调用。
  • join()：等待线程结束，常用于主线程等待其他线程完成。

示例：

class JoinExample extends Thread {
    public void run() {
        System.out.println(Thread.currentThread().getName() + " is running");
    }

    public static void main(String[] args) throws InterruptedException {
        JoinExample thread = new JoinExample();
        thread.start();
        thread.join(); // 主线程等待 JoinExample 完成
        System.out.println("Main thread continues");
    }
}

解析：主线程调用 join()，会等待 JoinExample 线程执行完毕后再继续执行。

7. 线程池

使用线程池可以有效地管理线程资源，避免频繁创建和销毁线程的开销。

示例：

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

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

        for (int i = 0; i < 10; i++) {
            int taskId = i;
            pool.submit(() -> {
                System.out.println("Task " + taskId + " is being executed by " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000); // 模拟任务执行
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        pool.shutdown(); // 关闭线程池
    }
}

 解析：在这个例子中，使用线程池管理多个任务，并发执行，避免了创建线程的开销。

8. 并发编程中的常见问题

8.1 死锁

死锁是指两个或多个线程在执行过程中，因为争夺资源而造成的一种相互等待的现象。

示例：

class DeadlockExample {
    static class A {
        synchronized void methodA(B b) {
            System.out.println("Thread 1: Holding lock A...");
            try { Thread.sleep(100); } catch (InterruptedException e) {}
            System.out.println("Thread 1: Waiting for lock B...");
            b.last();
        }
        synchronized void last() {}
    }

    static class B {
        synchronized void methodB(A a) {
            System.out.println("Thread 2: Holding lock B...");
            try { Thread.sleep(100); } catch (InterruptedException e) {}
            System.out.println("Thread 2: Waiting for lock A...");
            a.last();
        }
        synchronized void last() {}
    }

    public static void main(String[] args) {
        final A a = new A();
        final B b = new B();

        new Thread(() -> a.methodA(b)).start();
        new Thread(() -> b.methodB(a)).start();
    }
}

解析：在这个例子中，两个线程相互持有对方的锁，导致死锁。

8.2 饥饿

饥饿是指某个线程长时间得不到执行，导致无法运行的现象。

示例：

import java.util.concurrent.locks.ReentrantLock;

public class StarvationExample {
    private static final ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) {
        Runnable task = () -> {
            while (true) {
                lock.lock();
                try {
                    System.out.println(Thread.currentThread().getName() + " is running");
                } finally {
                    lock.unlock();
                }
            }
        };

        new Thread(task).start();
        new Thread(task).start();
    }
}

 解析：由于锁的竞争，某些线程可能一直无法获得锁，导致饥饿现象。

9. 总结

Java 提供了强大的线程和并发支持，通过核心类（Thread、Runnable、Lock 等）和 java.util.concurrent 包，可以方便地实现多线程编程。理解线程的生命周期、同步机制、并发工具，以及常见问题和解决方案，能够帮助开发者编写高效、安全的并发程序。

10. 进一步学习

建议深入了解 Java 并发的相关书籍，如《Java并发编程实战》，以获取更深入的知识和最佳实践。同时，通过实践项目来提高自己的并发编程能力。

十八岁妙龄光头
关注
java 模拟多线程并发_Java中模拟同时并发请求
weixin_30647423的博客
02-12 3011
有时需要测试一下某个功能的并发性能，又不要想借助于其他工具，索性就自己的开发语言，来一个并发请求就最方便了。java中模拟并发请求，自然是很方便的，只要多开几个线程，发起请求就好了。但是，这种请求，一般会存在启动的先后顺序了，算不得真正的同时并发！怎么样才能做到真正的同时并发呢？是本文想说的点，java中提供了闭锁 CountDownLatch, 刚好就用来做这种事就最合适了。只需要：开启n个线程...
java-java面试题库整理-基础-JVM-线程并发-框架等.zip
02-06
这份"java-java面试题库整理-基础-JVM-线程并发-框架等.zip"文件提供了一个全面的复习资源，帮助求职者准备Java相关的面试。 1. **Java基础知识** - 类与对象：Java是一种面向对象的语言，了解类的定义、构造器、...
Java多线程与并发
lydms的博客
06-21 1万+
假设线程A已经拥有了某个对象（不是类）的锁，而其它线程B、C想要调用这个对象的某个 synchronized方法（或者块），由于B、C线程在进入对象的 synchronized方法（或者块）之前必须先获得该对象锁的拥有权，而恰巧该对象的锁目前正被线程A所占用，此时B、C线程就会被阻塞，进入一个地方去等待锁的释放，这个地方便是该对象的锁池。假设线程A调用了某个对象的wat（）方法，线程A就会释放该对象的锁，同时线程A就进入到了该对象的等待池中，进入到等待池中的线程不会去竞争该对象的锁。
Java多线程并发编程技术详解
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
03-20 3万+
Java多线程并发编程是一项需要深入理解和熟练掌握的技术，只有合理地设计和使用多线程，才能真正发挥其在提升系统性能方面的巨大潜力。随着对Java并发机制及工具类库的深入学习和应用，开发者可以更好地构建高效、稳定的并发系统。
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
热门推荐
qq_35716689的博客
03-10 25万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
Java 并发和线程处理
沉淀、分享、成长，让自己和他人都能有所收获！
06-26 5万+
大家好，我是默语，擅长全栈开发、运维和人工智能技术。在本篇博客中，我们将深入探讨 Java 并发和线程处理的最佳实践，特别是在多线程编程中如何确保线程安全性和避免死锁。理解并发编程的原理及应用场景，对于开发高效稳定的 Java 应用程序至关重要。通过这篇文章，您将全面掌握 Java 并发处理的核心技术，并学会如何在实际项目中有效应用这些技术。并发是指多个任务在同一时间段内执行，线程是操作系统能够独立执行调度的最小单位。在 Java 中，通过多线程编程可以实现并发任务的处理，提高程序的执行效率。
Java--多线程之并发，并行，进程，线程（一）
MinggeQingchun的博客
03-12 2666
以下对并发、并行、进程、线程的理解引自 阿里巴巴技术专家Hollis Java并发编程 一、并发 并发（Concurrent），在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行。 无论是Windows、Linux还是MacOS等其实都是多用户多任务分时操作系统。使用这些操作系统的用户是可以“同时”干多件事的 二、并行 并行（Parallel），当系统有一个以上CPU时，当一个CPU执行一个进程时，另一个CPU可以执行另一个进程，两个进.
JAVA多线程并发
xunjiu的博客
02-22 1万+
JAVA线程实现/创建方式 1.继承Thread类 Thread类本质上时实现了Runnable接口的一个实例，代表一个现成的实例。启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法 public class MyThread extends Thread{ public void run(){ System.out.println("MyTread.r...
JAVA多线程并发编程汇总
lsp12lsp的博客
10-26 2058
java并发编程汇总
JAVA多线程和并发编程（三）- JAVA多线程信息共享
u010888864的博客
11-15 2730
JAVA多线程和并发编程
并发编程- (2) Java线程
weixin_51275389的博客
09-03 1978
直接调用run方法不会开启新线程 ==> 不会异步。
人工智能-项目实践-多线程-Java多线程高并发实例.zip
01-04
通过分析和运行这些代码，你将能够更深入地理解Java多线程在高并发场景下的实际运用，从而在你的人工智能项目中实现更高效、更稳定的数据处理。 总之，这个项目实例旨在帮助开发者掌握Java多线程技术，提升处理高...
Java-并发-线程通信详解和案例演示
12-22
  多个线程并发执行时,在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行,那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据。...
JAVA并发编程-2-线程并发工具类
01-20
本章主要介绍java.util.concurrent下给我们提供的线程并发工具类的作用和使用场景。 一、Fork/Join 1、分而治之与工作密取 Fork/Join框架体现了分而治之的思想，就是在必要的情况下，将一个大任务进行拆分(fork)成...
Java 多线程与并发(1-26)-Java 并发 - 理论基础.pdf
07-12
Java 多线程与并发是 Java 编程语言中的一种机制，用于提高程序的执行效率和响应速度。多线程的出现是为了解决 CPU、内存、I/O 设备速度差异的问题，通过分时复用 CPU、缓存和进程、线程机制来平衡速度差异。 Java...
基于SSM班级事务管理系统的设计
最新发布
2401_87849773的博客
10-15 383
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Java分布式锁
juanmiao的专栏
10-12 680
每种方法都有其优点和适应的场景，数据库通常简单，但可能存在性能问题，redis非常快，但需要第三方库，并且可能引入网诺问题，Zookeeper提供了更复杂的同步原语，但需要额外学习曲线。分布式锁的实现比线程锁和进程锁要复杂得多，因为它需要在网诺中的多个节点之间进行协调，以保证锁的唯一性和一致性。在实现分布式锁时，通常会有一个中心节点（或者称为锁服务），所有需要获取锁的节点都需要向这个中心节点申请。这个中心节点负责协调和管理所有节点的锁请求，确保锁的唯一性和一致性。创建临时节点，执行业务逻辑，释放锁。
Java安卓开发之Fragment开发（通俗易懂版）——第8章
一个脚本小子的博客
10-13 686
FragmentManager中的getSupportFragmentManager()方法不支持Activity，不论是旧版的FragmentManager还是新版的，因此我们要把继承Activity类改成继承AppCompatActivity类。
确保Spring Boot定时任务只执行一次方案
2301_76419561的博客
10-14 511
确保Spring Boot定时任务只执行一次有多种方法，你可以根据实际需求选择最适合的方法。如果你需要更复杂的任务调度或周期性执行，@Scheduled注解和接口是更合适的选择。而对于一次性的初始化任务或应用程序启动任务，注解和实现接口则更为简洁明了。
Java多线程与并发编程详解
"Java多线程与并发编程...Java的多线程与并发编程提供了一套全面的工具和概念，帮助开发者构建能够有效利用硬件资源并处理复杂并发场景的应用。理解和熟练掌握这些概念和工具，对于编写高效、稳定的并发程序至关重要。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值