目录
如何理解实现Callable接口创建多线程的方式比实现Runnable接口创建多线程的方式强大?
一、基本概念
程序、进程、线程
程序:程序是为了完成特定任务、用某种语言编写的一组指令集合。即一段静态的代码,静态对象。
进程:进程是程序的一次执行过程,或是正在运行的一段程序。是一个动态的过程,有它自身的产生 、存在和消亡的过程(生命周期)。
说明:
1、程序是静态的,进程是动态的。
2、进程作为资源分配的单位,系统在运行时会为每个进程分配不同的内存区域。
线程:进程可进一步细化为线程,是一个程序内部的一条执行路径。
- 若一个进程同一时间并行执行多个线程,就是支持多线程的
- 线程作为调度和执行的单位,每个线程拥有独立的运行栈和程序计数器(pc),线程切换的开销小
- 一个进程中的多个线程共享相同的内存单元/内存地址空间-->它们从同一堆中分配对象,可以访问相同的变量和对象。这就使得线程更加简便、高效。但多个线程操作共享的系统资源可能会带来线程安全问题
单核CPU和多核CPU
单核CPU,其实是一种假的多线程,因为在一个时间单元内,也只能执行一个线程的任务。但是因为CPU时间单元特别短,因此感觉不出来。
如果是多核的话,才能更好的发挥多线程的效率。(现在的服务器都是多核的)
一个Java应用程序java.exe,其实至少有三个线程:main()主线程,gc() 垃圾回收线程,异常处理线程。当然如果发生异常,会影响主线程。
并行与并发
并行:多个CPU同时执行多个任务。比如:多个人同时做不同的事。
并发:一个CPU(采用时间片)同时执行多个任务。比如:秒杀、多个人做同一件事。
使用多线程的优点
1. 提高应用程序的响应。对图形化界面更有意义,可增强用户体验。
2. 提高计算机系统CPU的利用率
3. 改善程序结构。将既长又复杂的进程分为多个线程,独立运行,利于理解和修改
二、线程的创建与使用
线程的创建和启动
Java语言的JVM允许多个线程同时运行,它通过java.lang.Thread类来体现
Thread类
Thread类的特性
1.每个线程都是通过某个特定的Thread对象的run()来完成的,经常把run()的主体称为线程体
2.通过该线程对象的start()来启动这个线程,而非直接调用run()
Thread类的构造器
- Thread():创建新的Thread对象
- Thread(String threadname):创建线程并指定线程实例名
- Thread(Runnable target):指定创建线程的目标对象,它实现了Runnable接口中的run方法
- Thread(Runnable target, String name):创建新的Thread对象
API中创建线程的两种方式
JDK1.5之前创建新执行的线程有两种方式:
- 继承Thread类
- 实现Runnable接口的方式
创建线程方式一:继承Thread类
创建线程步骤:
1)定义子类继承于Thread类
2)子类中重写Thread类中的run()方法------>将执行线程的操作声明在run()中
3)创建Thread类的子类对象
4)通过此对象调用start()方法
注意点:
1、如果自己手动调用run()方法,那么就只是普通方法,没有启动多线程模式。
2、run()方法由JVM调用,什么时候调用,执行的过程控制都有操作系统的CPU 调度决定。
3、想要启动多线程,必须调用start()方法。
4、一个线程对象只能调用一次start()方法启动,如果重复调用了,则将抛出异常:“IllegalThreadStateException”。
5、如果想要在创建一个线程,应重新创建一个线程对象
创建继承Thread类线程方式练习
创建一个分线程,打印输出1-20以内偶数;主线程中输出1-20以内奇数
public class ThreadTest1 {
public static void main(String[] args) {
// 3、创建Tread类的子类对象
myThread p1=new myThread();
// 4、通过此对象调用start():①启动当前线程②调用当前线程的run()方法
p1.start();
//如下操作依旧在main线程中操作
for(int i=0;i<=20;i++){
if(i%2!=0){
System.out.println(i+"'*******main()*******");
}
}
}
}
//创建Thread类的子类对象
//1、继承于Thread子类
class myThread extends Thread {
//2、重写Thread类中的run()方法
public void run(){
for(int i=0;i<20;i++){
if(i%2==0){
System.out.println(i);
}
}
}
}
运行结果如下:
创建线程方式二:实现Runnable接口
创建线程步骤:
1)定义实现类实现Runnable接口
2)子类中重写Runnable接口中的抽象方法:run()-------->将线程执行的操作声明在run()中
3)创建实现类的对象
4)将实现类的对象作为参数传递到Thread类的构造器中,并创建Thread类对象
5)通过Thread类的对象调用start()方法
创建实现Runnable接口线程方式练习
创建一个分线程,打印输出1-20以内偶数;主线程中输出1-20以内奇数
//1、创建一个实现了Runnable接口的类
class MThread implements Runnable{
//2、实现类的Runnable接口的抽象方法:run()
@Override
public void run() {
for(int i=0;i<=20;i++){
if (i%2==0){
System.out.println(i);
}
}
}
}
public class ThreadTest2 {
public static void main(String[] args) {
//3、创建实现类的对象
MThread mThread=new MThread();
//4、将此对象作为参数传递到Thread类的构造其中,创建Thread类的对象
//5、通过Thread类的对象调用start()方法:①启动线程 ②调用当前线程的run()-->调用了Runnable类的target的run()
new Thread(mThread).start();
//主线程
for(int i=0;i<=20;i++){
if (i%2!=0){
System.out.println(i+"************main()***********");
}
}
}
}
运行结果为:
比较创建线程的继承方式和实现Runnable接口方式
开发中优先选择实现Runnable接口的方式
实现Runnable接口方式的好处:
1、实现Runnable接口方式的方式没有类的单继承性的约束
2、多个线程可以共享同一个接口实现类的对象,非常适合多个相同线程来处理同一份资源。
继承方式和实现Runnable接口方式的联系与区别
区别:
- 继承Thread类:线程代码存放在Thread子类的run()中
- 实现Runnable:线程代码存放在接口的子类的run()中
联系:
- Thread类本身也实现了Runnable接口
- 两种方式都重写了run(),将线程要执行的操作声明在run()中
JDK5.0新增线程创建方式
创建线程方式三:实现Callable接口
创建线程步骤:
1)创建一个Callable接口的实现类
2)重写Callable接口的抽象方法:call()------->将此线程操作声明在call()中(该方法有返回值)
3)创建Callable接口的实现类的对象
4)将此Callable接口的实现类的对象作为参数传递到FutureTask类的构造其中,并创建FutureTask类的对象
5)将FutureTask类的对象作为参数传递到Thread类的构造器中,并创建Thread类的对象
6)调用创建好的Thread类的对象的start()方法
7)可以获取call()的返回值(按需选择)
实现Callable接口创建线程方式的练习
创建一个线程打印1-20以内偶数,并求和,返回求和值
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class ThreadNew1 {
public static void main(String[] args) {
// 3、创建Callable接口实现类的对象
NumThread numThread=new NumThread();
// 4、将此Callable接口实现类的对象作为参数传给FutureTask构造器中,创建FutureTask类对象
FutureTask futureTask = new FutureTask(numThread);
// 5、将创建好的FutureTask对象作为参数传递给Thread构造其中,创建Thread类对象
Thread thread = new Thread(futureTask);
// 并调用该类对象的start()
thread.start();
try {
//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值
Object sum = futureTask.get();
System.out.println("总和为:"+sum);
} catch (InterruptedException e) {
throw new RuntimeException(e);
} catch (ExecutionException e) {
throw new RuntimeException(e);
}
}
}
// 1、创建一个实现Callable接口的实现类
class NumThread implements Callable{
// 2、实现call(),将此线程需要执行的操作声明在call()中;call()可以有返回值
@Override
public Object call() throws Exception {
int sum=0;
for(int i=1;i<=20;i++){
if(i%2==0){
System.out.println(i);
sum+=i;
}
}
return sum;//存在自动装箱
}
}
运行结果如下:
如何理解实现Callable接口创建多线程的方式比实现Runnable接口创建多线程的方式强大?
1)相比run()方法,call()方法有返回值
2)call()方法可以抛出异常
3)支持泛型的返回值
4)需要借助FutureTask类,比如获取返回结果
Future接口:
可以对具体Runnable、Callable任务的执行结果进行取消、查询是 否完成、获取结果等。
FutrueTask是Futrue接口的唯一的实现类
FutureTask 同时实现了Runnable, Future接口。它既可以作为 Runnable被线程执行,又可以作为Future得到Callable的返回值
创建线程方式四:使用线程池
创建线程步骤:
1)创建一个指定数量的线程池
2)执行指定的线程操作。需要提供实现Runnable接口或Callable接口实现类的对象
3)关闭线程池
线程池相关API:
JDK 5.0起提供了线程池相关API:ExecutorService 和 Executors
ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor
- void execute(Runnable command) :执行任务/命令,没有返回值,一般用来执行 Runnable
- Future submit(Callable task):执行任务,有返回值,一般又来执行 Callable
- void shutdown() :关闭连接池
Executors:工具类、线程池的工厂类,用于创建并返回不同类型的线程池
- Executors.newCachedThreadPool():创建一个可根据需要创建新线程的线程池
- Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
- Executors.newSingleThreadExecutor() :创建一个只有一个线程的线程池
- Executors.newScheduledThreadPool(n):创建一个线程池,它可安排在给定延迟后运 行命令或者定期地执行。
使用线程池创建多线程方式练习
使用线程池创建线程,一个线程打印输出1-20以内偶数,一个线程打印输出1-20以内奇数
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class ThreadNew2 {
public static void main(String[] args) {
// 1、提供指定线程数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
// 2、执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
service.execute(new NumberThread());//适用于Runnable
Future future = service.submit(new NumberThread1());//适用于Callable接口
// 3、关闭连接池
service.shutdown();
}
}
class NumberThread implements Runnable{
@Override
public void run() {
for (int i = 0; i <=20; i++) {
if(i%2==0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}
class NumberThread1 implements Callable{
@Override
public Object call() throws Exception {
for (int i = 0; i <=20; i++) {
if(i%2!=0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
return null;
}
}
运行结果: