代码编织梦想

1.线程的创建

线程有五种创建方法(一般使用lambda表达式):

(1)继承 Thread, 重写 run

class MyThread extends Thread {
    public void run() {
        System.out.println("重写run");
    }
}
public class Demo1 {
    public static void main(String[] args) {
           MyThread t = new MyThread();
           t.start();
    }
}

(2)实现 Runnable, 重写 run

class MyRunnable implements Runnable{
    @Override
    public void run() {
        while(true) {
            System.out.println("实现 Runnable, 重写 run");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class Demo2 {
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread t= new Thread(runnable);
        t.start();

        while(true) {
            System.out.println("你好");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

(3)继承 Thread, 重写 run, 使用匿名内部类

public class Demo3 {
    public static void main(String[] args) {
        Thread t = new Thread(){
            public void run() {
                while(true) {
                    System.out.println("你好");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t.start();
    }
}

(4)实现 Runnable, 重写 run, 使用匿名内部类

public class Demo4 {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while(true) {
                    System.out.println("你好");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        t.start();
    }
}

(5)使用 lambda 表达式

public class Demo5 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while(true) {
                System.out.println("你好");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
    }
}

2.线程中断

线程中断有两种:
(1)自己定义一个标注位,作为线程是否结束的标记

public class Demo8 {
    private static boolean isSign = false;//标志位

    public static void main(String[] args) {
        Thread t = new Thread(() -> {
           while(!isSign) {
               System.out.println("你好");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
            System.out.println("t线程打印完成");
        });

        t.start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        isSign = true;
        System.out.println("设置t 线程中断");
    }
}

(2)使用标准库自带的标志位

public class Demo9 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while(!Thread.currentThread().isInterrupted()) {
                System.out.println("你好");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    //e.printStackTrace();
                    break;
                    //这个地方换成break
                }
            }
            System.out.println("t线程打印完成");
        });
        t.start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t.interrupt();
        System.out.println("设置t 线程中断");
    }
}

interrupt 方法的行为有两种情况
1.t线程在运行状态,会把Thread.currentThread().isInterrupted()这个标注位设置位true
2.t线程在阻塞状态(sleep)就不会设置标志位,而是触发一个InterruptedException,这个异常会把sleep提前唤醒,但e.printStackTrace()只是打印了日志,并没有结束循环,所以会导致继续执行,把catch里换成break就能解决了

3.线程等待

使用join,在main线程中调用t.join就是让main线程阻塞等待,等到t执行完了,main才能继续执行

public class Demo10 {
    public static void main(String[] args) {
        Thread t =new Thread(() -> {
           for (int i = 0; i < 5; i++) {
               System.out.println("你好");
           }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        t.start();
        System.out.println("main 线程join之前");
        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("main线程join之后");
        System.out.println("不好");
    }

}

执行结果:
在这里插入图片描述

4.线程休眠

sleep会让线程休息一会(阻塞等待)
可以看作有两个队列,像链表那样串在一起,一个是就绪队列,一个是阻塞队列,操作系统在管理这些PCB时会有多个链表.
例如我们使用了Thread.sleep(1000),就能把这个线程由就绪队列放到阻塞队列当中,不是说只阻塞1000ms,而是要至少1000ms,下一次使用的时间是由操作系统的需求来决定的,

5.获取线程实例

使用Thread.currentThread()来获取

public class Demo11 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            Thread thread = Thread.currentThread();
            System.out.println(thread.getName());
        });
        t.start();
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName());
    }
}

代码结果:
在这里插入图片描述

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/qq_62740215/article/details/129638095

java的thread类_thread 类详解-爱代码爱编程

java.lang.Thread类详解 一、前言 位于java.lang包下的Thread类是非常重要的线程类,它实现了Runnable接口,今天我们来学习一下Thread类,在学习Thread类之前,先介绍与线程相关知识:线程的几种状态、上下文切换,然后接着介绍Thread类中的方法的具体使用。 二、线程的状态 在正式学习Thread类中的具

一、C# Thread类的基本用法-爱代码爱编程

C# 线程的定义和使用   一、C# Thread类的基本用法     通过System.Threading.Thread类可以开始新的线程,并在线程堆栈中运行静态或实例方法。可以通过Thread类的的构造方法传递一个无参数,并且不返回值(返回void)的委托(ThreadStart),这个委托的定义如下:     [ComVisibleAttri

c语言的thread的用法,C++并发编程实战 part2 thread基本用法-爱代码爱编程

前言 本章讲述thread的基本用法 Managing threads 总体而言,C++设计理论是让thread管理变得简单。 所有与之相关的管理都通过std::thread对象关联thread资源。 2.1 basic thread management 每个程序都至少有一个thread,即main()作为起始thread, 而每个新加

C++多线程 -- std::thread的基本用法-爱代码爱编程

依赖头文件: #include< thread > 用法: std::thread 和 join或 detach一起用 std::thread t1(调用函数名称,调用函数参数1,调用函数参数2,。。。,调用函数参数n) t1.join(); //表示同步(阻塞),调用线程走完,才能走后面的流程 t1.detach(); //表示异步,主线程只

Java中的Thread类-爱代码爱编程

目录 一.什么是Thread类 二.Thread类的基本用法 三.线程的并发执行 一.什么是Thread类        在java标准库中,提供了一个Thread类,用来表示/操作线程,Thread类可以视为是Java标准库提供的API,Java是支持多线程编程的,在Java中创建好的Thread实例,其实和操作系统中的线程是一一对应

Thread类的基本用法-爱代码爱编程

目录 一.线程的创建方法 2.创建一个类实现Runnable接口.再创建Runnable实例传给Thread实例 3.创建Thread类,使用匿名内部类 4.使用Runnable接口,并使用匿名内部类重写run方法 5.使用Lambda表达式   二.线程中断 三.线程等待   四.线程休眠  五.获取当前线程实例 一.线程的创

javaee thread类的基本用法(一)_naion的博客-爱代码爱编程

        上一篇文章我们讲了Java关于线程的基本知识和如何创建一个简单的线程。Java使用Thread类来创建线程。多线程编程对于以前没有相关经验的人来说,最难理解的地方在于操作系统调度的执行过程。对于这样的代码: public static void main(String[] args) { Thread thread

thread类的基本用法_平 行的博客-爱代码爱编程

1.线程创建 1.继承Thread重写run方法。 2.通过实现Runnable接口重写run方法。 3.通过匿名内部类。 4.通过lambda表达式。 class MyThread extends Thread{ @Override public void run() { System.out.println("

c++中的thread最全用法归纳-爱代码爱编程

基本 std::thread 的用法 最简单的 std::thread 范例如下所示,调用 thread 将立即同时开始执行这个新建立的线程,之后 main() 的主线程也会继续执行,基本上这就是一个基本的建立多线程的功能

c++:std::thread:线程用法-爱代码爱编程

1:std::thread的基本用法 最简单的 std::thread用法如下,调用 thread将立即同时开始执行这个新建立的线程,新线程的任务执行完毕之后, main()的主线程也会继续执行。 #include<iostream> #include<thread> #include<windows.h>

java中thread类的基本使用_java thread-爱代码爱编程

Thread类的基本用法: 1.创建子类,继承自Thread并且重写run方法: class MyThread extends Thread { @Override public void ru

thread 类的基本用法(附详细代码),通俗易懂。_部分代码new thread 运行-爱代码爱编程

目录 1、线程创建 2、线程中断 3、线程等待 4、线程休眠 5、获取线程实例 6、yield让出执行权 1、线程创建 1.1 继承Thread类 /** * 继承Thread创建线程 */ public class ThreadDemo3 { public static void main(String[

【javaee初阶】多线程 _ 基础篇 _ thread类的使用、线程的几个重要操作和状态_java中new thread后会发生什么-爱代码爱编程

☕导航小助手☕     🍱写在前面         🧇一、Thread类的常见构造方法         🍚二、Thread 的几个常见属性         🍛三、和线程相关的几个重要的操作                     🍞🍞3.1 启动线程 - start()                     🍣🍣3.2 中断线程      

thread的基本用法_thread使用-爱代码爱编程

目录 1.创建线程 2.1 继承Thread类,重写run方法 2.2 实现Runnable,重写run方法 2.3 使用匿名内部类继承Thread类,重写run方法 2.4 使用匿名内部类实现Runnable接口,重写run方法 2.5 使用lambda表达式 3.Thread类的构造方法 4.Thread类的常见属性的获取方法 5