1.概述
1.1 进程
进程的特征:
(1)独立性:进程是系统中独立存在的实体,他可以拥有自己独立的资源,每一个进程都拥有自己私有的地址空间,在没有经过进程本身允许的情况下,一个用户进程不可以直接访问其他进程的地址空间
(2)动态性:程序只是一个静态的指令集合,进程是一个正在系统中活动的指令集合。在进程中加入了时间的概念。进程具有自己的生命周期和各种不同的状态,这些概念在程序中都是不具备的。
(3)并发性:多个进程可以在单个处理器上并发执行,多个进程之间不会相互影响。
并行:指在同一时刻,有多条指令在多个处理器上同时执行;
并发:指在同一时刻,只能有一条指令执行,但多个进程指令被快速轮换执行,使得在宏观上具有多个进程同时执行的效果。
1.2线程
(1)线程是进程的执行单元,线程在程序中是独立的、并发的执行流。
(2)当进程被初始化后,主线程就被创建了。
(3)线程是进程的组成部分,一个进程可以拥有多个线程,一个线程必须有一个父进程。线程的调度和管理由金城本身负责完成。
(4)线程可以拥有自己的堆栈、自己的程序计数器和自己的局部变量,但不拥有系统资源,他与父进程的其他线程共享该进程所拥有的全部资源。
(5)一个线程可以创建和撤销另一个进程,同一个进程中的多个线程之间可以并发执行。
1.3多线程的优势
与分割的进程相比,进程中线程之间的隔离程度要小。他们共享内存、文件句柄和其他每个进程应有的状态。进程在执行过程中拥有独立的内存单元,而多个线程共享内存。
线程比进程具有更高的性能,因为**多个线程共享同一个进程的虚拟空间。**线程的共享还包括:**进程代码段**、**进程的共有数据等**。利用这些共享的数据,线程很容易实现相互之间的通信。
多线程编程的优点:
(1)进程之间不能共享内存,但线程之间共享内存非常容易;
(2)系统创建进程时需要为该进程重新分配系统资源,但创建线程则代价小得多,因此使用多线程来实现多任务并发比多进程的效率高。
(3)Java语言内置了多线程功能支持,而不是淡出地作为底层操作系统的调度方式,从而化简了Java的多线程编程。
2.线程的创建和启动
Java使用Thread类代表线程,所有的线程都必须是Thread类或其子类的实例。下面是三种创建线程类的方式。
2.1 继承Thread类创建线程类
步骤:
1.定义Thread类的子类,并重写该类的run()方法,该run()方法的方法体就代表了线程需要完成的任务,因此吧run()方法称为线程执行体。
2.创建Thread子类的实例,即创建了线程对象。
3.调用线程对象的start()方法来启动该线程。
主线程的线程执行体不是由run()方法确定的,而是由main()方法确定的——main()方法的方法体代表主线程的线程执行体。
注意:使用继承Thread类的方法来创建线程时,多个线程之间无法共享线程类的实例变量。
Eg:
public class FirstThread extends Thread{
private int i;
public void run(){
for ( ; i < 100; i++) {
//当线程类集成Thread类时,直接使用this即可获得当前线程
System.out.println(getName()+" "+i);
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+" "+i);
if (i == 20) {
//创建并启动线程
new FirstThread().start();
new FirstThread().start();
}
}
}
}
2.2 实现Runnable创建线程类
步骤:
1.定义Runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。
2.创建Runnable实现类的实例,并以此实例作为Thread的target来创建Thread对象,该Thread对象才是真正的线程对象。
3.调用线程对象的start()方法来启动线程。
Runnable对象仅仅作为Thread对象的target,Runnable实现类里包含的run()方法仅作为线程执行体。而实际的线程对象依然是Thread实例,只是该Thread线程负责执行其target的run()方法。
public class SecondThread implements Runnable {
private int i;
@Override
public void run() {
// TODO Auto-generated method stub
for (; i < 100; i++) {
//当线程类实现Runnable接口时,如果想获取当前线程,只能用Thread.currentThread()方法
System.out.println(Thread.currentThread().getName()+" "+i);
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+" "+i);
if (i == 20) {
SecondThread st = new SecondThread();
new Thread(st,"新线程1").start();
new Thread(st,"新线程2").start();
}
}
}
}
采用Runnable接口的方式创建的多个线程可以共享线程类的实例变量。因为在这种方式下,程序所创建的Runnable对象只是线程的target,而多个线程可以共享同一个target,所以多个线程可以共享同一个线程类(实际上应该是现成的target类)的实例变量。
Runnable接口中只包含一个抽象方法,从Java8开始,Runnable接口使用了@FunctionalInterface修饰。也就是说,Runnable接口是函数式接口,可使用Lambda表达式创建Runnable对象。
2.3 使用Callable和Future创建线程
Callable接口提供了一个call()方法可以作为线程执行体,call()方法可以有返回值,且可以声明抛出异常。
Java5提供了Future接口来代表Callable接口里call()方法的返回值,并为Future接口提供了一个FutureTask实现类,该实现类实现了Future接口,并实现了Runnable接口——可以作为Thread类的target。
Callable接口有泛型限制,Callable接口里的泛型形参类型与call()方法返回值类型相同。而且Callble接口是函数式接口,因此可使用Lambda表达式创建Callable对象。
步骤:
1.创建Callable接口的实现类,并实现call()方法,该call()方法将作为线程执行体,且该call()方法有返回值,再创建Callable实现类的实例。从Java8开始,可以直接使用Lambda表达式创建Callable对象。
2.使用FutureTask类来包装Callable对象,该FutureTask对象封装了该Callable对象的call()方法的返回值。
3.使用FutureTask对象作为Thread对象的target创建并启动新的线程。
4.调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。
Eg.
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
public class ThirdThred {
public static void main(String[] args) {
// TODO Auto-generated method stub
//创建Callable对象
ThirdThred rt = new ThirdThred();
//先使用Lambda表达式创建Callable<Integer>对象
//使用FutureTask来包装Callable对象
//FutureTask ft = new FutureTask<>(callable);
FutureTask task = new FutureTask<Integer>((Callable<Integer>) () -> {
int i = 0 ;
for (; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+"的i="+i);
}
//call()可以有返回值
return i;
});
for (int i=0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+"的i="+i);
if(i==20){
//实质上还是以Callable对象来创建和启动线程的
new Thread(task,"有返回值的线程").start();
}
}
try{
//获取返回值
System.out.println("子线程的返回值:"+task.get());
}catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
}
}
3 创建线程的三种方式对比
- 实现Runnable、Callable接口的方式创建多线程的优缺点:
1.线程类只是实现了Runnable接口或Callable接口,还可以继承其他类。
2.在这种方式下,多个线程可以共享同一个target对象,所以非常适合多个相同线程来处理同一份资源的情况,从而可以将CPU、代码和数据分开,形成清晰的模型,较好地体现了面向对象的思想。
3.劣势是,编程稍稍复杂,如果需要访问当前线程,则必须使用Thread.currentThread()方法。
- 继承Thread类的方式创建多线程的优缺点:
1.编写简单,如果需要访问当前线程,则无需使用Thread.currentThread()方法,直接this即可获得当前线程。
2.劣势是,因为线程类已经继承了Thread类,所以不能再继承其他父类。