基本线程机制
一个程序可以被划分为多个独立的任务,每个独立的任务可以由线程来驱动执行;
一个进程可以包含若干个线程,即拥有若干个并发执行的任务,在程序运行时,CPU时间被划分成片段分配给所有的线程;
在单处理器的机器上使用多线程可以提高性能的原因在于任务阻塞;
为机器增加处理器可以显著加快使用多线程程序的运行速度;
使用线程机制使程序更加透明、可扩展,代码不需要知道它是运行在单处理器还是多处理器上;
创建线程方式
方式一、创建一个任务类实现Runnable接口,并将其具体对象提交给Thread构造器
创建一个发射类LiftOff实现Runnable接口:
package concurrency;
public class LiftOff implements Runnable {
protected int countDown = 10; // Default
private static int taskCount = 0;
private final int id = taskCount++;
public LiftOff() {
}
public LiftOff(int countDown) {
this.countDown = countDown;
}
public String status() {
return Thread.currentThread() + "#" + id + "(" + (countDown > 0 ? countDown : "Liftoff!") + "), ";
}
public void run() {
while (countDown-- > 0) {
System.out.println(status());
Thread.yield();
}
}
}
以上代码中调用了Thread.yield()方法,该方法的作用是建议线程调度器切换到其它线程执行任务,注意,只是建议,不保证采纳;
创建完任务类之后,可以在Main函数中使用LiftOff对象创建一个Thread对象,并调用其start方法启动该线程,如下:
package concurrency;
public class BasicThreads {
public static void main(String[] args) {
Thread t = new Thread(new LiftOff());
t.start();
System.out.println(Thread.currentThread() + "Waiting for LiftOff");
}
}
打印结果如下,注意该程序中是同时存在两个线程(main和Thread-0)在运行的;
另外关于Thread对象的打印形式为[Thread-0,5,main],其中依次代表[线程名,线程优先级、线程组名], 具体可查看Thread类的toString方法;
Thread[main,5,main]Waiting for LiftOff
Thread[Thread-0,5,main]#0(9),
Thread[Thread-0,5,main]#0(8),
Thread[Thread-0,5,main]#0(7),
Thread[Thread-0,5,main]#0(6),
Thread[Thread-0,5,main]#0(5),
Thread[Thread-0,5,main]#0(4),
Thread[Thread-0,5,main]#0(3),
Thread[Thread-0,5,main]#0(2),
Thread[Thread-0,5,main]#0(1),
Thread[Thread-0,5,main]#0(Liftoff!),
最后,提个醒,有些人在创建完任务类后,直接在main函数中新建一个任务类对象,并调用其run方法,如下代码,运行正常,也看到了run方法中的运行结果,以为创建了线程,其实这种使用方式是错误的,并没有创建任何新线程,只是在main线程里调用执行了一个普通对象的方法而已;
package concurrency;
public class MainThread {
public static void main(String[] args) {
LiftOff launch = new LiftOff();
launch.run();
}
}
方式二、继承Thread类,调用其具体对象的start方法
package concurrency;
public class SimpleThread extends Thread {
private int countDown = 5;
private static int threadCount = 0;
public SimpleThread() {
// Store the thread name:
super(Integer.toString(++threadCount));
start();
}
public String toString() {
return "#" + getName() + "(" + countDown + "), ";
}
public void run() {
while (true) {
System.out.println(this);
if (--countDown == 0)
return;
}
}
public static void main(String[] args) {
for (int i = 0; i < 5; i++)
new SimpleThread();
}
}
对比通过实现Runnable接口的方式,该方式不建议使用,因为java的单继承机制,通常通过实现接口比继承会更好点;
另外还可以通过内部内部类将线程代码隐藏在类中,如下写法;
class InnerThread1 {
private int countDown = 5;
private Inner inner;
private class Inner extends Thread {
Inner(String name) {
super(name);
start();
}
public void run() {
try {
while (true) {
print(this);
if (--countDown == 0)
return;
sleep(10);
}
} catch (InterruptedException e) {
print("interrupted");
}
}
public String toString() {
return getName() + ": " + countDown;
}
}
public InnerThread1(String name) {
inner = new Inner(name);
}
}
方式三、创建一个任务类实现Runnable接口,并将其具体对象提交给Executors【推荐】
java.util.concurrent包中的执行器Executors可以帮助我们管理Thread对象,简化并发编程,如下,可以使用Executors类中的newCachedThreadPool静态方法创建一个可缓存的线程池,并用其执行相关任务;
package concurrency;
import java.util.concurrent.*;
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();
}
}
在Executors类中,除了通过newCachedThreadPool创建线程池外,还可以创建通过以下方法创建其它种类的线程池:
newFixedThreadPool:固定大小度的线程池
newSingleThreadExecutor:单线程线程池
newScheduledThreadPool:执行定时和周期性任务
方式四、创建一个任务类实现Callable接口,并将其具体对象提交给Executors【推荐】
实现Callable接口的类同样是一个任务类,与实现Runnable接口的区别是该方式可以有返回值;
在实现Callable接口的类中,线程执行的方法是call方法(有返回值),而不是run方法;
在main方法中可以通过调用ExecutorService的submit方法,返回一个Future对象,通过该对象可以获取线程运行的返回值,注意需要等Future完成后才能取得结果,可以通过isDone方法来查询Future是否已完成,或者直接调用get方法来获取(会阻塞,直到结果准备就绪)。
package concurrency;
import java.util.concurrent.*;
import java.util.*;
class TaskWithResult implements Callable<String> {
private int id;
public TaskWithResult(int id) {
this.id = id;
}
public String call() {
return "result of TaskWithResult " + id;
}
}
public class CallableDemo {
public static void main(String[] args) {
ExecutorService exec = Executors.newCachedThreadPool();
ArrayList<Future<String>> results = new ArrayList<Future<String>>();
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) {
System.out.println(e);
return;
} catch (ExecutionException e) {
System.out.println(e);
} finally {
exec.shutdown();
}
}
}
小结
其实,更普遍的,我觉得创建线程就两种形式:
- 直接通过new Thread创建线程(可传入任务对象);
- 创建任务对象提交给Executors去创建(其实内部的线程工厂也是通过new Thread创建);
另外,这里的任务对象也有两种方式创建,通过实现Runnable接口和实现Callable接口;
守护线程(后台线程)
daemon线程是指在程序运行的时候,在后台提供一种通用服务的线程,这种线程的优先级非常低;
当所有其他线程结束时,会杀死进程中的所有守护线程;
可以在线程启动之前通过setDaemon(true)方法将线程设置为守护线程,注意只能在启动之前设置;
通过守护线程创建的线程会被自动设置为守护线程;
可以通过isDaemon方法来判断一个线程是否是守护线程;
举个守护线程的例子,代码如下,当main线程运行结束后,所有的守护线程也被终止:
package concurrency;
import java.util.concurrent.*;
public class SimpleDaemons implements Runnable {
public void run() {
try {
while (true) {
TimeUnit.MILLISECONDS.sleep(100);
System.out.println(Thread.currentThread() + " " + this);
}
} catch (InterruptedException e) {
System.out.println("sleep() interrupted");
}
}
public static void main(String[] args) throws Exception {
for (int i = 0; i < 10; i++) {
Thread daemon = new Thread(new SimpleDaemons());
daemon.setDaemon(true); // Must call before start()
daemon.start();
}
System.out.println("All daemons started");
TimeUnit.MILLISECONDS.sleep(175);
}
}
加入一个线程Thread.join方法
一个线程(T1)可以在其它线程(T2)之上调用join方法,结果是T1线程被挂起,等待T2线程执行完毕(T2.isAlive()==false),然后继续执行T1线程;
也可以在join方法上加一个超时参数,保证join方法在指定时间内总能返回;
join方法可以被中断,如调用T2.interrupt()方法,中断后,join方法可以立即返回;
代码实例:
package concurrency;
class Sleeper extends Thread {
private int duration;
public Sleeper(String name, int sleepTime) {
super(name);
duration = sleepTime;
start();
}
public void run() {
try {
sleep(duration);
} catch (InterruptedException e) {
System.out.println(getName() + " was interrupted. "
+ "isInterrupted(): " + isInterrupted());
return;
}
System.out.println(getName() + " has awakened");
}
}
class Joiner extends Thread {
private Sleeper sleeper;
public Joiner(String name, Sleeper sleeper) {
super(name);
this.sleeper = sleeper;
start();
}
public void run() {
try {
sleeper.join();
} catch (InterruptedException e) {
System.out.println("Interrupted");
}
System.out.println(getName() + " join completed");
}
}
public class Joining {
public static void main(String[] args) {
Sleeper sleepy = new Sleeper("Sleepy", 1500), grumpy = new Sleeper(
"Grumpy", 1500);
Joiner dopey = new Joiner("Dopey", sleepy), doc = new Joiner("Doc",
grumpy);
grumpy.interrupt();
try {
sleepy.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("main thread continue until sleepy thread over");
}
}
在该示例中,我们把dopey、main线程加入到sleepy线程,doc线程加入到grumpy线程,结果如下:
grumpy线程被中断,然后join方法立即返回,打印Doc join completed,在grumpy线程中,isInterrupted()之所以打印false是因为异常捕获时把该标志清理了;
sleepy线程执行完毕后,join方法返回,继续执行dopey线程和main线程未完成部分,打印“main thread continue until sleepy thread over”和“Dopey join completed”;
捕获线程异常
在main方法中使用try-catch不能捕获其它线程产生的异常,如下示例,RuntimeException未被处理:
package concurrency;
import java.util.concurrent.*;
public class ExceptionThread implements Runnable {
public void run() {
throw new RuntimeException();
}
public static void main(String[] args) {
try {
ExecutorService exec = Executors.newCachedThreadPool();
exec.execute(new ExceptionThread());
} catch (RuntimeException ue) {
System.out.println("Exception has been handled!");
}
}
}
在JAVA SE5之前,可以使用线程组捕获异常,在JAVA SE5之后可以用Executor来解决这个问题;
只需要写一个异常处理类并实现Thread.UncaughtExceptionHandler接口,然后在创建线程的时候,设置该线程的未捕获异常处理器为该类实例,通过setUncaughtExceptionHandler方法设置,如下代码;
package concurrency;
import java.util.concurrent.*;
class ExceptionThread2 implements Runnable {
public void run() {
Thread t = Thread.currentThread();
System.out.println("run() by " + t);
System.out.println("eh = " + t.getUncaughtExceptionHandler());
throw new RuntimeException();
}
}
class MyUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler {
public void uncaughtException(Thread t, Throwable e) {
System.out.println("caught " + e);
}
}
class HandlerThreadFactory implements ThreadFactory {
public Thread newThread(Runnable r) {
System.out.println(this + " creating new Thread");
Thread t = new Thread(r);
System.out.println("created " + t);
t.setUncaughtExceptionHandler(new MyUncaughtExceptionHandler());
System.out.println("eh = " + t.getUncaughtExceptionHandler());
return t;
}
}
public class CaptureUncaughtException {
public static void main(String[] args) {
ExecutorService exec = Executors
.newCachedThreadPool(new HandlerThreadFactory());
exec.execute(new ExceptionThread2());
}
}
除了为每个线程设置专门的未捕获异常处理器外,还可以设置默认的未捕获异常处理器,当系统检查到某个线程没有专门的未捕获异常处理器的时候,会使用默认的未捕获异常处理器;
package concurrency;
import java.util.concurrent.*;
public class SettingDefaultHandler {
public static void main(String[] args) {
Thread.setDefaultUncaughtExceptionHandler(new MyUncaughtExceptionHandler());
ExecutorService exec = Executors.newCachedThreadPool();
exec.execute(new ExceptionThread());
}
}
参考资料:JAVA编程思想-4