java多线程之Thread

最新推荐文章于 2024-08-18 23:26:05 发布
最新推荐文章于 2024-08-18 23:26:05 发布
阅读量440 收藏
点赞数
分类专栏： java

Thread类

学习java线程的开发者,首先遇到的第一个类就是Thread,通过使用Thread类,我们就可以启动,停止,中断一个线程. 在同一个时间片里, 可能会有多个线程在执行, 每个线程都拥有它自己的方法调用堆栈, 参数和变量.每个app至少会有一个线程–主线程(main thread).

创建一个线程

java创建线程有两种方式

  1. 创建一个继承Thread的子类,并实现run方法
  2. 使用Thread的构造方法public Thread(Runnable target)创建,这个需要传入一个实现Runnable接口的子类

实现

下面我们分别以这两种方式实现一下.

  • 编写SubThread继承Thread,并覆盖run方法 SubThread.java
public class SubThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i ++){
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }

    public static void main(String[] args) {
        System.out.println("begin main");
        SubThread sub = new SubThread();
        sub.start();
        System.out.println("end main");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 编写SubRunnable实现Runnable,然后使用构造器Thread(Runnable) 创建一个线程
public class SubRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i ++){
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
    public static void main(String[] args) {
        System.out.println("begin main");
        Thread thread = new Thread(new SubRunnable());
        thread.start();
        System.out.println("end main");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

区别

  • 使用第一种方法创建的话,你可以在run方法中,可以用this直接调用线程的方法,比如获取线程的id–>this.getId()
  • 而使用第二方法创建线程,在run中,this对象压根就没有getId()这个方法,这个时候你只能用Thread.cuurentThread()这个静态方法获取该线程.
  • 在这里一般推荐使用第二种方法创建,因为这样比较符合面对象的思路,Thread就只负责线程的启动,停止,中断等操作,而Runnable就只负责线程要运行某一个具体任务.

不管使用那种方式创建线程,都可以调用Thread.cuurentThread()获取当前的线程 
还有,Thread其实也是Runnable的一个子类 
除了上面两种创建方法,其中还有另外一种方法创建线程,那就是实现ThreadFactory接口,这种比较适合批量生成某一种规格的线程

让线程”睡”一会

调用线程的Thread.sleep()方法会让线程睡眠一段时间,这个时候线程会挂起,然后将CPU的时间片转移给其他线程,让其他线程获得执行的机会.

Thread.sleep()接收一个毫秒值做完参数,并抛出一个InterruptedException异常.

停止线程

不管是使用哪一种方法创建线程,run方法的任务执行完了,线程就自动停止. 
如果想在中途就停止线程,有下面几种方式 
* 调用线程的interrupt()方法,这时线程的中断位会被标识,并抛出InterruptedException,例如:

public class StopThread1 {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("begin main");
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {

                for (int i = 0; i < 10; i ++){
                    try {
                        Thread.sleep(100);
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                    } catch (InterruptedException e) {
                        break;
                    }
                }
            }
        });
        thread.start();
        System.out.println("main sleep 500ms");
        Thread.sleep(500);
        thread.interrupt();
        System.out.println("end main");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

在调用thread.interrupt();这个语句时,会对该线程的中断状态标识为true,然后在抛出InterruptedException异常时,会清空该中断位. 
修改程序,在抛出InterruptedException中添加System.out.println("InterruptedException:" + Thread.currentThread().isInterrupted());,然后再thread.interrupt();后面添加System.out.println("thread.isInterrupted:" + thread.isInterrupted());.然后运行程序.

这时候运行结果有可能打印出thread.isInterrupted:true;InterruptedException:false或者打印出thread.isInterrupted:false;InterruptedException:false,运行多次结果都有可能不一致,这个是因为主线程和子线程都通知在执行,还没有来的及执行主线程的打印语句,子线程异常中的打印语句就已经执行了.

  • 可以在线程中加一个boolean成员变量,提供setter方法,然后在run方法中判断该变量是否为true,若为true则停止线程,否则继续
public class StopThread2 {
    public static class StopRunnable implements Runnable{
        private boolean isStop = false;

        public void setStop(){
            this.isStop = true;
        }
        @Override
        public void run() {
            int count = 0;
            while (!isStop){
                try {
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + ":" + count++);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        System.out.println("begin main");
        StopRunnable stop = new StopRunnable();
        Thread thread = new Thread(stop);
        thread.start();
        Thread.sleep(200);
        stop.setStop();
        System.out.println("end main");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31

线程的属性

  • id: 通过Thread.getId()可以获取线程的id,线程的id是一个自增长的long, 不能修改
  • name: 通过Thread.getName(), 用一个字符串来标识线程的名字,可以通过Thread.setName()或部分构造器修改线程的名字
  • priority: 线程的优先级,线程创建默认优先级为5, 最小为优先级为1, 最大为10.优先级大的线程有机会先执行.但具体那个线程先执行还是要看CPU的心情了.
  • state: 线程的状态, 线程的状态有以下几种 
    • Thread.State.NEW: 新建状态:这个是线程已经被创建但还没有调用’start()’方法时的状态
    • Thread.State.RUNNABLE: 运行状态 当前线程已经在JVM中执行
    • Thread.State.BLOCKED: 阻塞状态 表示当前线程在等待进入一个同步块或同步方法,也可以等到一个同步快被提交. 常见的有IO阻塞等.
    • Thread.State.WAITING: 等待状态 但线程调用Object.wait(),Thread.join(),LockSupport.park()就会进入等待状态.当前线程在等待其他线程执行某一个特定操作.比如:当前线程执行Object.wait(),那么就需要其他线程执行Object.notify()或Object.notifyAll(),如果线程执行了Thread.join(),则需要等到指定的线程执行结束.
    • Thread.State.TIMED_WAITING: 有时间的等待 线程在等待某一个等待的时间.比如,线程执行了Thread.sleep,Object.wait(long),Thread.join(long)等
    • Thread.State.TERMINATED: 终结 线程已经执行完毕.
  • daemon: 这个用来标识线程为守护线程或非守护线程的,默认创建的线程都是非守护线程.应用程序所有的非守护线程执行完毕之后,则程序就停止运行.比如主线程都是非守护线程,所以主线程会等到主线程的所有语句执行完成,程序才会停止运行.JVM的资源回收则是一个守护线程.
public class TestDaemonThread {
    public static void main(String[] args) {
        System.out.println("start main");
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i ++){
                    try {
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                        Thread.sleep(10);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        thread.start();
        System.out.println("end main");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

该例子中,程序必须等到主线程和子线程同时执行完成才会停止,因为默认创建的线程都是非守护线程,如果在thread.start();前加入thread.setDaemon(true);, 那么程序不会等子线程执行完才结束程序的.

Thread.join()

等到某线程执行完毕才开始执行,如果调用Thread.join(long)则表示等到某线程执行完毕或指定的超时时间结束后才开始执行

public class ThreadJoinTest {
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            for (int i = 0;i < 10; i ++){
                try {
                    Thread.sleep(10);
                    System.out.println(Thread.currentThread().getName() + ":" + i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "thread1");
        Thread thread2 = new Thread(() -> {
            try {
                thread1.join();
                for (int i = 0;i < 10; i ++){
                    Thread.sleep(10);
                    System.out.println(Thread.currentThread().getName() + ":" + i);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "thread2");
        thread1.start();
        thread2.start();

    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

上面的例子,thread2线程会等thread1执行完之后才开始执行

Thread.yield

这个方法标识当前线程会按时线程调度者让其他线程先执行.但CPU是否让其他线程优先执行,还是要看CPU的心情了.

线程的异常

如果线程发现一些运行时异常而没有在run方法俘获,会怎么办?

程序会打印出一推错误堆栈,如果我们先把线程的错误按照某种可读的方式打印到问题,但又不想在每个run方法中增加try{...}catch(Exception e){...}怎么办? 
我们查看Thread类的源码发现,在Thread中有一个内部接口UncaughtExceptionHandler,这个正是我们所需要的.实现这个接口,并调用Thread.setUncaughtExceptionHandler,那么但线程出现时,则会回调uncaughtException方法

public class ThreadExceptionTest {

    public static void main(String[] args) throws InterruptedException {
        System.out.println("begin main");
        Thread thread = new Thread(() -> {
            int i = 1 / 0;
        },"myThread");
        thread.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
            @Override
            public void uncaughtException(Thread t, Throwable e) {
                System.out.println(String.format("%s发生异常%s", t.getName(), e.getMessage()));
            }
        });
        thread.start();
        System.out.println("end main");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
zhangxiaomaphp
关注
专栏目录
(一)java多线程之Thread
天之妖星的专栏
10-28 8544
(一)java多线程之Thread本人邮箱: kco1989@qq.com 欢迎转载,转载请注明网址 http://blog.csdn.net/tianshi_kco github: https://github.com/kco1989/kco代码已经全部托管github有需要的同学自行下载一java多线程之Thread 代码已经全部托管github有需要的同学自行下载 Thread类 创建一个
Java Thread多线程
web开发
02-09 220
JavaThread多线程 Java多线程例子1小例子 publicclassThreadDemo{ publicstaticvoidmain(String[]args){ newTestThread().start(); while(true){ System.out.println("main():"+Thread.currentThread().getName()+"isru...
java的Thread多线程
m0_58041398的博客
04-21 516
线程的三种创建方法 方法一： public class ThraedDemo1 { public static void main(String[] args) { //new一个新线程 Thread t = new MyThread(); t.start(); for (int i = 0; i < 5; i++) { System.out.println("主线程执行输出" + i); }
Java多线程Thread
qq_43609524的博客
04-19 1746
Java多线程Thread多线程实现原理线程内存图创建多线程的多种方法自定义Thread子类实现Runnable接口实现Runnable接口创建多线程程序的好处使用匿名内部类线程的方法获取线程的名称设置线程名称线程暂停（睡眠）方法 sleep 多线程实现原理 线程内存图 创建多线程的多种方法 自定义Thread子类 class MyThread extends Thread{ @Override public void run() { for (int i = 0; i
Java多线程(Thread)
m0_65137927的博客
04-19 290
/继承Thread类的启动方法 new Thread(new MyThread2()) . start();//实现Runnable接口的启动方法 FutureTask < Integer > futureTask = new FutureTask(new MyThread3());//实现Callable接口的启动方法 new Thread(futureTask) . start();try {
Java多线程之多线程异常捕捉
09-03
在Java多线程编程中，异常处理是一项关键的机制，特别是在多线程环境下，由于线程的并发执行，处理异常的方式与单线程有所不同。本文将深入探讨Java多线程中的异常捕捉，以及如何有效地在多线程环境中处理异常。 ...
java 多线程Thread与runnable的区别
08-29
Java 多线程 Thread 与 Runnable 的区别 Java 多线程技术是 Java 语言中的一种基础技术，用于实现多任务并发执行的功能。在 Java 中，实现多线程有两种方法：继承 Thread 类和实现 Runnable 接口。在本文中，我们将...
详解Java多线程处理List数据
08-26
详解Java多线程处理List数据 Java多线程处理List数据是指在Java编程中，使用多线程技术来处理List数据的操作。这种操作可以提高程序的执行效率和性能，特别是在处理大规模数据时。下面将详细介绍Java多线程处理List...
java多线程模拟队列实现排队叫号
04-15
总的来说，通过Java多线程和队列数据结构，我们可以有效地模拟排队叫号系统。这种模拟有助于理解和实践并发编程，同时也为我们解决实际问题提供了思路。在这个过程中，我们学习了线程同步、队列操作以及如何在Java中...
java_Thread.rar_java 多线程_java多线程
09-21
总之，Java多线程是Java程序员必须掌握的核心技能之一，它涉及到程序的并发性、性能优化以及资源管理等多个方面。通过"java_Thread.txt"这样的实例学习，可以帮助我们更好地理解和应用Java的多线程特性，提升我们的...
JAVA 系列——>多线程（Thread ）
JAVA求生之路——博主406766467
01-18 297
我们在之前，学习的程序在没有跳转语句的前提下，都是由上至下依次执行，那现在想要设计一个程序，边打游戏 边听歌，怎么设计？ 要解决上述问题,咱们得使用多进程或者多线程来解决. 并发与并行 并发：指两个或多个事件在同一个时间段内发生。 并行：指两个或多个事件在同一时刻发生（同时发生）。 在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单 CPU 系统中，每 一时刻只...
Java学习—多线程Thread
艺术的博客
12-11 984
多线程
java thread 多线程_java基础thread——多线程的纷争（循序渐进）
weixin_35538624的博客
02-12 107
一、多线程概述进程：正在运行的程序，是系统进行资源分配和调用的独立单位。每一个进程都有它自己的内存空间和系统资源。多进程有什么意义呢?单进程的计算机只能做一件事情，而我们现在的计算机都可以做多件事情。举例：一边玩游戏(游戏进程)，一边听音乐(音乐进程)。也就是说现在的计算机都是支持多进程的，可以在一个时间段内执行多个任务。并且呢，可以提高CPU的使用率。那问题来了，一边玩游戏，一边听音乐是同时进行...
java thread_java使用Thread类实现多线程
weixin_39585761的博客
02-12 128
这个时候只是做了一个顺序打印，而跟多线程没有关系。多线程的执行实际上和进程是相似的，也应该采用的是多个程序交替执行，而不是说各自执行各自的。正确启动多线程的方式应该调用的是Thread类中的start()方法：package com.gwolf;class MyThread extends Thread {//线程的主体类private String title;public MyThread(S...
Java基础之多线程（Thread）
qq_53350943的博客
02-27 705
一个任务并发个进程。在我主线程main方法CPU是中央处理器一个程序想要运行必须抢到CPU。Thread是线程的父类Thread()ThreadStringname) //publicThreadRunnablearget) //start() :线程启动方法。run() :线程运行方法。
java thread 多线程_java用Thread方式创建多线程
weixin_33744799的博客
02-12 119
进程：一个正在执行的程序，每一个进程都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。线程：进程中一个独立的控制单元。线程控制着进程的执行。一个进程中至少有一个线程。java VM中至少有一个线程负责java程序的执行。而且这个线程运行的代码存在于main方法中。该线程为主线程。扩展，jvm启动了两个线程，一个主线程，一个垃圾回收机制的线程。1.怎样创建一个多线程？第一种方法：通过继承T...
JAVA--多线程
最新发布
qq_56438516的博客
08-18 948
Java中的多线程是指在同一个Java虚拟机（JVM）中并发执行多个线程的能力。线程是程序执行的最小单元，Java提供了丰富的API来创建和管理线程。正确地使用多线程可以提高程序的性能和响应能力，但同时也需要小心处理线程间的交互和同步问题。线程状态的变化由线程的生命周期管理。：线程可以被中断，这是线程间通信的一种方式。方法，允许线程在某些条件下等待，或在条件满足时被唤醒。）来管理线程的创建和销毁，提高资源利用率和执行效率。方法中创建了两个线程，并通过调用它们的。类的构造器，从而创建一个新的线程。
Java--多线程--Thread类+Runnable接口
qq_40132294的博客
11-03 2020
一个进程是一个包含自身地址的程序，每个独立执行的程序都称为进程，也就是正在执行的程序，系统可以分配给每个进程一段有限的使用CPU的时间（CPU时间片），CPU在这个时间段中执行某个进程，然后下一个时间片又会跳至另一个进程中去执行；由于CPU转换很快，所以使得每个进程好像是在同时执行一样。Java语言提供了并发机制，程序中可以执行多个线程，每个线程完成一个功能，并于其他线程并发执行，这种机制被称为多线程。
JAVA线程——Thread 类
zzbzxzzdf的博客
03-23 2912
Thread 类我们可以理解为是 java 用于管理线程的一个类，里面封装了操作系统提供的线程管理这一方面的 API （Thread 是优化后的结果）, Java 代码创建的每一个线程，可以理解为为 Thread 实例化的对象，Thread 对象用于描述线程的信息。
Java多线程ThreadAPI深度解析
"Java多线程Thread API是Java语言中用于处理并发编程的核心API，它提供了创建、控制和管理线程的功能。本文将详细介绍Thread API的使用，包括构造方法、线程名设置、线程组以及Runnable接口的应用。" 在Java中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值