Java零基础入门:多线程总结

已于 2022-06-10 15:16:30 修改
阅读量485 收藏 28
点赞数 31
分类专栏： Java零基础入门 文章标签： java 开发语言
于 2022-06-06 20:36:32 首次发布
程序员飞鸟
本文链接：https://blog.csdn.net/A6_107/article/details/125153047
版权
本文详细介绍了Java中的多线程概念，包括进程、线程的区别，以及创建线程的两种方式：继承Thread类和实现Runnable接口。文中强调了实现Runnable接口的好处，并通过实例展示了如何创建和管理线程。此外，还讲解了线程同步的重要性，如互斥锁和死锁，并给出了实际的售票系统模拟案例，展示了线程同步机制的运用。
摘要由CSDN通过智能技术生成

文章目录

博主简介：
博客主页：Java知识分享博主
Java零基础入门专栏：Java零基础入门专栏
Java交流社区：飞鸟社区
欢迎阅读，如果文章对你有帮助点赞，支持一下！

什么是多线程

程序、进程、线程

  • 程序：从所周知的，编写代码组成的。

  • 进程：可以理解为运行中的程序，比如启动QQ，就启动一个进程，操作系统会为进程分配内存空间。

  • 线程：由进程创建的，是进程的一个实体。

单线程和多线程的区分：

  • 同一个时刻，只允许执行一个线程

  • 同一个时刻，可以执行多个线程，比如QQ可以同时打开多个聊天窗口

并发和并行（理解）

  • 一个多个任务交替执行，一个多个任务同时执行

创建线程的两种方式

通过继承 Thread 的方法和实现 Runnable 接口的方式创建多线程，哪个好？

实现Runnable接口好，原因有两个：

  • ①、避免了Java单继承的局限性
  • ②、适合多个相同的程序代码去处理同一资源的情况，把线程、代码和数据有效的分离，更符合面向对象的设计思想。

①、继承 Thread 的方法

  1. 当一个类（cat类）继承了 Thread 类， 该类就可以当做线程使用
  2. 我们会重写 run 方法，写上自己的业务代码
  3. run Thread 类 实现了 Runnable 接口的 run
package threaduse;

public class Thread01 {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.start();//启动线程
    }
}
class Cat extends Thread{
int times=0;
        public void run () { //重写 run 方法，写上自己的业务逻辑
            while(true) {
        System.out.println("猫会跑"+times++);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if(times==8){ //当时间到第8秒时，自动跳出
                    break;
                }

            }

    }

}

②、runnable接口实现run方法

1、dog.start();这里不能调用 start
2、创建了 Thread 对象，把 dog 对象(实现 Runnable),放入 Thread

package threaduse;

public class Thread02 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        
        // dog.start();这里不能调用 start
        //创建了 Thread 对象，把 dog 对象(实现 Runnable),放入 Thread
        
        Thread thread = new Thread(dog);
        thread.start();
    }
}
class Dog implements Runnable{//通过实现 Runnable 接口，开发线程
    int count=0;
    public void run(){
        while (true){
            System.out.println("小狗会汪汪叫。。"+(++count)+Thread.currentThread().getName());
            try {
                Thread.sleep(1000); //休眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count==8){
                break;
            }
        }

    }
}

为什么要重写run方法

因为run方法是用来封装被线程执行的代码。

run()方法和start()方法有什么区别？

  • run()：封装线程执行的代码，直接调用相当于调用普通方法。
  • start()：启动线程，然后由JVM 调用此线程的 run() 方法。

设计模式

package threaduse;

public class Thread02 {
    public static void main(String[] args) {
//        Dog dog = new Dog();
//       // dog.start();这里不能调用 start
//        //创建了 Thread 对象，把 dog 对象(实现 Runnable),放入 Thread
//        Thread thread = new Thread(dog);
//        thread.start();


        tiger tiger = new tiger();
        ThreadProxy threadProxy = new ThreadProxy(tiger);
        threadProxy.start();
    }
}
class Animal{}
class tiger extends Animal implements Runnable{
    public void run(){
        System.out.println("老虎嗷嗷叫");
    }
}
//线程代理类 , 模拟了一个极简的 Thread
class ThreadProxy implements Runnable{
private Runnable target =null;//属性，类型是Runnable
    public void run() {
        if(target!=null){
            target.run();//动态绑定（运行类型 Tiger）
        }
    }
    public ThreadProxy(Runnable target){
        this.target=target;//构造方法
    }
    public void start(){
        start0();//这个方法时真正实现多线程方法
    }
    public void start0(){
        run();
    }
}
class Dog implements Runnable{//通过实现 Runnable 接口，开发线程
    int count=0;
    public void run(){
        while (true){
            System.out.println("小狗会汪汪叫。。"+(++count)+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count==8){
                break;
            }
        }

    }
}

手动实践编程题

编写一个程序，创建两个线程，一个线程每隔1秒输出“helloworld”，输出10次退出， 一个线程每隔1秒输出“hi”，输出5次退出（可以手动敲一下.狗头）

package threaduse;
//编写一个程序，创建两个线程，一个线程每隔1秒输出“helloworld”，输出10次退出，
// 一个线程每隔1秒输出“hi”，输出5次退出
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;
    public void run(){
        while (true){
            System.out.println("helloworld"+(++count)+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count==10){
                break;
            }
        }
    }
}
class T2 implements Runnable{
    int count=0;
    public void run(){
        while (true){
            System.out.println("hi"+(++count)+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count==5){
                break;
            }
        }

    }
}

编程模拟三个售票窗口售票100张

package threaduse;
//编程模拟三个售票窗口售票100张，
// 分别使用继承Thread和实现Runnable方式，并分析有什么问题？
public class Thread04 {
    public static void main(String[] args) {
        SellTicket sellTicket = new SellTicket();

        new Thread(sellTicket).start();//第一个售票窗口
        new Thread(sellTicket).start();//第二个售票窗口
        new Thread(sellTicket).start();//第三个售票窗口

    }
}
class SellTicket extends Thread{
    private static int  num=100;
    public  void run(){
        while (true){
            if(num<=0){
                System.out.println("售票结束。。");
                break;

            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口"+Thread.currentThread().getName()+"售出一张票"+"剩余票数="+(--num));
        }
    }
}

手动实践编程题

启动一个线程t，要求main线程中去停止线程t，关键代码块

成员内部类中

package exit;

public class ThreadExit {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        new Thread(t).start();
        System.out.println("main线程休眠10秒");
        Thread.sleep(10*1000);
        t.setLoop(false);
    }
}
class T implements Runnable{
    private boolean loop=true;
    private int count=0;

    public void run(){
        while(loop){
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("a运行中。。。"+(++count));
        }
    }
    public void setLoop(boolean loop){
        this.loop=loop;
    }

}

线程常用方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kwlvk0H3-1654516203869)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20220602184235465.png)]

interrupt 中断线程

在这里插入图片描述

编程题

两个线程同时执行，当主线程执行输出5次时，让子线程执行剩下15次输出，主线程再次执行。

public class ThreadMethodExercise {
    public static void main(String[] args) throws InterruptedException {
        Thread t3 = new Thread(new T3());//创建子线程
        for (int i = 1; i <= 10; i++) {
            System.out.println("hi " + i);
            if(i == 5) {//说明主线程输出了 5 次 hi
                t3.start();//启动子线程 输出 hello... t3.join();
                t3.join();// 立即将 t3 子线程，插入到 main 线程，让 t3 先执行
            }
            Thread.sleep(1000);//输出一次 hi, 让 main 线程也休眠 1s
        }
    }
}

class T3 implements Runnable {
    private int count = 0;
    @Override
    public void run() {
        while (true) {
            System.out.println("hello " + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10) {
                break;
            }
        }
    }
}

Thread.yield;礼让不一定成功
t3.join();插队一定成功

用户线程和守护线程

在这里插入图片描述

//设t为子线程，即设为守护线程，当所有线程结束后，t也自动结束
//如果没有设置，那么main线程执行完毕，t也不退出
//前提是子线程无限循环
t.setDaemon(true);//关键字
t.start();

img

6种线程

public enum State {
    NEW,
    RUNNABLE,
    BLOCKED,
    WAITING,
    TIMED_WAITING,
    TERMINATED;
}

package state;

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(1000);
        }
        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;
        }
    }
}

线程同步机制（重点）

在这里插入图片描述

在这里插入图片描述

  • 编程模拟三个售票窗口售票100张，
  • 分别使用继承Thread和实现Runnable方式，并分析有什么问题？
package sys;

public class Thread05 {

    public static void main(String[] args) {

        SellTicket3 sellTicket3 = new SellTicket3();

        new Thread(sellTicket3).start();//第一个售票窗口
        new Thread(sellTicket3).start();//第二个售票窗口
        new Thread(sellTicket3).start();//第三个售票窗口

    }

}
class SellTicket3 implements Runnable{

    private int num=100;
    private boolean loop =true;
    public synchronized void sell(){ //同步线程，只允许一个线程执行

        if(num<=0){
            System.out.println("售票结束。。");
            loop=false;
            return;

        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("窗口"+Thread.currentThread().getName()+"售出一张票"+"剩余票数="+(--num));
    }
    public void run(){
        while (loop){

            sell();

        }
    }
}

互斥锁

在这里插入图片描述

//1. public synchronized static void m1() {} 锁是加在 SellTicket03.class
//2. 如果在静态方法中，实现一个同步代码块
/*
    synchronized (SellTicket4.class) {
        System.out.println("m2");
    }
*/
    public synchronized static void m1() {
    }
    public static void m2() {
        synchronized (SellTicket4.class) {
            System.out.println("m2");
        }
  • 1、 public synchronized void sell() {} 就是一个同步方法
  • 2、这时锁在this对象
  • 3、 也可以在代码块上写synchronize，同步代码块，互斥锁还是在this对象
package sys;
//编程模拟三个售票窗口售票100张，
// 分别使用继承Thread和实现Runnable方式，并分析有什么问题？
public class Thread06 {

    public static void main(String[] args) {

        SellTicket4 sellTicket3 = new SellTicket4();

        new Thread(sellTicket3).start();//第一个售票窗口
        new Thread(sellTicket3).start();//第二个售票窗口
        new Thread(sellTicket3).start();//第三个售票窗口

    }

}


class SellTicket4 implements Runnable{

    private int num=50;
    private boolean loop =true;
    Object object=new Object();
    

        public  void sell() { //同步方法，同一个时刻，只允许一个sell线程执行
        synchronized (object) {

            if (num <= 0) {
                System.out.println("售票结束。。");
                loop = false;
                return;

            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口" + Thread.currentThread().getName() + "售出一张票" + "剩余票数=" + (--num));
        }
    }
    public void run(){
        while (loop){

            sell();

        }
    }
}

在这里插入图片描述

线程的死锁

多个线程都占用对方的锁资源，但不肯互让，导致了死锁

package DeadLock;

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
    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) { // 这里获得 li 对象的监视权
                    System.out.println(Thread.currentThread().getName() + " 进入 2");
                }
            }
        } else {
            
            synchronized (o2) {
                System.out.println(Thread.currentThread().getName() + " 进入 3");
                synchronized (o1) { // 这里获得 li 对象的监视权
                    System.out.println(Thread.currentThread().getName() + " 进入 4");
                }
            }
        }
    }
}

编程题

在main方法中启动两个线程

第1个线程循环随机打印100以内的整数

直到第2个线程从键盘读取了“Q”命令

package Homework01;

import java.util.Locale;
import java.util.Scanner;

public class Homework01 {
    public static void main(String[] args) {
        A a = new A();
        B b = new B(a);
        a.start();
        b.start();
    }
}
class A extends Thread{
    private boolean loop =true;
    public void run(){

        while(loop){
            System.out.println((int)(Math.random()*100 +1));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}
class B extends Thread{
    private A a;
    private Scanner scanner=new Scanner(System.in);

    public B(A a){
        this.a=a;

    }
    public void run() {
        while (true) {
            //接受用户输入
            System.out.println("请输入（Q）指令结束退出:");
            char key=scanner.next().toUpperCase().charAt(0);
            if(key=='Q'){
                //以通知方式结束a线程
                a.setLoop(false);
                System.out.println("b线程退出");
                break;
            }
        }
    }
}

在这里插入图片描述

编程题

有2个用户分别从同一个卡上取钱（总额：1000）

每次都取1000，当余款不足时，就不能取款了

不能出现超取现象 线程同步问题

package Homework02;


public class Mon01 {
    public static void main(String[] args) {
        A a = new A();

        Thread thread1 = new Thread(a);
        thread1.setName("用户1");
        Thread thread2 = new Thread(a);
        thread2.setName("用户2");
        thread1.start();//第一个用户
        thread2.start();//第二个用户



    }


}
//涉及多个线程共享资源，使用接口的实现
class A implements Runnable{
    private int num=10000;
    public boolean loop=true;


    public void run(){
        while(loop){
           synchronized (this){
                if(num<0){
                    System.out.println("余款不足，不能取款");
                    loop=false;
                    return;
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
               num -=1000;
                System.out.println(Thread.currentThread().getName()+" "+"剩余余款:"+num);
            }

        }

    }
}

在这里插入图片描述

Java实现多线程的方式（通过继承Thread类）
m0_66884848的博客
03-14 1873
一、在提到线程之前，我们要理解什么是程序和进程。 1、程序：通过某种编程语言编写并实现一系列特定功能的静态代码。也就是说，我们编写好的代码，在没有运行之前，他就是一个程序。 2、进程：狭义来讲，是指正在运行的程序。一个正在运行的程序就是一个进程。广义来讲，进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。 举个类似的例子：当你从网上下载了一个QQ，你没有运行它，它就是一个程序。如果运行它，它就可以加载到内存空间，分配到cpu的资源。所以这时候，正在运行的QQ就是一个进程啦。 小提示：你
Java多线程的实现方式（继承Thread/实现Runnable/实现Callable/线程池）
N_Peng的博客
08-22 769
方式1、继承Thread类 继承Thread，覆写该类中的run()方法，run()方法中即为该线程要实现的具体业务。 public class NewThread1 extends Thread{ private String title; public NewThread1(String title){ this.title = title; } ...
通过继承Thread类实现多线程
Code_Ninja
11-27 679
//通过继承Thread类实现多线程package 多线程;class TestThread extends Thread{    public void run()    {        for(int i = 0 ; i         {            System.out.println("TestThread在运行");        }    }}public class T
132.继承Thread实现多线程
qq_43808700的博客
09-21 361
Thread 先写一个代码体会一下多线程 通过继承Thread类实现多线程 package yzy.cn; public class inheritThread extends Thread{ private int nums; //重载run方法 @Override public void run() { this.nums = nums; super.run(); for(int i=0; i<nums; ++i) System.out.println("singin.
java 创建线程thread_java线程之用Thread类创建线程的方法
weixin_42179184的博客
02-13 566
在Java中创建线程有两种方法：使用Thread类和使用Runnable接口。在使用Runnable接口时需要建立一个Thread实例。因此，无论是通过Thread类还是Runnable接口建立线程，都必须建立Thread类或它的子类的实例。Thread类的构造方法被重载了八次，构造方法如下：public Thread( );public Thread(Runnable target);publi...
Java多线程-继承Thread类实现多线程
这里是菠萝味菠萝啤的博客
12-28 397
方法体中的代码，都是自上而下执行，永远不变 package xiancheng.MyThread; public class ThreadTest { //java程序有一个main主线程和回收机制线程 public static void main(String[] args) { //新建一个分支线程对象 MyThread myThread = new MyThread(); //启动线程 //start()方法的作用：启动
Java多线程
余杯冷饮的博客
04-04 516
子类继承Thread类具备多线程能力启动线程：子类对象.start（）不建议使用：避免OOP单继承局限性创建线程方法一： 运行结果[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9AOdwcMO-1680580929830)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20230307160255323.png)]练习Thread，实现多线程同步下载图片： 运行结果：[外链图片转存
零基础Java入门课程-多线程
07-01
本"零基础Java入门课程-多线程"专为初学者设计，旨在通过最新的Java 14平台，引领学习者逐步掌握Java的基础及多线程相关知识。 Java集合框架是Java编程中的核心组成部分，它提供了对数据结构的有效管理，包括数组、...
2020老杜最新Java零基础进阶视频教程-多线程课件
12-10
【Java多线程详解】 Java多线程是Java编程中不可或缺的一部分，它允许程序同时执行多个不同的任务，从而提高了程序的效率和响应性。在Java中，多线程的实现主要有两种方式：继承Thread类和实现Runnable接口。 1. ...
零基础入门：Java语言特性与学习指南
零基础学Java的PPT教程首先引导学生理解Java的核心理念和优势，然后逐步探讨其面向对象、平台无关、分布式和多线程等关键特性，为初学者提供一个扎实的起点。阅读此PPT将有助于你建立起Java编程的基础，并为其后的...
最新Java零基础入门到精通300集
最新发布
07-07
"最新Java零基础入门到精通300集" 提供了一个全面的学习路径，帮助新手逐步从零开始，直至达到精通的程度。在这个过程中，IDEA（IntelliJ IDEA）作为强大的Java集成开发环境，以及Git作为版本控制系统，两者的重要性...
零基础入门：Java Web开发概览与Java语言特性
本资源是一本专门针对零基础学习者编写的Java.Web开发教程。该书从第一章起，即深入浅出地介绍了Java语言及其在Web开发中的核心地位。章节内容涵盖了Java语言的基础知识，包括其历史、特性与优势。 首先，1.1节简要...
java基础学习笔记(六)--多线程技术
m0_47419463的博客
08-05 237
多线程基本概念_程序_进程_线程 程序、进程、线程(这条路叫做进程,里面的两个车道可以看做线程,线程共享进程的内存资源,两个车道的允许效率高,可以有多条车道同时运行,多个线程共享代码和内存空间,在同一个地址切换的切换速度快,进程的切换是内存地址的切换,进程是在操作系统中,线程是在同一应用程序中有多个顺序流同时执行) 程序:Program,是一个指令的集合 进程:Process,(正在执行中的程序)是一个静态的概念进程是程序的一次静态态执行过程, 占用特定的地址空间.每个进程都是..
【JAVA】【PTA】线程基础题（Runnable接口）
○( ＾皿＾)っHiahiahia…的博客
06-01 2653
创建一个倒数计数线程。要求：1.该线程使用实现Runnable接口的写法；2.程序该线程每隔0.5秒打印输出一次倒数数值（数值为上一次数值减1）。 输入格式: N（键盘输入一个整数） 输出格式: 每隔0.5秒打印输出一次剩余数 输入样例: 6 输出样例: 在这里给出相应的输出。例如： 6 5 4 3 2 1 0 可提可不提的注意事项： 带本地的包名会WA，交JAVA题没经验，这次算是涨姿势了 i...
java线程顺序输出数字_多个线程顺序依次打印0到N个数字
weixin_39850167的博客
02-26 886
题目多个线程顺序依次打印0到N的整数。例如：3个线程顺序打印0到10的整数结果：Thread-0 0Thread-1 1Thread-2 2Thread-0 3Thread-1 4Thread-2 5Thread-0 6Thread-1 7Thread-2 8Thread-0 9Thread-1 10算法解析题目中各个线程顺序依次打印，相当于一种类似于责任链的模式，每一条线程都去通知其后面的线程进...
java多线程（2）----继承的方式创建多线程
xd1501013的博客
06-10 242
文章目录1.单线程举例2.多线程的创建与启动3.实例4.需要注意的地方5.参考资料 1.单线程举例 public class Test { public static void main(String[] args){ method2("yyzhang"); } public static void method1(String str){ System.out....
java多线程可以通过继承,Java多线程的实现
weixin_35020039的博客
03-15 233
前言虽然已经有了很多关于多线程的实现的博客和文章，但是我觉得还是写出自己的理解比较好，记录一下当时的理解，以后若是忘了可是快速按照自己当时的理解重新掌握。Java多线程的实现，我目前只掌握了2种方式：继承Thread类和实现Runnable接口，这两种方式的run方法都是无返回值的。继承Thread类Thread类需要调用Runnable接口才能执行，其实Thread本身也是实现了Runnable...
Java中使用继承的方式创建多线程
weixin_42614150的博客
04-09 418
实现步骤： 1: 创建Thread类的子类。 2: 重写Thread类的run()方法。 3: 创建Thread子类的对象。 4: 子类对象调用start()方法。 代码实现: /** * 遍历100以内的偶数 */ //1: 创建Thread类的子类 class MyThread extends Thread { //2: 重写Thread类的run()方法 @Override public void run() { for (int i=0; i<1.
Java自学笔记：继承Thread类实现多线程
weixin_48883622的博客
08-31 311
TestThread.java： //继承Thread类的方法实现多线程 public class TestThread extends Thread{ @Override public void run() { System.out.println("多线程的运行代码"); for (int i = 0 ; i<4;i++){ System.out.println("这是多线程的逻辑代码："+i); }...
评论 54
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员飞鸟

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值