并发（2）：基本的线程控制（上）

谁借莪１个温暖的怀抱￠ 2023-03-12 15:26 5阅读 0赞

并发编程使我们可以将程序划分为多个分离的、独立运行的任务。通过使用多线程机制，这些独立任务（也被称为子任务）中的每一个都将由执行线程来驱动。一个线程就是在进程中的一个单一的顺序控制流，因此，单个进程可以拥有多个并发执行的任务，但是你的程序使得每个任务都好像有其自己的CPU一样。其底层机制是切分CPU时间，但通常你不需要考虑它。

线程模型为编程带来了便利，它简化了在单一程序中同时交织在一起的多个操作的处理。在使用线程时，CPU将轮流给每个任务分配其占用时间。每个任务都觉得自己在一直占用CPU，但事实上CPU时间是划分成片段分配给了所有的任务（例外情况是程序确实运行在多个CPU之上）。线程的一大好处是可以使你从这个层次抽身出来，即代码不必知道它是运行在具有一个还是多个CPU的机器上。所以，使用线程机制是一种建立透明的、可扩展的程序的方法，如果程序运行的太慢，为机器增添一个CPU就能很容易地加快程序的运行速度。多任务和多线程往往是使用多处理器系统的最合理方式。

### 一、定义任务 ###

线程可以驱动任务，因此你需要一种描述任务的方式，这可以由Runnable接口来提供。要想定义任务，只需实现Runnable接口并编写run()方法，使得该任务可以执行你的命令。例如，下面的LiftOff任务将显示发射之前的倒计时：

package concurrency;
    
    public class LiftOff implements Runnable {
    
    	protected int countDown = 10;
    	private static int taskCount = 0;
    	private final int id = taskCount++;
    
    	public LiftOff() {
    	}
    
    	public LiftOff(int countDown) {
    		this.countDown = countDown;
    	}
    
    	public String status() {
    		return "#" + id + "(" + (countDown > 0 ? countDown : "Liftoff!") + "), ";
    	}
    
    	@Override
    	public void run() {
    		while (countDown-- > 0) {
    			System.out.println(status());
    			Thread.yield();
    		}
    	}
    }

标识符id可以用来区分任务的多个实例，它是final的，因为它一旦被初始化之后就不希望被修改。

任务的run()方法通常总会有某种形式的循环，使得任务一直运行下去直到不再需要，所以要设定跳出循环的条件（有一种选择是直接从run()返回）。通常，run()方法被写成无限循环的形式，这就意味着除非有某个条件使得run()终止，否则它将永远运行下去（在本章后面将会看到如何安全地终止线程）。

在run()中对静态方法Thread.yield()的调用是对线程调度器（java线程机制的一部分，可以将CPU从一个线程转移给另一个线程）的一种建议，它在声明：“我已经执行完声明周期中最重要的部分了，此刻正是切换给其他任务执行一段时间的大好时机。”这完全是选择性的，但是这里使用它是因为它会在这个示例中产生更加有趣的输出：你更有可能会看到任务换进换出的证据。

在下面的实例中，这个任务的run()不是由单独的线程驱动的，它是在main()中直接调用的（实际上，这里仍旧使用了线程，即总是分配给main()的那个线程）：

package concurrency;
    
    public class MainThread {
    	public static void main(String[] args) {
    		LiftOff launch = new LiftOff();
    		launch.run();
    	}
    }

当从Runnable导出一个类时，它必须具有run()方法，但是这个方法并无特殊之处——它不会产生任何内在的线程能力。要实现线程行为，你必须显式地将一个任务附着到线程上。

### 二、Thread类 ###

将Runnable对象转变为工作任务的传统方式是把它提交给一个Thread构造器，下面的示例展示了如何使用Thread来驱动LiftOff对象：

package concurrency;
    
    public class BasicThreads {
    	public static void main(String[] args) {
    		Thread t = new Thread(new LiftOff());
    		t.start();
    		System.out.println("waiting for LiftOff");
    	}
    }

Thread构造器只需要一个Runnable对象。调用Thread对象的start()方法为该线程执行必需的初始化操作，然后调用Runnable的run()方法，以便在这个新线程中启动该任务。尽管start()看起来是产生了一个对长期运行方法的调用，但是从输出中可以看到，start()迅速地返回了，因为"waiting for LiftOff"消息在倒计时完成之前就出现了。实际上，你产生的是对LiftOff.run()的方法调用，并且这个方法还没有完成，但是因为LiftOff.run()是由不同的线程执行的，因此你仍旧可以执行main()线程中的其他操作（这种能力并不局限于main()线程，任何线程都可以启动另一个线程）。因此，程序会同时运行两个方法，main()和LiftOff.run()是程序中与其他线程“同时”执行的代码。

你可以很容易地添加更多的线程去驱动更多的任务。下面，你可以看到所有任务彼此之间是如何互相呼应的：

package concurrency;
    
    public class MoreBasicThreads {
    	public static void main(String[] args) {
    		for (int i = 0; i < 5; i++) {
    			new Thread(new LiftOff()).start();
    		}
    		System.out.println("Waiting for LiftOff");
    	}
    }

输出说明不同任务的执行在线程被换进换出时混在了一起。这种交换是由线程调度器自动控制的。如果在你的机器上有多个处理器，线程调度器将会在这些处理器之间默默地分发线程。

这个程序一次运行的结果可能与另一次运行的结果不同，因为线程调度机制是非确定性的。事实上，你可以看到，在某个版本的JDK与下个版本之间，这个简单程序的输出会产生巨大的差异。例如，较早的JDK不会频繁对时间切片，因此线程1可能会首先循环到尽头，然后线程2会经历其所有循环，等等。这实际上与调用一个例程去同时执行所有的循环一样，只是启动所有线程的代价要更加高昂。较晚的JDK看起来会产生更好的时间切片行为，因此每个线程看起来都会获得更加正规的服务。通常，Sun并未提及这些种类的JDK的行为变化，因此你不能依赖于任何线程行为的一致性。最好的方式是编写使用线程的代码时，尽可能地保守。

当main()创建Thread对象时，它并没有捕获任何对这些对象的引用。在使用普通对象时，这对于垃圾回收来说是一场公平的游戏，但是在使用Thread时，情况就不同了。每个Thread都“注册”了它自己，因此确实有一个对它的引用，而且在它的任务退出其run()并死亡之前，垃圾回收器无法清除它。你可以从输出中看到，这些任务确实运行到了结束，因此，一个线程会创建一个单独的执行线程，在对start()的调用完成之后，它仍旧会继续存在。

### 三、使用Executor ###

javaSE5的java.util.concurrent包中的执行器（Executor）将为你管理Thread对象，从而简化了并发编程。Executor在客户端和任务执行之间提供了一个间接层；与客户端直接执行任务不同，这个中介对象将执行任务。Executor允许你管理异步任务的执行，而无须显式的管理线程的生命周期。Executor在java SE5/6中是启动任务的优选方法。

我们可以使用Executor来代替在MoreBasicThreads.java中显示地创建Thread对象。LiftOff对象知道如何运行具体的任务，与命令设计模式一样，它暴露了要执行的单一方法。ExecutorService（具有服务生命周期的Executor，例如关闭）知道如何构建恰当的上下文来执行Runnable对象。在下面的示例中，CachedThreadPool将为每个任务都创建一个线程。注意，ExecutorService对象是使用静态的Executor方法创建的，这个方法可以确定其Executor类型：

package concurrency;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class CachedThreadPool {
    	public static void main(String[] args) {
    		ExecutorService exec = Executors.newCachedThreadPool();
    		for (int i = 0; i < 5; i++) {
    			exec.execute(new LiftOff());
    		}
    		exec.shutdown();
    	}
    }

非常常见的情况是，单个Executor被用来创建和管理系统中所有的任务。

对shutdown()方法的调用可以防止新任务被提交给这个Executor，当前线程（在本例中，即驱动main()的线程）将继续运行在shutdown()被调用之前提交的所有任务。这个程序将在Executor中的所有任务完成之后尽快退出。

你可以很容易地将前面示例中的CachedThreadPool替换为不同类型的Executor。FixedThreadPool使用了有限的线程集来执行所提交的任务：

package concurrency;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class FixedThreadPool {
    	public static void main(String[] args) {
    		ExecutorService exec = Executors.newFixedThreadPool(5);
    		for (int i = 0; i < 5; i++) {
    			exec.execute(new LiftOff());
    		}
    		exec.shutdown();
    	}
    }

有了FixedTheadPool，你就可以一次性预先执行代价高昂的线程分配，因而也就可以限制线程的数量了。这可以节省时间，因为你不用为每个任务都固定付出创建线程的开销。在事件驱动的系统中，需要线程的事件处理器，通过直接从池中获取线程，也可以如你所愿尽快得到服务。你不会滥用可获得的资源，因为FixedThreadPool使用的Thread对象的数量是有界的。

注意，在任何线程池中，现有线程在可能的情况下，都会被自动复用。

尽管本章中将使用CachedThreadPool，但是也应该考虑在产生线程的代码中使用FixedThreadPool。CacheThreadPool在程序执行过程中通常会创建与所需数量相同的线程，然后在它回收旧线程时停止创建新线程，因此它是合理的Executor的首选。只有当这种方式会引发问题时，你才需要切换到FixedThreadPool。

SingleThreadExecutor就像是线程数量为1的FixedThreadPool。这对于你希望在另一个线程中连续运行的任何事物（长期存活的任务）来说，都是很有用的，例如监听进入的套接字连接的任务。它对于希望在线程中运行的短任务也同样很方便，例如，更新本地或远程日志的小任务，或者是事件分发线程。

如果向SingleThreadExecutor提交了多个任务，那么这些任务将排队，每个任务都会在下一个任务开始之前运行结束，所有的任务将使用相同的线程。在下面的示例中，你可以看到每个任务都是按照它们被提交的顺序，并且是在下一个任务开始之前完成的。因此，SingleThreadExecutor会序列化所有提交给它的任务，并会维护它自己（隐藏）的悬挂任务队列。

package concurrency;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class SingleThreadExecutor {
    	public static void main(String[] args) {
    		ExecutorService exec = Executors.newSingleThreadExecutor();
    		for (int i = 0; i < 5; i++) {
    			exec.execute(new LiftOff());
    		}
    		exec.shutdown();
    	}
    }

作为另一个示例，假设你有大量的线程，那它们运行的任务将使用文件系统。你可以用SingleThreadExecutor来运行这些线程，以确保任意时刻在任何线程中都只有唯一个任务在运行。在这种方式中，你不需要在共享资源上处理同步（同时不会过度使用文件系统）。有时更好的解决方案是在资源上同步（你将在本章稍后学习），但是SingleThreadExecutor可以让你省去只是为了维护某些事物的原型而进行的各种协调努力。通过序列化任务，你可以消除对序列化对象的需求。

### 四、从任务中产生返回值 ###

Runnable是执行工作的独立任务，但是它不返回任何值。如果你希望任务在完成时能够返回一个值，那么可以实现Callable接口而不是Runnable接口。在java SE5中引入了Callable是一种具有类型参数的泛型，它的类型参数表示是从方法call()（而不是run()）中返回的值，并且必须使用ExecutorService.submit()方法调用它，下面是一个简单的示例：

package concurrency;
    
    import java.util.ArrayList;
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.Future;
    
    class TaskWithResult implements Callable<String> {
    
    	private int id;
    
    	public TaskWithResult(int id) {
    		this.id = id;
    	}
    
    	@Override
    	public String call() throws Exception {
    		return "result of TaskWithResult " + id;
    	}
    }
    
    public class CallableDemo {
    	public static void main(String[] args) {
    		ExecutorService exec = Executors.newCachedThreadPool();
    		ArrayList<Future<String>> results = new ArrayList<>();
    		for (int i = 0; i < 10; i++) {
    			results.add(exec.submit(new TaskWithResult(i)));
    		}
    		for (Future<String> fs : results) {
    			try {
    				System.out.println(fs.get());
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    				return;
    			} catch (ExecutionException e) {
    				e.printStackTrace();
    			} finally {
    				exec.shutdown();
    			}
    		}
    	}
    }

submit()方法产生Future对象，它用Callable返回结果的特定类型进行了参数化。你可以用isDone()方法来查询Future是否已经完成。当任务完成时，它具有一个结果，你可以调用get()方法来获取该结果。你也可以不用isDone()进行检查直接调用get()，在这种情况下，get()阻塞，直至结果准备就绪。你还可以在试图调用get()来获取结果之前，先调用具有超时的get()，或者调用isDone()来查看任务是否完成。

### 五、休眠 ###

影响任务行为的一种简单方法是调用sleep()，这将使任务中止执行给定的时间，在LiftOff类中，要是把对yield()的调用换成调用sleep()，将得到如下结果：

package concurrency;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.TimeUnit;
    
    public class SleepingTask extends LiftOff {
    	public void run() {
    		try {
    			while (countDown-- > 0) {
    				System.out.println(status());
    				TimeUnit.MILLISECONDS.sleep(100);
    			}
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    	}
    
    	public static void main(String[] args) {
    		ExecutorService exec = Executors.newCachedThreadPool();
    		for (int i = 0; i < 5; i++) {
    			exec.execute(new SleepingTask());
    		}
    		exec.shutdown();
    	}
    }

对sleep()的调用可以抛出InterruptedException异常，并且你可以看到，它在run()中被捕获。因为异常不能跨线程传播回main()，所以你必须在本地处理所有在任务内部产生的异常。

java SE5引入了更加显式的sleep()版本，作为TimeUtil类的一部分，就像上面示例所示的那样。这个方法允许你指定sleep()延迟的时间单元，因此可以提供更好的可阅读性。TimeUtil还可以被用来执行转换，就像稍后你会看到的那样。

你可能会注意到，这些任务是按照“完美的分布”顺序运行的，即从0到4，然后再回过头从0开始，当然这取决于你的平台。这是有意义的，因为在每个打印语句之后，每个任务都将要睡眠（即阻塞），这使得线程调度器可以切换到另一个线程，进而驱动另一个任务。但是，顺序行为依赖于底层的线程机制，这种机制在不同的操作系统之间是有差异的，因此，你不能依赖于它。如果你必须控制任务执行的顺序，那么最好的押宝就是使用同步控制（稍后描述），或者在某些情况下，压根不使用线程，但是要编写自己的协作例程，这些例程将会按照指定的顺序在互相之间传递控制权。

**如果本文对您有很大的帮助，还请点赞关注一下。**