线程开始运行，拥有自己的运行空间，按照流程执行，但是运行中的线程如果只是孤立的运行，没有和其他线程的交互，那么就无法有效的完成复杂的逻辑，如果让多个线程之间互相通信，协作执行，那么就可以完成比较复杂的工作，带来巨大的收益。因此研究线程之间的通信机制就很有必要了，本文简单讨论一下线程之间的通信机制以及线程通信的用法。
volatile和synchronized关键字
Java支持多个线程同时访问一个对象或者对象的成员变量，由于每个线程可以拥有这个变量的拷贝，所以程序在执行过程中，一个线程看到的变量并不一定是最新的。
关键字volatile可以用来修饰字段（成员变量），就是告知程序任何对该变量的访问均需要从共享内存中获取，而对它的改变必须同步刷新回共享内存，它能保证所有线程对变量访问的可见性。
关键字synchronized可以修饰方法或者以同步块的形式来进行使用，它主要确保多个线程在同一个时刻，只能有一个线程处于方法或者同步块中，它保证了线程对变量访问的可见性和排他性。
等待/通知机制
等待/通知机制，是指一个线程A调用了对象O的wait()方法进入等待状态，而另一个线程B调用了对象O的notify()或者notifyAll()方法，线程A收到通知后从对象O的wait()方法返回，进而执行后续操作。上述两个线程通过对象O来完成交互，而对象上的wait()和notify/notifyAll()的关系就如同开关信号一样，用来完成等待方和通知方之间的交互工作。
等待/通知的经典范式分为两部分，分别针对等待方（消费者）和通知方（生产者）。
等待方遵循如下原则。
1）获取对象的锁。
2）如果条件不满足，那么调用对象的wait()方法，被通知后仍要检查条件。
3）条件满足则执行对应的逻辑。
synchronized(对象) {
while(条件不满足) {
对象.wait();
}
对应的处理逻辑
}通知方遵循如下原则：
1）获得对象的锁。
2）改变条件。
3）通知等待在对象上的线程。
synchronized(对象) {
改变条件
对象.notifyAll();
}public class WaitNotify{
static boolean flag = true;
static Object lock = new Object();
public static void main(String[] args) {
Thread waitThread = new Thread(new Wait(), "WaitThread");
waitThread.start();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
Thread notifyThread = new Thread(new Notify(), "NotifyThread");
notifyThread.start();
}
static class Wait implements Runnable{
@Override
public void run() {
// 加锁，拥有lock的Monitor
synchronized (lock) {
// 当条件不满足时，继续wait，同时释放了lock的锁
while(flag){
try {
System.out.println(Thread.currentThread() + " flag is true. wait@ " +
new SimpleDateFormat("HH:mm:ss").format(new Date()));
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 条件满足时，完成工作
System.out.println(Thread.currentThread()+"flag is false. running@ "+
new SimpleDateFormat("HH:mm:ss").format(new Date()));
}
}
}
static class Notify implements Runnable{
@Override
public void run() {
// 加锁，拥有lock的Monitor
synchronized (lock) {
System.out.println(Thread.currentThread()+"hold lock. notify @ "+
new SimpleDateFormat("HH:mm:ss").format(new Date()));
lock.notifyAll();
flag = false;
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
synchronized (lock) {
System.out.println(Thread.currentThread() + " hold lock again. sleep@ " +
new SimpleDateFormat("HH:mm:ss").format(new Date()));
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}调用wait()、notify()以及notifyAll()时需要注意的细节：
- 使用wait()、notify()和notifyAll()时需要先对调用对象加锁。
- 调用wait()方法后，线程状态由RUNNING变为WAITING，并将当前线程放置到对象的等待队列。
- notify()或notifyAll()方法调用后，等待线程依旧不会从wait()返回，需要调用notify()或notifAll()的线程释放锁之后，等待线程才有机会从wait()返回。
- notify()方法将等待队列中的一个等待线程从等待队列中移到同步队列中，而notifyAll()方法则是将等待队列中所有的线程全部移到同步队列，被移动的线程状态由WAITING变为BLOCKED。
- 从wait()方法返回的前提是获得了调用对象的锁。
线程间通信的应用
模拟简单的数据库连接池
使用等待超时模式来构造一个简单的数据库连接池，在示例中模拟从连接池中获
取、使用和释放连接的过程，而客户端获取连接的过程被设定为等待超时的模式，也就是在1000毫秒内如果无法获取到可用连接，将会返回给客户端一个null。设定连接池的大小为10个，然后通过调节客户端的线程数来模拟无法获取连接的场景。
public class ConnectionDataPool {
private LinkedList<Connection> pool = new LinkedList<>();
public ConnectionDataPool(int initialSize) {
if (initialSize > 0) {
for (int i = 0; i < initialSize; i++) {
pool.addLast(ConnectionDriver.createConnection());
}
}
}
// 释放连接
public void releaseConnection(Connection connection) {
if (connection != null) {
synchronized (pool) {
// 连接释放后需要进行通知，这样其他消费者能够感知到连接池中已经归还了一个连接
pool.addLast(connection);
pool.notifyAll();
}
}
}
// 在mills内无法获取到连接，将会返回null
public Connection fetchConnection(long mills) throws InterruptedException {
synchronized (pool) {
if (mills <= 0)
return null;
else {
while (pool.isEmpty() && mills > 0) {
pool.wait();
}
Connection con = null;
if (!pool.isEmpty()) {
con = pool.removeFirst();
}
return con;
}
}
}
}
class ConnectionDriver {
static class ConnectionHandler implements InvocationHandler {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if (method.getName().equals("commit")) {
Thread.sleep(100);
}
return null;
}
}
// 创建一个Connection的代理，在commit时休眠100毫秒
public static final Connection createConnection() {
return (Connection) Proxy.newProxyInstance(ConnectionDriver.class.getClassLoader(),
new Class[] { Connection.class }, new ConnectionHandler());
}
}线程池技术
对于服务端的程序，经常面对的是客户端传入的短小（执行时间短、工作内容较为单一）任务，需要服务端快速处理并返回结果。如果服务端每次接受到一个任务，创建一个线程，然后进行执行，这在原型阶段是个不错的选择，但是面对成千上万的任务递交进服务器时，如果还是采用一个任务一个线程的方式，那么将会创建数以万记的线程。因为这会使操作系统频繁的进行线程上下文切换，无故增加系统的负载，而线程的创建和消亡都是需要耗费系统资源的，也无疑浪费了系统资源。
线程池技术能够很好地解决这个问题，它预先创建了若干数量的线程，并且不能由用户
直接对线程的创建进行控制，在这个前提下重复使用固定或较为固定数目的线程来完成任务的执行。这样做的好处是，一方面，消除了频繁创建和消亡线程的系统资源开销，另一方面，面对过量任务的提交能够平缓的劣化。
public class DefaultThreadPool<Job extends Runnable> {
// 线程池最大限制数
private static final int MAX_WORKER_NUMBERS = 10;
// 线程池默认的数量
private static final int DEFAULT_WORKER_NUMBERS = 5;
// 线程池最小的数量
private static final int MIN_WORKER_NUMBERS = 1;
// 这是一个工作列表，将会向里面插入工作
private final LinkedList<Job> jobs = new LinkedList<Job>();
// 工作者列表
private final List<Worker> workers = Collections.synchronizedList(new ArrayList<Worker>());
// 工作者线程的数量
private int workerNum = DEFAULT_WORKER_NUMBERS;
// 线程编号生成
private AtomicInteger threadNum = new AtomicInteger();
//创建默认数量线程的线程池
public DefaultThreadPool() {
initializeWokers(DEFAULT_WORKER_NUMBERS);
}
//创建指定数量线程的线程池
public DefaultThreadPool(int num){
workerNum = num > MAX_WORKER_NUMBERS ? MAX_WORKER_NUMBERS : num < MIN_WORKER_NUMBERS
? MIN_WORKER_NUMBERS : num;
initializeWokers(workerNum);
}
//初始化线程工作者
private void initializeWokers(int defaultWorkerNumbers) {
for(int i = 0; i < defaultWorkerNumbers;i++){
Worker work = new Worker();
workers.add(work);
//每一个人物调用一个线程
Thread thread = new Thread(work, "ThreadPool-Worker-" + threadNum.incrementAndGet());
thread.start();
}
}
//添加任务，然后通知工作者
public void execute(Job job){
if(job != null){
// 添加一个工作，然后进行通知
synchronized (jobs) {
jobs.addLast(job);
jobs.notify();
}
}
}
//增加工作者
public void addWorkers(int num){
synchronized (jobs) {
// 限制新增的Worker数量不能超过最大值
if (num + this.workerNum > MAX_WORKER_NUMBERS) {
num = MAX_WORKER_NUMBERS - this.workerNum;
}
initializeWokers(num);
this.workerNum += num;
}
}
//减少工作者
public void removeWorker(int num){
synchronized (jobs) {
if(num > this.workerNum){
throw new IllegalArgumentException("beyond workNum");
}
//按照给定的数量停止工作者
int count = 0;
while(count < num){
Worker worker = workers.get(count);
if(workers.remove(worker)){
worker.shutdown();
count++;
}
}
this.workerNum -= count;
}
}
//关闭线程池
public void shutdown(){
for(Worker worker : workers){
worker.shutdown();
}
}
// 工作者，负责消费任务
class Worker implements Runnable{
// 是否工作
private volatile boolean running = true;
@Override
public void run() {
while(running){
Job job = null;
synchronized (jobs) {
// 如果工作者列表是空的，那么就wait
if(jobs.isEmpty()){
try {
jobs.wait();
} catch (InterruptedException e) {
// 感知到外部对WorkerThread的中断操作，返回
Thread.currentThread().interrupt();
return;
}
}
job = jobs.removeFirst();
}
if(job != null){
try {
job.run();
} catch (Exception e) {
}
}
}
}
//停止工作
public void shutdown(){
running = false;
}
}
}
扫一扫
793
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
