基本线程机制
基本线程机制
一个程序可以被划分为多个独立的任务,每个独立的任务可以由线程来驱动执行;
一个进程可以包含若干个线程,即拥有若干个并发执行的任务,在程序运行时,CPU时间被划分成片段分配给所有的线程;
在单处理器的机器上使用多线程可以提高性能的原因在于任务阻塞;
为机器增加处理器可以显著加快使用多线程程序的运行速度;
使用线程机制使程序更加透明、可扩展,代码不需要知道它是运行在单处理器还是多处理器上;
创建线程方式
方式一、创建一个任务类实现Runnable接口,并将其具体对象提交给Thread构造器
创建一个发射类LiftOff实现Runnable接口:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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方法
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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的单继承机制,通常通过实现接口比继承会更好点;
另外还可以通过内部内部类将线程代码隐藏在类中,如下写法;
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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方法设置,如下代码;
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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