java多线程系列----------- 终结任务（一）

最新推荐文章于 2021-04-19 23:43:22 发布

FreeQuantum

最新推荐文章于 2021-04-19 23:43:22 发布

阅读量649

点赞数

分类专栏： Java开发文章标签： java编程思想线程状态转换

本文链接：https://blog.csdn.net/zhoupenglei/article/details/46009489

版权

Java开发专栏收录该内容

14 篇文章 0 订阅

订阅专栏

能有此文十分感谢《Java编程思想》一书及其作者Bruce Eckel！

首先，先观察一个示例，它不仅演示了终止问题，而且还是一个资源共享的示例。

一、装饰性花园

在这个仿真程序中，花园委员会希望了解每天通过多个大门进入公园的总人数。每个大门都有一个某种形式的计数器，并且任何一个计数器值递增时，表示公园中的总人数的共享计数器的值也会递增。

import java.util.concurrent.*;
import java.util.*;

class Count {
	private int count = 0;
	private Random rand = new Random(47);

	// Remove the synchronized keyword to see counting fail:
	public synchronized int increment() {
		int temp = count;
		if (rand.nextBoolean()) // Yield half the time
			Thread.yield();
		return (count = ++temp);
	}

	public synchronized int value() {
		return count;
	}
}

class Entrance implements Runnable {
	private static Count count = new Count();
	private static List<Entrance> entrances = new ArrayList<Entrance>();
	private int number = 0;
	// Doesn't need synchronization to read:
	private final int id;
	private static volatile boolean canceled = false;

	// Atomic operation on a volatile field:
	public static void cancel() {
		canceled = true;
	}

	public Entrance(int id) {
		this.id = id;
		// Keep this task in a list. Also prevents
		// garbage collection of dead tasks:
		entrances.add(this);
	}

	public void run() {
		while (!canceled) {
			synchronized (this) {
				++number;
			}
			System.out.println(this + " Total: " + count.increment());
			try {
				TimeUnit.MILLISECONDS.sleep(100);
			} catch (InterruptedException e) {
				System.out.println("sleep interrupted");
			}
		}
		System.out.println("Stopping " + this);
	}

	public synchronized int getValue() {
		return number;
	}

	public String toString() {
		return "Entrance " + id + ": " + getValue();
	}

	public static int getTotalCount() {
		return count.value();
	}

	public static int sumEntrances() {
		int sum = 0;
		for (Entrance entrance : entrances)
			sum += entrance.getValue();
		return sum;
	}
}

public class OrnamentalGarden {
	public static void main(String[] args) throws Exception {
		ExecutorService exec = Executors.newCachedThreadPool();
		for (int i = 0; i < 5; i++)
			exec.execute(new Entrance(i));
		// Run for a while, then stop and collect the data:
		TimeUnit.SECONDS.sleep(3);
		Entrance.cancel();
		exec.shutdown();
		if (!exec.awaitTermination(250, TimeUnit.MILLISECONDS))
			System.out.println("Some tasks were not terminated!");
		System.out.println("Total: " + Entrance.getTotalCount());
		System.out.println("Sum of Entrances: " + Entrance.sumEntrances());
	}
}

这里使用单个的Count对象来跟踪花园参观者的主计数值，并且将其当作Entrance类中的一个静态域进行存储。Count.increment()和Count.value()都是synchronized的，用来控制对count域的访问。increment()方法使用了Random对象，目的是从把count读取到temp中，到递增temp并将其存储回count的这段时间里，有大约一半时间产生让步。如果将increment()上的synchronized关键字注释掉，那么这个程序就会崩溃，因为过个任务将同时访问并修改count（yield()会使问题更快地发生）。

每个Entrance任务都维护着一个本地值number，它包含通过某个特定入口进入的参观者的数量。这提供了对count对象的双重检查，以确保其记录的参观者数量是正确的。Entrance.run()只是递增number和count对象，然后休眠100毫秒。

因为Entrance.canceled是一个volatile布尔标志，而它只会被读取和赋值（不会与其他域组合一起被读取），所以不需要同步对其访问，就可以安全地操作它。如果你对诸如此类的情况有任何疑虑，那么最好使用synchronized。

这个程序在以稳定的方式关闭所有事物方面还有一些小麻烦，其部分原因是为了说明在终止多线程程序时你必须相当小心，而另一部分原因是为了演示interrupt()的值。

在3秒钟之后，main()向Entrance发送static cancel()消息，然后调用exec对象的shutdown()方法。ExecutorService.awaitTermination()等待每个任务结束，如果所有的任务在超时时间达到之前全部结束，则返回true，否则返回false。尽管这会导致每个任务都退出其run()方法，并因此作为任务而终止，但是Entrance对象仍旧是有效的，因为在构造器中，每个Entrance对象都存储在称为entrances的静态List<Entrance>中，因此，sumEntrances()仍旧可以作用于这些有效的Entrance对象。

当这个程序运行时，你将看到，在人们通过大门时，将显示总人数和通过每个入口的人数。如果移除Count.increment()上面的synchronized，将会看到总人数与你期望的有差异，每个入口统计的人数将与count中的值不同。只要用互斥来同步对Count的访问，问题就可以解决了。