Java多线程常见问题实例解析

原创 Myth丶恋晨 2024-10-21 23:03 75阅读 0赞

在Java多线程编程中,常见的问题包括但不限于以下几种:

  1. 死锁:两个或多个线程互相等待对方释放资源而造成的一种僵局。

实例:

  1. // 线程A
  2. public class ThreadA extends Thread {
  3. Object lockA = new Object();
  4. @Override
  5. public void run() {
  6. synchronized (lockA) { // 假设锁A是线程B的条件
  7. try {
  8. lockA.wait(); // A释放锁,进入wait状态
  9. } catch (InterruptedException e) {
  10. e.printStackTrace();
  11. }
  12. }
  13. // 获取锁A后执行任务
  14. System.out.println("Thread A is executing task after acquiring lock A.");
  15. // 重新获取锁B并释放锁A
  16. synchronized (lockA) {
  17. lockA.notifyAll(); // B通知所有等待锁A的线程
  18. try {
  19. lockA.wait(); // A再次进入wait状态,让位给B
  20. } catch (InterruptedException e) {
  21. e.printStackTrace();
  22. }
  23. }
  24. }
  25. }
  26. // 线程B
  27. public class ThreadB extends Thread {
  28. Object lockB = new Object();
  29. @Override
  30. public void run() {
  31. synchronized (lockB) { // 假设锁B是线程A的条件
  32. try {
  33. lockB.wait(); // B释放锁,进入wait状态
  34. } catch (InterruptedException e) {
  35. e.printStackTrace();
  36. }
  37. }
  38. // 获取锁B后执行任务
  39. System.out.println("Thread B is executing task after acquiring lock B.");
  40. // 重新获取锁A并释放锁B
  41. synchronized (lockB) {
  42. lockB.notifyAll(); // A通知所有等待锁B的线程
  43. try {
  44. lockB.wait(); // B再次进入wait状态,让位给A
  45. } catch (InterruptedException e) {
  46. e.printStackTrace();
  47. }
  48. }
  49. }
  50. }
  1. 资源争抢:多个线程同时访问有限资源(如文件、数据库连接等)。

实例:

  1. // 线程1
  2. public class Thread1 extends Thread {
  3. private Object lock = new Object();
  4. @Override
  5. public void run() {
  6. synchronized (lock) { // 获取锁
  7. try {
  8. // 执行任务,假设需要写入资源
  9. System.out.println("Thread 1 is executing task.");
  10. // 因资源有限,这里模拟等待锁释放
  11. lock.wait(); // 让位给其他线程
  12. } catch (InterruptedException e) {
  13. e.printStackTrace();
  14. }
  15. }
  16. // 如果任务完成,这里手动唤醒锁
  17. synchronized (lock) {
  18. lock.notifyAll(); // 唤醒所有等待锁的线程
  19. }
  20. }
  21. }
  22. // 线程2
  23. public class Thread2 extends Thread {
  24. private Object lock = new Object();
  25. @Override
  26. public void run() {
  27. synchronized (lock) { // 获取锁
  28. try {
  29. // 执行任务,假设需要读取资源
  30. System.out.println("Thread 2 is executing task.");
  31. // 因资源有限,这里模拟等待锁释放
  32. lock.wait(); // 让位给其他线程
  33. } catch (InterruptedException e) {
  34. e.printStackTrace();
  35. }
  36. }
  37. // 如果任务完成,这里手动唤醒锁
  38. synchronized (lock) {
  39. lock.notifyAll(); // 唤醒所有等待锁的线程
  40. }
  41. }
  42. }
  1. 死循环:多处可能导致无限循环的代码。

实例:

  1. public class InfiniteLoopExample {
  2. public void infiniteLoop() {
  3. while (true) { // 无限循环条件
  4. System.out.println("This is an infinite loop.");
  5. // 这里可能会导致无限等待,实际上需要睡眠或者处理其他任务
  6. Thread.sleep(1000); // 假设这需要1秒的睡眠时间
  7. }
  8. }
  9. public static void main(String[] args) {
  10. new InfiniteLoopExample().infiniteLoop();
  11. }
  12. }

以上例子展示了多线程编程中常见的问题及其解决方案。

文章版权声明:注明蒲公英云原创文章,转载或复制请以超链接形式并注明出处。

发表评论

表情:
评论列表 (有 0 条评论,75人围观)

还没有评论,来说两句吧...

相关阅读