一、线程和进程
进程:一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元,在传统的操作系统中,进程既是基本的分配单元,也是基本的执行单元。
线程:通常在一个进程中可以包含若干个线程,至少会有一个。线程可以利用进程所拥有的资源,是独立运行和独立调度的基本单位。
区别:每个进程拥有自己的一整套变量,而线程则共享数据。在有些操作系统中,线程比进程更“轻量级”,创建、撤销一个线程比启动新进程的开销要小得多。
进程的三个特征:
》独立性:进程是系统中独立存在的实体,拥有自己的独立资源和私有的地址空间。
》动态性:程序只是一个静态的指令集合,而进程是一个正在系统中活动的指令集合。
》并发性:多个进程可以在单个处理器上并发执行,进程之间不会互相影响。
并行:同一时刻,有多条指令在多个处理器上同时执行
并发:同一时刻,只能有一条指令执行。
多线程的优点:
》进程之间不能共享内存,但线程之间共享内存很容易。
》系统创建进程时需要为该进程重新分配系统资源,但创建线程则代价小得多,因此使用多线程实现多任务并发比多进程的效率高。
》Java语言内置了多线程的功能支持,而不是单纯地作为底层操作系统的调度方式,从而简化了Java的多线程编程。
二、实现多线程的方法
-
继承Thread类
1.定义Thread类的子类,重写其run()方法,该run方法即为线程执行体 。
2.创建Thread子类的实例,即创建线程对象。
3.调用线程对象的start()方法来启动线程。
/**
* Thread子类,run()中为线程执行体
**/
public class MyThread extends Thread {
private int i;
@Override
public void run() {
super.run();
while (i<10){
i++;
System.out.println(Thread.currentThread() + ":"+i);
}
}
}
/**
* Thread实现多线程-单元测试
**/
public class MyThreadTest {
@Test
public void testMyThread(){
MyThread myThread1 = new MyThread();
MyThread myThread2 = new MyThread();
myThread1.start();
myThread2.start();
}
}
打印结果:
由上面打印结果可见,Thread-0和Thread-1两个线程,打印的i值不连续。是因为i是MyThread的实例变量,而不是局部变量。程序每次创建线程对象时都需要创建一个MyThread对象,所以Thread-0和Thread-1不能共享该实例变量。
结论:
1.使用继承Thread类的方法创建线程类时,多个线程之间无法共享线程类的实例变量。
2.默认情况下,主线程名字为main,用户启动的多个线程的名字依次为Thread-0、Thread-1、…、Thread-n等。
Thread.currentThread():Thread类的静态方法,返回当前正在执行的线程对象。
getName():Thread类的实例变量,返回调用该方法的线程的名字。
setName():设置线程名称。
-
实现Runnable接口创建线程类
1.定义Runnable接口的实现类,并重写该接口的run()方法,该run()方法为线程执行体。
2.创建Runnable实现类的实例,以此实例作为Thread的target来创建Thread对象,该Thread对象才是真正的线程对象。
3.调用线程对象的start()方法来启动该线程。
/**
* Runnable接口实现类,run()为线程执行体
**/
public class MyRunnable implements Runnable {
private int i;
public void run() {
while (i<10){
i++;
System.out.println(Thread.currentThread().getName()+":i="+i);
}
}
}
/**
* 实现Runnable接口来实现多线程-单元测试
**/
public class MyRunnableTest {
@Test
public void testMyRunnable(){
MyRunnable myRunnable = new MyRunnable();
Thread t1 = new Thread(myRunnable);
Thread t2 = new Thread(myRunnable);
t1.start();
t2.start();
}
}
由打印结果可看,Thread-0和Thread-1打印的i值,是连续的。是因为这种情况下,程序创建的Runnable对象只是线程的target,而多个线程可以共享一个target,所以多个线程可以共享一个线程类(实际上是线程的target类)的实例变量。
结论:
1.Runnable对象仅仅作为Thread对象的target,Runnable实现类的run()方法仅作为线程执行体。实际的线程对象依然是Thread实例,只是该Thread线程负责执行其target的run()方法。
2.通过继承Thread类来获得当前线程,直接使用this即可;通过实现Runnable接口来获得当前线程对象,则必须使用Thread.currentThread()方法。
3.采用Runnable接口的方式创建的多线程,可以共享线程类的实例变量。
-
使用Callable和Future创建线程
Callable接口提供call()方法作为线程执行体,但是call()方法比run()方法功能更强大。
》call()方法可以有返回值。
》call()方法可以声明抛出异常。
Java提供了Future接口来代表Callable接口里call()方法的返回值。并未Future接口提供一个FutureTask实现类,该实现类实现了Future接口,也实现了Runnable接口,这个FutureTask的实现类作为Thread类的target。
Callable+Future 创建有返回值的线程的步骤:
1.创建Callable接口的实现类,并实现call()方法,该call()方法将作为线程执行体,且该call()方法有返回值,再创建Callable实现类的实力。
2.使用FutureTask类来包装Callable对象,该FutureTask对象封装了该Callable对象的call()方法的返回值。
3.使用FutureTask对象来作为Thread对象的target,创建并启动新线程。
4.调用FutureTask对象的get()方法,来获得子线程执行结束后的返回值。
代码示例:
/**
* Callable接口实现类,实现call()方法作为线程执行体
**/
public class MyCallable implements Callable<Integer> {
public Integer call() throws Exception {
int i = 0;
for (; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+" i="+i);
}
return i;
}
}
/**
* Callable创建线程并获取返回值-单元测试
**/
public class MyCallableTest {
@Test
public void testCallable(){
Thread t = new Thread();
FutureTask<Integer> task = new FutureTask<Integer>(new MyCallable());
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+"-"+i);
if(i == 5){
new Thread(task,"MyCallable Thread").start();
}
}
try{
//获取线程返回值
System.out.println("字线程的返回值:" + task.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
打印结果:(只截取部分)
call()方法会导致主线程被阻塞,直到call()方法结束并返回为止。
三、三种方式的对比
通过继承Thread类或实现Runnable、Callable接口都可以实现多线程,不过实现Runnable接口与实现Callable接口的方式基本相同,只是Callable接口定义的方法有返回值,也可以声明抛出异常。因此可以将实现Runnable接口和实现Callable接口归为一种方式。这种方式与继承Thread方式之间的主要差别如下。
采用实现Runnable、Callable接口的方式创建多线程的优缺点:
>线程类只是实现了Runnable接口或Callable接口,还可以继承其他类。
>在这种方式下,多个线程可以共享同一个target对象,所以非常适合多个相同线程来处理同一份资源的情况,从而可以将CPU、代码和数据分开,形成清晰的模型,较好的体现面向对象的思想。
>劣势:编程稍稍复杂,如果需要访问当前线程,必须使用Thread.currentThread()方法。
采用继承Thread类的方式创建多线程的优缺点:
>劣势:因为线程已经继承了Thread类,不能再继承其他父类。
>优势:编写简单,如果需要访问当前线程,直接使用this即可获得当前线程。
基于上面分析,一般推荐采用实现Runnable接口、Callable接口的方式来创建多线程。
Future API
boolean cancel(boolean mayInterruptIfRunning);试图取消该Future里关联的Callable任务。
V get();返回Callable任务里call()方法的返回值。调用该方法导致主线程阻塞,必须等子线程结束后才会得到返回值。
V get(long timeout,TimeUnit unit); 返回Callable任务里call()方法的返回值。该方法最多让程序阻塞timeout和unit指定的时间,如果经过指定时间Callable任务仍然没有返回值,将会抛出Timeout异常。
boolean isCancelled(); 如果Callable任务正常完成前被取消,则返回true。
boolean isDone(); 如果Callable任务已完成,则返回true。