目录
一、继承于Thread类
- java.lang.Thread是一个线程操作的核心类,JDK1.0提供。
- Thread类本质上也是实现了Runnable接口的一个实例。
package 线程创建;
/**
* @BelongsProject: untitled
* @BelongsPackage: 线程创建
* @Author: mcc
* @CreateTime: 2020-09-24 07:37
* @Description:
*/
//1.创建一个继承于Thread类的子类
class MyThread extends Thread {
//2.重写Thread类的run()-->将此线程执行的操作声明在run()中
@Override
public void run() {
//打印100内的偶数
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
System.out.println(i);
}
}
}
}
public class ThreadTest {
public static void main(String[] args) {
//3.创建Thread类的子类的对象
MyThread t1 = new MyThread();
//4.通过此对象调用start()
t1.start();
}
}
无论哪种方式实现多线程,线程启动一律调用Thread类提供的start()方法。
package 线程创建;
/**
* @BelongsProject: untitled
* @BelongsPackage: 线程创建
* @Author: mcc
* @CreateTime: 2020-09-24 07:37
* @Description:
*/
public class ThreadTest {
public static void main(String[] args) {
//创建Thread类的匿名子类
new Thread() {
@Override
public void run() {
//打印100内的偶数
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
System.out.println(i);
}
}
}
}.start();
}
}
1.为什么要覆写run()方法?
Thread类用于描述线程,该类就定义了一个功能,用于存储线程要运行的代码,该存储功能就是run方法。也就是说Thread类中的run方法用于存储线程要运行的代码。
2. start( )方法解析:
2.1功能
- Ⅰ.启动当前线程
- Ⅱ.调用当前线程的
run()
方法
2.2start( )方法工作流程
- Ⅰ.首先检查线程状态是否为0(线程状态默认为0表示未启动),如果线程已经启动再次调用
start()
方法会抛出IllegalThreadStateException。也就是说,一个线程的start( )方法只能调用一次。 - Ⅱ.通过
start0()
方法真正将线程启动。 - Ⅲ.JVM调用
start0()
方法进行资源分配与系统调度,准备好资源启动线程后回调run()
方法来执行线程的具体任务。
问题:为什么要通过start( )方法来调用run( )方法,而不是run( )直接执行?
只有通过调用start()
方法,让JVM来调用start0()
方法,这时JVM会进行资源分配与系统调度的准备工作;如果直接调用run()
方法,就缺少了这些准备工作,相当于调用了一个普通的run()
方法,就达不到启动线程的目的。
二、实现Runnable接口
1.引入(多窗口卖票)
package 卖票;
/**
* @BelongsProject: untitled
* @BelongsPackage: 卖票
* @Author: mcc
* @CreateTime: 2020-09-28 08:04
* @Description:创建三个窗口卖票,总票数为100张;存在线程安全问题,待解决
*/
class Window extends Thread {
private int ticket = 100;
@Override
public void run() {
while (true) {
if (ticket > 0) {
System.out.println(getName() + ": 卖票,票号为:" + ticket);
ticket--;
} else {
break;
}
}
}
}
public class WindowTest {
public static void main(String[] args) {
Window w1 = new Window();
Window w2 = new Window();
Window w3 = new Window();
w1.setName("窗口1");
w2.setName("窗口2");
w3.setName("窗口3");
w1.start();
w2.start();
w3.start();
}
}
从结果来看是三个窗口各自卖了100张票,没有达到预期的三个窗口共卖100张票的目的。由于Window这个线程子类中提供的ticket属性是一个实例变量,在主类中创建了3个对象,就意味着每个对象有一份,在调用run方法的时候每个对象判断自己的ticket是否大于0,所以导致卖了300张票;要解决这个问题可以将ticket设为静态
这时每个对象共享同一个静态变量,如果不想将ticket设置为静态,那该怎么做呢?
2.实现Runnable接口创建多线程
package 线程创建;
/**
* @BelongsProject: untitled
* @BelongsPackage: 线程创建
* @Author: mcc
* @CreateTime: 2020-09-29 07:52
* @Description:
*/
//1.创建一个实现Runnable接口的类
class MThread implements Runnable {
//2.实现类去实现Runnable接口的抽象方法:run
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}
public class ThreadTest1 {
public static void main(String[] args) {
//3.创建实现类的对象
MThread mThread = new MThread();
//4.将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象
Thread t1 = new Thread(mThread);
t1.setName("线程1");
Thread t2 = new Thread(mThread);
t2.setName("线程2");
//5.通过Thread类的对象调用start方法
t1.start();
t2.start();
}
}
提问:
Thread对象通过调用start方法,从而调用了当前线程(Thread类)的run方法,为什么会调用到MThread类中实现的run方法?
//源码
@Override
public void run() {
if (target != null) {
target.run();
}
}
/* What will be run. */
private Runnable target;
public Thread(Runnable target) {
this(null, target, "Thread-" + nextThreadNum(), 0);
}
- 调用start方法时,所执行的是Thread类的run方法
- Thread类的run方法中,如果target不等于null,则调用target的run方法,所以我们要清楚target的run方法到底是什么
- 而target是Thread类中声明的Runnable类型的属性
- 构造器
public Thread(Runnable target)
中的形参恰好是target,相当于放到形参位置的MThread的对象去赋值target,然后Thread的run方法中,target被赋过值,所以不等于null,这时调用target的run方法,而target的run就是MThread对象所重写的run方法
3.Runnable接口实现多窗口卖票
package 卖票;
/**
* @BelongsProject: untitled
* @BelongsPackage: 卖票
* @Author: mcc
* @CreateTime: 2020-10-08 10:40
* @Description:创建三个窗口卖票,总票数为100张;存在线程安全问题,待解决
*/
class Window1 implements Runnable {
private int ticket = 100;
@Override
public void run() {
while (true) {
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + ":卖票,票号为" + ticket);
ticket--;
} else {
break;
}
}
}
}
public class Window1Test {
public static void main(String[] args) {
Window1 window1 = new Window1();
Thread thread1 = new Thread(window1);
Thread thread2 = new Thread(window1);
Thread thread3 = new Thread(window1);
thread1.setName("窗口1");
thread2.setName("窗口2");
thread3.setName("窗口3");
thread1.start();
thread2.start();
thread3.start();
}
}
比较创建线程的两种方式:
开发中优先选择实现Runnable接口的方式
原因:
- 实现方式没有类的单继承局限性
- 实现方式更适合来处理多个线程共享数据的情况
联系:public class Thread implementb Runnable
相同点:两种方式都需要重写run,将线程要执行的逻辑声明在run中
三、通过Callable接口实现多线程(Futuretask方式)
出现Callable接口实现多线程的原因:由于Runnable接口的run( )方法没有返回值,但是有些线程执行完后可能带来一些返回结果,为了解决这种问题,就出现了Callable接口实现多线程的方式。
package 线程创建;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
* @BelongsProject: untitled
* @BelongsPackage: 线程创建
* @Author: mcc
* @CreateTime: 2020-10-19 07:34
* @Description:创建线程方式三:实现Callable接口,JDK5.0新增 计算100内偶数的和
*/
//1.创建一个实现Callable的实现类
class NumThread implements Callable {
//2.实现call方法,将此线程要执行的操作声明在call方法中
@Override
public Object call() throws Exception {
int sum = 0;
for (int i = 1; i <= 100; i++) {
if (i % 2 == 0) {
System.out.println(i);
sum += i;
}
}
return sum;
}
}
public class ThreadNew {
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对象,并调用start
new Thread(futureTask).start();
try {
//6.获取Callable中call方法的返回值
//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值
Object sum = futureTask.get();
System.out.println("总和:" + sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
如何理解实现Callable接口的方式创建多线程比Runnable方式更强大?
- call()可以有返回值
- call()可以抛出异常,被外面的操作捕获,获取异常信息
- Callable是支持范型的
四、线程池(开发常用)
1.背景
经常创建和销毁使用量特别大的资源,比如并发情况下的线程,对性能影响很大
2.思路
提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中。可以避免频繁创建销毁,实现重复利用。类似生活中的公共交通工具
3.好处
- 提高响应速度(减少了创建新线程的时间)
- 降低资源消耗(重复利用线程池中的线程,不需要每次都创建)
- 便于线程管理
corePoolSize:核心池的大小
maximumPoolSize:最大线程数
KeepAliveTime:县城没有任务时最多保持多长时间后会终止
。。。
package 线程创建;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @BelongsProject: untitled
* @BelongsPackage: 线程创建
* @Author: mcc
* @CreateTime: 2020-10-21 07:32
* @Description:使用线程池实现多线程
*/
class NumberThread implements Runnable {
@Override
public void run() {
for (int i = 1; i <= 100; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}
class NumberThread1 implements Runnable {
@Override
public void run() {
for (int i = 1; i <= 100; i++) {
if (i % 2 != 0) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}
public class ThreadPool {
public static void main(String[] args) {
//1.提供指定线程数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
//2.执行指定的线程操作,需要提供实现Runnable接口或Callable接口实现类的对象
service.execute(new NumberThread());//适用于Runnable
service.execute(new NumberThread1());//适用于Runnable
//3.关闭连接池
service.shutdown();
}
}
4.线程池相关API
ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor
void execute(Runnable command)
:执行任务/命令,没有返回值,一般用来执行Runnbale<T>Future<T>submit(Callable<T>task)
:执行任务,有返回值,一般用来执行Callablevoid shutdown()
:用来关闭连接池
Executors:工具类,线程池的工厂类,用于创建并返回不同类型的线程池
Executors.newCachedThreadPool()
:创建一个可以根据需要创建新线程的线程池Executors.newFixedThreadPool()
:创建一个可重用固定线程数的线程池Executors.newSingleThreadExecutor()
:创建一个只有一个线程的线程池Executors.newScheduledThreadPool()
:创建一个线程池,它可以排在给定延迟后运行命令或者定期的执行