多线程的创建(超详解）

最新推荐文章于 2023-06-21 15:58:03 发布
最新推荐文章于 2023-06-21 15:58:03 发布
阅读量751 收藏 7
点赞数 11
分类专栏： 多线程 文章标签： 多线程 thread java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46804966/article/details/116563441
版权

文章目录

1.线程创建的三种方式

1.1继承Thread类

代码示例：

package thread_5_9;

public class Demo03 {

    static class MyThread extends Thread{

        @Override
        public void run() {
            //写你的业务代码
            //打印当前线程的名称
            System.out.println("子线程: "+Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();

        System.out.println("主线程: "+Thread.currentThread().getName());
    }
}

运行结果：

主线程: main
子线程: Thread-0

1.2实现Runnable接口

代码示例：

package thread_5_9;

public class Demo05 {
    static  class  MyRunnable implements Runnable{
        @Override
        public void run() {
            System.out.println("子线程-->"+Thread.currentThread().getName());
        }
    }
    public static void main(String[] args) {
        //创建runnable的实现类对象
        MyRunnable myRunnable = new MyRunnable();
        //创建线程对象
        Thread t = new Thread(myRunnable);
        //启动线程
        t.start();
    }
}

运行结果：

子线程-->Thread-0

注意：

我们可以看出，前两种方式没有本质的区别，最终都是调用了Thread类的start方法来开启线程。但是在外观上有很大的区别，第一种方式是继承了Thread类，Java是单继承，继承了Thread类就不能继承其他类；而第二种是实现了Runnable接口，区别于第一种，较为方便

1.3实现Callable接口

示例代码：

package thread_5_9;

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/*
    创建一个带返回值的线程
 */
public class Demo08 {

    static class MyCallable implements Callable<Integer> {

        @Override
        public Integer call() throws Exception {
            int num = new Random().nextInt(100);
            System.out.println("线程名："+Thread.currentThread().getName()+"  随机数："+num);
            return num;
        }
    }
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //1.创建Callable的实现类对象
        MyCallable myCallable = new MyCallable();

        //2.使用FutureTask来接收callable对象
        FutureTask<Integer> task = new FutureTask<>(myCallable);

        //3.创建线程并设置任务
        Thread thread = new Thread(task);

        //4.启动线程
        thread.start();
        int num = task.get();
        System.out.println("线程返回结果："+num);
    }
}

运行结果：

线程名：Thread-0  随机数：28
线程返回结果：28

1.4三种方式比较

  1. Thread：继承方式，不建议使用，因为java是单继承的，继承了Thread类，就不能继承其他类
  2. Runable：比Thread更加灵活
  3. Callable：Thread和Runnable都是重写的run（）方法并且没有返回值，而Callable是重写的call（）方法并且有返回值，返回值用FutureTask来接收
  4. 不需要返回值时就用Runnable，需要返回值时就用Callable
  5. Thread类是实现Runnable，Callable封装成FutureTask，FutureTask实现RunnableFuture，RunnableFuture继承Runnable，所以Callable也算是一种Runnable，所以三种实现方式本质上都是Runnable实现

2.线程分组

在这里插入图片描述

示例：

package thread_5_9;

public class App {
    public static void main(String[] args) {

        ThreadGroup threadGroup = new ThreadGroup("线程分组");

        Thread t1 = new Thread(threadGroup, new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                    System.out.println("选手1到达终点了");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });

        t1.start();

        Thread t2 = new Thread(threadGroup, new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1200);
                    System.out.println("选手2到达终点了");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });

        t2.start();

        //等待分组中的所有线程执行结束
        while(threadGroup.activeCount() != 0){

        }
        System.out.println("比赛结束了");

    }
}

运行结果：

选手1到达终点了
选手2到达终点了
比赛结束了

3.Thread类及常见方法

3.1Thread类的常见构造方法

在这里插入图片描述

3.2Thread类的常见属性

在这里插入图片描述
示例：

package thread_5_9;

/*
    演示线程的常见方法
 */
public class Demo11 {
    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                Thread thread = Thread.currentThread();
                System.out.println("线程ID："+thread.getId());
                System.out.println("线程名称："+thread.getName());
                System.out.println("线程状态："+thread.getState());

                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"张三");

        t1.start();
        Thread.sleep(100);
        System.out.println("t1线程状态："+t1.getState());
        System.out.println("优先级："+t1.getPriority());
        System.out.println("是否是守护线程："+t1.isDaemon());
        System.out.println("是否存活："+t1.isAlive());
        System.out.println("是否被中断："+t1.isInterrupted());
    }
}

运行结果：

线程ID：11
线程名称：张三
线程状态：RUNNABLE
t1线程状态：TIMED_WAITING
优先级：5
是否是守护线程：false
是否存活：true
是否被中断：false
3.2.1线程优先级
  • 线程的优先级取值范围为1到10，默认优先级为5
  • 线程的优先级越高，CPU执行权重越高

示例：

package thread_5_9;

public class Demo12 {
    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                int a = 0;
                for (int i = 0; i < 10_0000_0000; i++) {
                    a++;
                }
                System.out.println("线程t1执行结束");
            }
        });

        t1.start();

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                int a = 0;
                for (int i = 0; i < 10_0000_0000; i++) {
                    a++;
                }
                System.out.println("线程t2执行结束");
            }
        });

        t2.start();

        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                int a = 0;
                for (int i = 0; i < 10_0000_0000; i++) {
                    a++;
                }
                System.out.println("线程t3执行结束");
            }
        });

        t3.start();


        t1.setPriority(5);  //默认优先级
        t2.setPriority(1);  //优先级最低
        t3.setPriority(10); //优先级最高
    }
}

运行结果：

线程t3执行结束
线程t1执行结束
线程t2执行结束
3.2.2线程分类
  • 用户线程：默认创建的线程就是用户线程
  • 守护线程（后台线程）：守护线程是为用户线程服务，当用户线程执行完成后，守护线程也会跟随用户线程一起结束

注意事项：
1.守护线程的设置必须放在开启线程之前
2.在守护线程中创建的线程默认是守护线程

守护线程的使用场景：

1.垃圾回收器
2.监控检测任务

示例：

package thread_5_9;

public class Demo13 {
    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("i:  "+i);
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        //t1.setDaemon(true);
        t1.start();
        System.out.println("t1是否为守护线程："+t1.isDaemon());
        System.out.println("main是否为守护线程："+Thread.currentThread().isDaemon());
    }
}

运行结果：

t1是否为守护线程：false
main是否为守护线程：false
i:  0
i:  1
i:  2
i:  3
i:  4
i:  5
i:  6
i:  7
i:  8
i:  9

去掉注释后：

t1是否为守护线程：true
main是否为守护线程：false
i:  0
3.2.3线程练习

题目：
使用两个线程打印出AABBCCDD，每个线程只能打印ABCD

代码示例：

package thread_5_9;

public class Demo14 {
    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                String str = "ABCD";
                for(char c:str.toCharArray()){
                    System.out.print(c);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        t1.start();

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                String str = "ABCD";
                for(char c:str.toCharArray()){
                    System.out.print(c);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        t2.start();
    }
}

3.3启动一个线程-start( )

run( ) vs start( )

  1. run方法是一个对象的普通方法，它使用的是主线程来执行任务的
  2. start方法是线程的开启方法，它使用新的线程来执行任务
  3. run方法可以执行多次，start方法只能执行一次

代码示例：

package thread_5_9;

public class Demo16 {
    public static void main(String[] args) {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("线程名："+Thread.currentThread().getName());
            }
        };

        Thread thread = new Thread(r);
        thread.run();
        thread.run();
        thread.run();

        thread.start();
        thread.start();
    }
}

运行结果：

线程名：main
线程名：main
线程名：main
线程名：Thread-0
Exception in thread "main" java.lang.IllegalThreadStateException
	at java.lang.Thread.start(Thread.java:708)
	at thread_5_9.Demo16.main(Demo16.java:18)

3.4中断一个线程-interrupt（）

1.自定义全局标识来实现中断
示例：

package thread_5_9;

public class Demo17 {

    //全局变量
    private static boolean flag = false;

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(()->{
            while(!flag){


                //休眠线程
                try {
                    Thread.sleep(100);
                    System.out.println("我正在转账……");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("差点误了大事");
        },"张三");
        t1.start();

        //休眠主线程一段时间
        Thread.sleep(310);

        //停止交易
        System.out.println("停止交易……");
        flag = true;
    }
}

运行结果：

我正在转账……
我正在转账……
我正在转账……
停止交易……
我正在转账……
差点误了大事

2.使用Thread中的interrupted来中断

代码示例：

package thread_5_9;

public class Demo18 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
           while(!Thread.interrupted()){
               try {
                   Thread.sleep(100);
                   System.out.println("我正在转账……");
               } catch (InterruptedException e) {
                   //e.printStackTrace();
                   break;
               }
           }
            System.out.println("差点误了大事");
        });

        t1.start();
        Thread.sleep(310);

        System.out.println("停止交易");
        t1.interrupt();
    }
}

运行结果：

我正在转账……
我正在转账……
我正在转账……
停止交易
差点误了大事

小结：

  • 使用interrupt可以及时的终止线程，而使用自定义的全局变量终止线程的方式，比较温柔不能及时的终止
  • 两种判断线程状态的方式。第一种：Thread.interrupted（）
    第二种：Thread.currentThread.isInterrupted（）
  • Thread.interrupted（）第一次接收到终止状态是true，之后会将状态复位（恢复为false），即调用后清除标志位
  • Thread.currentThread.isInterrupted（）只用来获得线程状态，不会复位，不会清除标志位

3.5等待一个线程-join（）

有时，我们需要等待一个线程完成它的工作后，才能进行自己的下一步工作。例如，张三只有等李四转账成功，才决定是否存钱，这时我们需要一个方法明确等待线程的结束。
在这里插入图片描述
代码示例：

package thread_5_9;

public class Demo21 {
    public static void main(String[] args) throws InterruptedException {

        //定义一个公共的任务
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                String name = Thread.currentThread().getName();
                System.out.println(name+"上班");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(name+"下班");
            }
        };

        Thread t1 = new Thread(runnable,"张三");
        Thread t2 = new Thread(runnable,"李四");
        t1.start();
        t1.join();
        t2.start();
    }
}

运行结果：

张三上班
张三下班
李四上班
李四下班

3.6获得当前线程引用

在这里插入图片描述
代码示例：

package thread_5_9;

public class Demo03 {

    static class MyThread extends Thread{

        @Override
        public void run() {
            //写你的业务代码
            //打印当前线程的名称
            System.out.println("子线程: "+Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();

        System.out.println("主线程: "+Thread.currentThread().getName());
    }
}

3.7线程休眠

在这里插入图片描述

代码示例：

package thread_5_9;

import java.util.concurrent.TimeUnit;

public class Demo01 {
    public static void main(String[] args) throws InterruptedException {
        String str = "即佛牌精品店是陈建平你师父或是看到破开始比较搜狐号奇偶皮卡食品厂模拟配件什么票不能说明课程编号搜索" +
                "键盘你视频女排说明书牌是什么吗";

        for(char c:str.toCharArray()){
            System.out.print(c);

            //线程休眠方式一：Thread.sleep()
            //Thread.sleep(200);

            //线程休眠方式二：
            //TimeUnit.SECONDS.sleep(1);

            //线程休眠方式三：
            Thread.sleep(TimeUnit.SECONDS.toMillis(1));
        }
    }
}

4.线程的状态

4.1线程的所有状态

线程的状态是一个枚举类型 Thread.State

package thread_5_9;

public class Demo22 {
    public static void main(String[] args) {

        for(Thread.State state:Thread.State.values()){
            System.out.println(state);
        }
    }
}

运行结果：

NEW
RUNNABLE
BLOCKED
WAITING
TIMED_WAITING
TERMINATED

4.2线程状态图

在这里插入图片描述
示例：

package thread_5_9;

public class Demo23 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        System.out.println("执行之前："+t1.getState());
        t1.start();
        System.out.println("start之后："+t1.getState());
        Thread.sleep(100);
        System.out.println("休眠100毫秒后："+t1.getState());

        //等待t1执行结束
        t1.join();
        System.out.println("t1执行结束后："+t1.getState());
    }
}

运行结果：

执行之前：NEW
start之后：RUNNABLE
休眠100毫秒后：TIMED_WAITING
t1执行结束后：TERMINATED

4.3yield（）方法

yield() 大公无私，让出 CPU的执行权，让线程进入就绪状态，等待重新获取CPU执行时间

星光_依旧灿烂
关注
  • 11
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
多线程创建
noSimBa的博客
07-13 71
C++线程池的创建
多线程(一)--线程创建
Lily所能及
11-06 95
开发一些大型的分布式项目时，多线程的使用必不可少的，今天我们看一下，常见的几种多线程创建方法。 为什么要用多线程：使用多线程可以提高程序的执行效率 什么是线程：线程是进程中的一条执行路径。 什么是进程：进程是某一应用的线程集合。 注意：开启线程的是start方法而不是run方法 1.继承Thread类重写run 方法： pubilc class ThreadTest extends ...
创建多线程（8种方式）
qq_1757537040的博客
03-29 9342
无论有多少种形式，创建多线程的真正的方法， 其实只有两种： > 继承 Thread 类 > 实现 Runnable 接口 其它形式都是这两种方式的变体。 1、继承 Thread 类 ①实现方式 第一步：继承 Thread 类 第二步：重写 run() 方法 第三步：创建 Thread 子类对象 第四步：调用 start() 方法启动线程 ②start() 方法和 run() 方法区别 调用 run() 方法仅仅只是调用了一个子类中重写的父类...
第一章 线程
qq_39354297的博客
09-08 330
第一章 线程 1.1 多线程原理 画一个多线程执行时序图来体现一下多线程程序的执行流程。代码如下：自定义线程类： 1 public class MyThread extends Thread { 2 /* 3 * 利用继承中的特点 4 * 将线程名称传递 进行设置 5 */ 6 ...
多线程的创建
遇安的博客
04-23 2659
创建方式一：继承Thread类创建多线程 public class 多线程_1创建 { public static void main(String[] args) { //创建方式一 Thread t=new MyThread();//创建MyThread线程对象 //直接调run()方法会被当成普通方法执行，此时相当于还是单线程执行， // 所以需要调用start()方法启动多线程 t.start();//调.
创建多线程的四种方式
qq_31856061的博客
06-21 1183
注意：实现Runnable接口方式中，调用的不是Thread类的run()方法，而是在线程启动后，去调用Runnable类型的run()方法，也就是我们传入的实现类中的run()方法。就是一个无边界队列，对于一个无边界队列来说，是可以不断的向队列中加入任务的，这种情况下就有可能因为任务过多而导致内存溢出问题。是一个用链表实现的有界阻塞队列，在不设置的情况下，将是一个无边界的阻塞队列，最大长度为。创建线程池，主要是避免使用其中的默认实现，那么我们可以自己直接调用。的静态方法创建线程池时，用的是。
多线程的创建方式
qq_49005459的博客
10-29 3150
多线程的创建有七种方式： (1)继承Thread类创建线程 (2)实现Runnable接口创建线程 (3)使用匿名内部类的形式创建线程 (4)使用lambda表达式创建线程 (5)使用Callable和Future创建线程 (6)使用线程池例如用Executor框架 (7)spring 的@Async异步注解 1.继承Thread类创建 public class ThreadDemo extends Thread{ //程序执行的代码就在run()方法中 @Override pub
Java多线程详解（超详细）_狂神说笔记完整版_项目代码_适合小白随课程学习
08-08
Java多线程详解 在Java编程中，多线程是一种重要的技术，它使得程序能够同时执行多个任务，提高系统的效率和响应性。本教程将详细讲解Java中的多线程概念，包括线程的创建、状态、同步以及高级主题，旨在帮助初学者...
Java多线程超级详解(看这篇就足够了).pdf
11-16
本篇文章将深入探讨Java多线程的基本概念、线程状态、控制线程以及创建线程的方式。 首先，我们需要理解多线程的基础概念。一个进程可以包含多个线程，例如，当你运行一个视频播放器时，可能有多个线程分别负责播放...
CThreadBase超级多线程类库
05-25
《CThreadBase超级多线程类库详解及应用》 在计算机编程中，多线程是一种常见的并发执行机制，能够有效提升程序的运行效率。在Windows环境下，Microsoft Foundation Classes (MFC) 提供了对多线程的支持，但直接...
基于多线程的下载
06-04
【标题】：“基于多线程的下载”技术详解与实现 【描述】：多线程下载是一种优化资源获取效率的方法，结合断点续传技术，能够显著提升文件下载的稳定性和速度。本篇将深入探讨多线程技术、HTTP协议以及断点续传在...
QT多线程Http源码
04-25
QT多线程Http源码实现详解 在编程领域，尤其是涉及到网络I/O操作时，多线程技术常常被用来提高程序的并发性能。QT库，一个跨平台的应用开发框架，提供了丰富的多线程支持和HTTP协议处理功能。本文将深入探讨如何在...
c#超级Socket库SuperSocket，SOCKET多线程编程
11-24
1. **多线程支持**：SuperSocket采用了多线程模型来处理客户端的连接，确保了服务器的高并发性能。每个客户端连接都会被分配到一个独立的工作线程，从而避免单个连接阻塞其他连接的情况。 2. **简单易用的API**：...
http多线程下载程序
04-10
《使用Winsock实现的HTTP多线程下载程序详解》 在互联网技术日新月异的今天，高效的数据传输成为了一项基本需求。特别是在处理大文件下载时，传统的单线程下载方式往往耗时过长，用户体验不佳。为了解决这个问题，...
violate java-Java 之 volatile 超级详解
最新发布
11-20
Java中的`volatile`关键字是多线程编程中一个非常重要的概念，它用于修饰变量，确保在并发环境下，多个线程可以正确地共享和同步数据。本文将深入探讨`volatile`关键字的工作原理、特性以及如何使用它来解决多线程中...
创建多线程的四种方法
adieu_c的博客
04-13 1103
四种创建多线程的方法，你get到了吗？~~~
创建多线程的四种方式 看完不懂，你来捶我！！！
m0_69901140的博客
04-01 1947
线程(thread)是一个程序内部的一条执行路径。我们之前启动程序执行后，main方法的执行其实就是一条单独的执行路径，程序中如果只有一条执行路径，那么这个程序就是单线程的程序。多线程是指从软硬件上实现多条执行流程的技术。
学习多线程，创建多线程的三种方式
weixin_45627271的博客
09-04 1657
学习多线程，创建多线程的三种方式
duilib 多线程创建
06-08
Duilib 是一个基于 C++ 的 UI 框架，支持多线程创建。在 Duilib 中，使用多线程创建 UI 界面可以提高程序的响应速度，增强用户体验。下面是一个简单的多线程创建 UI 界面的示例代码： ```c++ #include "stdafx.h" #include <Windows.h> #include "DuiLib/UIlib.h" using namespace DuiLib; class CMainFrame : public WindowImplBase { public: CMainFrame() {} virtual ~CMainFrame() {} virtual CDuiString GetSkinFolder() { return _T("skin"); } virtual CDuiString GetSkinFile() { return _T("MainWnd.xml"); } virtual LPCTSTR GetWindowClassName(void) const { return _T("DUIMainFrame"); } virtual LRESULT HandleCustomMessage(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) { if (uMsg == WM_CREATE) { // 创建子线程 HANDLE hThread = CreateThread(NULL, 0, ThreadProc, this, 0, NULL); CloseHandle(hThread); } return 0; } static DWORD WINAPI ThreadProc(LPVOID lpParameter) { CMainFrame* pThis = (CMainFrame*)lpParameter; // 在子线程中创建 UI 界面 pThis->Create(NULL, _T("Duilib 多线程创建示例"), WS_OVERLAPPEDWINDOW, WS_EX_WINDOWEDGE); pThis->ShowWindow(true); pThis->CenterWindow(); return 0; } }; int APIENTRY _tWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow) { CPaintManagerUI::SetInstance(hInstance); CMainFrame mainFrame; mainFrame.Create(NULL, _T("Duilib 多线程创建示例"), UI_WNDSTYLE_FRAME, WS_EX_WINDOWEDGE); mainFrame.CenterWindow(); mainFrame.ShowWindow(true); CPaintManagerUI::MessageLoop(); return 0; } ``` 在上述代码中，我们在主线程中创建了一个 `CMainFrame` 对象，并调用了 `Create` 方法创建了主窗口。在主窗口的 `HandleCustomMessage` 方法中，我们调用了 `CreateThread` 函数创建了一个子线程，并在子线程中调用了 `Create` 方法创建了一个 UI 界面。这样，我们就实现了在多线程中创建 UI 界面的功能。
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值