当前位置： 首页 > news >正文

java多并发问题与解决办法以及为什么不能在多线程环境中使用非线程安全的集合？

news 来源：原创 2025/5/15 4:08:12

 

目录

 1. 线程安全问题

 2. 死锁问题

 3. 资源竞争问题

 4. 线程饥饿问题

 5. 内存可见性问题

 6. 线程池资源耗尽问题

 7. 并发集合的误用问题

 8. Future 和 CompletableFuture 的异常处理问题

 9. 锁的误用问题

 10. 并发中的性能瓶颈问题

11. 拓展：为什么不能在多线程环境中使用非线程安全的集合？

 1. 非线程安全集合的设计问题

 2. 具体问题示例

 示例 1：HashMap 的并发问题

 示例 2：ArrayList 的并发问题

 3. 为什么不能使用非线程安全集合？

 4. 解决方案

 4.1 使用 ConcurrentHashMap

 4.2 使用 Collections.synchronizedMap

 4.3 使用 CopyOnWriteArrayList

 5. 总结

12. 总结

      在Java并发编程中，多线程和并发问题是非常常见的。以下是一些典型的并发问题及其示例代码，帮助你理解这些问题是如何发生的以及如何解决。

 1. 线程安全问题

线程安全问题是指多个线程同时访问共享资源时，可能导致数据不一致或意外行为。

 示例：线程不安全的计数器

public class UnsafeCounter {

    private int count = 0;



    public void increment() {

        count++; // 不是原子操作

    }



    public int getCount() {

        return count;

    }



    public static void main(String[] args) throws InterruptedException {

        UnsafeCounter counter = new UnsafeCounter();

        int threadCount = 1000;



        // 创建多个线程同时调用 increment

        Thread[] threads = new Thread[threadCount];

        for (int i = 0; i < threadCount; i++) {

            threads[i] = new Thread(() -> {

                for (int j = 0; j < 1000; j++) {

                    counter.increment();

                }

            });

            threads[i].start();

        }



        // 等待所有线程完成

        for (Thread thread : threads) {

            thread.join();

        }



        System.out.println("Expected count: 1000000, Actual count: " + counter.getCount());

        // 输出可能小于 1000000，因为 increment 不是原子操作

    }

}

 解决方法：

- 使用 synchronized 关键字确保方法或代码块的线程安全。

- 使用 AtomicInteger 等原子类。

- 使用 ReentrantLock 等显式锁。

 2. 死锁问题

死锁是指两个或多个线程因为互相等待对方持有的锁而无法继续执行。

 示例：死锁的产生

public class DeadlockExample {

    private final Object lockA = new Object();

    private final Object lockB = new Object();



    public void methodA() {

        synchronized (lockA) {

            System.out.println("Acquired lockA in methodA");

            try {

                Thread.sleep(100); // 模拟耗时操作

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

            synchronized (lockB) {

                System.out.println("Acquired lockB in methodA");

            }

        }

    }



    public void methodB() {

        synchronized (lockB) {

            System.out.println("Acquired lockB in methodB");

            try {

                Thread.sleep(100); // 模拟耗时操作

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

            synchronized (lockA) {

                System.out.println("Acquired lockA in methodB");

            }

        }

    }



    public static void main(String[] args) {

        DeadlockExample example = new DeadlockExample();



        Thread thread1 = new Thread(() -> example.methodA());

        Thread thread2 = new Thread(() -> example.methodB());



        thread1.start();

        thread2.start();

    }

}

 解决方法：

- 避免嵌套锁。

- 按固定的顺序获取锁。

- 使用 tryLock 方法尝试获取锁，而不是直接锁定。

 3. 资源竞争问题

资源竞争是指多个线程同时访问共享资源，导致资源状态不一致。

 示例：资源竞争

public class ResourceRace {

    private boolean flag = false;



    public void setFlag() {

        flag = true;

        System.out.println("Flag set to true");

    }



    public void checkFlag() {

        if (flag) {

            System.out.println("Flag is true");

        } else {

            System.out.println("Flag is false");

        }

    }



    public static void main(String[] args) {

        ResourceRace race = new ResourceRace();



        // 线程1设置 flag

        Thread thread1 = new Thread(() -> {

            try {

                Thread.sleep(100);

                race.setFlag();

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        });



        // 线程2检查 flag

        Thread thread2 = new Thread(() -> {

            race.checkFlag();

        });



        thread1.start();

        thread2.start();

    }

}

 解决方法：

- 使用 volatile 关键字确保变量的可见性。

- 使用 synchronized 或 Lock 确保操作的原子性。

 4. 线程饥饿问题

线程饥饿是指某些线程因为资源竞争而无法获得足够的执行时间。

 示例：线程饥饿

public class ThreadStarvation {

    private final Object lock = new Object();

    private boolean flag = false;



    public void producer() {

        while (true) {

            synchronized (lock) {

                flag = true;

                System.out.println("Producer set flag to true");

                try {

                    Thread.sleep(100);

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

            }

        }

    }



    public void consumer() {

        while (true) {

            synchronized (lock) {

                if (flag) {

                    System.out.println("Consumer found flag true");

                    flag = false;

                } else {

                    System.out.println("Consumer found flag false");

                }

                try {

                    Thread.sleep(100);

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

            }

        }

    }



    public static void main(String[] args) {

        ThreadStarvation starvation = new ThreadStarvation();



        Thread producerThread = new Thread(starvation::producer);

        Thread consumerThread = new Thread(starvation::consumer);



        producerThread.setPriority(Thread.MAX_PRIORITY);

        consumerThread.setPriority(Thread.MIN_PRIORITY);



        producerThread.start();

        consumerThread.start();

    }

}

 解决方法：

- 调整线程优先级。

- 使用公平锁（如 ReentrantLock 的公平模式）。

- 使用线程池合理分配任务。

 5. 内存可见性问题

内存可见性问题是指一个线程对共享变量的修改，其他线程可能无法立即看到。

 示例：内存可见性问题

public class VisibilityIssue {

    private boolean ready = false;



    public void prepare() {

        ready = true;

        System.out.println("Resource is ready");

    }



    public void use() {

        if (ready) {

            System.out.println("Resource is used");

        } else {

            System.out.println("Resource is not ready");

        }

    }



    public static void main(String[] args) {

        VisibilityIssue issue = new VisibilityIssue();



        Thread preparer = new Thread(() -> {

            try {

                Thread.sleep(100);

                issue.prepare();

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        });



        Thread user = new Thread(() -> {

            issue.use();

        });



        preparer.start();

        user.start();

    }

}

 解决方法：

- 使用 volatile 关键字确保变量的可见性。

- 使用 synchronized 或 Lock 确保操作的同步。

 6. 线程池资源耗尽问题

线程池配置不当可能导致资源耗尽，例如线程池的队列过长或线程数不足。

 示例：线程池资源耗尽

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.TimeUnit;



public class ThreadPoolExhaustion {

    public static void main(String[] args) {

        // 创建一个固定大小的线程池，线程数为 2

        ExecutorService executor = Executors.newFixedThreadPool(2);



        // 提交大量任务

        for (int i = 0; i < 1000; i++) {

            executor.submit(() -> {

                try {

                    // 模拟耗时任务

                    Thread.sleep(1000);

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

            });

        }



        // 关闭线程池

        executor.shutdown();

        try {

            // 等待所有任务完成

            executor.awaitTermination(1, TimeUnit.MINUTES);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    }

}

 解决方法：

- 合理配置线程池的大小和队列长度。

- 使用 RejectedExecutionHandler 处理拒绝的任务。

- 根据实际需求调整线程池的配置。

 7. 并发集合的误用问题

如果使用了非线程安全的集合（如 ArrayList 或 HashMap），在多线程环境下可能会导致数据不一致或程序崩溃。

 示例：HashMap 的并发问题

import java.util.HashMap;

import java.util.Map;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;



public class HashMapConcurrentIssue {

    private static final Map<Integer, Integer> map = new HashMap<>();



    public static void main(String[] args) {

        ExecutorService executor = Executors.newFixedThreadPool(10);



        // 多线程向 HashMap 中添加数据

        for (int i = 0; i < 1000; i++) {

            executor.submit(() -> {

                for (int j = 0; j < 1000; j++) {

                    map.put(j, j);

                }

            });

        }



        executor.shutdown();

    }

}

 解决方法：

- 使用线程安全的集合（如 ConcurrentHashMap）。

- 使用 Collections.synchronizedMap 包装非线程安全的集合。

- 在多线程环境中避免使用非线程安全的集合。

 8. Future 和 CompletableFuture 的异常处理问题

在使用 Future 或 CompletableFuture 时，如果没有正确处理异常，可能会导致程序崩溃或未预期的行为。

 示例：CompletableFuture 的异常处理

import java.util.concurrent.CompletableFuture;

import java.util.concurrent.ExecutionException;



public class CompletableFutureException {

    public static void main(String[] args) {

        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {

            // 模拟异常

            throw new IllegalArgumentException("Something went wrong");

        });



        future.thenAccept(result -> System.out.println("Result: " + result));



        try {

            future.get(); // 这里会抛出异常

        } catch (InterruptedException | ExecutionException e) {

            e.printStackTrace();

        }

    }

}

 解决方法：

- 使用 exceptionally 方法处理异常。

- 使用 handle 方法捕获异常并返回默认值。

- 在调用 get() 时捕获异常。

 9. 锁的误用问题

过度使用锁可能导致性能下降，甚至引发死锁。

 示例：过度使用锁

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;



public class LockOveruse {

    private final Lock lock = new ReentrantLock();



    public void methodA() {

        lock.lock();

        try {

            // 模拟耗时操作

            Thread.sleep(1000);

        } catch (InterruptedException e) {

            e.printStackTrace();

        } finally {

            lock.unlock();

        }

    }



    public void methodB() {

        lock.lock();

        try {

            // 模拟耗时操作

            Thread.sleep(1000);

        } catch (InterruptedException e) {

            e.printStackTrace();

        } finally {

            lock.unlock();

        }

    }



    public static void main(String[] args) {

        LockOveruse example = new LockOveruse();



        // 多线程调用 methodA 和 methodB

        for (int i = 0; i < 10; i++) {

            new Thread(example::methodA).start();

            new Thread(example::methodB).start();

        }

    }

}

 解决方法：

- 使用更细粒度的锁（如分段锁）。

- 使用无锁数据结构（如 ConcurrentHashMap）。

- 使用 synchronized 或 ReentrantLock 的公平模式。

 10. 并发中的性能瓶颈问题

并发程序中，锁竞争或线程切换可能导致性能瓶颈。

 示例：锁竞争导致的性能瓶颈

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;



public class LockContention {

    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) throws InterruptedException {

        LockContention counter = new LockContention();

        int threadCount = 1000;



        Thread[] threads = new Thread[threadCount];

        for (int i = 0; i < threadCount; i++) {

            threads[i] = new Thread(() -> {

                for (int j = 0; j < 1000; j++) {

                    counter.increment();

                }

            });

            threads[i].start();

        }



        for (Thread thread : threads) {

            thread.join();

        }



        System.out.println("Final count: " + counter.count);

    }

}

 解决方法：

- 使用原子类（如 AtomicInteger）减少锁竞争。

- 使用无锁算法或并发集合。

- 优化锁的粒度和使用方式。

11. 拓展：为什么不能在多线程环境中使用非线程安全的集合？

在多线程环境中，不能使用非线程安全的集合（如 ArrayList、HashMap 等），因为它们的设计没有考虑并发安全问题，这会导致数据不一致、程序崩溃或其他不可预测的行为。以下是详细原因和示例：

 1. 非线程安全集合的设计问题

非线程安全的集合（如 ArrayList、HashMap）在单线程环境下是完全安全的，因为它们的实现假设只有一个线程在操作数据。然而，在多线程环境下，多个线程可能会同时访问或修改同一个集合，导致以下问题：

- 竞态条件（Race Conditions）：多个线程同时访问或修改集合，导致数据不一致。

- 并发修改异常（ConcurrentModificationException）：一个线程在迭代集合时，另一个线程修改了集合。

- 数据丢失或覆盖：多个线程同时写入数据，导致某些数据被覆盖或丢失。

- 程序崩溃：某些操作（如 HashMap 的扩容）在并发环境下可能导致无限循环或其他异常。

 2. 具体问题示例

 示例 1：HashMap 的并发问题
import java.util.HashMap;

import java.util.Map;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;



public class HashMapConcurrentIssue {

    private static final Map<Integer, Integer> map = new HashMap<>();



    public static void main(String[] args) {

        ExecutorService executor = Executors.newFixedThreadPool(10);



        // 多线程向 HashMap 中添加数据

        for (int i = 0; i < 1000; i++) {

            executor.submit(() -> {

                for (int j = 0; j < 1000; j++) {

                    map.put(j, j); // 并发写入

                }

            });

        }



        executor.shutdown();

    }

}

问题：

- HashMap 的 put 操作不是原子性的，多个线程同时调用 put 可能导致数据丢失或覆盖。

- 在扩容时，HashMap 的内部链表可能会形成循环链表，导致无限循环。

 示例 2：ArrayList 的并发问题
import java.util.ArrayList;

import java.util.List;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;



public class ArrayListConcurrentIssue {

    private static final List<Integer> list = new ArrayList<>();



    public static void main(String[] args) {

        ExecutorService executor = Executors.newFixedThreadPool(10);



        // 多线程向 ArrayList 中添加数据

        for (int i = 0; i < 1000; i++) {

            executor.submit(() -> {

                for (int j = 0; j < 1000; j++) {

                    list.add(j); // 并发写入

                }

            });

        }



        executor.shutdown();

    }

}

问题：

- ArrayList 的 add 操作不是线程安全的，多个线程同时调用 add 可能导致数据丢失或数组越界。

- 如果一个线程在迭代 ArrayList 时，另一个线程修改了列表，会抛出 ConcurrentModificationException。

 3. 为什么不能使用非线程安全集合？

非线程安全集合在多线程环境下会导致以下问题：

- 数据不一致：多个线程同时读写数据，导致数据状态不一致。

- 异常行为：如 ConcurrentModificationException 或无限循环。

- 性能问题：频繁的异常处理或数据修复会降低程序性能。

 4. 解决方案

在多线程环境中，应该使用线程安全的集合，以下是几种常见的解决方案：

 4.1 使用 ConcurrentHashMap

ConcurrentHashMap 是线程安全的哈希表实现，适用于高并发场景：

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;



public class ConcurrentHashMapExample {

    private static final ConcurrentHashMap<Integer, Integer> map = new ConcurrentHashMap<>();



    public static void main(String[] args) {

        ExecutorService executor = Executors.newFixedThreadPool(10);



        for (int i = 0; i < 1000; i++) {

            executor.submit(() -> {

                for (int j = 0; j < 1000; j++) {

                    map.put(j, j); // 线程安全的写入

                }

            });

        }



        executor.shutdown();

    }

}
 4.2 使用 Collections.synchronizedMap

Collections.synchronizedMap 可以将普通的 Map 包装成线程安全的版本：

import java.util.Collections;

import java.util.Map;

import java.util.HashMap;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;



public class SynchronizedMapExample {

    private static final Map<Integer, Integer> map = Collections.synchronizedMap(new HashMap<>());



    public static void main(String[] args) {

        ExecutorService executor = Executors.newFixedThreadPool(10);



        for (int i = 0; i < 1000; i++) {

            executor.submit(() -> {

                for (int j = 0; j < 1000; j++) {

                    map.put(j, j); // 线程安全的写入

                }

            });

        }



        executor.shutdown();

    }

}
 4.3 使用 CopyOnWriteArrayList

CopyOnWriteArrayList 是线程安全的列表实现，适用于读多写少的场景：

import java.util.concurrent.CopyOnWriteArrayList;

import java.util.List;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;



public class CopyOnWriteArrayListExample {

    private static final List<Integer> list = new CopyOnWriteArrayList<>();



    public static void main(String[] args) {

        ExecutorService executor = Executors.newFixedThreadPool(10);



        for (int i = 0; i < 1000; i++) {

            executor.submit(() -> {

                for (int j = 0; j < 1000; j++) {

                    list.add(j); // 线程安全的写入

                }

            });

        }



        executor.shutdown();

    }

}

 5. 总结

在多线程环境中，不能使用非线程安全的集合，因为它们会导致数据不一致、异常行为和性能问题。解决方法是使用线程安全的集合，如：

- ConcurrentHashMap：适用于高并发的哈希表操作。

- Collections.synchronizedMap：包装普通集合为线程安全版本。

- CopyOnWriteArrayList：适用于读多写少的场景。

通过选择合适的线程安全集合，可以确保程序在多线程环境下的稳定性和可靠性。

12. 总结

并发编程中的问题通常与线程安全、死锁、资源竞争、线程饥饿和内存可见性有关。解决这些问题的关键在于：

1. 确保共享资源的访问是线程安全的。

2. 避免死锁和资源竞争。

3. 合理管理线程优先级和资源分配。

4. 使用 Java 提供的并发工具（如 synchronized、volatile、Lock、Atomic 类等）来解决问题。

5. 合理选择并发工具（如线程池、原子类、并发集合等）。

6. 避免过度使用锁，尽量使用无锁或低锁的解决方案。

7. 正确处理异常和资源释放。

8. 根据实际需求优化并发程序的性能。

如果你有具体的场景或问题，可以进一步讨论，我可以提供更针对性的建议！

如果文章对您有帮助，还请您点赞支持
感谢您的阅读，欢迎您在评论区留言指正分享

相关文章：

  • ES 查看索引的属性的http请求
  • 2025年3月个人工作生活总结
  • 如何修复 SQL Server 数据库中的恢复挂起状态？
  • 数字电子技术基础（三十七）——利用Multisim软件实现16线-4线编码器和4线-16线译码器
  • LeetCode Hot100 刷题笔记（9）—— 二分查找、技巧
  • SQL Server：触发器
  • 【最后203篇系列】026 FastAPI+Celery(续)
  • 网络原理(详解TCP原理,应答机制三握四挥等)
  • oracle常用sql
  • 2025年渗透测试面试题总结-某 欧科云链-安全开发（题目+回答）
  • 使用 Sales_data 类实现交易合并（三十）
  • Clion刷题攻略-配置Cmake
  • TypeError: __init__() got an unexpected keyword argument ‘device_type‘
  • 模型部署与调用
  • OrbStack 作为 Mac 用户的 Docker 替代方案
  • 数据结构每日一题day9（顺序表）★★★★★
  • Thrust库中,host_vector和device_vector数据之间如何高效传输，有异步传输方式吗？
  • Linux 企业项目服务器组建（附脚本）
  • C++学习笔记（三十二）——priority_queue
  • Java基础 4.1
  • 李家超：明日起香港特区护照持有人可免签入境阿联酋
  • 菲律宾中期选举初步结果出炉，杜特尔特家族多人赢得地方选举
  • 通化市委书记孙简升任吉林省副省长
  • 字母哥动了离开的心思，他和雄鹿队的缘分早就到了头
  • 河北邯郸一酒店婚宴发生火灾：众人惊险逃生，酒店未买保险
  • 习近平会见古巴国家主席迪亚斯-卡内尔