目录
1.认识线程
1.1线程的引入
在认识线程之前要先了解一下进程。引入多个进程是在多核CPU时代实现并发编程的刚需,然而创建,销毁,调度一个进程消耗时间比较多,效率不高。进程是资源分配的基本单位,消耗在申请资源上的时间较多,于是分配内存操作便成了一个大工程。
为了解决以上问题,就引入了线程(Thread),线程也叫做”轻量级进程“。它不能独立存在而要依附于进程。所以创建线程的时候,不需要再重新申请资源了,直接复用之前已经分配给进程的资源,创建效率就更高了。
举例:
阿红家的工厂想扩大生产规模,多增加一条生产线。现在两个方案,请你思考哪一个方案更节约成本呢?
显然,方案二更节约成本并提高了效率。方案一就是多进程的方式,方案二就是多线程的方式。
1.2进程与线程的区别(面试题)
1.进程包含线程,一个进程里至少有一个线程。
2.同一个进程里的线程之间共享一份资源(内存+硬盘),节省了申请资源的开销。
3.进程与进程之间具有独立性,一个进程的好坏不影响别的进程。同一个进程内的线程之间可能相互影响。
4.进程是资源分配的基本单位,线程是调度执行的基本单位。
2.Thread类及其常见方法
2.1构造线程的常见方法
*继承Thread类并实现run方法
步骤:1.继承Thread创建一个线程类->2.创建MyThread的实例->3.调用start()方法启动线程
class MyThread extends Thread {
@Override
public void run() {
System.out.println("hello, thread!");
}
}
public class ThreadDemo {
public static void main(String[] args) {
MyThread01 t = new MyThread01();
t.start();
}
}
*实现Runnable接口,并实现run方法
步骤:1.实现Runnable接口->2.创建Thread类实例,将Runnable对象作为目标参数->3.调用start()方法启动线程
class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("hello, thread!");
}
}
public class ThreadDemo{
public static void main(String[] args) {
// 实例化Runnable对象
MyRunnable01 runnable = new MyRunnable();
Thread t = new Thread(runnable);
t.start();
}
}
使用Runnable接口的好处?
1.解耦:通过实现Runnable接口,并在run方法中实现具体的任务,将线程与任务分离,可以在需要执行该任务的地方创建一个线程,并将任务传入线程中执行。
2.提高代码复用性:实现Runnable接口可以让多个线程共享同一个任务对象,减少重复代码的编写,同时方便统一修改。
*继承 Thread, 重写 run, 使用匿名内部类
public class ThreadDemo {
public static void main(String[] args) {
Thread t = new Thread(){
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
};
t.start();
}
}
*实现 Runnable, 重写 run, 使用匿名内部类
public class ThreadDemo {
public static void main(String[] args) {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
});
t.start();
}
}
*使用 lambda 表达式
public class ThreadDemo {
public static void main(String[] args) {
Thread t = new Thread(() -> {
while (true) {
System.out.println(Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t.start();
}
}
2.2线程的常见属性
属性 | 获取方法 | 解释 |
ID | getID() | ID是线程的唯一标识 |
名称 | getName() | 各种调试工具用得到 |
状态 | getState() | 表示线程当前所处的情况 |
优先级 | getPriority() | 优先级高的更容易被调度到 |
是否后台线程 | isDaemon() | 后台线程不会影响进程结束,而前线程会影响进程结束。 |
是否存活 | isAlive() | 看run方法是否运行结束 |
是否被中断 | isInterrupted() | 让run方法尽快执行结束 |
2.3启动一个线程-start()
(面试题:start和run的区别)
前面知道了重写run方法是为了创建一个线程对象,但线程对象创建出来并不意味着线程开始运行,run方法只是描述出了线程要执行的内容。而调用start()方法才是线程真正去独立执行了。本质上的差别就是有没有在系统内部创建新的线程。
2.4中断一个线程
线程中断是指一个线程发送中断请求给另一个正在执行的线程,让该线程停止执行当前任务。但不立即中止线程执行,而是设置了一个中断标志,当线程在阻塞状态时检查这个标志,并根据需要中止执行。
Thread收到中断信号的方式有两种:
1.当线程在阻塞状态时,以InterruptedException异常的形式通知,清除中断标志。
2.内部的一个中断标志被设置,可以通过:
Thread.interrupted()判断当前中断标志被设置,清除中断标志
Thread.currentThread().isInterrupted()判断指定线程的中断标志被设置,不清除中断标志。
public class demo {
public static void main(String[] args) {
Thread t = new Thread(()->{
//Thread类内部有一个现成的标志位,可以同来判断当前循环是否要结束
while (!Thread.currentThread().isInterrupted()){
System.out.println("线程工作中");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
//1.假装没收到,继续正常执行循环
e.printStackTrace();
//2.加上一个break,表示线程立即结束
//break
//3.做一些收尾工作再结束
break;
}
}
});
t.start();
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("让线程t终止");
t.interrupt();//把上述Thread对象内部的标志位设为true了
}
}
2.5等待一个线程-join()
使用Thread类中的join()方法明确等待线程结束,当有新线程加入时,主线程会进入等待状态,一直到新线程执行结束为止。
public class demo20 {
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(()->{
for (int i = 0; i < 5; i++) {
System.out.println("t线程工作中!");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t.start();
/*让主线程等待t线程执行结束
一旦调用join,主线程就会触发阻塞,此时t线程就可以趁机完成后面的工作
一直阻塞到t执行完毕,join才会解除阻塞,主线程才能继续执行*/
System.out.println("join等待开始");
t.join();
System.out.println("join等待结束");
}
}
2.6休眠当前线程-sleep()
sleep()方法可以让线程进入休眠状态,不会占用CPU资源,也不会释放锁。过了规定时间 后继续执行代码。
sleep()和wait()方法的异同:
1.相同点:都可以使线程暂停执行
2.不同点:
sleep()方法是Thread类的静态方法,而wait()方法是Object类的实例方法
sleep()可以在任何地方使用,wait()通常搭配synchronized使用
sleep()不会释放锁,而wait()会释放对象的锁
sleep()用于控制线程执行的时间间隔,wait()通常用于线程间的通信和同步操作
3.线程的状态
线程的状态是一个枚举类型Thread.State
NEW (新建): 对象创建好了,但是还没有调用start()方法开始行动。
RUNNABLE (运行): 分为正在工作的和即将开始工作的,准备CPU的调度。
BLOCKED(阻塞) : 由于锁竞争导致的阻塞。
WAITING (等待): 由于wait这种不固定时间的方式产生的阻塞,处于这个状态的线程会释放持有的锁。
TIMED_WAITING(计时等待):由于sleep这种固定时间的方式产生的阻塞,超出等待时间会自动唤醒。
TERMINATED(终止):对象还在,内核中的线程没了,无法再次启动。
实际中线程状态可能会相互转换,线程的状态转换由Java虚拟机和操作系统共同管理。