一、线程与进程
操作系统中可以支持多个程序同时运行,每个程序就代表了一个进程,各个程序即进程间相互独立工作,而每个程序中可能包含多个顺序执行流,每个执行流就代表了一个线程,各个线程共享进程中的资源。
1.什么是进程
进程是系统进行资源调度与分配的最小单位,一般而言,进程具有三个特点:
- 独立性:每个进程都有自己独立的私有资源,不与其他进程共享,也就是说,其他进程不可以直接访问其他进程的地址空间。
- 动态性:进程具有自己的生命周期和状态转变。
- 并发性:并发是指在同一时刻只能有一条指令执行,但多个进程可以被快速轮换执行,由于处理速度非常快,感觉上多个进程在同时进行。
2.什么是线程
线程也被成为轻量级进程,当进程中需要并发执行多个任务时,就需要使用线程的概念,线程是进程的执行单元,它们可以共享进程中的资源。
3.进程与线程的区别
- 进程是资源的分配和调度的一个独立单元,而线程是CPU调度的基本单元。
- 同一个进程中可以包含多个线程,一个进程中至少包含一个主线程。
- 同一进程中的多个线程共享代码段(代码和常量),数据段(全局变量和静态变量),扩展段(堆存储)。但是每个线程拥有自己的栈段,栈段又叫运行时段,用来存放所有局部变量和临时变量。
- 同一个进程中的线程可以并发执行。
- 线程间的通信比进程间通信要方便的多,但是线程之间需要处理好同步与互斥的关系。
二、线程的创建与启动
Java使用Thread类代表线程,所有的线程对象都必须是Thread类或其子类的实例,Java中创建多线程有三种方法:
- 继承Thread类重写run方法
- 实现Runnable接口重写run方法
- 使用Callable和Future创建线程
1.继承Thread类创建线程类
(1)定义Thread类的子类,并重写该类的run方法,该run方法的方法体就代表了线程要完成的任务。
(2)创建Thread子类的实例,即创建了线程对象。
(3)调用线程对象的start()方法来启动该线程。
代码如下所示:
public class ThreadTest extends Thread{
int i = 0;
@Override
public void run(){
for(;i<50;i++){
System.out.println(getName() + " " +i);
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ThreadTest thread1 = new ThreadTest();
ThreadTest thread2 = new ThreadTest();
for(int i=0; i<50;i++){
System.out.println(Thread.currentThread().getName()+" : "+i);
if(i==10)
{
thread1.start();
thread2.start();
}
}
}
}
运行结果可能如下所示:
main : 15
Thread-1 0
Thread-1 1
Thread-1 2
Thread-1 3
Thread-1 4
Thread-1 5
main : 16
Thread-1 6
main : 17
Thread-0 0
Thread-1 7
Thread-0 1
main : 18
Thread-0 2
Thread-1 8
Thread-0 3
main : 19
main : 20
Thread-0 4
由测试结果可知,main进程执行至i=10时,开始新建两个新线程,两个新线程从i=0开始分别执行,Thread-0和Thread-1中的i值是不连续的,证明两个线程中的i值不共享,因为两个新线程是ThreadTest创建的两个实例,Thread-0和Thread-1不能共享实例变量。
2.实现Runnable接口创建线程类
(1)定义runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。
(2)创建 Runnable实现类的实例,并依此实例作为Thread的target来创建Thread对象,该Thread对象才是真正的线程对象。
(3)调用线程对象的start()方法来启动该线程。
代码如下所示:
public class RunnableTest implements Runnable{
int i = 0;
@Override
public void run() {
// TODO Auto-generated method stub
for(;i<50;i++){
System.out.println(Thread.currentThread().getName() + " " +i);
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
RunnableTest runnable = new RunnableTest();
for(int i = 0;i < 100;i++)
{
System.out.println(Thread.currentThread().getName()+" "+i);
if(i==20)
{
new Thread(runnable,"线程1").start();
new Thread(runnable,"线程2").start();
}
}
}
}
运行结果可能如下所示:
main 53
main 54
main 55
main 56
线程1 0
线程2 0
main 57
线程1 1
main 58
线程2 2
main 59
线程1 3
main 60
线程2 4
main 61
由测试结果可知,两个子线程的i值是连续变化的,说明使用Runnable接口的方式创建的多个线程可以共享线程类的实例变量。
3.使用Callable和Future创建线程
(1)创建Callable接口的实现类,并实现call()方法,该call()方法将作为线程执行体,并且有返回值,call()方法还可以抛出异常。
(2)创建Callable实现类的实例,使用FutureTask类来包装Callable对象,该FutureTask对象封装了该Callable对象的call()方法的返回值。
(3)使用FutureTask对象作为Thread对象的target创建并启动新线程。
(4)调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
实现代码如下所示:
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
* 创建Callable接口的实现类,并实现call()方法,该call()方法将作为线程执行体,并且有返回值
* @author zhx
*
*/
class CallableDemo implements Callable<Integer> {
@Override
public Integer call() throws Exception {
// 计算1-100的和
int sum = 0;
for (int i = 1; i <= 100; i++)
sum += i;
return sum;
}
}
public class CallableTest {
public static void main(String[] args) {
CallableDemo cd = new CallableDemo();
//创建Callable实现类的实例,使用FutureTask类来包装Callable对象
//该FutureTask对象封装了该Callable对象的call()方法的返回值
FutureTask<Integer> result = new FutureTask<>(cd);
//使用FutureTask对象作为Thread对象的target创建并启动新线程。
new Thread(result).start();
int sum = 0;
// 接收运算结果
// 只有当该线程执行完毕后才会获取到运算结果,等同于闭锁的效果
try {
//调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
sum = result.get();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
System.out.println("sum is " + sum);
}
}
三、三种创建方式的对比
1.采用实现Runnable、Callable接口的方式创见多线程
优势:
线程类只是实现了Runnable接口或Callable接口,还可以继承其他类。
在这种方式下,多个线程可以共享同一个target对象,所以非常适合多个相同线程来处理同一份资源的情况,从而可以将CPU、代码和数据分开,形成清晰的模型,较好地体现了面向对象的思想。
劣势:
编程稍微复杂,如果要访问当前线程,则必须使用Thread.currentThread()方法。
2.使用继承Thread类的方式创建多线程
优势:
编写简单,如果需要访问当前线程,则无需使用Thread.currentThread()方法,直接使用this即可获得当前线程。
劣势:
线程类已经继承了Thread类,所以不能再继承其他父类。