多线程
一、什么是多线程
线程:
线程是操作系统能够进行运算调度的最小单位。
线程被包含在进程之中,是进程中的实际运作单位。
进程:
进程是程序的基本执行实体
可以说一个软件运行后,就是一个进程。
在任务管理器中我们可以看到在电脑上运行的一个个进程。
所以线程可以简单理解为:应用软件中互相独立,可以同时运行的功能。
有了多线程,我们就可以让程序同时做多件事情。
多线程的作用:
可以充分利用程序当中的等待时间,让CPU在多个程序当中切换,提高程序的运行效率。
多线程的应用场景:
只要想让多个事情同时运行就需要用到多线程(如软件中的耗时操作、聊天软件、服务器等)。
二、多线程的两个概念(并发和并行)
1.并发:在同一时刻,有多个指令在单个CPU上交替执行
2.并行:在同一时刻,有多个指令在多个CPU上同时执行
计算机的CPU可以分为2核四4线程、4核8线程、8核16线程、16核32线程、32核64线程。
以2核4线程为例:表示在计算机当中如果只有4条线程,那么这四个线程可以同时执行,不需要切换,但线程数超过了4条,就需要切换执行。
所以说并发和并行有可能同时进行。
三、多线程的实现方式
3.1继承Thread类的方式
1.自己定义一个类继承Thread
2.重写run方法
3.创建子类的对象,并启动线程。
package com.practice;
/**
* @Author YJ
* @Date 2023/7/21 9:41
* Description:继承Thread类的方式
*/
public class MyThread extends Thread{
@Override
public void run() {
//书写线程要执行的方法
//getName()获取线程名
for (int i = 0; i < 100; i++) {
System.out.println(getName() + ":hello world");
}
}
}
package com.practice;
/**
* @Author YJ
* @Date 2023/7/21 9:37
* Description:继承Thread类的方式
*/
public class ThreadDemo1 {
public static void main(String[] args) {
//创建对象,启动线程
MyThread thread1 = new MyThread();
MyThread thread2 = new MyThread();
//为线程命名
thread1.setName("线程1");
thread2.setName("线程2");
//开启线程
thread1.start();
thread2.start();
}
}
3.2实现Runnable接口的方式
.1.自己定义一个类实现Runnable接口
2.重写里面的run方法
3.创建自己的类的对象
4.创建一个Thread类的对象,并开启线程。
package com.practice.threaddemo2;
/**
* @Author YJ
* @Date 2023/7/21 9:53
* Description:实现Runnable接口的方式
*/
public class MyRun implements Runnable{
@Override
public void run() {
//获取当前线程的对象
Thread thread = Thread.currentThread();
for (int i = 0; i < 100; i++) {
System.out.println(thread.getName() + ":hello world!");
}
}
}
package com.practice.threaddemo2;
/**
* @Author YJ
* @Date 2023/7/21 9:53
* Description:实现Runnable接口的方式
*/
public class ThreadDemo {
public static void main(String[] args) {
//创建自己类MyRun的对象
MyRun myRun = new MyRun();
//创建线程对象,并传递任务
Thread thread1 = new Thread(myRun);
Thread thread2 = new Thread(myRun);
//给线程命名
thread1.setName("线程1");
thread2.setName("线程2");
//开启线程
thread1.start();
thread2.start();
}
}
3.3利用Callable接口和Future接口方式
特点:可以获取到多线程运行的结果
1.创建一个类实现Callable接口
2.重写call(有返回值,表示多线程运行的结果)
3.创建实现Callable接口的类的对象(表示多线程要执行的任务)
4.创建FutureTask的对象(作用管理多线程运行的结果)
5.创建Thread类的对象,并启动线程。
package com.practice.threaddemo3;
import java.util.concurrent.Callable;
/**
* @Author YJ
* @Date 2023/7/21 10:11
* Description:利用Callable接口和Future接口方式
*/
public class MyCallable implements Callable<Integer> {
//求1-100的和
int sum = 0;
@Override
public Integer call() throws Exception {
for (int i = 0; i <= 100; i++) {
sum += i;
}
return sum;
}
}
package com.practice.threaddemo3;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
* @Author YJ
* @Date 2023/7/21 10:11
* Description:利用Callable接口和Future接口方式
*/
public class ThreadDemo {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//创建实现Callable接口的类的对象(表示多线程要执行的任务)
MyCallable mc = new MyCallable();
//创建FutureTask的对象(作用管理多线程运行的结果)
FutureTask<Integer> ft = new FutureTask<>(mc);
//创建Thread类的对象,并启动线程。
Thread t1 = new Thread(ft);
Thread t2 = new Thread(ft);
//启动线程
t1.start();
t2.start();
//获取结果
Integer result = ft.get();
System.out.println(result);
}
}
四、多线程中常用的成员方法
4.1基本成员方法
String getName()
返回线程名字
void setName()
设置线程名字(Thread 构造方法也可实现)
细节:
1.如果没有给线程设置名字,线程有默认名字(格式:Thread-X(X是序号,从0开始))
2.如果要给线程设置名字,可以通过set方法设置,也可通过构造方法设置。
package com.practice.threaddemo4;
/**
* @Author YJ
* @Date 2023/7/21 10:26
* Description:构造方法设置名字
*/
public class MyThread extends Thread{
public MyThread() {
}
public MyThread(String name) {
super(name);
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(getName() + "@" + i);
}
}
}
package com.practice.threaddemo4;
/**
* @Author YJ
* @Date 2023/7/21 10:26
* Description:构造方法设置名字
*/
public class ThreadDemo {
public static void main(String[] args) {
//创建线程对象
MyThread t1 = new MyThread("蓝1");
MyThread t2 = new MyThread("红2");
//开启线程
t1.start();
t2.start();
}
}
static Thread currentThread()
获取当前线程对象
细节:
当JVM虚拟机启动之后,会自动地启动多条线程,其中有一条线程就叫做main线程,
它的作用就是去调用main方法,并执行里面的代码
在以前我们写的所有的代码,都是运行在main线程中的。
static void sleep(long time)
:让线程休眠指定的时间,单位为毫秒
细节:
1.哪条线程执行到这里,该线程就会在此停留对应的时间
2.方法的参数,表示睡眠的时间,单位毫秒
3.当时间到了,线程会自动醒来,继续执行代码。
package com.practice.threaddemo4;
/**
* @Author YJ
* @Date 2023/7/21 10:43
* Description:sleep演示
*/
public class ThreadDemoSleep {
public static void main(String[] args) throws InterruptedException {
System.out.println("你好~");
Thread.sleep(5000);
System.out.println("hi~");
}
}
4.2线程的优先级
线程的调度:
1.抢占式调度:多个线程在抢夺CPU的执行权,CPU执行线程是不确定的,执行多长时间也不确定(随机性);
2.非抢占式调度:所有的线程轮流执行。
Java中用的是抢占式调度(注意随机性)
Java中优先级分为1-10级
Thread .getPriority()
获取优先级
Thread .setPriority()
设置优先级
优先级越高,抢占到CPU的概率越大,但并不是一定的
package com.practice.threaddemo5;
/**
* @Author YJ
* @Date 2023/7/21 11:04
* Description:
*/
public class ThreadDemo {
public static void main(String[] args) {
MyRun mr = new MyRun();
Thread t1 = new Thread(mr,"1");
Thread t2 = new Thread(mr,"2");
t1.setPriority(1);
t2.setPriority(10);
t1.start();
t2.start();
}
}
4.3守护线程
final void setDaemon()
当其他非守护线程执行完毕后,守护线程会陆续结束,守护线程不一定执行完
例如:有两个线程,线程1为1号线程,线程2为2号线程,把线程2设置为守护线程,当两个线程执行的时候,若1号线程执行完毕2号线程没有执行完毕,此时2号线程会陆续结束,即使它没有执行完也会结束。
因为非守护线程已经执行完,守护线程就没有存在的必要了。
package com.practice.threaddemo6;
/**
* @Author YJ
* @Date 2023/7/21 11:19
* Description:
*/
public class ThreadDemo {
public static void main(String[] args) {
MyThread1 t1 = new MyThread1();
MyThread2 t2 = new MyThread2();
t1.setName("1号");
t2.setName("2号");
//设置2号为守护线程(备胎线程)
//当1号线程结束了,2号线程就没有存在的必要了
t2.setDaemon(true);
t1.start();
t2.start();
}
}
4.4出让/礼让线程
public static void yield()
尽可能将线程均匀
package com.practice.threaddemo7;
/**
* @Author YJ
* @Date 2023/7/21 9:41
* Description:
*/
public class MyThread extends Thread{
@Override
public void run() {
//书写线程要执行的方法
//getName()获取线程名
for (int i = 0; i < 100; i++) {
System.out.println(getName() + "@" + i);
Thread.yield();
}
}
}
4.5插入线程
public static void join()
表示把某个线程插入到当前线程之前
当插入的线程执行完后,才执行当前线程
package com.practice.threaddemo8;
/**
* @Author YJ
* @Date 2023/7/21 11:19
* Description:
*/
public class ThreadDemo {
public static void main(String[] args) throws InterruptedException {
MyThread t1 = new MyThread();
t1.setName("1号");
t1.start();
//执行在main线程上的
//当前线程:main线程
//表示将t1线程插入到main线程之前
t1.join();
for (int i = 0; i < 10; i++) {
System.out.println("main线程" + i);
}
}
}
五、线程的生命周期
新建状态:创建线程对象
start()
就绪状态(不停的抢CPU):有执行资格,没有执行权
运行状态(代码):有执行资格,有执行权
1.若被其他线程抢走CPU执行权就会回到就绪状态
2.若是有sleep()
或是其他阻塞式方法会变成阻塞状态
3.若是执行完毕run()
会变成死亡状态:线程死亡,变成垃圾
阻塞状态(等着):没有执行资格,没有执行权
死亡状态:线程死亡,变成垃圾
总结
经过本篇文章,我们了解到了线程的基本概念及如何实现多线程,欢迎各位伙伴评论+点赞!!!
我会持续学习并更新博客,欢迎各位评论!!!