前言
1、程序、进程、线程的基本概念
- **程序(program)：**是为了完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
- **进程(process)：**是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程——生命周期。
- 如：运行中的QQ、QQ音乐、杀毒软件等
- 程序是静态的代码，进程是动态的(正在运行的代码)
- 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域
- **线程(thread)：**进程可进一步细化为线程，是一个程序内部的一条执行路径
- 若一个进程同一时间并行执行多个线程，就是支持多线程的
- 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小
- 一个进程中的多个线程共享相同的内存单元/内存地址空间->它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患
- 单核CPU和多核CPU的理解
- 单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。例如：虽然有多车道，但是收费站只有一个工作人员在收费，只有收了费才能通过，那么CPU就好比收费人员。如果有某个人不想交钱，那么收费人员可以把他"挂起"(晾着他，等他想通了，准备好了钱，再去收费)。但是因为CPU时间单元特别短，因此感觉不出来
- 如果是多核的话，才能更好的发挥多线程的效率。
- 一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程
- 并行与并发
- 并行：多个CPU同时执行多个任务。比如：多个人同事做不同的事。
- 并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事
2、使用多线程的优点
- 提高应用程序的相应。对图形化界面更有意义，可增强用户体验
- 提高计算机系统CPU的利用率
- 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改
3、何时需要多线程
- 程序需要同时执行两个或多个任务
- 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等
- 需要一些后台运行的程序时
4、线程的生命周期
只有死亡/销毁，才是线程的最终状态，阻塞不是。下面方法可以在后面的常用方法演示中看到
1、创建线程的两种方式
**注意：**所有线程皆是以
start()方法运行，不是run()方法以下演示的是JDK刚开始就有的创建线程的两种方式
继承Thread类和实现Runnable接口方式，后面会讲到使用JDK5.0新增的两种方式以下演示使用两个线程(主线程与自创线程)打印0-100之间的所有数
为了方便观看，我们这里先使用Thread.currentThread().getName()方法，来获取当前线程的名称
1.1、继承Thread类
-
在main方法中编写一个for循环，打印0-100的数
-
然后创建内部类
MyDemo1，继承Thread类，并重写run()方法，然后在方法里面打印0-100以内的数 -
编写好后，在mian方法里创建
MyDemo1对象，调用start()方法，让线程跑起来，查看结果 -
代码如下
package com.tcc.test; /** * @author 宇辰 * @date 2022/8/31-8:53 **/ public class Test{ public static void main(String[] args) { MyDemo1 demo1 = new MyDemo1(); demo1.start(); for (int i = 0; i < 100; i++) { System.out.println(Thread.currentThread().getName() + "：" + i); } } } class MyDemo1 extends Thread{ @Override public void run() { for (int i = 0; i < 100; i++) { System.out.println(Thread.currentThread().getName() + "：" + i); } } } -
结果：可以发现有两个线程在分别打印(主线程[main方法]的线程名称默认为main)
1.2、实现Runnable接口
-
第一步和上面的一样，先使用主线程打印一遍
-
MyDemo1类不再继承Thread类了，改为implements Runnable接口 -
实现接口需要重写里面的
run方法，内容和我们上面写的方法一样 -
启动线程步骤不一样，可以看如下
main方法中的代码：package com.tcc.test; /** * @author 宇辰 * @date 2022/8/31-8:53 **/ public class Test{ public static void main(String[] args) { MyDemo1 demo1 = new MyDemo1(); // 把实现了Runnable的类当做Thread的构造参数创建对象，然后调用start()方法，启动线程 Thread t1 = new Thread(demo1); t1.start(); for (int i = 0; i < 100; i++) { System.out.println(Thread.currentThread().getName() + "：" + i); } } } class MyDemo1 implements Runnable{ @Override public void run() { for (int i = 0; i < 100; i++) { System.out.println(Thread.currentThread().getName() + "：" + i); } } } -
结果：
1.3、简化版
我们进入Runnable里面，可以看到类上面有
@FunctionalInterface注解，代表了这个接口我们可以使用lamdba表达式来代替,我这里就不写简化的步骤了，直接写最终版(后面讲lamdba会详细讲解)
package com.tcc.test;
/**
* @author 宇辰
* @date 2022/8/31-8:53
**/
public class Test{
public static void main(String[] args) {
new Thread(() -> {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + "：" + i);
}
}).start();
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + "：" + i);
}
}
}
1.4、两者对比
相同点
-
都可以用他们来创建线程
-
都是使用的Thread类的start方法来启动线程
-
点开Thread类可以发现，它自己也是实现了Runnable接口的
不同点(Runnable的优点)
- 因为Java是单继承模式，所以继承Thread有局限性，不可以再继承其他类了。而implements可以多实现，扩展更好
- 使用继承方式，每次需要创建线程都需要重新new一个对象，每个线程都会拥有自己单独的一份属性。而使用实现方式，只需要new一个对象，所有线程都共享这个对象里的数据(章节1.5)会进行演示
1.5、区别演示:
下面演示的是售票窗口的案例，多个窗口(线程)共卖100张票的案例
准备
创建一个
Window类(窗口)，，然后里面定义票(tickets)为100，再写一个方法，对票数进行–，并打印剩余票数
class Window extends Thread{
private int tickets = 100;
@Override
public void run() {
while (true){
if(tickets > 0){
tickets--;
// 因为是继承，所以this可以省略，Thread.currentThread().getName() == this.getName == 当前写的getName()
System.out.println(getName() + ",当前剩余票数：" + tickets);
// 因为是实现，跟Thread类没有任何关系，所以需要全部都写上
// System.out.println(Thread.currentThread().getName() + ",当前剩余票数：" + tickets);
}else {
break;
}
}
}
}
(1)、Thread方式
看完下面的步骤和结果再来看这，解决办法：
- 肯定就是使用继承Runnable接口的方式，下面会演示
- 把tickeds设置为静态属性，这样它就只会加载一次，每次new出来的对象都会共用同一个属性了
运行
public class Test{
public static void main(String[] args) {
Window w1 = new Window();
Window w2 = new Window();
Window w3 = new Window();
w1.start();
w2.start();
w3.start();
}
}
结果
结果：(可以看到每个线程都有自己的100张票)，这样就是300张票了，不符合逻辑
(2)、Runnable方式
在执行的时候，可能会有重票的概率，效果如下，现在不用在意，下面第三章中会详细讲到解决办法
运行
public class Test{
public static void main(String[] args) {
Window w = new Window();
new Thread(w).start();
new Thread(w).start();
new Thread(w).start();
}
}
结果
2、线程的常用方法
2.1、start()
void start()：启动线程，并执行对象的run()方法。上面都是使用的start()启动线程，这里就不演示了
2.2、run()
void run()：线程在被调度时执行的操作。就是上面继承以后重写的run()方法，如果没重写，则什么也不执行
2.3、getName()
String getName()：返回线程的名称，继承方式直接调用即可
public class Test{
public static void main(String[] args) {
Window window = new Window();
System.out.println(window.getName()); // Thread-0
}
}
class Window extends Thread{
}
2.4、setName()
void setName()：修改当前线程的名称，继承方式直接调用即可
public class Test{
public static void main(String[] args) {
Window window = new Window();
System.out.println(window.getName()); // Thread-0
window.setName("MyThread");
System.out.println(window.getName()); // MyThread
}
}
2.5、currentThread()
Thread currentThread()：返回当前线程，在Thread子类中就是this，通常用于主线程和Runnable实现类
public class Test{
public static void main(String[] args) {
Window w = new Window();
w.start();
System.out.println(Thread.currentThread().getName()); // main
}
}
class Window extends Thread{
@Override
public void run() {
System.out.println("getName：" + getName()); // getName：Thread-0
System.out.println("currentThread().getName()：" + Thread.currentThread().getName()); // currentThread().getName()：Thread-0
}
}
2.6、yield()
static void yield()：线程让步
- 暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
- 若队列中没有同优先级的线程，忽略此方法
设置线程优先级
范围0-10，默认为5
public final static int MIN_PRIORITY = 1; public final static int NORM_PRIORITY = 5; public final static int MAX_PRIORITY = 10;
- 设置线程优先级：setPriority(int newPriority)
- 获得线程优先级：getPriority()
查看结果可以看到大部分几率是在打印到
main：20的时候，下面就开始打印Thread-0线程的东西了。也有部分情况：在礼让之后，自己又被分配到继续执行了
package com.tcc.test;
/**
* @author 宇辰
* @date 2022/8/31-8:53
**/
public class Test{
public static void main(String[] args) {
Window w = new Window();
// 需要在启动前设置
w.setPriority(Thread.MAX_PRIORITY);
w.start();
Thread thread = Thread.currentThread();
thread.setPriority(Thread.MIN_PRIORITY);
for (int i = 0; i < 100; i++) {
System.out.println(thread.getName() + "：" + i);
if(i == 20){
Thread.yield();
}
}
}
}
class Window extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(getName() + "：" + i);
}
}
}
2.7、join()
void join()：当某个程序执行流中调用其他线程的join()方法时，调用线程将被阻塞，直到join()方法假如的join线程执行完为止
- 低优先级的线程也可以获得执行
查看结果可以看到大部分几率是在打印到
main：20的时候，下面就开始打印Thread-0线程的东西了。也有部分情况：在礼让之后，自己又被分配到继续执行了
package com.tcc.test;
/**
* @author 宇辰
* @date 2022/8/31-8:53
**/
public class Test{
public static void main(String[] args) {
Window w = new Window();
// 需要在启动前设置
w.setPriority(Thread.MAX_PRIORITY);
w.start();
Thread thread = Thread.currentThread();
thread.setPriority(Thread.MIN_PRIORITY);
for (int i = 0; i < 100; i++) {
System.out.println(thread.getName() + "：" + i);
if(i == 20){
try {
w.join(); // 主线程被阻塞，Thread-0线程插入
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
class Window extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(getName() + "：" + i);
}
}
}
2.8、sleep(long millis)
static sleep(long millis)：
public class Test{
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
if(i == 20){
System.out.println(LocalTime.now()); // 17:55:21.554
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(LocalTime.now());// 17:55:23.562
}
}
}
}
2.9、stop()
强制线程生命周期结束，不推荐使用(@Deprecated)，和下面案例结合来讲
2.10、isAlive()
boolean isAlive()：判断线程是否还活着，如果已经死亡，则错误
public class Test{
public static void main(String[] args) {
Window window = new Window();
window.start();
}
}
class Window extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(getName() + "：" + i);
if(i == 20){
System.out.println(i); // 20
System.out.println(isAlive()); // true
stop();
System.out.println(isAlive()); // 无结果
}
}
}
}
3、线程的安全问题与使用问题
3.1、问题回显
还是用上面的那个售票案例，三个窗口(线程)同卖100张票。这是使用两种方法创建线程都可以，我这里使用继承方式了。
代码
package com.tcc.test;
import java.time.LocalTime;
/**
* @author 宇辰
* @date 2022/8/31-8:53
**/
public class Test{
public static void main(String[] args) {
Window w1 = new Window();
Window w2 = new Window();
Window w3 = new Window();
w1.start();
w2.start();
w3.start();
}
}
class Window extends Thread{
// 使用静态属性，解决继承下三个线程卖300张票问题
private static int tickets = 100;
@Override
public void run() {
while (true){
if(tickets > 0){
tickets--;
System.out.println(getName() + ",当前剩余票数：" + tickets);
}else {
break;
}
}
}
}
结果
可以看到有重票的概率，这就是线程安全问题
原理
在线程-0执行完–方法后,值为99，阻塞了，没有打印tickets。然后线程-1也进来了，也执行完–方法后98，这时候线程-0也取消阻塞了，然后两个线程都会同时打印98
3.2、synchronized关键字(解决问题)
语法：synchronized(同步监视器){
// 需要被同步的代码块
}
说明：
- 操作共享数据的代码，即为需要被同步的代码
- 共享数据，多个线程共同操作的变量。比如：tickets就是共享数据
- 同步监视器，俗称：锁。任何一个类的对象，都可以充当锁
所有线程必须共用同一把锁才有用，在继承
Thread类上有体现
3.2.1、同步代码块
(1)、在继承Thread类的情况上使用
package com.tcc.test;
import java.time.LocalTime;
/**
* @author 宇辰
* @date 2022/8/31-8:53
**/
public class Test{
public static void main(String[] args) {
Window w1 = new Window();
Window w2 = new Window();
Window w3 = new Window();
w1.start();
w2.start();
w3.start();
}
}
class Window extends Thread{
// 使用静态属性，解决继承下三个线程卖300张票问题
private static int tickets = 100;
/*
不能这么写
因为使用继承方式，会创建三个Window对象，三个线程就会拥有三把自己的锁，无效，所有线程必须共用同一把锁才有用
*/
// private Object object = new Object();
private static Object object = new Object();
@Override
public void run() {
while (true){
// 这里需要一个对象充当锁，我这里就在类里面建一个object属性充当
synchronized (object){
if(tickets > 0){
tickets--;
System.out.println(getName() + ",当前剩余票数：" + tickets);
}else {
break;
}
}
}
}
}
结果：没有任何线程安全问题
(2)、在实现Runnable的情况上使用
这种方式和上面一样，惟一的区别就是，属性不需要设置为
static了，因为只会创建一个对象
3.2.2、同步方法
语法：private synchronized void saleTicket()
使用同步方法的话是不需要你自己定义同步监视器的，会使用Java默认的，具体原因会在3.3章中介绍
(1)、在继承Thread类的情况上使用
package com.tcc.test;
import java.time.LocalTime;
/**
* @author 宇辰
* @date 2022/8/31-8:53
**/
public class Test{
public static void main(String[] args) {
Window w1 = new Window();
Window w2 = new Window();
Window w3 = new Window();
w1.start();
w2.start();
w3.start();
}
}
class Window extends Thread{
// 使用静态属性，解决继承下三个线程卖300张票问题
private static int tickets = 100;
@Override
public void run() {
while (true){
this.saleTicket();
}
}
// 如果我们对共享数据的操作在一个方法里面，就可以直接在方法上加synchronized关键字即可
// 这么写不是不需要同步监视器，而是java使用了默认的同步监视器，这样就不用考虑哪种方式创建的多线程了
private synchronized void saleTicket(){
if(tickets > 0){
tickets--;
System.out.println(getName() + ",当前剩余票数：" + tickets);
}
// 方法里面就不写break了，可自行关闭程序
}
}
结果：没有任何问题
(2)、在实现Runnable的情况上使用
这个和上面继承一模一样的，都不需要写
static，具体原因会在3.3章讲到，java的默认的同步监视器
3.3、同步监视器的简单参数
3.3.1、同步代码块的简单参数
我们在上面使用同步监视器，是自己在类中定义的Object类，并且继承方式的话还要声明为静态的。
如果说我们不想每次都自己定义一个类来充当锁，而是直接写一个值就可以，当然可以，如下
this
适用于实现
Runnable接口，因为我们只需要创建一个对象，这个this就指向的当前创建的这个对象
package com.tcc.test;
import java.time.LocalTime;
/**
* @author 宇辰
* @date 2022/8/31-8:53
**/
public class Test{
public static void main(String[] args) {
Window w1 = new Window();
new Thread(w1).start();
new Thread(w1).start();
new Thread(w1).start();
/*Window w2 = new Window();
Window w3 = new Window();
w1.start();
w2.start();
w3.start();*/
}
}
class Window implements Runnable{
// 使用静态属性，解决继承下三个线程卖300张票问题
private static int tickets = 100;
@Override
public void run() {
while (true){
// 这个this就指向的上面创建w1对象，只创建了一次，所以也是所有线程共享同一把锁
synchronized (this){
if(tickets > 0){
tickets--;
System.out.println(Thread.currentThread().getName() + ",当前剩余票数：" + tickets);
}else {
break;
}
}
}
}
}
结果：没有任何问题
类名.class
两种方法创建线程的方式都适用
原因是类也是一个类–Class类，只会被系统加载一次，所以也可以充当锁，具体会在后面讲反射的时候讲到Class类
package com.tcc.test;
import java.time.LocalTime;
/**
* @author 宇辰
* @date 2022/8/31-8:53
**/
public class Test{
public static void main(String[] args) {
Window w1 = new Window();
Window w2 = new Window();
Window w3 = new Window();
w1.start();
w2.start();
w3.start();
}
}
class Window extends Thread{
// 使用静态属性，解决继承下三个线程卖300张票问题
private static int tickets = 100;
@Override
public void run() {
while (true){
// 当前这个类充当锁
synchronized (Window.class){
if(tickets > 0){
tickets--;
System.out.println(Thread.currentThread().getName() + ",当前剩余票数：" + tickets);
}else {
break;
}
}
}
}
}
3.3.2、同步方法的默认参数理解
我们上面看到，同步方法是直接写在方法上的，所以不需要我们写同步监视器，但是并不代表它没有。
当我们使用实现方式创建的线程，那它默认就是
this，如果我们使用的是继承的方式，那它默认就是类名.class
3.4、synchronized原理
3.5、Lock接口(解决问题)
- 从JDK5.0开始，Java提供了更强大的线程同步机制———通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当
- Java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
- ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁
package com.tcc.test;
import java.time.LocalTime;
import java.util.concurrent.locks.ReentrantLock;
/**
* @author 宇辰
* @date 2022/8/31-8:53
**/
public class Test{
public static void main(String[] args) {
Window w1 = new Window();
Window w2 = new Window();
Window w3 = new Window();
w1.start();
w2.start();
w3.start();
}
}
class Window extends Thread{
// 使用静态属性，解决继承下三个线程卖300张票问题
private static int tickets = 100;
// 1.实例化ReentrantLock，继承方式需要定义为static，多线程共享同一把锁
private static ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true){
// 最好放到try，finally里面，因为怕里面代码异常，锁不被打开
try {
// 2.调用lock()
lock.lock();
if(tickets > 0){
tickets--;
System.out.println(Thread.currentThread().getName() + ",当前剩余票数：" + tickets);
}else {
break;
}
}finally {
// 3. 释放锁
lock.unlock();
}
}
}
}
结果：没有任何问题
3.6、synchronized与Lock的区别
相同点
- 两者都可以解决线程安全问题
不同点
- Lock是显式锁(手动开启和关闭锁，别忘记关锁！)，synchronized是隐式锁，出了作用域自动释放
- Lock只有代码块锁，synchronized有代码块锁和方法所
- 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性(提供更多的子类)
优先使用顺序
Lock->同步代码块(已经进入了方法体，分配了相应资源)->同步方法(在方法体之外)
3.7、锁使用问题
-
多个线程必须共享同一把锁(上面有讲到，使用继承方式，同步监视器必须定义为static的，否则多个线程会有多个锁)
-
使用synchronized的时候，不论是同步代码块或同步方法，都不能多包({xxx})，或者少包内容
-
案例
package com.tcc.test; import java.time.LocalTime; /** * @author 宇辰 * @date 2022/8/31-8:53 **/ public class Test{ public static void main(String[] args) { Window w1 = new Window(); Window w2 = new Window(); Window w3 = new Window(); w2.start(); w1.start(); w3.start(); } } class Window extends Thread{ // 使用静态属性，解决继承下三个线程卖300张票问题 private static int tickets = 100; @Override public void run() { // 当线程进去后，就会进入无限循环，直到执行完毕，然后才释放锁，其他线程一进去,tickets以及=0了，就不执行了 synchronized (Window.class){ while (true){ if(tickets > 0){ tickets--; System.out.println(Thread.currentThread().getName() + ",当前剩余票数：" + tickets); }else { break; } } } } } -
以上案例，如果把
while(true)也包在了里面，则多线程就无效了，只有一个线程全部执行完毕
-
-
线程的死锁
- 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
- 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
-
解决办法
- 专门的算法、原则
- 尽量减少同步资源的定义
- 尽量避免嵌套同步
演示
package com.tcc.test;
import java.time.LocalTime;
/**
* @author 宇辰
* @date 2022/8/31-8:53
**/
public class Test{
public static void main(String[] args) {
W1 w1 = new W1();
W2 w2 = new W2();
w1.start();
w2.start();
}
}
class W1 extends Thread{
@Override
public void run() {
synchronized (W2.class){
System.out.println(getName() + "：进去了，打开了W2的锁-1");
// 为了增加死锁的概率
try {
sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (W1.class){
System.out.println(getName() + "：进去了，打开了W1的锁-2");
}
System.out.println(getName() + "：出来了，关闭了W1的锁");
}
System.out.println(getName() + "：出来了，关闭了W2的锁");
}
}
class W2 extends Thread{
@Override
public void run() {
synchronized (W1.class){
System.out.println(getName() + "：进去了，打开了W1的锁-1");
synchronized (W2.class){
System.out.println(getName() + "：进去了，打开了W2的锁");
}
System.out.println(getName() + "：出来了，关闭了W2的锁");
}
System.out.println(getName() + "：出来了，关闭了W1的锁");
}
}
结果：
线程-0进去了->打开了w2的锁 线程-0等待w1的锁打开后进入
线程-1进去了->打开了w1的锁 线程-1等待w2的锁打开后进入
谁也不让谁，然后就形成了死锁问题
4、线程的通信
线程的通信就是指线程与线程之间的交替执行
实现线程通信主要有三个方法(定义在Object类中的)
- wait()：让线程处于等待状态**(同时释放同步监视器)**
- notify()：唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级最高的
- notifyAll()：和notify功能一样，都是解除线程的等待，区别是唤醒所有被wait的线程
wait()，notify()，notifyAll三个方法必须使用在同步代码块或同步方法中
使用
package com.tcc.test;
/**
* @author 宇辰
* @date 2022/8/31-8:53
**/
public class Test{
public static void main(String[] args) {
new W1().start();
new W1().start();
}
}
class W1 extends Thread {
private int ticket = 100;
@Override
public void run() {
while (true){
synchronized (W1.class){
// 解除当前线程的等待状态
W1.class.notify();
if(ticket > 0){
ticket--;
System.out.println(Thread.currentThread().getName() + "：当前票数：" + ticket);
try {
// 执行完毕后，当前线程进入等待状态，直到下一个线程进入
W1.class.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}else {
break;
}
}
}
}
}
结果
4.1、sleep和wait的异同
相同
- 执行方法，都可以让线程进入阻塞状态
不同
- 两个方法声明的位置不同。
- Thread类中生命sleep()
- Object类中生命wait()
- 调用要求不同
- sleep()可以在任何需要的场景下调用。
- wait()必须使用在同步方法或同步代码块中
5、JDK5新增创建线程方式
5.1、实现Callable接口(可接收返回值)
与使用Runnable相比，Callable功能更强大些
- 相比run()方法，可以有返回值
- 方法可以抛出异常
- 支持泛型的返回值
- 需要借助
FutureTask类，比如获取返回结果Future接口
- 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等
- FutureTask是Future接口的唯一实现类
- FutureTask同时实现了Runnable、Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值
Callable接口是支持泛型的，如果写了泛型，则返回值为泛型类型，后面获取返回值无需做强转操作
使用
package com.tcc.test;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
* @author 宇辰
* @date 2022/8/31-8:53
**/
public class Test{
public static void main(String[] args){
// 3. 创建实现了Callable接口的对象
Window w = new Window();
// 4. 把创建好的对象传递给FutureTask类的构造函数中
FutureTask futureTask = new FutureTask<>(w);
// 如果是使用的implements Runnable方法创建的对象，则使用如下方式带入返回值
// FutureTask futureTask = new FutureTask<>(w,"123");
// 5. 因为FutureTask实现了RunnableFuture，而它又继承了Runnable，所以可以当做参数传入，启动线程
new Thread(futureTask).start();
try {
// 6. 线程运行完后，通过get()方法获取线程执行完毕后返回的结果
Object o = futureTask.get();
System.out.println(o);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}finally {
// 记住要关闭线程池
service.shutdown();
}
}
}
// 1. 继承Callable类
// Callable是支持泛型的，如果写了泛型，则返回值为泛型类型，后面获取返回值无需做强转操作
class Window implements Callable {
// 2. 重写Callable接口的call方法，可以接收Object类型的返回值
@Override
public Object call() throws Exception {
for (int i = 0; i < 100; i++) {
System.out.println(i);
}
return "我执行完了";
}
}
结果
5.2、线程池(常用)
- 背景
- 经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大
- 思路
- 提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。
- 好处
- 提高响应速度(减少创建新线程的时间)
- 降低资源消耗(重复利用线程池中线程，不需要每次都创建)
- 便于线程管理
- corePoolSize：核心池的大小
- maximumPoolSize：最大线程数
- keepAliveTime：线程没有任务时最多保持多长时间后悔终止
- …
5.2.1、线程池相关API
JDK5.0起提供了线程池相关API：
ExecutorService和ExecutorsExecutorService：真正的线程池接口。常见子类ThreadProolExecutor
- void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnable
- Future submit(Callable task)：执行任务，有返回值，一般用来执行Callable
Executors：工具类、线程池的工具类，用于创建并返回不同类型的线程池
- Executors.newCachedThreadProol()：创建一个可根据需要创建新线程的线程池
- Executors.newFixedThreadProol(n)：创建一个可重用固定线程数的线程池
- Executors.newSingleThreadExecutor()：创建一个只有一个线程的线程池
- Executors.newScheduledThreadProol(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行
Executors创建线程池可能造成很多潜在问题，具体可以查看：https://blog.csdn.net/qq_42764468/article/details/123373042，尽量使用
ThreadPoolExecutor来创建线程池，后面会出一个讲解线程池的文章本次拿第二个创建指定数量的线程池举例
使用
package com.tcc.test;
import java.util.concurrent.*;
/**
* @author 宇辰
* @date 2022/8/31-8:53
**/
public class Test{
public static void main(String[] args){
// 创建一个执行线程数量的线程池
ExecutorService service = Executors.newFixedThreadPool(8);
// 适用于实现Runnable接口的方式
// service.execute(Runnable command);
// 适用于实现Callable接口的方式
Future submit = service.submit(new Window());
try {
Object o = submit.get();
System.out.println(o);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
// 1. 继承Callable类
class Window implements Callable {
// 2. 重写Callable接口的call方法，可以接收Object类型的返回值
@Override
public Object call() throws Exception {
for (int i = 0; i < 100; i++) {
System.out.println(i);
}
return "我执行完了";
}
}
结果
5969
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
