【Java 11】多线程 - 程序、进程、线程、线程的创建和使用、线程的生命周期、线程的同步、线程的通信、JDK5.0新增线程创建方式

最新推荐文章于 2024-06-26 15:31:02 发布

白雪青冢黄河黑山

最新推荐文章于 2024-06-26 15:31:02 发布

阅读量303

点赞数

本文链接：https://blog.csdn.net/a903003911/article/details/108081885

版权

本文深入探讨Java 11中的多线程概念，包括程序、进程和线程的区分，线程的创建（继承Thread、实现Runnable和JDK5.0新增的Callable接口）、线程调度与优先级，线程同步（同步代码块、同步方法和Lock），线程通信（wait、notify和notifyAll）以及线程池的使用。此外，还讨论了不同线程创建方式的优缺点和线程安全问题。

摘要由CSDN通过智能技术生成

一 Idea

1 快捷补全

new Method()

使用Alt + Enter 可补全

Method method = new Method()；

psvm : 可生成 main 方法
sout : System.out.println() 快捷输出

soutp=System.out.println("方法形参名 = " + 形参名); soutv=System.out.println("变量名 = " + 变量); soutm=System.out.println(“当前类名.当前方法”); “abc”.sout => System.out.println(“abc”);
fori : 可生成 for 循环

iter：可生成增强 for 循环

itar：可生成普通 for 循环
list.for : 可生成集合 list 的 for 循环

List list = new ArrayList();

输入: list.for 即可输出

for(String s:list){ }

又如：list.fori 或 list.forr
ifn：可生成 if(xxx = null)

inn：可生成 if(xxx != null) 或 xxx.nn 或 xxx.null
prsf：可生成 private static final

psf：可生成 public static final

psfi：可生成 public static final int

psfs：可生成 public static final String

外加：

*
 * @description: <br>
 * @param: $param$
 * @return: $return$
 * @author: $user$
 * @date: $date$ $time$
 */

二线程

1 程序、进程、线程

2 线程的创建和使用

2.1 多线程的创建

2.1.1 方式一：继承Thread类

2.1.1.1 步骤

定义子类继承Thread类
子类中重写Thread类中的run方法 —> 将此线程执行的操作声明在run（）中
创建Thread子类对象，即创建了线程对象
通过此线程对象 调用 start（）方法：启动线程，调用run方法

public class ThreadNew {
   
    public static void main(String[] args) {
   
        
        //3.创建Thread子类对象，即创建线程对象
        MyThread01 mt = new MyThread01();
        //4.调用线程对象start方法：启动线程，调用run方法
        mt.start();
        //new MyThread01().start();
        
    }
}

//1.定义子类继承Thread类
class MyThread01 extends Thread {
   
    
    //2.子类中重写Thread类中的run方法
    @Override
    public void run() {
   
        System.out.println("-----MyThread01");
    }
    
}

2.1.1.2 start（）方法的作用

启动当前线程
调用当前线程的run（）

2.1.1.3 一些问题

问题一：我们不能通过直接调用run（）的方式启动线程

问题二：再启动一个线程，不可以还让已经start（）的线程去执行。会报IllegalThreadStateException异常

2.1.1.4 步骤整合

new Thread(){
   
    @Override
    public void run(){
   
        
    }
}.start();

2.1.1.5 Thread类常用方法

void start（）：启动当前线程；调用当前线程的run（）
run（）：线程在被调度时执行的操作。通常需要重写Thread类中的方法，将创建的线程要执行的操作声明在此方法中
static Thread currentThread（）：静态方法，返回执行当前代码的线程【在Thread子类中就是this】

【Thread.currentThread（）.getName（）= mt.getName（）】
String getName（）：获取当前线程的名字
void setName（）：设置当前线程的名字
static void yield（）：线程让步。释放当前CPU的执行权

暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程

若队列中没有同优先级的线程，忽略此方法
join（）：当线程a中调用线程b的join（），此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。

低优先级的线程也可以获得执行
static void sleep（long millitime）：让当前线程“睡眠”指定millitime毫秒。在指定的millitime毫秒时间内，线程是阻塞状态
stop（）：强制线程生命期结束，不推荐使用
boolean isAlive（）：返回boolean，判断线程是否还活着

2.1.1.6 Thread类构造器

Thread（）：创建新的Thread对象
Thread（String threadname）：创建线程并指定线程实例名
Thread（Runnable target）：指定创建线程的目标对象，它实现了Runnable接口中的run方法
Thread（Runnable target, String name）：创建新的Thread对象

2.1.2 方式二：实现Runnable接口

2.1.2.1 步骤

定义子类，实现Runnable接口
子类中重写Runnable接口中的run（）方法
创建实现类的对象
将Runnable接口的子类对象作为实际参数传递给 Thread类的构造器中

通过Thread类的对象去调用start（）方法

【开启线程，调用Runnable子类接口的run方法】

【调用了Runable类型的target的run（）方法】

Thread.java
 
public class Thread implements Runnable{
      
 
 private Runnable target;
 
 public Thread(Runnable target){
      
     init(null; target; "Thread-" + nextThreadNum(), 0);
 }
 
 public void run(){
      
 	if(target != null){
      
  	   target.run();
 	}
	}
 
}

public class ThreadTest02 {
   

    public static void main(String[] args) {
   

        //3.创建实现类的对象
        MyThread02 myThread02 = new MyThread02();
        //4.将Runnable接口的子类对象 作为实际参数 传递给 Thread类的构造器中
        Thread t2 = new Thread(myThread02);
        //5.通过Thread类的对象去调用start（）方法
        t2.start();
        
    }

}

//1.定义子类，实现Runnable接口
class MyThread02 implements Runnable {
   
    //2.子类中重写Runnable接口中的run（）方法
    @Override
    public void run() {
   
        System.out.println("-----MyThread02");
    }
}