【线程的基本用法（创建、常见的构造方法、中断、等待、休眠）】

已于 2022-04-18 17:52:58 修改
阅读量618 收藏
点赞数
分类专栏： java_ee 文章标签： java-ee
于 2022-04-13 21:29:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AlinaQ05/article/details/124135129
版权

线程的基本用法

线程创建

  1. 继承Thread
/**
 * 继承Thread 创建线程
 */
public class ThreadDemo1 {
    public static void main(String[] args) {
        //创建线程
        Thread thread = new MyThread();
        //启动线程
        thread.start();
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
    //具体的业务代码
        Thread thread = Thread.currentThread();
        System.out.println("线程名称 " + thread.getName());
    }
}

在这里插入图片描述

继承Thread新建线程的缺点：因为java中有单继承特性，所以如果继承了Thread之后，就不能继承其他类。

  1. Thread的变种方式，使用匿名内部类
/**
 * 继承Thread 使用匿名内部类
 */
public class ThreadDemo3 {
    public static void main(String[] args) {
        Thread thread = new Thread() {
            @Override
            public void run() {
                //具体的业务代码
                Thread t = Thread.currentThread();
                System.out.println("线程名称 " + t.getName());
            }
        };
        //启动线程
        thread.start();
    }
}
  1. 实现Runnable接口
/**
 * 实现Runnable接口
 */
public class ThreadDemo2 {
    public static void main(String[] args) {
        //创建Runnable子对象
        MyThread2 myThread = new MyThread2();
        //创建线程
        Thread thread = new Thread(myThread);
        thread.start();
    }
}

class MyThread2 implements Runnable{
    @Override
    public void run() {
        Thread thread = Thread.currentThread();
        System.out.println("线程名称 " + thread.getName());
    }
}
  1. 实现Runnable接口，使用匿名内部类 （Runnable的变种1）（常用创建方式）
/**
 1. 实现Runnable接口，使用匿名内部类
 */
public class ThreadDemo4 {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                Thread t = Thread.currentThread();
                System.out.println("线程名称 " + t.getName());
            }
        });
        thread.start();
    }
}
  1. 使用Lambda匿名Runnable方式（jdk8之后的版本,不需要返回值时，建议使用这种创建方法）
/**
 * 使用 lambda 表达式
 */
public class ThreadDemo5 {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            Thread t = Thread.currentThread();
            System.out.println("线程名称 " + t.getName());
        });
        thread.start();
    }
}

以上五种创建线程的方法有一个共同点，都没有返回值，即当主线程运行完成后没有新线程的执行结果。

  1. 带返回值的Callable
/**
 * 带返回值的Callable
 */
public class ThreadDemo7 {
    //实现Callable接口
    public static class MyCallable implements Callable<Integer> {

        @Override
        public Integer call() throws Exception {
            //生成随机数0-19
            int randomNum = new Random().nextInt(20);
            System.out.println(Thread.currentThread().getName() + " 生成随机数：" + randomNum);
            return randomNum;
        }

        public static void main(String[] args) throws ExecutionException, InterruptedException {
            //创建Callable子对象
            MyCallable myCallable = new MyCallable();
            //使用FutureTask用于接收Callable结果的对象
            FutureTask<Integer> futureTask = new FutureTask<>(myCallable);
            //创建线程
            Thread thread = new Thread(futureTask);
            //启动线程
            thread.start();
            //得到线程执行的结果
            int result = futureTask.get();
            System.out.println(Thread.currentThread().getName() + " 中拿到新线程执行的结果为：" + result);
        }
    }
}

在这里插入图片描述

  1. 匿名Callable（常用创建方式）
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * 匿名Callable
 */
public class ThreadDemo8 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<Integer> futureTask = new FutureTask<>(new Callable<Integer>() {
            @Override
            public Integer call() {
                int[] arr = new int[]{1, 2, 3};
                Integer result = arr[new Random().nextInt(2)];
                System.out.println(Thread.currentThread().getName() + " 随机数组元素:" + result);
                return result;
            }
        });
        //创建新线程
        Thread thread = new Thread(futureTask);
        thread.start();
        //FutureTask函数是用来接受返回值
        Integer result = futureTask.get();
        System.out.println(Thread.currentThread().getName() + " 中得到新线程的返回值:" + result);
    }

}

线程的常见构造方法

  1. Thread()
    创建线程对象
    在这里插入图片描述

  2. Thread(Runnable target)
    使用Runnable对象创建线程对象
    在这里插入图片描述

  3. Thread(Runnable target,String name)
    使用Runnable对象创建线程对象，并命名

在这里插入图片描述

  1. Thread(String name) 创建线程对象，并命名

在这里插入图片描述

可以使用jconsole观察该线程是否创建：
在这里插入图片描述

  1. Thread(ThreadGroup group,Runnable target)
    线程组，可以用来分组管理线程

package thread;

import java.util.Random;

/**
 * 线程组
 */
public class ThreadDemo11 {
    public static void main(String[] args) {
        //创建分组
        ThreadGroup group = new ThreadGroup("thread-group");
        //设置公共的任务（线程的任务）
        Runnable runTask = new Runnable() {
            @Override
            public void run() {
                //生成一个跑步能几秒到达终点的任务
                //随机生成数1-4
                int num = (1 + new Random().nextInt(5));
                try {
                    //sleep 的单位时毫秒
                    Thread.sleep(num * 1000);
                    System.out.println("选手到达终点：" + num + "s");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        //创建线程
        Thread t1 = new Thread(group, runTask);
        Thread t2 = new Thread(group, runTask);
        Thread t3 = new Thread(group, runTask);
        //启动线程
        t1.start();
        t2.start();
        t3.start();
        
        //等到所有人都到达终点，宣布成绩
        while (group.activeCount() != 0) {//activeCount 活跃线程数，所有人到达之后，才能宣布成绩
        }
        System.out.println("宣布成绩结果");

    }
}

在这里插入图片描述

线程中断

常见的两种方式：
1.通过自定义标记符来进行终端
2.调用interrupt（）方法来中断

/**
 * 使用自定义标识符终止线程
 */
public class ThreadInterrupt1 {
    private volatile static boolean flag = false;

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            while (!flag) {
                System.out.println("正在转帐...");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("差点被发现了！");
        });
        thread.start();
        Thread.sleep(3000);
        //终止线程
        System.out.println("有内鬼终止交易");
        flag = true;
    }
}

在这里插入图片描述

/**
 * 使用interrupt终止线程
 */
public class ThreadInterrupt2 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            //判断方法(两种方法）
//            while (!Thread.interrupted()) {
//                System.out.println("正在转账...");
//                try {
//                    Thread.sleep(500);
//                } catch (InterruptedException e) {
//                    break;
//                }
//            }
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("正在转账...");
//                try {
//                    Thread.sleep(500);
//                } catch (InterruptedException e) {
//                    break;
//                }
            }
            System.out.println("差点误了大事！");
            System.out.println("终止标志位2:" +Thread.currentThread().isInterrupted());
//            System.out.println("终止标志位4：" +Thread.interrupted());

        });
        thread.start();
        Thread.sleep(1000);

        //执行方法
        thread.interrupt();

    }
}

Thread.interrupted()和Thread.currentThread().isInterrupted()的区别
1.interrupted()属于静态方法，所有程序都可以直接调用的全局方法；而isInterrupted属于某个实例的方法
2.interrupted()在使用完后会重置终端标识符，而isInterrupted不会重置中断标识符

interrupted():
在这里插入图片描述
isInterrupted:
在这里插入图片描述

线程等待

import java.time.LocalDateTime;

/**
 * join示例
 * 第一种使用：直接使用线程.join()  意思是等待某种线程执行完成后再执行后续线程
 * 第二种使用： 使用线程.join(时间)  意思是等待上一种线程执行最多多长时间后就执行后续线程，不会等到上一种线程执行完
 * 等到某个线程执行完成后，在执行后续代码
 * join不设置等待参数的情况下，是无限等待
 * 优势（相比于isAlive）：写法优雅，实行的是阻塞等待wait（），所运行的资源更少
 */
public class ThreadByJoin {
    //执行的顺寻应该为1.3.1.3
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            //1.张三开始上班
            System.out.println("1.张三开始上班！" + LocalDateTime.now());
            //2.张三正在上班
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //3.张三下班
            System.out.println("3.张三下班！" + LocalDateTime.now());
        });
        thread1.start();
//        while (thread1.isAlive()) {
//        }
        thread1.join(500);
        Thread thread2 = new Thread(() -> {
            //1.李四开始上班！
            System.out.println("1.李四开始上班！" + LocalDateTime.now());
            //2.李四正在上班
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //3.李四下班！
            System.out.println("3.李四下班！" + LocalDateTime.now());
        });
        thread2.start();

    }
}

线程休眠

使用sleep休眠

Thread.sleep(3*1000);//单位是毫秒

使用TimeUnit休眠

        TimeUnit.DAYS.sleep(1);//天
        TimeUnit.HOURS.sleep(1);//小时
        TimeUnit.MINUTES.sleep(3);//分钟
        TimeUnit.SECONDS.sleep(3);//秒
        TimeUnit.MILLISECONDS.sleep(1);//毫秒
        TimeUnit.MICROSECONDS.sleep(1);//微秒
        TimeUnit.NANOSECONDS.sleep(1);//纳秒

获取线程实例

package thread;

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

/**
 * 实现多线程数组求和
 */
public class ThreadDemo6 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //记录开始执行的时间
        long stime = System.currentTimeMillis();
        int[] array = new int[10000000];
        //随机数初始化
        Random random = new Random();
        for (int i = 0; i < array.length; i++) {
            array[i] = (1 + random.nextInt(100));
        }

        // 创建两个线程相加
        // 计算偶数下标元素的和
        FutureTask<Integer> task1 = new FutureTask<>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int temp = 0;
                for (int i = 0; i < array.length; i = i + 2) {
                    temp += array[i];
                }
                System.out.println("线程1：" + temp);
                return temp;
            }
        });
        Thread t1 = new Thread(task1);
        t1.start();

        //计算奇数下标元素的和
        FutureTask<Integer> task2 = new FutureTask<Integer>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int temp = 0;
                for (int i = 1; i < array.length; i = i + 2) {
                    temp += array[i];
                }
                System.out.println("线程2：" + temp);
                return temp;
            }
        });
        Thread t2 = new Thread(task2);
        t2.start();
        
        int sum = task1.get() + task2.get();
        System.out.println("多线程数组总和：" + sum);
        //执行完成结束时间
        long etime = System.currentTimeMillis();
        //执行时间
        System.out.println("最终执行时间：" + (etime - stime));
    }

}
掉了颗兔牙lx
关注
专栏目录
线程的基本知识和使用方法
kelery的博客
05-12 4095
线程 - 基本操作 派生：线程在进程内派生出来，它即可由进程派生，也可由线程派生。 线程的状态与操作图册 阻塞（Block）：如果一个线程在执行过程中需要等待某个事件发生，则被阻塞。 激活（unblock）：如果阻塞线程的事件发生，则该线程被激活并进入就绪队列。 调度（schedule）：选择一个就绪线程进入执行状态。 结束（Finish）：如果一个线程执行结束，它的寄
多线程的创建、启动、中断、等待、休眠、获取线程实例
azhe12345690的博客
04-17 482
1、创建线程 1.1 继承Thread 重写run方法 1.2：实现 Runnable接口, 重写 run 1.3：继承 Thread, 重写 run, 使用匿名内部类 这是第一种方法的延申 1.4:实现 Runnable, 重写 run, 使用匿名内部类 这是第二种方法的延申 1.5:使用 lambda 表达式 其实就是第四种的延申。 通常认为Runnable这种写法更好一点 能够让线程和线程执行的任务 更好的解耦. 2、线程的启动 run 单纯的只是一个普通的方法 描述了任务的内容 并没有创建
Android开发--初识多线程/线程的创建，开启，休眠，中断
移动开发记录
01-24 203
在Android开发中有一项非常重要的技术---多线程，本文针对线程的创建，开启，休眠和中断做介绍。 如同在JAVA开发中一样，在Android中，提供了两种方法创建线程，一种是通过Thread类的构造方法创建线程对象，并重写run（）方法，另一种是实现Runnable接口，本实例中用到的方法是第一种，第二种方法类似。 本实例实现的是在另一个线程中播放音乐，并使用一个按钮中断线程的...
python并发编程之多线程1
weixin_30247307的博客
08-28 71
一、多线程的概念介绍 threading模块介绍 threading模块和multiprocessing模块在使用层面，有很大的相似性。 二、开启多线程的两种方式 1 1.创建线程的开销比创建进程的开销小，因而创建线程的速度快 2 from multiprocessing import Process 3 from threading import Thread ...
线程的用法
weixin_43748216的博客
03-14 1492
一、线程的状态 从创建到消亡，线程一般包含以下几种状态：创建（new），就绪（runnable），运行（running），阻塞（blocked），waiting，time_waiting，消亡（dead）。 当需要新起一个线程去执行某个子任务的时候，线程被创建（new）。创建之后还需要JVM为其分配一些内存空间后，才会进入就绪状态（runnable）。 线程进入就绪状态后，不一定会立刻得到C...
Java线程调度之线程休眠用法分析
09-03
如果线程在休眠期间被中断，`sleep()`方法会抛出`InterruptedException`，需要捕获并处理这个异常。在示例中，`catch (InterruptedException e)`块就是用来处理这种异常的。 值得注意的是，线程调度还受到操作系统...
java基本教程之线程休眠 java多线程教程
09-04
调用`sleep(long milliseconds)`方法会让线程休眠指定的毫秒数，直到指定的时间过去或者被其他外部因素（如中断或通知）唤醒。需要注意的是，`sleep()`不会立即返回，而是等待指定时间后才将线程置于就绪状态，等待...
Java中断线程的方法
08-30
在给定的代码示例中，`SleepInterrupt`类展示了如何中断正在休眠的线程。当`Thread.sleep(20000)`被调用时，如果线程在此期间被中断，它会抛出`InterruptedException`，并且在`catch`块中处理这个异常。如果`return`...
进程、线程的创建方法及 Thread 类的基本用法
dddddrrrzz的博客
04-01 1030
一、进程 操作系统是一个管理的软件。 对下，要管理好各种硬件设备，对上，操作系统要个各种软件提供稳定的运行环境。 进程是操作系统对一个正在运行的程序的一种抽象，换言之，可以把进程看做程序的一次运行过程；同时，在操作系统内部，进程又是操作系统进行资源分配的基本单位。 进程（process）又叫任务（task） 操作系统是如何管理进程的？ 1.先描述一个进程（描述出一个进程上的一些相关属性） 2.再组织若干个进程（使用一些数据结构，把很多描述进程的信息放在一起买方便进行增删改
线程池用法
12-11
按先后顺序执行线程 public static void main(String[] args) { ExecutorService t = Executors.newSingleThreadExecutor(); for (int i = 0; i < 10; i++) { t.submit(new AA(i)); } System.out.println("kkkkkkkkkk"); t.shutdown(); }
线程的使用
weixin_48656058的博客
12-01 4361
线程 首先要了解进程和线程的区别: 进程是唯一的,一个进程可以开启多个线程。 比如:你的电脑开机了,你任务管理器里面运行的程序就是线程 1.线程的生命周期有五种状态: 创建、就绪、运行、阻塞、死亡 1.1 创建(创建方式往下找): 创建一个线程,线程进入创建状态。 1.2 就绪: start()方法用于使一个线程进入就绪状态。 1.3 运行: 执行run()方法使线程进入运行状态 1.4 阻塞: wait(等待)会让线程进入阻塞状态,会失去所占用的资源; 还有其他方式可以让一
volatile和synchronized区别
u012061196的博客
04-04 476
volatile和synchronized特点 首先需要理解线程安全的两个方面：执行控制和内存可见。 执行控制的目的是控制代码执行（顺序）及是否可以并发执行。 内存可见控制的是线程执行结果在内存中对其它线程的可见性。根据Java内存模型的实现，线程在具体执行时，会先拷贝主存数据到线程本地（CPU缓存），操作完成后再把结果从线程本地刷到主存。 synchronized关键字解
线程及其用法
YZ_FTB的博客
08-04 226
一、什么是线程？ 线程是进程的一个实体，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源，但是可以与同属于一个进程的其他的线程共享进程拥有的全部资源。 说道线程那么就必须要了解进程，因为线程依赖进程的地址空间； 那么进程的空间是什么样的呢？   进程空间：      栈      堆    数据段    代码段    线...
线程的基本用法
最新发布
Lzm的博客
03-16 274
2.否则，只是内部的一个中断标志被设置，thread 可以通过 Thread.interrupted() 判断当前线程的中断标志被设置，清除中断标志 Thread.currentThread().isInterrupted() 判断指定线程的中断标志被设 置，不清除中断标志 这种方式通知收到的更及时，即使线程正在 sleep 也可以马上收到。Thread t3 = new Thread(() -> System.out.println("使用匿名内部类创建Thread 子类对象"));
Android线程的创建、开启、休眠、中断
houdezaiwu01的博客
05-29 657
1.线程的创建（两种方式） 1）通过Thread类的构造方法创建线程： Thread thread = new Thread(new Runnable() { @Override public void run() { // TODO Auto-generated method stub //线程里要执行的操作 } }); thread.start();//开启线程，调用这句
线程的基本使用方法
qq_44863031的博客
03-08 286
线程的基本使用方法
线程的一些基本使用方法
weixin_48788281的博客
10-28 1754
一 线程 1.1 线程基本概念 基本概念：程序、进程、线程 程序(program)是为完成特定任务,用某种语言编写的一组指令的集合,即指一 段静态的代码，静态对象 进程(process)是程序的一次执行过程,或是正在运行的一个程序,是一个动态的过程:有它自身的产生,存在和消亡的过程——生命周期 1如:运行中的QQ,运行中的MP3播放器 2程序是静态的,进程是动态的 3进程作为资源分配的单位,系统在运行时会为每...
Java中断线程机制详解
"Java中断线程的方法主要涉及Java线程编程中的中断机制，通过调用Thread对象的`interrupt()`方法来实现。这种方法并不会立即停止线程的执行，而是设置一个中断标志，使得线程在检查到这个标志时能够自行终止或进行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值