线程基础
1、线程介绍
1.1、线程相关概念
- 程序(program):是完成特定任务,用某种语言编写的一组的集合(例如:java代码就是一个程序)
- 进程:是指运行中的程序(比如:我现在使用的Typora)
- 进程是程序的一次执行过程
- 是动态的过程:由他自身的产生、存在和消亡的过程
- 什么是线程?
- 线程是由进程创建的,是进程的一个实体
- 一个进程可以拥有多个线程
- 其他概念
- 单线程:同一时刻,只允许执行一个线程
- 多线程:同一时刻,可以执行多个线程
- 并发:同一时刻,多个任务交替执行(单CPU实现多任务就是并发)
- 并行:同一时刻,多个任务同时执行(多核CPU可以实现并行)
2、线程基本使用
创建线程的两种方式:
2.1、 继承Thread 类,重写run方法
线程应用案例1——继承Thread类:
/**
* @author java小豪
* @version 1.0.0
* @date 2022/12/3
* @description 实体类
* <p>
* 1.当一个类继承 Thread类, 该类就可以当做线程使用
* 2.我们会重写run方法,写上自己的业务代码
* 3.run Thread 类实现了 Runnable 接口的run方法
* public void run() {
* if (target != null) {
* target.run();
* }
* }
* </p>
*/
public class Cat extends Thread{
int times = 0;
@Override
public void run() {
while(true) {
// 每隔1秒,在控制台输出“喵喵,我是小猫咪"
System.out.println("喵喵,我是小喵咪" + (++times) + "线程名=" + Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 当times输出8次是我们就退出线程
if (times == 80) {
break;
}
}
}
}
/**
* @author java小豪
* @version 1.0.0
* @date 2022/12/3
* @description 线程的基本使用
*/
public class Thread01{
public static void main(String[] args) throws InterruptedException {
// 创建一个Cat对象,当线程使用
Cat cat = new Cat();
// 启动线程
cat.start();
// 当main线程启动一个子线程 Thread-0,主线程不会阻塞,会继续执行
// 主线程和子线程是交替执行的
System.out.println("主线程继续执行" + Thread.currentThread().getName());
for (int i = 0; i < 60; i++) {
System.out.println("主线程 i = " + i);
// 让主线成休眠
Thread.sleep(1000);
}
}
}
启动线程为什么是start:
启动线程最终会执行cat的run方法,而cat.run()方法就是一个普通的方法,并没有真正的启动多线程,run执行完毕后才会向下执行
我们可以追踪下源码进行分析
2.2、实现Runnable接口,重写run方法
线程应用案例2——实现Runnable接口:
/**
* @author java小豪
* @version 1.0.0
* @date 2022/12/3
* @description 通过实现Runnable接口, 开发线程类
*/
public class Dog implements Runnable{
int count = 0;
@Override
public void run() {
while (true) {
System.out.println("Hello World!" + (++count) + Thread.currentThread().getName());
// 休眠1秒
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (count == 10) {
break;
}
}
}
}
public class Thread02 {
public static void main(String[] args) {
Dog dog = new Dog();
// 这里不能调用start dog.start();
Thread thread = new Thread(dog);
thread.start();
}
}
在Thread thread = new Thread(dog);中使用到了一种设计模式:静态代理模式
在Thread类里面有个私有属性:==private Runnable target;==当我们实现Runnable接口的run方法时会调用如下的方法,
当我们==Thread thread = new Thread(dog)==;时,因为Dog实现了Runnable接口,所以这里的==dog==就相当于时==target==
个人理解:如有不对的地方请批评指正
@Override
public void run() {
if (target != null) {
target.run();
}
}
2.3、多线程的简单演示:
/**
* @author java小豪
* @version 1.0.0
* @date 2022/12/3
* @description 在main线程启动两个子线程
*/
public class Thread03 {
public static void main(String[] args) {
T1 t1 = new T1();
T2 t2 = new T2();
Thread thread1 = new Thread(t1);
Thread thread2 = new Thread(t2);
thread1.start();
thread2.start();
}
}
class T1 implements Runnable{
int count = 0;
@Override
public void run() {
while (true){
// 给隔1秒输出”hello world!" 输出10次
System.out.println("Hello World!" + (++count));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (count == 10) {
break;
}
}
}
}
class T2 implements Runnable {
int count = 0;
@Override
public void run() {
while (true){
// 给隔1秒输出”hello world!" 输出10次
System.out.println("Hello" + (++count));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (count == 5) {
break;
}
}
}
}
子线程的理解:
2.4、继承Thread 和实现Runnable 的区别
- 从java设计角度看,通过继承Thread和实现Runnable接口来创建线程本质上没有区别
- 实现Runnable接口方式更加适合多个线程共享一个资源的情况,避免了单继承的限制
- 建议使用Runnable接口的方式开启线程。
2.5、线程终止
- 当线程完成任务后,会自动退出
- 还可以通过使用变量来控制run方法退出的方式进行停止线程,即通知方式
线程终止演示:
/**
* @author java小豪
* @version 1.0.0
* @date 2022/12/3
* @description 线程的退出
*/
public class ThreadEit_ {
public static void main(String[] args) throws InterruptedException {
Th th = new Th();
th.start();
// main线程去控制th线程的终止, 必修可以修改 loop
// 让th退出run方法,从而终止 th线程 -> 通知方式
System.out.println("主线程休眠10S");
Thread.sleep(1000 * 10);
th.setLoop(false);
}
}
class Th extends Thread{
int count = 0;
private boolean loop = true;
@Override
public void run() {
while (loop) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Th 运行中...." + (++count));
}
}
public void setLoop(boolean loop) {
this.loop = loop;
}
}
3、线程方法
3.1、线程常用的方法一:
方法名 | 说明 |
---|---|
setName | 设置线程名称,使之与参数name相同 |
getName | 返回该线程的名字 |
start | 使该线程开始执行;Java虚拟机底层调用该线程的start0方法 |
run | 调用线程对象run方法 |
setPriority | 更改线程的优先级 |
getPriority | 获取线程的优先级 |
sleep | 在指定的毫秒数内让当前正在执行的线程休眠 |
interrupt | 中断进程 |
-
注意事项和细节:
- start底层会创建新的线程,调用run,run是一个简单方法调用,不会启动新线程
- 线程优先级的范围
- interrupt,中断线程,单并没有真正的结束线程,一般用于中断正在休眠线程
- sleep:线程的静态方法,使当前线程休眠
演示:
/**
* @author java小豪
* @version 1.0.0
* @date 2022/12/3
* @description 线程方法的使用
*/
public class ThreadMethod01 {
public static void main(String[] args) throws InterruptedException {
// 测试方法
Th th = new Th();
th.setName("小豪");
th.setPriority(Thread.MIN_PRIORITY);
// 启动子线程
th.start();
// 主线程打印5 hi,然后进行中断,子线程休眠
for (int i = 0; i <= 5; i++) {
Thread.sleep(1000);
System.out.println("hi " + i);
}
System.out.println(th.getName() + " 线程优先级 = " + th.getPriority());
// 当执行到这里时,就会中断 th线程的休眠
th.interrupt();
}
}
class Th extends Thread {
@Override
public void run() {
while (true){
for (int i = 0; i <= 100; i++) {
// Thread.currentThread().getName() 获取当前线程名称
System.out.println(Thread.currentThread().getName() + "吃包子~~~~~~~~");
}
try {
System.out.println(Thread.currentThread().getName() + "休眠中~~~~~~");
Thread.sleep(20000);
} catch (InterruptedException e) {
// 当该线程执行到一个interrupt 方法时,就会catch 一个异常,可以加入自己的业务代码
System.out.println(Thread.currentThread().getName() + "被interrupt中断了~~~~~~");
}
}
}
}
3.2、线程的常用方法二:
方法名称 | 解释说明 |
---|---|
yield | 线程的礼让。让出CPU,让其他线程执行,但礼让的时间不确定,所以也不一定礼让成功 |
join | 线程的插队。插队线程一旦插入成功,则肯定先执行完插入的线程的所有任务 |
线程join说明:
示例演示:
main线程创建一个子线程,每隔1s输出hello,输出20次,主线线程每隔1s输出 hi,输出20次,要求:两个线程同时执行,当主线程输出5次后,就让子线程运行完毕,主线程再继续。
/**
* @author java小豪
* @version 1.0.0
* @date 2022/12/3
* @description 线程方法的使用
*/
public class ThreadMethod02 {
public static void main(String[] args) throws InterruptedException {
T2 t2 = new T2();
t2.start();
for (int i = 1; i<= 20; i++) {
Thread.sleep(1000);
System.out.println("主线程吃了" + i + " 包子");
if (i == 5) {
System.out.println("主线程让子线程先吃");
// join,线程插队
// t2.join(); 这里是让t2线程执行完毕
Thread.yield();
System.out.println("子线程吃完主线程接着吃");
}
}
}
}
class T2 extends Thread {
@Override
public void run() {
for (int i = 1; i <= 20; i++) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("子线程吃了" + i + "包子");
}
}
}
3.3、用户线程和守护线程
- 用户线程:也叫工作线程,当线程的任务执行完或通知方式结束
- 守护线程:一般是为工作线程服务的,当所有的用户线程结束,守护线程自动结束
- 常见的守护线程:垃圾回收机制
演示示例:
/**
* @author java小豪
* @version 1.0.0
* @date 2022/12/3
* @description 守护线程演示
*/
public class ThreadMethod0 {
public static void main(String[] args) throws InterruptedException {
MyDaemonThread myDaemonThread = new MyDaemonThread();
myDaemonThread.start();
// 当主线程结束后,子线程自动结束,只需将子线程设置为守护线程即可
myDaemonThread.setDaemon(true);
for (int i = 1; i <= 10; i++) {
System.out.println("小豪再敲代码");
Thread.sleep(10000);
}
}
}
class MyDaemonThread extends Thread {
@Override
public void run() {
for (; ;) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("小豪在和女友聊天......");
}
}
}
4、线程生命周期
线程状态。 线程可以处于以下状态之一:
- NEW : 尚未启动的线程处于此状态。
- RUNNABLE 在Java虚拟机中执行的线程处于此状态。
- BLOCKED 被阻塞等待监视器锁定的线程处于此状态。
- WAITING 正在等待另一个线程执行特定动作的线程处于此状态。
- TIMED_WAITING 正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
- TERMINATED 已退出的线程处于此状态。
实例演示:
/**
* @author java小豪
* @version 1.0.0
* @date 2022/12/3
* @description 线程的状态
*/
public class Threadstate_ {
public static void main(String[] args) throws InterruptedException {
T t = new T();
System.out.println(t.getName() + "状态 " + t.getState());
t.start();
while (Thread.State.TERMINATED != t.getState()) {
System.out.println(t.getName() + "状态 " + t.getState());
Thread.sleep(500);
}
System.out.println(t.getName() + "状态 " + t.getState());
}
}
class T extends Thread {
@Override
public void run() {
while (true){
for (int i = 0; i < 10; i++) {
System.out.println("hi " + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
break;
}
}
}
运行结果:
5、Synchronized
**线程同步机制:**在多线程编程,一些敏感数据不允许被多线程同时访问,此时就使用同步访问技术,保证数据在任何同一时刻,最多有一个线程访问,以保证数据的完整性。
-
同步具体方法—Synchronized
- 同步代码块
synchronized(对象) { // 得到对象的锁,才能操作同步代码 // 需要被同步的代码; }
- synchronized还可以放在方法声明中,表示整个方法—为同步方法
public synchronized void m(String name) { // 需要被同步的代码; }
使用synchronized解决火车票超卖问题
/**
* @author java小豪
* @version 1.0.0
* @date 2022/12/3
* @description 模拟售票
*/
public class SellTicket {
public static void main(String[] args) {
// 解决火车票超卖问题
SellTicket03 sellTicket03 = new SellTicket03();
Thread thread1 = new Thread(sellTicket03);
Thread thread2 = new Thread(sellTicket03);
Thread thread3 = new Thread(sellTicket03);
thread1.start();
thread2.start();
thread3.start();
}
}
/** 实现接口方式, 使用synchronized实现线程同步**/
class SellTicket03 implements Runnable{
private int ticketNum = 100;
private boolean loop = true;
public synchronized void m() { // 同步方法,在同一时刻,只能有一个线程来执行run方法
if (ticketNum <= 0) {
System.out.println("售票结束...");
loop = false;
return;
}
// 休眠50秒
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口 " + Thread.currentThread().getName() + "售出一张票"
+ " 剩余票数 = " + (--ticketNum));
}
@Override
public void run() {
while (loop) {
// m方法是一个同步方法
m();
}
}
}
6、互斥锁
基本介绍:
- Java语言中,引入了对象互斥锁的概念,来保证共享数据操作的完整性
- 每个对象都对应一个可称为“互斥锁”的标记,这个标记用来保证在任意时刻,该对象只能被一个线程调用
- 关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时,表明该对象在任意时刻只能由一个线程访问
- 同步的局限性:导致程序的执行效率要降低
- 同步方法(非静态的)的锁可以使this,也可以是其他对象
- 同步方法(静态的)的锁为当前类本身
- 同步方法(静态的)的锁为当前类本身
注意事项和细节:
- 同步方法如果没有使用static修饰:默认锁对象为this
- 如果方法使用static修饰,默认锁对象:当前类
- 实现的落地步骤:
- 需要先分析上锁的代码
- 选择同步代码块和同步方法
- 要求多个线程的锁对象为同一个即可
7、死锁
基本介绍:
多个线程都占用了对方的锁资源,始终不肯释放,就导致了死锁
案例演示:
/**
* @author java小豪
* @version 1.0.0
* @date 2022/12/4
* @description 死锁模拟
*/
public class DeadLock_ {
public static void main(String[] args) {
// 模拟死锁现象
DeadLockDemo A = new DeadLockDemo(true);
A.setName("A线程");
DeadLockDemo B = new DeadLockDemo(false);
B.setName("B线程");
A.start();
B.start();
}
}
class DeadLockDemo extends Thread {
static Object o1 = new Object();
static Object o2 = new Object();
boolean flag;
public DeadLockDemo(boolean flag) {
this.flag = flag;
}
@Override
public void run() {
// 1.如果flag为 T,线程A 就会先得到 o1对象锁, 然后尝试去获取 o2 对象锁
// 2.如果线程A 得不到 o2 对象锁,就会Blocked
// 3.如果flag为 F, 线程B 就会先得到 o2对象锁,然后尝试去获取 o1 对象锁
// 4.如果线程B 得不到 o1 对象锁, 就会Blocked
if (flag) {
synchronized (o1) {
System.out.println(Thread.currentThread().getName() + " 进入1");
synchronized (o2) {
System.out.println(Thread.currentThread().getName() + " 进入2");
}
}
} else {
synchronized (o2) {
System.out.println(Thread.currentThread().getName() + " 进入3");
synchronized (o1) {
System.out.println(Thread.currentThread().getName() + " 进入4");
}
}
}
}
}
释放锁
- 下面操作会释放锁
- 当前线程的同步方法、同步代码块执行结束
- 当前线程在同步代码块、同步方法中遇到break、return
- 当前线程在同步代码块、同步方法中出现了未处理的Error或者Exception,导致异常结束
- 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法,当前线程暂停,并释放锁
- 下面操作不会释放锁
- 线程执行同步代码块或同步方法时,程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行,不会释放锁
- 线程执行同步代码块时,其他线程调用了该线程的suspend()方法将该线程挂起,该线程不会释放锁应避免suspend()和resume()方法来控制线程