Java 编程问题:十、并发-线程池、可调用对象和同步器1

简介: Java 编程问题:十、并发-线程池、可调用对象和同步器

本章包括涉及 Java 并发的 14 个问题。我们将从线程生命周期以及对象级和类级锁定的几个基本问题开始。然后我们继续讨论 Java 中线程池的一系列问题,包括 JDK8 工作线程池。在那之后,我们有关于CallableFuture的问题。然后,我们将几个问题专门讨论 Java 同步器(例如,屏障、信号量和交换器)。在本章结束时,您应该熟悉 Java 并发的主要坐标,并准备好继续处理一组高级问题。

问题

使用以下问题来测试您的并发编程能力。我强烈建议您在使用解决方案和下载示例程序之前,先尝试一下每个问题:

  1. 线程生命周期状态:编写多个程序,捕捉线程的每个生命周期状态。
  2. 对象级与类级的锁定:写几个例子来举例说明通过线程同步实现对象级与类级的锁定。
  3. Java 中的线程池:简要概述 Java 中的线程池。
  4. 单线程线程池:编写一个程序,模拟一条装配线,用两个工作器来检查和打包灯泡。
  5. 固定线程数的线程池:编写一个程序,模拟一条装配线,使用多个工作器检查和打包灯泡。
  6. 缓存和调度线程池:编写一个程序,模拟装配线,根据需要使用工作器检查和打包灯泡(例如,调整打包机的数量(增加或减少)以吸收检查器产生的传入流量)。
  7. 偷工线程池:编写依赖偷工线程池的程序。更准确地说,编写一个程序,模拟一条装配线来检查和打包灯泡,如下所示:检查在白天进行,打包在晚上进行。检查过程导致每天有 1500 万只灯泡排队。
  8. CallableFuture:用CallableFuture编写模拟灯泡检查打包流水线的程序。
  9. 调用多个Callable任务:编写一个模拟装配线的程序,对灯泡进行检查和打包,如下所示:检查在白天进行,打包在晚上进行。检查过程导致每天有 100 个灯泡排队。包装过程应一次包装并归还所有灯泡。也就是说,我们应该提交所有的Callable任务,等待它们全部完成。
  10. 锁存器:编写一个依赖CountDownLatch的程序来模拟服务器的启动过程。服务器在其内部服务启动后被视为已启动。服务可以同时启动并且相互独立。
  11. 屏障:编写一个依赖CyclicBarrier来模拟服务器启动过程的程序。服务器在其内部服务启动后被视为已启动。服务可以同时启动(这很费时),但它们是相互依赖的—因此,一旦准备好启动,就必须一次启动所有服务。
  12. 交换器:编写一个程序,模拟使用Exchanger,一条由两名工作器组成的灯泡检查打包流水线。一个工作器(检查人员)正在检查灯泡,并把它们放进篮子里。当篮子装满时,工作器将篮子交给另一个工作器(包装工),他们从另一个工作器那里得到一个空篮子。这个过程不断重复,直到装配线停止。
  13. 信号量:编写一个程序,模拟每天在理发店使用一个Semaphore。我们的理发店一次最多只能接待三个人(只有三个座位)。当一个人到达理发店时,他们试着坐下。理发师为他们服务后,这个人就把座位打开。如果一个人在三个座位都坐满的时候到达理发店,他们必须等待一定的时间。如果这段时间过去了,没有座位被释放,他们将离开理发店。
  14. 移相器:编写一个依赖Phaser的程序,分三个阶段模拟服务器的启动过程。服务器在其五个内部服务启动后被视为已启动。在第一阶段,我们需要同时启动三个服务。在第二阶段,我们需要同时启动另外两个服务(只有在前三个服务已经运行的情况下才能启动)。在第三阶段,服务器执行最后一次签入,并被视为已启动。

解决方案

以下各节介绍上述问题的解决方案。记住,解决一个特定问题通常不是只有一种正确的方法。另外,请记住,这里显示的解释仅包括解决问题所需的最有趣和最重要的细节。下载示例解决方案以查看更多详细信息,并在这个页面中试用程序。

199 线程生命周期状态

Java 线程的状态通过Thread.State枚举表示。Java 线程的可能状态如下图所示:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SM3wWnYZ-1657345732714)(https://github.com/apachecn/apachecn-java-zh/raw/master/docs/java-coding-prob/img/49d6745e-1417-4768-aad8-ea8ab6832ed6.png)]

不同的生命周期状态如下:

  • 新建状态
  • 可运行状态
  • 阻塞状态
  • 等待状态
  • 定时等待状态
  • 终止状态

让我们在下面的部分学习所有不同的状态。

新建状态

如果 Java 线程已创建但未启动,则该线程处于新建状态(线程构造器以新建状态创建线程)。这是它的状态,直到start()方法被调用。本书附带的代码包含几个代码片段,这些代码片段通过不同的构造技术(包括 Lambda)揭示了这种状态。为简洁起见,以下只是其中一种结构:

public class NewThread {
  public void newThread() {
    Thread t = new Thread(() -> {});
    System.out.println("NewThread: " + t.getState()); // NEW
  }
}
NewThread nt = new NewThread();
nt.newThread();

可运行状态

通过调用start()方法获得从新建可运行的转换。在此状态下,线程可以正在运行或准备运行。当它准备好运行时,线程正在等待 JVM 线程调度器为它分配运行所需的资源和时间。一旦处理器可用,线程调度器就会运行线程。

下面的代码片段应该打印RUNNABLE,因为我们在调用start()之后打印线程的状态。但由于线程调度器的内部机制,这一点无法保证:

public class RunnableThread {
  public void runnableThread() {
    Thread t = new Thread(() -> {});
    t.start();
    // RUNNABLE
    System.out.println("RunnableThread : " + t.getState()); 
 }
}
RunnableThread rt = new RunnableThread();
rt.runnableThread();

阻塞状态

当线程试图执行 I/O 任务或同步块时,它可能会进入阻塞状态。例如,如果一个线程t1试图进入另一个线程t2正在访问的同步代码块,那么t1将保持在阻塞状态,直到它能够获得锁为止。

此场景在以下代码片段中形成:

  1. 创建两个线程:t1t2
  2. 通过start()方法启动t1
  1. t1将执行run()方法并获取同步方法syncMethod()的锁。
  2. 因为syncMethod()有一个无限循环,所以t1将永远留在里面。
  1. 2 秒(任意时间)后,通过start()方法启动t2
  1. t2将执行run()代码,由于无法获取syncMethod()的锁,最终进入阻塞状态。

代码段如下:

public class BlockedThread {
  public void blockedThread() {
    Thread t1 = new Thread(new SyncCode());
    Thread t2 = new Thread(new SyncCode());
    t1.start();
    Thread.sleep(2000);
    t2.start();
    Thread.sleep(2000);
    System.out.println("BlockedThread t1: " 
      + t1.getState() + "(" + t1.getName() + ")");
    System.out.println("BlockedThread t2: " 
      + t2.getState() + "(" + t2.getName() + ")");
    System.exit(0);
  }
  private static class SyncCode implements Runnable {
    @Override
    public void run() {
      System.out.println("Thread " + Thread.currentThread().getName() 
        + " is in run() method");
      syncMethod();
    }
    public static synchronized void syncMethod() {
      System.out.println("Thread " + Thread.currentThread().getName() 
        + " is in syncMethod() method");
      while (true) {
        // t1 will stay here forever, therefore t2 is blocked
      }
    }
  }
}
BlockedThread bt = new BlockedThread();
bt.blockedThread();

下面是一个可能的输出(线程的名称可能与此处不同):

Thread Thread-0 is in run() method
Thread Thread-0 is in syncMethod() method
Thread Thread-1 is in run() method
BlockedThread t1: RUNNABLE(Thread-0)
BlockedThread t2: BLOCKED(Thread-1)

等待状态

等待另一个线程t2完成的线程t1处于等待状态。

此场景在以下代码片段中形成:

  1. 创建线程:t1
  2. 通过start()方法启动t1
  3. t1run()方法中:
  1. 创建另一个线程:t2
  2. 通过start()方法启动t2
  3. t2运行时,调用t2.join()——由于t2需要加入t1(也就是说t1需要等待t2死亡),t1处于等待状态。
  1. t2run()方法中t2打印t1的状态,应该是等待(打印t1状态时t2正在运行,所以t1正在等待)。

代码段如下:

public class WaitingThread {
  public void waitingThread() {
    new Thread(() -> {
      Thread t1 = Thread.currentThread();
      Thread t2 = new Thread(() -> {
        Thread.sleep(2000);
        System.out.println("WaitingThread t1: " 
          + t1.getState()); // WAITING
      });
      t2.start();
      t2.join();
    }).start();
  }
}
WaitingThread wt = new WaitingThread();
wt.waitingThread();

定时等待状态

等待另一个线程t2完成显式时间段的线程t1处于定时等待状态。

此场景在以下代码片段中形成:

  1. 创建线程:t1
  2. 通过start()方法启动t1
  3. t1run()方法中,增加 2 秒的睡眠时间(任意时间)。
  4. t1运行时,主线程打印t1状态,该状态应为定时等待,因为t1处于两秒后过期的sleep()中。

代码段如下:

public class TimedWaitingThread {
  public void timedWaitingThread() {
    Thread t = new Thread(() -> {
      Thread.sleep(2000);
    });
    t.start();
    Thread.sleep(500);
    System.out.println("TimedWaitingThread t: " 
      + t.getState()); // TIMED_WAITING
  }
}
TimedWaitingThread twt = new TimedWaitingThread();
twt.timedWaitingThread();

终止状态

成功完成任务或异常中断的线程处于终止状态。模拟起来非常简单,如下面的代码片段(应用的主线程打印线程的状态,t——发生这种情况时,线程t已经完成了它的工作):

public class TerminatedThread {
  public void terminatedThread() {
    Thread t = new Thread(() -> {});
    t.start();
    Thread.sleep(1000);
    System.out.println("TerminatedThread t: " 
      + t.getState()); // TERMINATED
  }
}
TerminatedThread tt = new TerminatedThread();
tt.terminatedThread();

为了编写线程安全类,我们可以考虑以下技术:

  • 没有状态(类没有实例和static变量)
  • 状态,但不共享(例如,通过RunnableThreadLocal等使用实例变量)
  • 状态,但状态不可变
  • 使用消息传递(例如,作为 Akka 框架)
  • 使用synchronized
  • 使用volatile变量
  • 使用java.util.concurrent包中的数据结构
  • 使用同步器(例如,CountDownLatchBarrier
  • 使用java.util.concurrent.locks包中的锁

200 对象级与类级锁定

在 Java 中,标记为synchronized的代码块一次可以由一个线程执行。由于 Java 是一个多线程环境(它支持并发),因此它需要一个同步机制来避免并发环境特有的问题(例如死锁和内存一致性)。

线程可以在对象级或类级实现锁。

对象级别的锁定

对象级的锁定可以通过在非static代码块或非static方法(该方法的对象的锁定对象)上标记synchronized来实现。在以下示例中,一次只允许一个线程在类的给定实例上执行synchronized方法/块:

  • 同步方法案例:
public class ClassOll {
  public synchronized void methodOll() {
    ...
  }
}
  • 同步代码块:
public class ClassOll {
  public void methodOll() {
    synchronized(this) {
      ...
    }
  }
}
  • 另一个同步代码块:
public class ClassOll {
  private final Object ollLock = new Object();
  public void methodOll() {
    synchronized(ollLock) {
      ...
    }
  }
}

类级别的锁定

为了保护static数据,可以通过标记static方法/块或用synchronized获取.class引用上的锁来实现类级锁定。在以下示例中,一次只允许运行时可用实例之一的一个线程执行synchronized块:

  • synchronized static方法:
public class ClassCll {
  public synchronized static void methodCll() {
    ...
  }
}
  • .class同步块:
public class ClassCll {
  public void method() {
    synchronized(ClassCll.class) {
      ...
    }
  }
}
  • 同步的代码块和其他static对象的锁定:
public class ClassCll {
  private final static Object aLock = new Object();
  public void method() {
    synchronized(aLock) {
      ...
    }
  }
}

很高兴知道

以下是一些暗示同步的常见情况:

  • 两个线程可以同时执行同一类的synchronized static方法和非static方法(参见P200_ObjectVsClassLevelLockingApp 的OllAndCll类)。这是因为线程在不同的对象上获取锁。
  • 两个线程不能同时执行同一类的两个不同的synchronized static方法(或同一synchronized static方法)(检查P200_ObjectVsClassLevelLocking应用的TwoCll类)。这不起作用,因为第一个线程获得了类级锁。以下组合将输出staticMethod1(): Thread-0,因此,只有一个线程执行一个static synchronized方法:
TwoCll instance1 = new TwoCll();
TwoCll instance2 = new TwoCll();
  • 两个线程,两个实例:
new Thread(() -> {
  instance1.staticMethod1();
}).start();
new Thread(() -> {
  instance2.staticMethod2();
}).start();
  • 两个线程,一个实例:
new Thread(() -> {
  instance1.staticMethod1();
}).start();
new Thread(() -> {
  instance1.staticMethod2();
}).start();
  • 两个线程可以同时执行非synchronizedsynchronized staticsynchronizedstatic方法(检查P200_ObjectVsClassLevelLocking应用的OllCllAndNoLock类)。
  • 从需要相同锁的同一类的另一个synchronized方法调用synchronized方法是安全的,因为synchronized可重入的(只要是相同的锁,第一个方法获取的锁也会用于第二个方法)。检查P200_ObjectVsClassLevelLocking应用的TwoSyncs类。

根据经验,synchronized关键字只能用于static/非static方法(不是构造器)/代码块。避免同步非final字段和String文本(通过new创建的String实例是可以的)。

Java 编程问题:十、并发-线程池、可调用对象和同步器2https://developer.aliyun.com/article/1426162

相关文章
|
22小时前
|
设计模式 运维 安全
深入理解Java并发编程:线程安全与性能优化
【4月更文挑战第15天】在Java开发中,多线程编程是提升应用程序性能和响应能力的关键手段。然而,它伴随着诸多挑战,尤其是在保证线程安全的同时如何避免性能瓶颈。本文将探讨Java并发编程的核心概念,包括同步机制、锁优化、线程池使用以及并发集合等,旨在为开发者提供实用的线程安全策略和性能优化技巧。通过实例分析和最佳实践的分享,我们的目标是帮助读者构建既高效又可靠的多线程应用。
|
1天前
|
SQL 安全 Java
Java安全编程:防范网络攻击与漏洞
【4月更文挑战第15天】本文强调了Java安全编程的重要性,包括提高系统安全性、降低维护成本和提升用户体验。针对网络攻击和漏洞,提出了防范措施:使用PreparedStatement防SQL注入,过滤和转义用户输入抵御XSS攻击,添加令牌对抗CSRF,限制文件上传类型和大小以防止恶意文件,避免原生序列化并确保数据完整性。及时更新和修复漏洞是关键。程序员应遵循安全编程规范,保障系统安全。
|
2天前
|
Java 程序员 编译器
Java中的线程同步与锁优化策略
【4月更文挑战第14天】在多线程编程中,线程同步是确保数据一致性和程序正确性的关键。Java提供了多种机制来实现线程同步,其中最常用的是synchronized关键字和Lock接口。本文将深入探讨Java中的线程同步问题,并分析如何通过锁优化策略提高程序性能。我们将首先介绍线程同步的基本概念,然后详细讨论synchronized和Lock的使用及优缺点,最后探讨一些锁优化技巧,如锁粗化、锁消除和读写锁等。
|
3天前
|
Java 编译器
Java并发编程中的锁优化策略
【4月更文挑战第13天】 在Java并发编程中,锁是一种常见的同步机制,用于保证多个线程之间的数据一致性。然而,不当的锁使用可能导致性能下降,甚至死锁。本文将探讨Java并发编程中的锁优化策略,包括锁粗化、锁消除、锁降级等方法,以提高程序的执行效率。
11 4
|
4天前
|
Java
探秘jstack:解决Java应用线程问题的利器
探秘jstack:解决Java应用线程问题的利器
14 1
探秘jstack:解决Java应用线程问题的利器
|
4天前
|
Java 调度 开发者
Java 21时代的标志:虚拟线程带来的并发编程新境界
Java 21时代的标志:虚拟线程带来的并发编程新境界
14 0
|
4天前
|
存储 安全 Java
Java语法掌握:打好编程基础的关键(二)
Java语法掌握:打好编程基础的关键
24 0
|
7天前
|
存储 Java 数据库连接
java多线程之线程通信
java多线程之线程通信
|
18天前
|
存储 缓存 NoSQL
Redis单线程已经很快了6.0引入多线程
Redis单线程已经很快了6.0引入多线程
31 3
|
20天前
|
消息中间件 安全 Linux
线程同步与IPC:单进程多线程环境下的选择与权衡
线程同步与IPC:单进程多线程环境下的选择与权衡
57 0